Skip to main content

nautilus_derive/
execution.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Live execution client implementation for the Derive adapter.
17//!
18//! An [`ExecutionClientCore`] holds identity and connection state, an
19//! [`ExecutionEventEmitter`] publishes order/account events back to the live
20//! engine, and the venue clients ([`DeriveHttpClient`], [`DeriveWebSocketClient`])
21//! handle the wire. All state-changing requests are EIP-712 typed-data signed
22//! against the per-action module contracts on the Derive Chain; the
23//! `private/order` body in particular is built by [`order_to_derive_payload`].
24
25use std::{
26    borrow::Cow,
27    cell::RefCell,
28    future::Future,
29    rc::Rc,
30    sync::{
31        Arc,
32        atomic::{AtomicBool, Ordering},
33    },
34    time::Duration,
35};
36
37use ahash::{AHashMap, AHashSet};
38use alloy_primitives::U256;
39use anyhow::Context;
40use async_trait::async_trait;
41use indexmap::IndexMap;
42use nautilus_common::{
43    cache::ORDER_NOT_FOUND,
44    clients::{ExecutionClient, ExecutionReportTask},
45    enums::LogLevel,
46    live::{
47        dst::time::{self, Instant},
48        runner::{get_exec_event_sender, try_get_data_event_sender, try_get_exec_event_sender},
49    },
50    messages::{
51        DataEvent, ExecutionReport,
52        execution::{
53            BatchCancelOrders, CancelAllOrders, CancelOrder, GenerateFillReports,
54            GenerateOrderStatusReport, GenerateOrderStatusReports, GeneratePositionStatusReports,
55            ModifyOrder, QueryAccount, QueryOrder, SubmitOrder, SubmitOrderList,
56        },
57    },
58    runner::{TimeEventMessage, TimeEventSender, try_get_time_event_sender},
59    timer::{TimeEvent, TimeEventCallback},
60};
61use nautilus_core::{
62    AtomicMap, DurationNanos, Params, UUID4, UnixNanos,
63    string::secret::SecretString,
64    time::{AtomicTime, get_atomic_clock_realtime},
65};
66use nautilus_live::{
67    ExecutionClientCore, ExecutionEventEmitter, SocketControl,
68    execution::{failure::CommandFailure, reports::retain_order_status_reports},
69    task::{TaskGroup, TaskGroupGuard},
70};
71use nautilus_model::{
72    accounts::AccountAny,
73    data::QuoteTick,
74    enums::{OmsType, OrderSide, OrderStatus, OrderType, PositionSide},
75    events::{
76        OrderAccepted, OrderCanceled, OrderDeniedReason, OrderEventAny, OrderExpired, OrderFilled,
77        OrderRejected, OrderUpdated,
78    },
79    identifiers::{
80        AccountId, ClientId, ClientOrderId, InstrumentId, StrategyId, Venue, VenueOrderId,
81    },
82    instruments::{Instrument, InstrumentAny},
83    orders::{Order, OrderAny},
84    reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
85    types::{AccountBalance, Currency, MarginBalance, Price, Quantity},
86};
87use parking_lot::Mutex;
88use rust_decimal::Decimal;
89use tokio_util::sync::CancellationToken;
90use ustr::Ustr;
91
92use crate::{
93    common::{
94        consts::{
95            DECIMAL_SCALE, DERIVE_ACCOUNT_REGISTRATION_TIMEOUT_SECS, DERIVE_VENUE,
96            MIN_SIGNATURE_TTL, TRIGGER_ORDER_SIGNATURE_TTL, WS_REQUEST_TIMEOUT,
97        },
98        credential::DeriveCredential,
99        enums::{
100            DeriveInstrumentType, DeriveOrderSide, DeriveOrderStatus, DeriveOrderType,
101            DeriveTimeInForce,
102        },
103        parse::{
104            STRATEGY_REASON_MAX_CHARS, derive_order_type_to_nautilus_for_order,
105            derive_rejection_due_post_only, derive_status_to_nautilus, format_instrument_id,
106            format_venue_symbol, parse_derive_instrument_any, strategy_rejection_reason,
107        },
108        retry::{http_retry_config, is_write_outcome_ambiguous_ws},
109    },
110    config::DeriveExecutionClientConfig,
111    http::{
112        DeriveCredentials, DeriveHttpClient, DeriveHttpError,
113        models::{
114            DeriveInstrument, DeriveOrder, DeriveOrderResult, DeriveReplaceOutcome,
115            DeriveSubaccount, DeriveTrade,
116        },
117        parse::{
118            CommissionError, parse_derive_order_to_report_with_precision,
119            parse_derive_position_to_report_with_precision, parse_derive_subaccount_to_balances,
120            parse_derive_trade_to_fill_report_with_precision,
121        },
122        query::{
123            DeriveCancelByInstrumentParams, DeriveCancelByLabelParams, DeriveCancelParams,
124            DeriveCancelTriggerOrderParams, DeriveGetOpenOrdersParams, DeriveGetOrderHistoryParams,
125            DeriveGetOrderParams, DeriveGetPositionsParams, DeriveGetSubaccountParams,
126            DeriveGetTradeHistoryParams, DeriveGetTriggerOrdersParams, DeriveOrderParams,
127            PaginationCursor, order_replace_to_derive_payload, order_to_derive_payload,
128            trigger_order_to_derive_payload, validate_order_support,
129            validate_trigger_order_support,
130        },
131    },
132    signing::{
133        context::{SigningContext, resolve_signing_context},
134        encoding::decimal_to_scaled_u256,
135        nonce::{NONCE_FUTURE_NS, NonceError, NonceManager},
136    },
137    websocket::{
138        DeriveOrdersSubscriptionData, DeriveTradesSubscriptionData, DeriveWebSocketClient,
139        DeriveWsChannel, DeriveWsCredentials, DeriveWsError, DeriveWsExecutionHandle,
140        DeriveWsMessage, OrderIdentity, WsDispatchState,
141        dispatch::{OrderBinding, ReplaceCompletion},
142        parse::parse_ticker_quote_from_rest,
143    },
144};
145
146const DERIVE_PRIVATE_PAGE_SIZE: u32 = 500;
147const CANCEL_ON_DISCONNECT_CONFIRMATION_TIMEOUT: Duration = Duration::from_secs(30);
148
149/// Live execution client for Derive.
150///
151/// Owns the HTTP and WebSocket clients used to talk to the venue plus an
152/// [`ExecutionEventEmitter`] that publishes order/account events back to the
153/// live engine. Order operations are signed against the per-environment
154/// EIP-712 signing context resolved at construction.
155#[derive(Debug)]
156pub struct DeriveExecutionClient {
157    core: ExecutionClientCore,
158    clock: &'static AtomicTime,
159    config: DeriveExecutionClientConfig,
160    credential: DeriveCredential,
161    emitter: ExecutionEventEmitter,
162    http_client: DeriveHttpClient,
163    ws_client: DeriveWebSocketClient,
164    ws_exec: DeriveWsExecutionHandle,
165    instruments: Arc<AtomicMap<InstrumentId, Arc<DeriveInstrument>>>,
166    nonce_manager: Arc<NonceManager>,
167    signing: SigningContext,
168    is_connected: Arc<AtomicBool>,
169    cancellation_token: CancellationToken,
170    session_tasks: TaskGroup,
171    pending_tasks: TaskGroup,
172    shutdown_errors: Vec<String>,
173    dispatch_state: Arc<WsDispatchState>,
174    reconciliation_request: Mutex<Option<ReconciliationSnapshotRequest>>,
175}
176
177impl DeriveExecutionClient {
178    /// Creates a new [`DeriveExecutionClient`].
179    ///
180    /// Resolves wallet/session-key/subaccount from the supplied config, falling
181    /// back to the documented environment variables when fields are unset, and
182    /// parses the EIP-712 signing constants (domain separator, action typehash,
183    /// trade-module address) from config overrides or the shipped per-environment
184    /// defaults.
185    ///
186    /// # Errors
187    ///
188    /// Returns an error if:
189    /// - `max_fee_per_contract` is missing or not greater than zero.
190    /// - Required credentials are not provided via config or environment.
191    /// - Signing constants are still placeholders or cannot be parsed as hex.
192    /// - The HTTP or WebSocket client cannot be constructed.
193    pub fn new(
194        core: ExecutionClientCore,
195        config: DeriveExecutionClientConfig,
196    ) -> anyhow::Result<Self> {
197        config.validate()?;
198
199        let credential = DeriveCredential::resolve(
200            config.wallet_address.clone(),
201            config.session_key.clone().map(SecretString::into_inner),
202            config.subaccount_id,
203            config.environment,
204        )?;
205
206        let http_credentials = DeriveCredentials::new(
207            credential.wallet_address().to_string(),
208            credential.session_key(),
209        )
210        .context("failed to build Derive HTTP credentials")?;
211        let retry_config = http_retry_config(
212            config.max_retries,
213            config.retry_delay_initial_ms,
214            config.retry_delay_max_ms,
215        );
216        let proxy_url = config
217            .proxy_url
218            .as_ref()
219            .map(|value| value.expose_secret().to_owned());
220        let http_client = DeriveHttpClient::with_credentials(
221            config.rest_url(),
222            http_credentials,
223            Some(config.http_timeout_secs),
224            proxy_url,
225            Some(retry_config),
226        )
227        .context("failed to create Derive HTTP client")?;
228
229        let ws_client = create_ws_client(&config, &credential)?.with_socket_control(
230            SocketControl::new(core.client_id, Some(*DERIVE_VENUE), "derive-user-streams"),
231        );
232
233        // The handle shares the client's command channel, which survives the
234        // reconnect swap, so it stays valid for the client's lifetime.
235        let ws_exec = ws_client.execution_handle();
236
237        let signing = resolve_signing_context(&credential, &config)?;
238
239        let clock = get_atomic_clock_realtime();
240
241        let mut emitter = ExecutionEventEmitter::new(
242            clock,
243            core.trader_id,
244            core.account_id,
245            core.account_type,
246            core.base_currency,
247        );
248
249        if let Some(sender) = try_get_exec_event_sender() {
250            emitter.set_sender(sender);
251        }
252
253        let session_tasks = TaskGroup::new();
254        let pending_tasks = TaskGroup::new();
255
256        let dispatch_state = Arc::new(WsDispatchState::new(credential.subaccount_id()));
257
258        Ok(Self {
259            core,
260            clock,
261            config,
262            credential,
263            emitter,
264            http_client,
265            ws_client,
266            ws_exec,
267            instruments: Arc::new(AtomicMap::new()),
268            nonce_manager: Arc::new(NonceManager::new()),
269            signing,
270            is_connected: Arc::new(AtomicBool::new(false)),
271            cancellation_token: CancellationToken::new(),
272            session_tasks,
273            pending_tasks,
274            shutdown_errors: Vec::new(),
275            dispatch_state,
276            reconciliation_request: Mutex::new(None),
277        })
278    }
279
280    /// Returns the resolved subaccount id.
281    #[must_use]
282    pub const fn subaccount_id(&self) -> u64 {
283        self.credential.subaccount_id()
284    }
285
286    /// Returns a reference to the resolved configuration.
287    #[must_use]
288    pub fn config(&self) -> &DeriveExecutionClientConfig {
289        &self.config
290    }
291
292    /// Returns a reference to the underlying HTTP client.
293    #[must_use]
294    pub fn http_client(&self) -> &DeriveHttpClient {
295        &self.http_client
296    }
297
298    /// Caches a Derive instrument by instrument ID so order submission can
299    /// resolve `base_asset_address` and `base_asset_sub_id` without
300    /// re-querying the venue.
301    ///
302    /// # Errors
303    ///
304    /// Returns an error if instrument identity or price and size increments are invalid.
305    pub fn cache_instrument(&self, instrument: DeriveInstrument) -> anyhow::Result<()> {
306        let instrument_id = self.register_instrument_precision(&instrument)?;
307        self.instruments.insert(instrument_id, Arc::new(instrument));
308        Ok(())
309    }
310
311    fn register_instrument_precision(
312        &self,
313        instrument: &DeriveInstrument,
314    ) -> anyhow::Result<InstrumentId> {
315        let instrument_id = format_instrument_id(instrument.instrument_name)?;
316        anyhow::ensure!(
317            instrument.tick_size > Decimal::ZERO,
318            "Derive tick_size must be positive"
319        );
320        anyhow::ensure!(
321            instrument.amount_step > Decimal::ZERO,
322            "Derive amount_step must be positive"
323        );
324        let price_increment =
325            Price::from_decimal_dp(instrument.tick_size, instrument.tick_size.scale() as u8)
326                .context("invalid Derive tick_size")?;
327        let size_increment =
328            Quantity::from_decimal_dp(instrument.amount_step, instrument.amount_step.scale() as u8)
329                .context("invalid Derive amount_step")?;
330        self.dispatch_state.register_instrument_precision(
331            instrument_id,
332            price_increment.precision,
333            size_increment.precision,
334        );
335        Ok(instrument_id)
336    }
337
338    fn spawn_task<F>(&self, description: impl Into<Cow<'static, str>>, fut: F)
339    where
340        F: std::future::Future<Output = anyhow::Result<()>> + Send + 'static,
341    {
342        let description = description.into();
343        let task_description = description.clone();
344
345        let future = async move {
346            if fut.await.is_err() {
347                log::warn!("{task_description} failed");
348            }
349        };
350
351        if let Err(e) = self.pending_tasks.spawn(future) {
352            log::warn!("Skipping Derive {description} after shutdown began: {e}");
353        }
354    }
355
356    fn abort_pending_tasks(&self) {
357        self.pending_tasks.begin_shutdown();
358    }
359
360    fn abort_session_tasks(&self) {
361        let request = self.reconciliation_request.lock().take();
362        if let Some(request) = request {
363            request.close();
364        }
365
366        self.session_tasks.begin_shutdown();
367        self.ws_client.begin_shutdown();
368    }
369
370    async fn await_pending_tasks(&self) -> anyhow::Result<()> {
371        self.pending_tasks.begin_shutdown();
372        self.pending_tasks
373            .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2))
374            .await
375            .map_err(|e| anyhow::anyhow!("Failed to terminate Derive execution tasks: {e}"))?;
376        Ok(())
377    }
378
379    async fn await_session_tasks(&self) -> anyhow::Result<()> {
380        self.session_tasks.begin_shutdown();
381        self.session_tasks
382            .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2))
383            .await
384            .map_err(|e| {
385                anyhow::anyhow!("Failed to terminate Derive execution session tasks: {e}")
386            })?;
387
388        Ok(())
389    }
390
391    async fn ensure_instruments_initialized(&self) -> anyhow::Result<()> {
392        if self.core.instruments_initialized() {
393            return Ok(());
394        }
395
396        let instruments: Vec<_> = self
397            .core
398            .cache()
399            .instruments(&DERIVE_VENUE, None)
400            .into_iter()
401            .cloned()
402            .collect();
403
404        let mut pending = Vec::with_capacity(instruments.len());
405        let result: anyhow::Result<()> = (|| {
406            for instrument in &instruments {
407                let definition = Self::native_instrument(instrument)?;
408                let instrument_id = self.register_instrument_precision(&definition)?;
409                pending.push((instrument_id, Arc::new(definition)));
410            }
411
412            Ok(())
413        })();
414
415        self.instruments.rcu(|cache| {
416            cache.extend(pending.iter().cloned());
417        });
418
419        result?;
420
421        self.core.set_instruments_initialized();
422        Ok(())
423    }
424
425    async fn initialize_portfolio(&self) -> anyhow::Result<()> {
426        let snapshot = self
427            .http_client
428            .get_subaccount(&DeriveGetSubaccountParams::new(self.subaccount_id()))
429            .await?;
430        self.reconciliation_context()
431            .emit_account_snapshot(&snapshot)?;
432        let triggers = self
433            .http_client
434            .get_trigger_orders(&DeriveGetTriggerOrdersParams::new(self.subaccount_id()))
435            .await?;
436        let mut names: AHashSet<Ustr> = snapshot
437            .open_orders
438            .iter()
439            .chain(triggers.orders.iter())
440            .map(|order| order.instrument_name)
441            .chain(
442                snapshot
443                    .positions
444                    .iter()
445                    .map(|position| position.instrument_name),
446            )
447            .filter(|name| instrument_in_scope(name.as_str(), self.config.load_ids.as_deref()))
448            .collect();
449        {
450            let cache = self.core.cache();
451            for order in cache.orders_refs(
452                Some(&DERIVE_VENUE),
453                None,
454                None,
455                Some(&self.core.account_id),
456                None,
457            ) {
458                if (order.is_open() || order.is_inflight())
459                    && cache.client_id(&order.client_order_id()) == Some(&self.core.client_id)
460                {
461                    names.insert(format_venue_symbol(&order.instrument_id())?);
462                }
463            }
464        }
465
466        let mut names: Vec<_> = names.into_iter().collect();
467        names.sort_unstable();
468        let mut required = Vec::with_capacity(names.len());
469        for name in names {
470            let id = format_instrument_id(name)?;
471            required.push(id);
472            if self.core.cache().instrument(&id).is_some() {
473                continue;
474            }
475
476            let raw = cached_or_fetch_instrument(
477                &self.http_client,
478                &self.instruments,
479                &id,
480                name.as_str(),
481            )
482            .await?;
483            let instrument = parse_derive_instrument_any(&raw, self.clock.get_time_ns())?
484                .context("unsupported required Derive portfolio instrument")?;
485            self.cache_instrument(raw)?;
486            let sender = try_get_data_event_sender()
487                .context("Derive instrument event sender is unavailable")?;
488            sender
489                .send(DataEvent::Data(instrument.into()))
490                .map_err(|e| {
491                    anyhow::anyhow!("Failed to publish required Derive instrument {id}: {e}")
492                })?;
493        }
494
495        self.await_instruments_registered(&required).await?;
496        self.await_account_registered(DERIVE_ACCOUNT_REGISTRATION_TIMEOUT_SECS)
497            .await?;
498        Ok(())
499    }
500
501    async fn await_instruments_registered(&self, required: &[InstrumentId]) -> anyhow::Result<()> {
502        let started = Instant::now();
503        let timeout = Duration::from_secs_f64(DERIVE_ACCOUNT_REGISTRATION_TIMEOUT_SECS);
504
505        loop {
506            if required
507                .iter()
508                .all(|id| self.core.cache().instrument(id).is_some())
509            {
510                return Ok(());
511            }
512
513            anyhow::ensure!(
514                started.elapsed() < timeout,
515                "Timeout waiting for required Derive instruments to be registered"
516            );
517            time::sleep(Duration::from_millis(10)).await;
518        }
519    }
520
521    fn cache_native_instrument(&self, instrument: &InstrumentAny) -> anyhow::Result<()> {
522        self.cache_instrument(Self::native_instrument(instrument)?)
523    }
524
525    fn native_instrument(instrument: &InstrumentAny) -> anyhow::Result<DeriveInstrument> {
526        let info = instrument
527            .info()
528            .context("Derive instrument has no venue metadata")?;
529        let definition: DeriveInstrument = serde_json::from_value(serde_json::to_value(info)?)
530            .context("invalid Derive instrument metadata")?;
531        anyhow::ensure!(
532            format_instrument_id(definition.instrument_name)? == instrument.id(),
533            "Derive metadata identity does not match {}",
534            instrument.id(),
535        );
536        Ok(definition)
537    }
538
539    fn reconciliation_context(&self) -> DeriveReconciliationContext {
540        let (orders, terminal_revision) = cached_order_bindings(&self.core, &self.dispatch_state);
541
542        DeriveReconciliationContext {
543            http_client: self.http_client.clone(),
544            emitter: self.emitter.clone(),
545            client_id: self.core.client_id,
546            account_id: self.core.account_id,
547            subaccount_id: self.credential.subaccount_id(),
548            clock: self.clock,
549            dispatch_state: Arc::clone(&self.dispatch_state),
550            instruments: Arc::clone(&self.instruments),
551            orders,
552            terminal_revision,
553            report_observations: None,
554            load_ids: self.config.load_ids.clone(),
555        }
556    }
557
558    fn report_task<T, F, C, M>(
559        &self,
560        instrument_id: Option<InstrumentId>,
561        collect: F,
562        finish: M,
563    ) -> Option<ExecutionReportTask<T>>
564    where
565        T: Send + 'static,
566        F: FnOnce(DeriveReconciliationContext) -> C,
567        C: Future<Output = anyhow::Result<T>> + Send + 'static,
568        M: FnOnce(T, &DeriveReconciliationContext) -> anyhow::Result<T> + 'static,
569    {
570        let _delivery = self.dispatch_state.delivery_guard();
571
572        // Resolving a pending replacement can emit events, so retain the inline path
573        if self
574            .dispatch_state
575            .unresolved_client_order_id(instrument_id)
576            .is_some()
577        {
578            return None;
579        }
580
581        let core = self.core.clone();
582        let mut context = self.reconciliation_context();
583        let orders = std::mem::take(&mut context.orders);
584
585        let mut collection = DeriveReconciliationContext {
586            orders,
587            ..context.clone()
588        };
589
590        let observations = Arc::new(Mutex::new(ReportObservations::default()));
591        collection.report_observations = Some(Arc::clone(&observations));
592
593        Some(ExecutionReportTask::new(
594            collect(collection),
595            move |reports| {
596                let dispatch_state = Arc::clone(&context.dispatch_state);
597                let _delivery = dispatch_state.delivery_guard();
598                context.ensure_order_context()?;
599                ensure_bindings_resolved(&context.dispatch_state, instrument_id)?;
600                let (orders, _) = cached_order_bindings(&core, &context.dispatch_state);
601                let current = DeriveReconciliationContext { orders, ..context };
602                let observations = observations.lock();
603
604                for (client_order_id, binding) in &observations.bindings {
605                    anyhow::ensure!(
606                        current.order_binding(*client_order_id) == *binding,
607                        "Derive order binding changed during report collection for {client_order_id}",
608                    );
609                }
610
611                let reports = finish(reports, &current)?;
612                for (order, report) in &observations.trigger_orders {
613                    observe_trigger_order(&current.dispatch_state, order, report);
614                }
615
616                for report in &observations.trigger_fills {
617                    observe_trigger_fill(&current.dispatch_state, report);
618                }
619
620                Ok(reports)
621            },
622        ))
623    }
624
625    fn validate_order(&self, order: &OrderAny) -> anyhow::Result<()> {
626        if is_derive_trigger_order_type(order.order_type()) {
627            validate_trigger_order_support(order)?;
628        } else {
629            validate_order_support(order)?;
630        }
631
632        let cache = self.core.cache();
633
634        if order.is_reduce_only()
635            && matches!(
636                cache.instrument(&order.instrument_id()),
637                Some(InstrumentAny::CurrencyPair(_))
638            )
639        {
640            anyhow::bail!(OrderDeniedReason::UnsupportedReduceOnly);
641        }
642
643        if order.order_type() == OrderType::Market && cache.quote(&order.instrument_id()).is_none()
644        {
645            anyhow::bail!(OrderDeniedReason::MarketPriceUnavailable {
646                order_type: order.order_type(),
647                instrument_id: order.instrument_id(),
648            });
649        }
650
651        Ok(())
652    }
653
654    fn restore_active_orders(&self) {
655        let _delivery = self.dispatch_state.delivery_guard();
656        let cache = self.core.cache();
657        for order in cache.orders_refs(
658            Some(&self.core.venue),
659            None,
660            None,
661            Some(&self.core.account_id),
662            None,
663        ) {
664            if (order.is_open() || order.is_inflight())
665                && cache.client_id(&order.client_order_id()) == Some(&self.core.client_id)
666            {
667                self.dispatch_state.restore_order(&order);
668            }
669        }
670    }
671
672    // Account events populate the cache asynchronously, so connect waits for registration
673    // before strategies can issue orders against the portfolio.
674    async fn await_account_registered(&self, timeout_secs: f64) -> anyhow::Result<()> {
675        let account_id = self.core.account_id;
676
677        if self.core.cache().account(&account_id).is_some() {
678            log::info!("Account {account_id} registered");
679            return Ok(());
680        }
681
682        let start = Instant::now();
683        let timeout = Duration::from_secs_f64(timeout_secs);
684        let interval = Duration::from_millis(10);
685        loop {
686            time::sleep(interval).await;
687
688            if self.core.cache().account(&account_id).is_some() {
689                log::info!("Account {account_id} registered");
690                return Ok(());
691            }
692
693            if start.elapsed() >= timeout {
694                anyhow::bail!(
695                    "Timeout waiting for account {account_id} to be registered after {timeout_secs}s"
696                );
697            }
698        }
699    }
700
701    // Shared by disconnect and failed connect steps so the next connect starts clean
702    async fn teardown_partial_connect(&mut self) -> anyhow::Result<()> {
703        self.cancellation_token.cancel();
704        self.abort_session_tasks();
705        self.abort_pending_tasks();
706
707        if let Err(e) = self.ws_client.disconnect().await {
708            self.shutdown_errors
709                .push(format!("Derive WebSocket shutdown failed: {e}"));
710        }
711
712        let (session_result, pending_result) =
713            tokio::join!(self.await_session_tasks(), self.await_pending_tasks());
714        self.core.set_disconnected();
715        self.is_connected.store(false, Ordering::Release);
716
717        if let Err(e) = session_result {
718            self.shutdown_errors.push(e.to_string());
719        }
720
721        if let Err(e) = pending_result {
722            self.shutdown_errors.push(e.to_string());
723        }
724
725        if !self.shutdown_errors.is_empty() {
726            anyhow::bail!(std::mem::take(&mut self.shutdown_errors).join("; "));
727        }
728
729        Ok(())
730    }
731
732    async fn connect_ws(&mut self) -> anyhow::Result<()> {
733        if self.config.cancel_on_disconnect
734            && let Err(e) = self.enable_cancel_on_disconnect().await
735        {
736            if let Err(teardown_error) = self.teardown_partial_connect().await {
737                return Err(e.context(format!(
738                    "Derive cancel-on-disconnect startup teardown failed: {teardown_error}"
739                )));
740            }
741
742            return Err(e);
743        }
744
745        if let Err(e) = self.ws_client.connect().await {
746            let e = anyhow::Error::new(e).context("failed to connect Derive WebSocket");
747            if self.config.cancel_on_disconnect
748                && let Err(teardown_error) = self.teardown_partial_connect().await
749            {
750                return Err(e.context(teardown_error));
751            }
752
753            return Err(e);
754        }
755
756        Ok(())
757    }
758
759    async fn enable_cancel_on_disconnect(&self) -> anyhow::Result<()> {
760        #[derive(serde::Deserialize)]
761        struct AccountSettings {
762            cancel_on_disconnect: bool,
763        }
764
765        let mut setup_client = create_ws_client(&self.config, &self.credential)?;
766        let setup_result = async {
767            setup_client
768                .connect()
769                .await
770                .context("failed to authenticate Derive cancel-on-disconnect setup connection")?;
771            setup_client
772                .set_cancel_on_disconnect(true)
773                .await
774                .context("failed to enable Derive cancel-on-disconnect")?;
775
776            let confirmation = time::timeout(CANCEL_ON_DISCONNECT_CONFIRMATION_TIMEOUT, async {
777                loop {
778                    let settings: AccountSettings = self
779                        .http_client
780                        .send_private(
781                            "private/get_account",
782                            &serde_json::json!({"wallet": self.credential.wallet_address()}),
783                        )
784                        .await
785                        .context("failed to read Derive cancel-on-disconnect setting")?;
786
787                    if settings.cancel_on_disconnect {
788                        return Ok::<(), anyhow::Error>(());
789                    }
790
791                    time::sleep(Duration::from_millis(250)).await;
792                }
793            });
794
795            Box::pin(confirmation).await.with_context(|| {
796                format!(
797                    "Derive cancel-on-disconnect was not confirmed within {} seconds",
798                    CANCEL_ON_DISCONNECT_CONFIRMATION_TIMEOUT.as_secs(),
799                )
800            })?
801        }
802        .await;
803
804        let disconnect_result = setup_client
805            .disconnect()
806            .await
807            .context("failed to close Derive cancel-on-disconnect setup connection");
808
809        match (setup_result, disconnect_result) {
810            (Err(e), Err(disconnect_error)) => Err(e.context(disconnect_error)),
811            (Err(e), Ok(())) => Err(e),
812            (Ok(()), result) => result,
813        }
814    }
815
816    fn start_ws_dispatch(
817        &self,
818        rx: tokio::sync::mpsc::UnboundedReceiver<DeriveWsMessage>,
819    ) -> anyhow::Result<()> {
820        let emitter = self.emitter.clone();
821        let account_id = self.core.account_id;
822        let clock = self.clock;
823        let cancellation = self.cancellation_token.clone();
824        let dispatch_state = self.dispatch_state.clone();
825        let reconciliation = self.reconciliation_context();
826        let timeout = self
827            .config
828            .ws_timeout_secs
829            .map_or(WS_REQUEST_TIMEOUT, Duration::from_secs);
830
831        let request = ReconciliationSnapshotRequest::new(
832            self.core.clone(),
833            reconciliation.clone(),
834            cancellation.clone(),
835            timeout,
836        );
837        *self.reconciliation_request.lock() = request.clone();
838        let is_connected = Arc::clone(&self.is_connected);
839        let session_spawner = self
840            .session_tasks
841            .spawner()
842            .map_err(|e| anyhow::anyhow!("Derive session task admission is closed: {e}"))?;
843
844        self.session_tasks.spawn(async move {
845            let mut rx = rx;
846
847            loop {
848                tokio::select! {
849                    biased;
850                    () = cancellation.cancelled() => break,
851                    maybe = rx.recv() => {
852                        match maybe {
853                            Some(DeriveWsMessage::Reconnected) => {
854                                let context = reconciliation.clone();
855                                let request = request.clone();
856                                let task_cancellation = cancellation.clone();
857
858                                if let Err(e) = session_spawner.spawn(async move {
859                                    tokio::select! {
860                                        biased;
861                                        () = task_cancellation.cancelled() => {}
862                                        result = async {
863                                            let (context, ts_init) = match request {
864                                                Some(request) => request.snapshot().await?,
865                                                None => (context, clock.get_time_ns()),
866                                            };
867                                            context.recover_after_reconnect(ts_init).await
868                                        } => {
869                                            if result.is_err() {
870                                                log::warn!("Derive post-reconnect recovery failed");
871                                            }
872                                        }
873                                    }
874                                }) {
875                                    log::warn!("Skipping Derive reconnect recovery after shutdown began: {e}");
876                                }
877                            }
878                            Some(DeriveWsMessage::SessionRecoveryFailed(_)) => {
879                                is_connected.store(false, Ordering::Release);
880                                log::error!("Derive execution WebSocket recovery failed");
881                            }
882                            Some(DeriveWsMessage::Subscription(payload))
883                                if payload.channel == DeriveWsChannel::balances(dispatch_state.subaccount_id()).to_string() =>
884                            {
885                                let context = reconciliation.clone();
886                                let task_cancellation = cancellation.clone();
887
888                                if let Err(e) = session_spawner.spawn(async move {
889                                    tokio::select! {
890                                        biased;
891                                        () = task_cancellation.cancelled() => {}
892                                        result = context.refresh_account_state() => {
893                                            if result.is_err() {
894                                                log::warn!("Derive balance update refresh failed");
895                                            }
896                                        }
897                                    }
898                                }) {
899                                    log::warn!("Skipping Derive account refresh after shutdown began: {e}");
900                                }
901                            }
902                            Some(message) => handle_ws_message(
903                                message,
904                                &emitter,
905                                account_id,
906                                clock,
907                                &dispatch_state,
908                            ),
909                            None => break,
910                        }
911                    }
912                }
913            }
914
915            is_connected.store(false, Ordering::Release);
916
917            if !cancellation.is_cancelled() {
918                log::warn!("Derive execution WebSocket stream ended unexpectedly");
919            }
920        })?;
921
922        Ok(())
923    }
924
925    fn select_cancel_orders(
926        &self,
927        cmd: &CancelAllOrders,
928    ) -> Option<Vec<(ClientOrderId, VenueOrderId, bool)>> {
929        let side_filter = cmd.order_side;
930        let cache = self.core.cache();
931        let orders = cache.orders_open_refs(
932            Some(&self.core.venue),
933            Some(&cmd.instrument_id),
934            None,
935            Some(&self.core.account_id),
936            side_filter,
937        );
938        let mut cancels = Vec::with_capacity(orders.len());
939
940        for order in orders {
941            let client_order_id = order.client_order_id();
942            if cache.client_id(&client_order_id) != Some(&self.core.client_id) {
943                continue;
944            }
945
946            let is_trigger = is_derive_trigger_order_type(order.order_type());
947            if side_filter.is_none() && !is_trigger {
948                continue;
949            }
950
951            let Some(venue_order_id) = self
952                .dispatch_state
953                .bound_venue_order_id(&client_order_id)
954                .or_else(|| order.venue_order_id())
955            else {
956                log::warn!(
957                    "Cannot cancel all orders for {}: order {client_order_id} has no venue_order_id",
958                    cmd.instrument_id,
959                );
960                return None;
961            };
962
963            cancels.push((client_order_id, venue_order_id, is_trigger));
964        }
965
966        Some(cancels)
967    }
968}
969
970#[async_trait(?Send)]
971impl ExecutionClient for DeriveExecutionClient {
972    fn is_connected(&self) -> bool {
973        self.is_connected.load(Ordering::Acquire)
974    }
975
976    fn client_id(&self) -> ClientId {
977        self.core.client_id
978    }
979
980    fn account_id(&self) -> AccountId {
981        self.core.account_id
982    }
983
984    fn venue(&self) -> Venue {
985        *DERIVE_VENUE
986    }
987
988    fn oms_type(&self) -> OmsType {
989        self.core.oms_type
990    }
991
992    fn get_account(&self) -> Option<AccountAny> {
993        self.core.cache().account_owned(&self.core.account_id)
994    }
995
996    fn venue_order_ids(
997        &self,
998        mass_status: &ExecutionMassStatus,
999    ) -> Option<IndexMap<ClientOrderId, Vec<VenueOrderId>>> {
1000        let reports = mass_status.order_reports();
1001        let mut groups: IndexMap<ClientOrderId, Vec<&OrderStatusReport>> = IndexMap::new();
1002
1003        for report in reports.values() {
1004            if let Some(id) = report.client_order_id {
1005                groups.entry(id).or_default().push(report);
1006            }
1007        }
1008
1009        let cache = self.core.cache();
1010        let mut order_venue_ids = IndexMap::new();
1011
1012        for (id, mut group) in groups {
1013            if cache.order_exists(&id) {
1014                continue;
1015            }
1016
1017            let mut open = group.iter().filter(|report| report.order_status.is_open());
1018
1019            let Some(current) = open.next().copied() else {
1020                continue;
1021            };
1022
1023            if group.len() < 2
1024                || open.next().is_some()
1025                || group.iter().any(|report| {
1026                    cache.client_order_id(&report.venue_order_id).is_some()
1027                        || report.account_id != current.account_id
1028                        || report.instrument_id != current.instrument_id
1029                        || report.order_side != current.order_side
1030                        || report.order_type != current.order_type
1031                        || report.venue_order_id != current.venue_order_id
1032                            && !matches!(
1033                                report.order_status,
1034                                OrderStatus::Canceled | OrderStatus::Expired | OrderStatus::Filled
1035                            )
1036                })
1037            {
1038                continue;
1039            }
1040
1041            group.sort_by_key(|report| report.ts_accepted);
1042            let venue_order_ids = group
1043                .into_iter()
1044                .filter(|report| report.venue_order_id != current.venue_order_id)
1045                .map(|report| report.venue_order_id)
1046                .chain(std::iter::once(current.venue_order_id))
1047                .collect();
1048            order_venue_ids.insert(id, venue_order_ids);
1049        }
1050
1051        (!order_venue_ids.is_empty()).then_some(order_venue_ids)
1052    }
1053
1054    fn register_external_order(
1055        &self,
1056        client_order_id: ClientOrderId,
1057        venue_order_id: VenueOrderId,
1058        instrument_id: InstrumentId,
1059        strategy_id: StrategyId,
1060        _ts_init: UnixNanos,
1061    ) {
1062        let _delivery = self.dispatch_state.delivery_guard();
1063        let cache = self.core.cache();
1064        if let Some(order) = cache.order_ref(&client_order_id)
1065            && order.is_open()
1066            && order.account_id() == Some(self.core.account_id)
1067            && order.instrument_id() == instrument_id
1068            && order.strategy_id() == strategy_id
1069            && order.venue_order_id() == Some(venue_order_id)
1070            && cache.client_id(&client_order_id) == Some(&self.core.client_id)
1071        {
1072            self.dispatch_state.restore_order(&order);
1073        }
1074    }
1075
1076    fn start(&mut self) -> anyhow::Result<()> {
1077        self.emitter.set_sender(get_exec_event_sender());
1078        self.restore_active_orders();
1079        flush_pending_delivery(
1080            &self.emitter,
1081            self.core.account_id,
1082            self.clock,
1083            &self.dispatch_state,
1084        );
1085
1086        if self.core.is_started() {
1087            return Ok(());
1088        }
1089
1090        self.core.set_started();
1091
1092        log::info!(
1093            "Started: client_id={}, account_id={}, subaccount_id={}, environment={:?}, proxy_url={:?}",
1094            self.core.client_id,
1095            self.core.account_id,
1096            self.credential.subaccount_id(),
1097            self.config.environment,
1098            self.config.proxy_url,
1099        );
1100        Ok(())
1101    }
1102
1103    fn stop(&mut self) -> anyhow::Result<()> {
1104        if self.core.is_stopped()
1105            && self.cancellation_token.is_cancelled()
1106            && !self.session_tasks.is_open()
1107            && !self.pending_tasks.is_open()
1108        {
1109            return Ok(());
1110        }
1111
1112        log::info!("Stopping Derive execution client");
1113
1114        self.cancellation_token.cancel();
1115        self.abort_session_tasks();
1116        self.abort_pending_tasks();
1117
1118        self.core.set_stopped();
1119        self.core.set_disconnected();
1120        self.is_connected.store(false, Ordering::Release);
1121
1122        log::info!("Derive execution client stopped");
1123        Ok(())
1124    }
1125
1126    fn reset(&mut self) -> anyhow::Result<()> {
1127        self.stop()
1128    }
1129
1130    fn dispose(&mut self) -> anyhow::Result<()> {
1131        self.stop()
1132    }
1133
1134    async fn connect(&mut self) -> anyhow::Result<()> {
1135        if self.is_connected()
1136            && !self.cancellation_token.is_cancelled()
1137            && self.session_tasks.is_open()
1138            && self.pending_tasks.is_open()
1139        {
1140            return Ok(());
1141        }
1142
1143        log::info!("Connecting Derive execution client");
1144
1145        if self.cancellation_token.is_cancelled()
1146            || !self.session_tasks.is_open()
1147            || !self.pending_tasks.is_open()
1148        {
1149            self.teardown_partial_connect().await?;
1150            self.session_tasks
1151                .start_generation()
1152                .map_err(|e| anyhow::anyhow!("Failed to start Derive session generation: {e}"))?;
1153            self.pending_tasks
1154                .start_generation()
1155                .map_err(|e| anyhow::anyhow!("Failed to start Derive task generation: {e}"))?;
1156            self.cancellation_token = CancellationToken::new();
1157        }
1158
1159        let cancellation_token = self.cancellation_token.clone();
1160        let ws_shutdown = self.ws_client.shutdown_handle();
1161
1162        let setup_guard =
1163            TaskGroupGuard::new(&[&self.session_tasks, &self.pending_tasks], move || {
1164                cancellation_token.cancel();
1165                ws_shutdown.begin_shutdown();
1166            });
1167
1168        self.ensure_instruments_initialized()
1169            .await
1170            .context("failed to initialize Derive instruments")?;
1171        self.initialize_portfolio()
1172            .await
1173            .context("failed initial Derive account state refresh")?;
1174        self.restore_active_orders();
1175
1176        if self.dispatch_state.has_active_orders() {
1177            let context = self.reconciliation_context();
1178            let mut instruments: Vec<_> = context
1179                .orders
1180                .iter()
1181                .filter(|(id, _)| self.dispatch_state.identity(id).is_some())
1182                .map(|(_, binding)| binding.identity.instrument_id)
1183                .collect::<AHashSet<_>>()
1184                .into_iter()
1185                .collect();
1186            instruments.sort_unstable();
1187            for instrument_id in instruments {
1188                context.prime_order_bindings(instrument_id).await?;
1189            }
1190        }
1191
1192        self.connect_ws().await?;
1193
1194        let Some(rx) = self.ws_client.take_event_receiver() else {
1195            let e = anyhow::anyhow!("Derive execution WS event receiver not initialized");
1196            if let Err(teardown_error) = self.teardown_partial_connect().await {
1197                return Err(e.context(format!(
1198                    "Derive execution startup teardown failed: {teardown_error}"
1199                )));
1200            }
1201
1202            return Err(e);
1203        };
1204
1205        let subaccount_id = self.credential.subaccount_id();
1206        let channels = vec![
1207            DeriveWsChannel::orders(subaccount_id),
1208            DeriveWsChannel::private_trades(subaccount_id),
1209            DeriveWsChannel::balances(subaccount_id),
1210        ];
1211
1212        if let Err(e) = self.ws_client.subscribe_channels(channels).await {
1213            log::warn!(
1214                "Derive private WS subscriptions failed: {}; tearing down",
1215                e.redacted_message()
1216            );
1217
1218            if let Err(teardown_error) = self.teardown_partial_connect().await {
1219                return Err(anyhow::Error::new(e).context(format!(
1220                    "Derive execution startup teardown failed: {teardown_error}"
1221                )));
1222            }
1223
1224            return Err(anyhow::Error::new(e).context("failed Derive private WS subscriptions"));
1225        }
1226
1227        self.initialize_portfolio()
1228            .await
1229            .context("failed subscribed Derive portfolio refresh")?;
1230
1231        if let Err(e) = self.start_ws_dispatch(rx) {
1232            if let Err(teardown_error) = self.teardown_partial_connect().await {
1233                return Err(e.context(format!(
1234                    "Derive execution startup teardown failed: {teardown_error}"
1235                )));
1236            }
1237
1238            return Err(e.context("failed to register Derive execution WebSocket dispatch task"));
1239        }
1240
1241        self.core.set_connected();
1242        self.is_connected.store(true, Ordering::Release);
1243        setup_guard.disarm();
1244        log::info!(
1245            "Connected Derive execution client ({:?})",
1246            self.config.environment
1247        );
1248        Ok(())
1249    }
1250
1251    async fn disconnect(&mut self) -> anyhow::Result<()> {
1252        log::info!("Disconnecting Derive execution client");
1253        self.teardown_partial_connect().await?;
1254        log::info!("Derive execution client disconnected");
1255        Ok(())
1256    }
1257
1258    fn generate_account_state(
1259        &self,
1260        balances: Vec<AccountBalance>,
1261        margins: Vec<MarginBalance>,
1262        reported: bool,
1263        ts_event: UnixNanos,
1264        info: Option<Params>,
1265    ) -> anyhow::Result<()> {
1266        self.emitter
1267            .emit_account_state(balances, margins, reported, ts_event, info);
1268        Ok(())
1269    }
1270
1271    fn on_instrument(&mut self, instrument: InstrumentAny) {
1272        if let Err(e) = self.cache_native_instrument(&instrument) {
1273            log::warn!("Cannot cache Derive instrument {}: {e:#}", instrument.id());
1274        }
1275    }
1276
1277    fn generate_order_status_report_task(
1278        &self,
1279        cmd: &GenerateOrderStatusReport,
1280    ) -> Option<ExecutionReportTask<Option<OrderStatusReport>>> {
1281        let command = cmd.clone();
1282        self.report_task(
1283            cmd.instrument_id,
1284            |context| async move { context.generate_order_status_report(&command).await },
1285            |report, _| Ok(report),
1286        )
1287    }
1288
1289    fn generate_order_status_reports_task(
1290        &self,
1291        cmd: &GenerateOrderStatusReports,
1292    ) -> Option<ExecutionReportTask<Vec<OrderStatusReport>>> {
1293        let command = cmd.clone();
1294        self.report_task(
1295            cmd.instrument_id,
1296            |context| async move { context.collect_order_status_reports(&command).await },
1297            |reports, _| Ok(reports),
1298        )
1299    }
1300
1301    fn generate_fill_reports_task(
1302        &self,
1303        cmd: &GenerateFillReports,
1304    ) -> Option<ExecutionReportTask<Vec<FillReport>>> {
1305        let command = cmd.clone();
1306        self.report_task(
1307            cmd.instrument_id,
1308            |context| async move { context.collect_fill_reports(command).await },
1309            |mut reports, context| {
1310                reports.retain(|report| !context.dispatch_state.contains_trade(&report.trade_id));
1311                Ok(reports)
1312            },
1313        )
1314    }
1315
1316    fn generate_position_status_reports_task(
1317        &self,
1318        cmd: &GeneratePositionStatusReports,
1319    ) -> Option<ExecutionReportTask<Vec<PositionStatusReport>>> {
1320        let command = cmd.clone();
1321        let context = self.reconciliation_context();
1322        Some(ExecutionReportTask::new(
1323            async move { context.collect_position_status_reports(&command).await },
1324            Ok,
1325        ))
1326    }
1327
1328    async fn generate_order_status_report(
1329        &self,
1330        cmd: &GenerateOrderStatusReport,
1331    ) -> anyhow::Result<Option<OrderStatusReport>> {
1332        self.reconciliation_context()
1333            .generate_order_status_report(cmd)
1334            .await
1335    }
1336
1337    async fn generate_order_status_reports(
1338        &self,
1339        cmd: &GenerateOrderStatusReports,
1340    ) -> anyhow::Result<Vec<OrderStatusReport>> {
1341        self.reconciliation_context()
1342            .collect_order_status_reports(cmd)
1343            .await
1344    }
1345
1346    async fn generate_fill_reports(
1347        &self,
1348        cmd: GenerateFillReports,
1349    ) -> anyhow::Result<Vec<FillReport>> {
1350        self.reconciliation_context()
1351            .collect_fill_reports(cmd)
1352            .await
1353    }
1354
1355    async fn generate_position_status_reports(
1356        &self,
1357        cmd: &GeneratePositionStatusReports,
1358    ) -> anyhow::Result<Vec<PositionStatusReport>> {
1359        self.reconciliation_context()
1360            .collect_position_status_reports(cmd)
1361            .await
1362    }
1363
1364    async fn generate_mass_status(
1365        &self,
1366        lookback_mins: Option<u64>,
1367    ) -> anyhow::Result<Option<ExecutionMassStatus>> {
1368        let ts_init = self.clock.get_time_ns();
1369        Box::pin(
1370            self.reconciliation_context()
1371                .generate_mass_status(lookback_mins, ts_init, true),
1372        )
1373        .await
1374        .map(Some)
1375    }
1376
1377    fn submit_order(&self, cmd: SubmitOrder) -> anyhow::Result<()> {
1378        let order = self.core.cache().try_order_owned(&cmd.client_order_id)?;
1379
1380        if order.is_closed() {
1381            log::warn!("Cannot submit closed order {}", order.client_order_id());
1382            return Ok(());
1383        }
1384
1385        if let Err(reason) = self.validate_order(&order) {
1386            log::warn!("Cannot submit order {}: {reason}", order.client_order_id());
1387            self.emitter.emit_order_denied(&order, &reason.to_string());
1388            return Ok(());
1389        }
1390
1391        let is_trigger_order = is_derive_trigger_order_type(order.order_type());
1392        let cancel_on_disconnect = self.config.cancel_on_disconnect;
1393        let market_quote = (order.order_type() == OrderType::Market).then_some(());
1394
1395        let venue_symbol = format_venue_symbol(&cmd.instrument_id)?.to_string();
1396        let http_client = self.http_client.clone();
1397        let ws_exec = self.ws_exec.clone();
1398        let signing = self.signing.clone();
1399        let nonce_manager = self.nonce_manager.clone();
1400        let wallet_str = self.credential.wallet_address().to_string();
1401        let emitter = self.emitter.clone();
1402        let clock = self.clock;
1403        let instruments = self.instruments.clone();
1404        let instrument_id = cmd.instrument_id;
1405        let order_for_task = order.clone();
1406        let account_id = self.core.account_id;
1407
1408        // Capture identity so the WS dispatch can route subsequent updates
1409        // for this order to proper events rather than execution reports.
1410        let identity = OrderIdentity {
1411            instrument_id: order.instrument_id(),
1412            strategy_id: order.strategy_id(),
1413            order_side: order.order_side(),
1414            order_type: order.order_type(),
1415        };
1416
1417        self.dispatch_state
1418            .register_identity(order.client_order_id(), identity);
1419        self.dispatch_state.record_order_shape(
1420            order.client_order_id(),
1421            order.quantity(),
1422            order.price(),
1423        );
1424
1425        self.emitter.emit_order_submitted(&order);
1426
1427        let slippage_bps = self.signing.market_order_slippage_bps;
1428        let dispatch_state = self.dispatch_state.clone();
1429
1430        self.spawn_task("submit_order", async move {
1431            let instrument = match cached_or_fetch_instrument(
1432                &http_client,
1433                &instruments,
1434                &instrument_id,
1435                &venue_symbol,
1436            )
1437            .await
1438            {
1439                Ok(i) => i,
1440                Err(e) => {
1441                    log::warn!("Failed to resolve instrument {venue_symbol}: {e}");
1442                    dispatch_state.forget(&order_for_task.client_order_id());
1443                    let ts = clock.get_time_ns();
1444                    emit_submit_failure(
1445                        &emitter,
1446                        &order_for_task,
1447                        CommandFailure::not_sent(format!("instrument resolution failed: {e}")),
1448                        ts,
1449                        false,
1450                    );
1451                    return Ok(());
1452                }
1453            };
1454
1455            // Lazy-resolution net: the synchronous deny is skipped when the
1456            // cache was empty at submit time. OrderSubmitted already fired, so
1457            // reject here rather than deny.
1458            if order_for_task.is_reduce_only()
1459                && instrument.instrument_type == DeriveInstrumentType::Erc20
1460            {
1461                let reason = format!(
1462                    "reduce-only is not supported for spot instrument {}; Derive spot has no position to reduce",
1463                    order_for_task.instrument_id(),
1464                );
1465                log::warn!("{reason}");
1466                dispatch_state.forget(&order_for_task.client_order_id());
1467                let ts = clock.get_time_ns();
1468                emit_submit_failure(
1469                    &emitter,
1470                    &order_for_task,
1471                    CommandFailure::not_sent(&reason),
1472                    ts,
1473                    false,
1474                );
1475                return Ok(());
1476            }
1477
1478            // Avoid signing against a quote captured before instrument resolution
1479            let explicit_price = if market_quote.is_some() {
1480                let quote = match refresh_market_order_quote(
1481                    &http_client,
1482                    &venue_symbol,
1483                    &instrument,
1484                    clock,
1485                )
1486                .await
1487                {
1488                    Ok(quote) => quote,
1489                    Err(e) => {
1490                        let reason = format!(
1491                            "market-order quote refresh failed for {}: {e}",
1492                            order_for_task.client_order_id(),
1493                        );
1494                        log::warn!("{reason}");
1495                        dispatch_state.forget(&order_for_task.client_order_id());
1496                        let ts = clock.get_time_ns();
1497                        emit_submit_failure(
1498                            &emitter,
1499                            &order_for_task,
1500                            CommandFailure::not_sent(&reason),
1501                            ts,
1502                            false,
1503                        );
1504                        return Ok(());
1505                    }
1506                };
1507
1508                match market_order_limit_price(
1509                    &quote,
1510                    order_for_task.order_side(),
1511                    slippage_bps,
1512                    instrument.tick_size,
1513                ) {
1514                    Some(p) => Some(p),
1515                    None => {
1516                        let reason = format!(
1517                            "market-order slippage bound is non-positive for {} ({} bps)",
1518                            order_for_task.client_order_id(),
1519                            slippage_bps,
1520                        );
1521                        log::warn!("{reason}");
1522                        dispatch_state.forget(&order_for_task.client_order_id());
1523                        let ts = clock.get_time_ns();
1524                        emit_submit_failure(
1525                            &emitter,
1526                            &order_for_task,
1527                            CommandFailure::not_sent(&reason),
1528                            ts,
1529                            false,
1530                        );
1531                        return Ok(());
1532                    }
1533                }
1534            } else if matches!(
1535                order_for_task.order_type(),
1536                OrderType::StopMarket | OrderType::MarketIfTouched
1537            ) {
1538                let trigger_price = match order_for_task.trigger_price() {
1539                    Some(price) => price.as_decimal(),
1540                    None => {
1541                        let reason = format!(
1542                            "trigger market order {} is missing trigger_price",
1543                            order_for_task.client_order_id(),
1544                        );
1545                        log::warn!("{reason}");
1546                        dispatch_state.forget(&order_for_task.client_order_id());
1547                        let ts = clock.get_time_ns();
1548                        emit_submit_failure(
1549                            &emitter,
1550                            &order_for_task,
1551                            CommandFailure::not_sent(&reason),
1552                            ts,
1553                            false,
1554                        );
1555                        return Ok(());
1556                    }
1557                };
1558
1559                match trigger_market_limit_price(
1560                    trigger_price,
1561                    order_for_task.order_side(),
1562                    slippage_bps,
1563                    instrument.tick_size,
1564                ) {
1565                    Some(p) => Some(p),
1566                    None => {
1567                        let reason = format!(
1568                            "trigger market-order slippage bound is non-positive for {} ({} bps)",
1569                            order_for_task.client_order_id(),
1570                            slippage_bps,
1571                        );
1572                        log::warn!("{reason}");
1573                        dispatch_state.forget(&order_for_task.client_order_id());
1574                        let ts = clock.get_time_ns();
1575                        emit_submit_failure(
1576                            &emitter,
1577                            &order_for_task,
1578                            CommandFailure::not_sent(&reason),
1579                            ts,
1580                            false,
1581                        );
1582                        return Ok(());
1583                    }
1584                }
1585            } else {
1586                None
1587            };
1588
1589            let matching_reservation = match ws_exec
1590                .reserve_matching_request(
1591                    "private/order",
1592                    &instrument.instrument_name,
1593                )
1594                .await
1595            {
1596                Ok(reservation) => reservation,
1597                Err(e) => {
1598                    let (reason, due_post_only) = ws_rejection_reason(&e);
1599                    log::warn!(
1600                        "Cannot reserve Derive order quota for {}: {reason}",
1601                        order_for_task.client_order_id(),
1602                    );
1603                    dispatch_state.forget(&order_for_task.client_order_id());
1604                    let ts = clock.get_time_ns();
1605                    emit_submit_failure(
1606                        &emitter,
1607                        &order_for_task,
1608                        CommandFailure::not_sent(&reason),
1609                        ts,
1610                        due_post_only,
1611                    );
1612                    return Ok(());
1613                }
1614            };
1615
1616            let expiry =
1617                match normal_order_signature_expiry(
1618                    clock,
1619                    if is_trigger_order {
1620                        TRIGGER_ORDER_SIGNATURE_TTL.as_secs()
1621                    } else {
1622                        signing.signature_expiry_secs
1623                    },
1624                ) {
1625                    Ok(expiry) => expiry,
1626                    Err(e) => {
1627                        log::warn!(
1628                            "Order expiry validation failed for {}: {e}",
1629                            order_for_task.client_order_id()
1630                        );
1631                        dispatch_state.forget(&order_for_task.client_order_id());
1632                        let ts = clock.get_time_ns();
1633                        emit_submit_failure(
1634                            &emitter,
1635                            &order_for_task,
1636                            CommandFailure::not_sent(format!(
1637                                "order expiry validation failed: {e}"
1638                            )),
1639                            ts,
1640                            false,
1641                        );
1642                        return Ok(());
1643                    }
1644                };
1645
1646            let nonce = match resolve_submit_nonce(
1647                nonce_manager.next_nonce(&wallet_str, signing.subaccount_id),
1648                &emitter,
1649                &dispatch_state,
1650                &order_for_task,
1651                clock,
1652            ) {
1653                Some(nonce) => nonce,
1654                None => return Ok(()),
1655            };
1656
1657            let payload_result = if is_trigger_order {
1658                trigger_order_to_derive_payload(
1659                    &order_for_task,
1660                    &instrument,
1661                    signing.subaccount_id,
1662                    signing.wallet_address,
1663                    &signing.signer,
1664                    nonce,
1665                    expiry,
1666                    signing.trade_module_address,
1667                    signing.domain_separator,
1668                    signing.action_typehash,
1669                    signing.max_fee_per_contract,
1670                    explicit_price,
1671                    "",
1672                    "",
1673                )
1674                .map(|params| params.order)
1675            } else {
1676                order_to_derive_payload(
1677                    &order_for_task,
1678                    &instrument,
1679                    signing.subaccount_id,
1680                    signing.wallet_address,
1681                    &signing.signer,
1682                    nonce,
1683                    expiry,
1684                    signing.trade_module_address,
1685                    signing.domain_separator,
1686                    signing.action_typehash,
1687                    signing.max_fee_per_contract,
1688                    explicit_price,
1689                )
1690            };
1691
1692            let mut payload = match payload_result {
1693                Ok(p) => p,
1694                Err(e) => {
1695                    log::warn!("Order encode failed for {}: {e}", order_for_task.client_order_id());
1696                    dispatch_state.forget(&order_for_task.client_order_id());
1697                    let ts = clock.get_time_ns();
1698                    emit_submit_failure(
1699                        &emitter,
1700                        &order_for_task,
1701                        CommandFailure::not_sent(format!("order encoding failed: {e}")),
1702                        ts,
1703                        false,
1704                    );
1705                    return Ok(());
1706                }
1707            };
1708
1709            enable_resting_order_mmp(&mut payload, cancel_on_disconnect);
1710
1711            // Pre-flight debug log so a venue 11012-style rejection can be
1712            // diagnosed without re-running with full payload tracing.
1713            log::debug!(
1714                "Derive submit payload client_order_id={} instrument_name={} direction={} order_type={} time_in_force={} amount={} limit_price={}",
1715                order_for_task.client_order_id(),
1716                payload.instrument_name.as_str(),
1717                payload.direction,
1718                payload.order_type,
1719                payload.time_in_force,
1720                payload.amount,
1721                payload.limit_price,
1722            );
1723
1724            match ws_exec
1725                .submit_order_after_rate_limit(&payload, matching_reservation)
1726                .await
1727                .map_err(|e| ws_command_failure(&e))
1728            {
1729                Ok(result) => {
1730                    dispatch_order_result(
1731                        result,
1732                        order_for_task.client_order_id(),
1733                        &emitter,
1734                        account_id,
1735                        clock,
1736                        &dispatch_state,
1737                    );
1738                    log::debug!(
1739                        "Order submitted: client_order_id={}",
1740                        order_for_task.client_order_id(),
1741                    );
1742                }
1743                // See docs/integrations/derive.md "Order rejection semantics".
1744                Err((CommandFailure::Ambiguous(reason), _)) => {
1745                    log::warn!(
1746                        "Derive submit for {} returned ambiguous WS outcome: {reason}; awaiting reconciliation",
1747                        order_for_task.client_order_id(),
1748                    );
1749                }
1750                Err((failure, due_post_only)) => {
1751                    log::debug!(
1752                        "Derive rejected order {}: {failure:?}",
1753                        order_for_task.client_order_id(),
1754                    );
1755
1756                    if dispatch_state
1757                        .take_identity(&order_for_task.client_order_id())
1758                        .is_some()
1759                    {
1760                        let ts = clock.get_time_ns();
1761                        emit_submit_failure(&emitter, &order_for_task, failure, ts, due_post_only);
1762                    }
1763                }
1764            }
1765
1766            Ok(())
1767        });
1768
1769        Ok(())
1770    }
1771
1772    fn submit_order_list(&self, cmd: SubmitOrderList) -> anyhow::Result<()> {
1773        let orders = self.core.get_orders_for_list(&cmd.order_list)?;
1774
1775        if orders.iter().any(|order| {
1776            order.is_contingency()
1777                || order.is_child_order()
1778                || order.linked_order_ids().is_some_and(|ids| !ids.is_empty())
1779        }) {
1780            let reason = OrderDeniedReason::UnsupportedOrderList {
1781                detail: "Derive does not support native contingent order lists".to_string(),
1782            }
1783            .to_string();
1784
1785            for order in &orders {
1786                self.emitter.emit_order_denied(order, &reason);
1787            }
1788
1789            return Ok(());
1790        }
1791
1792        let denials: Vec<_> = orders
1793            .iter()
1794            .map(|order| self.validate_order(order).err())
1795            .collect();
1796
1797        if denials.iter().any(Option::is_some) {
1798            for (order, denial) in orders.iter().zip(denials) {
1799                let reason = denial.unwrap_or_else(|| {
1800                    OrderDeniedReason::OrderListDenied {
1801                        order_list_id: cmd.order_list.id,
1802                    }
1803                    .into()
1804                });
1805
1806                self.emitter.emit_order_denied(order, &reason.to_string());
1807            }
1808
1809            return Ok(());
1810        }
1811
1812        for order in orders {
1813            let sub = SubmitOrder::from_order(
1814                &order,
1815                cmd.trader_id,
1816                cmd.client_id,
1817                cmd.position_id,
1818                UUID4::new(),
1819                cmd.ts_init,
1820            );
1821            self.submit_order(sub)?;
1822        }
1823
1824        Ok(())
1825    }
1826
1827    fn cancel_order(&self, cmd: CancelOrder) -> anyhow::Result<()> {
1828        if let Err(e) = ensure_order_binding_resolved(&self.dispatch_state, cmd.client_order_id) {
1829            emit_cancel_failure(
1830                &self.emitter,
1831                cmd.strategy_id,
1832                cmd.instrument_id,
1833                cmd.client_order_id,
1834                self.dispatch_state
1835                    .bound_venue_order_id(&cmd.client_order_id)
1836                    .or(cmd.venue_order_id),
1837                CommandFailure::not_sent(e.to_string()),
1838                self.clock.get_time_ns(),
1839                Some(cmd.command_id),
1840            );
1841            return Ok(());
1842        }
1843
1844        let http_client = self.http_client.clone();
1845        let ws_exec = self.ws_exec.clone();
1846        let subaccount_id = self.credential.subaccount_id();
1847        let venue_symbol = format_venue_symbol(&cmd.instrument_id)?.to_string();
1848        let emitter = self.emitter.clone();
1849        let clock = self.clock;
1850        let account_id = self.core.account_id;
1851        let dispatch_state = self.dispatch_state.clone();
1852        let strategy_id = cmd.strategy_id;
1853        let instrument_id = cmd.instrument_id;
1854        let client_order_id = cmd.client_order_id;
1855        let venue_order_id = dispatch_state
1856            .bound_venue_order_id(&client_order_id)
1857            .or(cmd.venue_order_id);
1858        let is_trigger_order = self
1859            .core
1860            .cache()
1861            .order(&client_order_id)
1862            .is_some_and(|order| is_derive_trigger_order_type(order.order_type()));
1863
1864        self.spawn_task("cancel_order", async move {
1865            let venue_order_id = if venue_order_id.is_none() && is_trigger_order
1866                && !dispatch_state.trigger_active(&client_order_id)
1867            {
1868                match resolve_trigger_cancel_id(&http_client, &dispatch_state, subaccount_id, client_order_id, venue_symbol.as_str()).await {
1869                    Ok(id) => Some(id),
1870                    Err(reason) => {
1871                        log::warn!("Cannot cancel trigger order {client_order_id}: {reason}");
1872                        emit_cancel_failure(
1873                            &emitter,
1874                            strategy_id,
1875                            instrument_id,
1876                            client_order_id,
1877                            None,
1878                            CommandFailure::not_sent(&reason),
1879                            clock.get_time_ns(),
1880                            Some(cmd.command_id),
1881                        );
1882                        return Ok(());
1883                    }
1884                }
1885            } else { dispatch_state.bound_venue_order_id(&client_order_id).or(venue_order_id) };
1886
1887            let is_trigger_order = is_trigger_order && !dispatch_state.trigger_active(&client_order_id);
1888            let expected_cancel_id = venue_order_id;
1889
1890            let outcome = match venue_order_id {
1891                Some(venue_order_id) if is_trigger_order => {
1892                    ws_exec
1893                        .cancel_trigger_order_current(
1894                            &DeriveCancelTriggerOrderParams::new(subaccount_id, venue_order_id.as_str()),
1895                            &DeriveCancelParams::new(subaccount_id, venue_symbol.as_str(), venue_order_id.as_str()),
1896                            || dispatch_state.trigger_active(&client_order_id),
1897                        )
1898                        .await
1899                }
1900                Some(venue_order_id) => ws_exec
1901                    .cancel_order(&DeriveCancelParams::new(
1902                        subaccount_id,
1903                        venue_symbol.as_str(),
1904                        venue_order_id.as_str(),
1905                    ))
1906                    .await
1907                    .map(|()| None),
1908                None => ws_exec
1909                    .cancel_by_label(&DeriveCancelByLabelParams::new(
1910                        subaccount_id,
1911                        client_order_id.as_str(),
1912                    ))
1913                    .await
1914                    .map(|result| {
1915                        if result.cancelled_orders == 0 {
1916                            let reason = "no open order matched the client_order_id label";
1917                            log::debug!(
1918                                "Derive rejected cancel for {client_order_id}: {reason}"
1919                            );
1920                            let ts = clock.get_time_ns();
1921                            emit_cancel_failure(
1922                                &emitter,
1923                                strategy_id,
1924                                instrument_id,
1925                                client_order_id,
1926                                None,
1927                                CommandFailure::venue_rejected(reason),
1928                                ts,
1929                                Some(cmd.command_id),
1930                            );
1931                        }
1932
1933                        None
1934                    }),
1935            };
1936
1937            match outcome.map_err(|e| ws_command_failure(&e)) {
1938                Ok(Some(canceled_order)) => {
1939                    emit_trigger_cancel_result(&canceled_order, expected_cancel_id, &cmd, &emitter, &dispatch_state, account_id, clock)?;
1940                }
1941                Ok(None) => {}
1942                // See docs/integrations/derive.md "Order rejection semantics".
1943                Err((CommandFailure::Ambiguous(reason), _)) => {
1944                    log::warn!(
1945                        "Derive cancel for {client_order_id} returned ambiguous WS outcome: {reason}; awaiting reconciliation",
1946                    );
1947                }
1948                Err((failure, _)) => {
1949                    log::debug!("Derive rejected cancel for {client_order_id}: {failure:?}");
1950                    let ts = clock.get_time_ns();
1951                    emit_cancel_failure(
1952                        &emitter,
1953                        strategy_id,
1954                        instrument_id,
1955                        client_order_id,
1956                        venue_order_id,
1957                        failure,
1958                        ts,
1959                        Some(cmd.command_id),
1960                    );
1961                }
1962            }
1963
1964            Ok(())
1965        });
1966
1967        Ok(())
1968    }
1969
1970    fn cancel_all_orders(&self, cmd: CancelAllOrders) -> anyhow::Result<()> {
1971        ensure_bindings_resolved(&self.dispatch_state, Some(cmd.instrument_id))?;
1972        let venue_symbol = format_venue_symbol(&cmd.instrument_id)?.to_string();
1973        let side_filter = cmd.order_side;
1974
1975        let Some(cancels) = self.select_cancel_orders(&cmd) else {
1976            return Ok(());
1977        };
1978
1979        if side_filter.is_some() && cancels.is_empty() {
1980            return Ok(());
1981        }
1982
1983        let ws_exec = self.ws_exec.clone();
1984        let subaccount_id = self.credential.subaccount_id();
1985
1986        let dispatch_state = Arc::clone(&self.dispatch_state);
1987        self.spawn_task("cancel_all_orders", async move {
1988            for (client_order_id, venue_order_id, is_trigger) in cancels {
1989                let is_trigger = is_trigger && !dispatch_state.trigger_active(&client_order_id);
1990                if side_filter.is_none() && !is_trigger {
1991                    continue;
1992                }
1993
1994                let outcome = if is_trigger {
1995                    ws_exec
1996                        .cancel_trigger_order_current(
1997                            &DeriveCancelTriggerOrderParams::new(
1998                                subaccount_id,
1999                                venue_order_id.as_str(),
2000                            ),
2001                            &DeriveCancelParams::new(
2002                                subaccount_id,
2003                                venue_symbol.as_str(),
2004                                venue_order_id.as_str(),
2005                            ),
2006                            || dispatch_state.trigger_active(&client_order_id),
2007                        )
2008                        .await
2009                        .map(|_| ())
2010                } else {
2011                    ws_exec
2012                        .cancel_order(&DeriveCancelParams::new(
2013                            subaccount_id,
2014                            venue_symbol.as_str(),
2015                            venue_order_id.as_str(),
2016                        ))
2017                        .await
2018                };
2019
2020                if let Err(e) = outcome {
2021                    log::warn!(
2022                        "Derive cancel_all_orders: cancel for {venue_order_id} failed: {:?}",
2023                        ws_command_failure(&e).0,
2024                    );
2025                }
2026            }
2027
2028            if side_filter.is_none() {
2029                match ws_exec
2030                    .cancel_by_instrument(&DeriveCancelByInstrumentParams::new(
2031                        subaccount_id,
2032                        venue_symbol.as_str(),
2033                    ))
2034                    .await
2035                {
2036                    Ok(result) if result.cancelled_orders == 0 => {
2037                        log::debug!("No open orders to cancel for {venue_symbol}");
2038                    }
2039                    Ok(_) => {}
2040                    Err(e) => {
2041                        log::warn!(
2042                            "Derive cancel_all_orders failed for {venue_symbol}: {:?}",
2043                            ws_command_failure(&e).0
2044                        );
2045                    }
2046                }
2047            }
2048
2049            Ok(())
2050        });
2051
2052        Ok(())
2053    }
2054
2055    fn batch_cancel_orders(&self, cmd: BatchCancelOrders) -> anyhow::Result<()> {
2056        for cancel in &cmd.cancels {
2057            ensure_order_binding_resolved(&self.dispatch_state, cancel.client_order_id)?;
2058        }
2059
2060        for inner in cmd.cancels {
2061            self.cancel_order(inner)?;
2062        }
2063
2064        Ok(())
2065    }
2066
2067    fn modify_order(&self, cmd: ModifyOrder) -> anyhow::Result<()> {
2068        let ts_now = self.clock.get_time_ns();
2069
2070        if let Err(e) = ensure_order_binding_resolved(&self.dispatch_state, cmd.client_order_id) {
2071            emit_modify_failure(
2072                &self.emitter,
2073                cmd.strategy_id,
2074                cmd.instrument_id,
2075                cmd.client_order_id,
2076                self.dispatch_state
2077                    .bound_venue_order_id(&cmd.client_order_id)
2078                    .or(cmd.venue_order_id),
2079                CommandFailure::not_sent(e.to_string()),
2080                ts_now,
2081                Some(cmd.command_id),
2082            );
2083            return Ok(());
2084        }
2085
2086        let Some(venue_order_id) = self
2087            .dispatch_state
2088            .bound_venue_order_id(&cmd.client_order_id)
2089            .or(cmd.venue_order_id)
2090        else {
2091            let reason = "venue_order_id is required for modify";
2092            log::warn!("Cannot modify order {}: {reason}", cmd.client_order_id);
2093            emit_modify_failure(
2094                &self.emitter,
2095                cmd.strategy_id,
2096                cmd.instrument_id,
2097                cmd.client_order_id,
2098                None,
2099                CommandFailure::not_sent(reason),
2100                ts_now,
2101                Some(cmd.command_id),
2102            );
2103            return Ok(());
2104        };
2105
2106        let Ok(order) = self.core.cache().try_order_owned(&cmd.client_order_id) else {
2107            let reason = ORDER_NOT_FOUND;
2108            log::warn!("Cannot modify order {}: {reason}", cmd.client_order_id);
2109            emit_modify_failure(
2110                &self.emitter,
2111                cmd.strategy_id,
2112                cmd.instrument_id,
2113                cmd.client_order_id,
2114                Some(venue_order_id),
2115                CommandFailure::not_sent(reason),
2116                ts_now,
2117                Some(cmd.command_id),
2118            );
2119            return Ok(());
2120        };
2121
2122        if is_derive_trigger_order_type(order.order_type()) {
2123            let reason = "Derive trigger orders cannot be modified; cancel and resubmit";
2124            log::warn!("Cannot modify order {}: {reason}", cmd.client_order_id);
2125            emit_modify_failure(
2126                &self.emitter,
2127                cmd.strategy_id,
2128                cmd.instrument_id,
2129                cmd.client_order_id,
2130                Some(venue_order_id),
2131                CommandFailure::not_sent(reason),
2132                ts_now,
2133                Some(cmd.command_id),
2134            );
2135            return Ok(());
2136        }
2137
2138        if let Err(e) =
2139            normal_order_signature_expiry(self.clock, self.signing.signature_expiry_secs)
2140        {
2141            emit_modify_failure(
2142                &self.emitter,
2143                cmd.strategy_id,
2144                cmd.instrument_id,
2145                cmd.client_order_id,
2146                Some(venue_order_id),
2147                CommandFailure::not_sent(format!("replace expiry validation failed: {e}")),
2148                ts_now,
2149                Some(cmd.command_id),
2150            );
2151            return Ok(());
2152        }
2153
2154        let (quantity, price) = self
2155            .dispatch_state
2156            .order_shape(&cmd.client_order_id)
2157            .unwrap_or_else(|| (order.quantity(), order.price()));
2158        let target_quantity = cmd.quantity.unwrap_or(quantity);
2159        let target_price = cmd.price.or(price);
2160        let cancel_on_disconnect = self.config.cancel_on_disconnect;
2161
2162        let venue_symbol = format_venue_symbol(&cmd.instrument_id)?.to_string();
2163        let http_client = self.http_client.clone();
2164        let ws_exec = self.ws_exec.clone();
2165        let signing = self.signing.clone();
2166        let nonce_manager = self.nonce_manager.clone();
2167        let wallet_str = self.credential.wallet_address().to_string();
2168        let emitter = self.emitter.clone();
2169        let clock = self.clock;
2170        let instruments = self.instruments.clone();
2171        let dispatch_state = self.dispatch_state.clone();
2172        let order_for_task = order;
2173        let strategy_id = cmd.strategy_id;
2174        let instrument_id = cmd.instrument_id;
2175        let client_order_id = cmd.client_order_id;
2176        let stale_venue_order_id = venue_order_id;
2177        let account_id = self.core.account_id;
2178        let voi_str = venue_order_id.to_string();
2179
2180        {
2181            let _delivery = dispatch_state.delivery_guard();
2182            if !dispatch_state.mark_pending_modify(client_order_id, stale_venue_order_id) {
2183                emit_modify_failure(
2184                    &emitter,
2185                    strategy_id,
2186                    instrument_id,
2187                    client_order_id,
2188                    Some(stale_venue_order_id),
2189                    CommandFailure::not_sent("Another modify is pending"),
2190                    clock.get_time_ns(),
2191                    Some(cmd.command_id),
2192                );
2193                return Ok(());
2194            }
2195
2196            dispatch_state.record_modify_target(client_order_id, target_quantity, target_price);
2197        }
2198
2199        self.spawn_task("modify_order", async move {
2200            let instrument = match cached_or_fetch_instrument(
2201                &http_client,
2202                &instruments,
2203                &instrument_id,
2204                &venue_symbol,
2205            )
2206            .await
2207            {
2208                Ok(i) => i,
2209                Err(e) => {
2210                    let reason = format!("instrument resolution failed: {e}");
2211                    log::warn!("Cannot modify order {client_order_id}: {reason}");
2212                    let ts = clock.get_time_ns();
2213                    emit_modify_failure(
2214                        &emitter,
2215                        strategy_id,
2216                        instrument_id,
2217                        client_order_id,
2218                        Some(stale_venue_order_id),
2219                        CommandFailure::not_sent(&reason),
2220                        ts,
2221                        Some(cmd.command_id),
2222                    );
2223                    dispatch_state.clear_pending_modify(&client_order_id);
2224                    return Ok(());
2225                }
2226            };
2227
2228            let matching_reservation = match ws_exec
2229                .reserve_matching_request("private/replace", &instrument.instrument_name)
2230                .await
2231            {
2232                Ok(reservation) => reservation,
2233                Err(e) => {
2234                    let (reason, _) = ws_rejection_reason(&e);
2235                    log::warn!("Cannot reserve Derive replace quota for {client_order_id}: {reason}");
2236                    let ts = clock.get_time_ns();
2237                    emit_modify_failure(
2238                        &emitter,
2239                        strategy_id,
2240                        instrument_id,
2241                        client_order_id,
2242                        Some(stale_venue_order_id),
2243                        CommandFailure::not_sent(&reason),
2244                        ts,
2245                        Some(cmd.command_id),
2246                    );
2247                    dispatch_state.clear_pending_modify(&client_order_id);
2248                    return Ok(());
2249                }
2250            };
2251
2252            let identity = OrderIdentity {
2253                instrument_id,
2254                strategy_id,
2255                order_side: order_for_task.order_side(),
2256                order_type: order_for_task.order_type(),
2257            };
2258
2259            let (remaining_amount, expected_filled_amount) = match replacement_amounts(&http_client, &dispatch_state, client_order_id, identity, stale_venue_order_id, target_quantity.as_decimal()).await {
2260                Ok(amounts) => amounts,
2261                Err(e) => {
2262                    log::warn!("Cannot prepare Derive replace for {client_order_id}: {e:#}");
2263                    emit_modify_failure(
2264                        &emitter,
2265                        strategy_id,
2266                        instrument_id,
2267                        client_order_id,
2268                        Some(stale_venue_order_id),
2269                        CommandFailure::not_sent(e.to_string()),
2270                        clock.get_time_ns(),
2271                        Some(cmd.command_id),
2272                    );
2273                    dispatch_state.clear_pending_modify(&client_order_id);
2274                    return Ok(());
2275                }
2276            };
2277
2278            let expiry = match normal_order_signature_expiry(clock, signing.signature_expiry_secs) {
2279                Ok(expiry) => expiry,
2280                Err(e) => {
2281                    let reason = format!("replace expiry validation failed: {e}");
2282                    log::warn!("Cannot modify order {client_order_id}: {reason}");
2283                    let ts = clock.get_time_ns();
2284                    emit_modify_failure(
2285                        &emitter,
2286                        strategy_id,
2287                        instrument_id,
2288                        client_order_id,
2289                        Some(stale_venue_order_id),
2290                        CommandFailure::not_sent(&reason),
2291                        ts,
2292                        Some(cmd.command_id),
2293                    );
2294                    dispatch_state.clear_pending_modify(&client_order_id);
2295                    return Ok(());
2296                }
2297            };
2298
2299            let nonce = match resolve_modify_nonce(
2300                nonce_manager.next_nonce(&wallet_str, signing.subaccount_id),
2301                &emitter,
2302                strategy_id,
2303                instrument_id,
2304                client_order_id,
2305                stale_venue_order_id,
2306                clock,
2307                Some(cmd.command_id),
2308            ) {
2309                Some(nonce) => nonce,
2310                None => {
2311                    dispatch_state.clear_pending_modify(&client_order_id);
2312                    return Ok(());
2313                }
2314            };
2315
2316            let mut payload = match order_replace_to_derive_payload(
2317                &order_for_task,
2318                &instrument,
2319                signing.subaccount_id,
2320                signing.wallet_address,
2321                &signing.signer,
2322                nonce,
2323                expiry,
2324                signing.trade_module_address,
2325                signing.domain_separator,
2326                signing.action_typehash,
2327                signing.max_fee_per_contract,
2328                Some(remaining_amount),
2329                target_price.map(|p| p.as_decimal()),
2330                &voi_str,
2331            ) {
2332                Ok(p) => p,
2333                Err(e) => {
2334                    let reason = format!("replace encoding failed: {e}");
2335                    log::warn!("Cannot modify order {client_order_id}: {reason}");
2336                    let ts = clock.get_time_ns();
2337                    emit_modify_failure(
2338                        &emitter,
2339                        strategy_id,
2340                        instrument_id,
2341                        client_order_id,
2342                        Some(stale_venue_order_id),
2343                        CommandFailure::not_sent(&reason),
2344                        ts,
2345                        Some(cmd.command_id),
2346                    );
2347                    dispatch_state.clear_pending_modify(&client_order_id);
2348                    return Ok(());
2349                }
2350            };
2351
2352            payload.expected_filled_amount = Some(expected_filled_amount);
2353            enable_resting_order_mmp(&mut payload.order, cancel_on_disconnect);
2354
2355            {
2356                let _delivery = dispatch_state.delivery_guard();
2357                dispatch_state.record_modify_nonce(client_order_id, nonce);
2358            }
2359
2360            let outcome = ws_exec
2361                .modify_order_after_rate_limit(&payload, matching_reservation)
2362                .await;
2363
2364            let _delivery = dispatch_state.delivery_guard();
2365
2366            match outcome.map_err(|e| ws_command_failure(&e)) {
2367                Ok(response) => {
2368                    dispatch_state.record_replace_completion(client_order_id, ReplaceCompletion {
2369                        old_venue_order_id: stale_venue_order_id,
2370                        nonce,
2371                        identity: OrderIdentity {
2372                            instrument_id,
2373                            strategy_id,
2374                            order_side: order_for_task.order_side(),
2375                            order_type: order_for_task.order_type(),
2376                        },
2377                        result: response.result,
2378                        trades: response.trades,
2379                    });
2380
2381                    flush_pending_delivery(&emitter, account_id, clock, &dispatch_state);
2382                }
2383                Err((CommandFailure::Ambiguous(reason), _)) => {
2384                    log::warn!(
2385                        "Derive modify for {client_order_id} returned ambiguous WS outcome: {reason}; awaiting reconciliation",
2386                    );
2387                }
2388                Err((failure, _)) => {
2389                    if !dispatch_state.take_pending_modify(
2390                        &client_order_id,
2391                        stale_venue_order_id,
2392                        None,
2393                    ) {
2394                        log::debug!(
2395                            "Skipping private/replace rejection for {client_order_id}: an incoming terminal frame already resolved the modify",
2396                        );
2397                        return Ok(());
2398                    }
2399
2400                    dispatch_state.take_modify_target(&client_order_id);
2401                    log::debug!("Derive rejected modify for {client_order_id}: {failure:?}");
2402                    let ts = clock.get_time_ns();
2403                    emit_modify_failure(
2404                        &emitter,
2405                        strategy_id,
2406                        instrument_id,
2407                        client_order_id,
2408                        Some(stale_venue_order_id),
2409                        failure,
2410                        ts,
2411                        Some(cmd.command_id),
2412                    );
2413                }
2414            }
2415
2416            Ok(())
2417        });
2418
2419        Ok(())
2420    }
2421
2422    fn query_account(&self, _cmd: QueryAccount) -> anyhow::Result<()> {
2423        let http_client = self.http_client.clone();
2424        let subaccount_id = self.credential.subaccount_id();
2425        let emitter = self.emitter.clone();
2426        let clock = self.clock;
2427        self.spawn_task("query_account", async move {
2428            let subaccount = http_client
2429                .get_subaccount(&DeriveGetSubaccountParams::new(subaccount_id))
2430                .await?;
2431            let (balances, margins, info) = parse_derive_subaccount_to_balances(&subaccount)?;
2432            let ts_event = clock.get_time_ns();
2433            emitter.emit_account_state(balances, margins, true, ts_event, Some(info));
2434            Ok(())
2435        });
2436
2437        Ok(())
2438    }
2439
2440    fn query_order(&self, cmd: QueryOrder) -> anyhow::Result<()> {
2441        let context = self.reconciliation_context();
2442
2443        let report_cmd = GenerateOrderStatusReport::new(
2444            cmd.command_id,
2445            cmd.ts_init,
2446            Some(cmd.instrument_id),
2447            Some(cmd.client_order_id),
2448            cmd.venue_order_id,
2449            cmd.params,
2450            cmd.correlation_id,
2451        );
2452
2453        self.spawn_task(
2454            format!(
2455                "query_order client_order_id={}, venue_order_id={:?}",
2456                cmd.client_order_id, cmd.venue_order_id
2457            ),
2458            async move {
2459                let report = context
2460                    .generate_order_status_report(&report_cmd)
2461                    .await
2462                    .with_context(|| {
2463                        format!(
2464                            "failed to query Derive order: client_order_id={}, venue_order_id={:?}",
2465                            cmd.client_order_id, cmd.venue_order_id,
2466                        )
2467                    })?;
2468
2469                if let Some(report) = report {
2470                    context.emitter.send_order_status_report(report);
2471                } else {
2472                    log::debug!(
2473                        "Derive order not found: client_order_id={}, venue_order_id={:?}",
2474                        cmd.client_order_id,
2475                        cmd.venue_order_id,
2476                    );
2477                }
2478
2479                Ok(())
2480            },
2481        );
2482
2483        Ok(())
2484    }
2485}
2486
2487fn deduplicate_order_status_reports(
2488    reports: Vec<OrderStatusReport>,
2489) -> anyhow::Result<Vec<OrderStatusReport>> {
2490    let mut indices = AHashMap::new();
2491    let mut unique: Vec<OrderReportEvidence> = Vec::with_capacity(reports.len());
2492
2493    for report in reports {
2494        let Some(&index) = indices.get(&report.venue_order_id) else {
2495            indices.insert(report.venue_order_id, unique.len());
2496            unique.push(OrderReportEvidence {
2497                client_order_id: report.client_order_id,
2498                ts_terminal_first: report.order_status.is_closed().then_some(report.ts_last),
2499                ts_active_last: (!report.order_status.is_closed()).then_some(report.ts_last),
2500                report,
2501            });
2502
2503            continue;
2504        };
2505
2506        unique[index].observe(report)?;
2507    }
2508
2509    Ok(unique.into_iter().map(|evidence| evidence.report).collect())
2510}
2511
2512struct OrderReportEvidence {
2513    report: OrderStatusReport,
2514    client_order_id: Option<ClientOrderId>,
2515    ts_terminal_first: Option<UnixNanos>,
2516    ts_active_last: Option<UnixNanos>,
2517}
2518
2519impl OrderReportEvidence {
2520    fn observe(&mut self, report: OrderStatusReport) -> anyhow::Result<()> {
2521        let previous = &self.report;
2522        anyhow::ensure!(
2523            previous.account_id == report.account_id
2524                && previous.instrument_id == report.instrument_id
2525                && previous.order_side == report.order_side
2526                && previous.order_type == report.order_type
2527                && (self.client_order_id.is_none()
2528                    || report.client_order_id.is_none()
2529                    || self.client_order_id == report.client_order_id),
2530            "Conflicting Derive order identity for {}",
2531            report.venue_order_id,
2532        );
2533
2534        let consistent = if report.order_status.is_closed() {
2535            self.ts_active_last.is_none_or(|ts| ts <= report.ts_last)
2536        } else {
2537            self.ts_terminal_first.is_none_or(|ts| report.ts_last <= ts)
2538        };
2539
2540        anyhow::ensure!(
2541            consistent,
2542            "Conflicting Derive order status for {}",
2543            report.venue_order_id
2544        );
2545
2546        self.client_order_id = self.client_order_id.or(report.client_order_id);
2547        if report.order_status.is_closed() {
2548            self.ts_terminal_first = Some(
2549                self.ts_terminal_first
2550                    .map_or(report.ts_last, |ts| ts.min(report.ts_last)),
2551            );
2552        } else {
2553            self.ts_active_last = Some(
2554                self.ts_active_last
2555                    .map_or(report.ts_last, |ts| ts.max(report.ts_last)),
2556            );
2557        }
2558
2559        if report.ts_last > previous.ts_last
2560            || (report.ts_last == previous.ts_last
2561                && (report.order_status.is_closed()
2562                    || (!previous.order_status.is_closed()
2563                        && previous.client_order_id.is_none()
2564                        && report.client_order_id.is_some())))
2565        {
2566            self.report = report;
2567        }
2568
2569        Ok(())
2570    }
2571}
2572
2573fn create_ws_client(
2574    config: &DeriveExecutionClientConfig,
2575    credential: &DeriveCredential,
2576) -> anyhow::Result<DeriveWebSocketClient> {
2577    let credentials = DeriveWsCredentials::new(
2578        credential.wallet_address().to_string(),
2579        credential.session_key(),
2580    )
2581    .context("failed to build Derive WebSocket credentials")?;
2582    let mut ws_client = DeriveWebSocketClient::with_credentials(
2583        Some(config.ws_url()),
2584        config.environment,
2585        config.transport_backend,
2586        config
2587            .proxy_url
2588            .as_ref()
2589            .map(|value| value.expose_secret().to_owned()),
2590        credentials,
2591        config.max_matching_requests_per_second,
2592        config.max_per_instrument_matching_requests_per_second,
2593    );
2594
2595    if let Some(secs) = config.ws_timeout_secs {
2596        ws_client.set_request_timeout(Duration::from_secs(secs));
2597    }
2598
2599    Ok(ws_client)
2600}
2601
2602fn enable_resting_order_mmp(payload: &mut DeriveOrderParams, enabled: bool) {
2603    if enabled
2604        && payload.order_type == DeriveOrderType::Limit
2605        && payload.trigger_type.is_none()
2606        && matches!(
2607            payload.time_in_force,
2608            DeriveTimeInForce::Gtc | DeriveTimeInForce::PostOnly
2609        )
2610    {
2611        payload.mmp = Some(true);
2612    }
2613}
2614
2615fn log_report_receipt(count: usize, report_type: &str, level: LogLevel) {
2616    match level {
2617        LogLevel::Off => {}
2618        LogLevel::Trace => log::trace!("Received {count} {report_type} reports"),
2619        LogLevel::Debug => log::debug!("Received {count} {report_type} reports"),
2620        LogLevel::Info => log::info!("Received {count} {report_type} reports"),
2621        LogLevel::Warning => log::warn!("Received {count} {report_type} reports"),
2622        LogLevel::Error => log::error!("Received {count} {report_type} reports"),
2623    }
2624}
2625
2626impl Drop for DeriveExecutionClient {
2627    fn drop(&mut self) {
2628        self.cancellation_token.cancel();
2629        self.abort_session_tasks();
2630    }
2631}
2632
2633#[derive(Debug, Clone)]
2634struct ReconciliationSnapshotRequest {
2635    sender: Arc<dyn TimeEventSender>,
2636    next: Arc<Mutex<Option<PendingReconciliationSnapshot>>>,
2637    cancellation: CancellationToken,
2638    timeout: Duration,
2639}
2640
2641#[derive(Debug)]
2642struct PendingReconciliationSnapshot {
2643    message: TimeEventMessage,
2644    result: tokio::sync::oneshot::Receiver<(DeriveReconciliationContext, UnixNanos)>,
2645}
2646
2647impl ReconciliationSnapshotRequest {
2648    fn new(
2649        core: ExecutionClientCore,
2650        context: DeriveReconciliationContext,
2651        cancellation: CancellationToken,
2652        timeout: Duration,
2653    ) -> Option<Self> {
2654        let request = Self {
2655            sender: try_get_time_event_sender()?,
2656            next: Arc::new(Mutex::new(None)),
2657            cancellation,
2658            timeout,
2659        };
2660
2661        request.arm(core, context);
2662        Some(request)
2663    }
2664
2665    fn arm(&self, core: ExecutionClientCore, mut template: DeriveReconciliationContext) {
2666        template.orders = AHashMap::new();
2667        let next = Arc::downgrade(&self.next);
2668        let sender = Arc::clone(&self.sender);
2669        let cancellation = self.cancellation.clone();
2670        let timeout = self.timeout;
2671        let ts_init = template.clock.get_time_ns();
2672        let (response, result) = tokio::sync::oneshot::channel();
2673        let response = RefCell::new(Some(response));
2674
2675        let callback = TimeEventCallback::RustLocal(Rc::new(move |_| {
2676            if cancellation.is_cancelled() {
2677                return;
2678            }
2679
2680            let Some(next) = next.upgrade() else {
2681                return;
2682            };
2683
2684            let ts_init = template.clock.get_time_ns();
2685            let (orders, terminal_revision) =
2686                cached_order_bindings(&core, &template.dispatch_state);
2687            let mut context = template.clone();
2688            context.orders = orders;
2689            context.terminal_revision = terminal_revision;
2690
2691            let request = Self {
2692                sender: Arc::clone(&sender),
2693                next,
2694                cancellation: cancellation.clone(),
2695                timeout,
2696            };
2697
2698            request.arm(core.clone(), template.clone());
2699
2700            if let Some(response) = response.borrow_mut().take() {
2701                let _ = response.send((context, ts_init));
2702            }
2703        }));
2704
2705        let message = TimeEventMessage::new(
2706            TimeEvent::new(
2707                Ustr::from("derive-reconciliation"),
2708                UUID4::new(),
2709                ts_init,
2710                ts_init,
2711            ),
2712            callback,
2713        );
2714        *self.next.lock() = Some(PendingReconciliationSnapshot { message, result });
2715    }
2716
2717    async fn snapshot(&self) -> anyhow::Result<(DeriveReconciliationContext, UnixNanos)> {
2718        let pending = self
2719            .next
2720            .lock()
2721            .take()
2722            .context("Derive cache snapshot refresh is already pending")?;
2723        self.sender.send(pending.message);
2724        tokio::select! {
2725            biased;
2726            () = self.cancellation.cancelled() => anyhow::bail!("Derive cache snapshot refresh canceled"),
2727            result = time::timeout(self.timeout, pending.result) => {
2728                result.context("Derive cache snapshot refresh timed out")?
2729                    .context("Derive cache snapshot refresh stopped without a result")
2730            }
2731        }
2732    }
2733
2734    fn close(&self) {
2735        let pending = self.next.lock().take();
2736        drop(pending);
2737    }
2738}
2739
2740fn cached_order_bindings(
2741    core: &ExecutionClientCore,
2742    dispatch_state: &WsDispatchState,
2743) -> (AHashMap<ClientOrderId, OrderBinding>, Arc<()>) {
2744    let _delivery = dispatch_state.delivery_guard();
2745    let cache = core.cache();
2746    let orders = cache
2747        .orders_refs(Some(&core.venue), None, None, Some(&core.account_id), None)
2748        .into_iter()
2749        .filter(|order| cache.client_id(&order.client_order_id()) == Some(&core.client_id))
2750        .map(|order| {
2751            (
2752                order.client_order_id(),
2753                OrderBinding {
2754                    identity: OrderIdentity {
2755                        instrument_id: order.instrument_id(),
2756                        strategy_id: order.strategy_id(),
2757                        order_side: order.order_side(),
2758                        order_type: order.order_type(),
2759                    },
2760                    venue_order_id: order.venue_order_id(),
2761                    venue_order_legs: order.venue_order_ids().into_iter().copied().collect(),
2762                },
2763            )
2764        })
2765        .collect();
2766
2767    (orders, dispatch_state.terminal_revision())
2768}
2769
2770#[derive(Debug, Clone)]
2771struct DeriveReconciliationContext {
2772    http_client: DeriveHttpClient,
2773    emitter: ExecutionEventEmitter,
2774    client_id: ClientId,
2775    account_id: AccountId,
2776    subaccount_id: u64,
2777    clock: &'static AtomicTime,
2778    dispatch_state: Arc<WsDispatchState>,
2779    instruments: Arc<AtomicMap<InstrumentId, Arc<DeriveInstrument>>>,
2780    orders: AHashMap<ClientOrderId, OrderBinding>,
2781    terminal_revision: Arc<()>,
2782    report_observations: Option<Arc<Mutex<ReportObservations>>>,
2783    load_ids: Option<Vec<InstrumentId>>,
2784}
2785
2786impl DeriveReconciliationContext {
2787    async fn refresh_account_state(&self) -> anyhow::Result<()> {
2788        let value = self
2789            .http_client
2790            .get_subaccount(&DeriveGetSubaccountParams::new(self.subaccount_id))
2791            .await
2792            .context("failed to fetch Derive subaccount snapshot")?;
2793        self.emit_account_snapshot(&value)
2794    }
2795
2796    fn emit_account_snapshot(&self, snapshot: &DeriveSubaccount) -> anyhow::Result<()> {
2797        let (balances, margins, info) = parse_derive_subaccount_to_balances(snapshot)
2798            .context("failed to parse Derive subaccount balances")?;
2799        let ts_event = self.clock.get_time_ns();
2800        self.emitter
2801            .emit_account_state(balances, margins, true, ts_event, Some(info));
2802        Ok(())
2803    }
2804
2805    async fn recover_after_reconnect(&self, ts_init: UnixNanos) -> anyhow::Result<()> {
2806        self.refresh_account_state().await?;
2807        let mass_status = Box::pin(self.generate_mass_status(None, ts_init, false)).await?;
2808        let order_count = mass_status.order_reports().len();
2809        let fill_count: usize = mass_status.fill_reports().values().map(Vec::len).sum();
2810        let position_count = mass_status.position_reports().len();
2811        self.emitter
2812            .send_execution_report(ExecutionReport::MassStatus(Box::new(mass_status)));
2813        log::info!(
2814            "Derive post-reconnect reconciliation submitted: orders={order_count}, fills={fill_count}, positions={position_count}",
2815        );
2816        Ok(())
2817    }
2818
2819    async fn collect_order_status_reports(
2820        &self,
2821        cmd: &GenerateOrderStatusReports,
2822    ) -> anyhow::Result<Vec<OrderStatusReport>> {
2823        let mut reports = self
2824            .generate_order_status_reports(cmd)
2825            .await?
2826            .into_complete("order")?;
2827
2828        if !cmd.open_only {
2829            let mut active_cmd = cmd.clone();
2830            active_cmd.open_only = true;
2831            let active = self
2832                .generate_order_status_reports(&active_cmd)
2833                .await?
2834                .into_complete("active order")?;
2835            reports.extend(active);
2836        }
2837
2838        self.ensure_order_context()?;
2839        let reports = deduplicate_order_status_reports(reports)?;
2840        log_report_receipt(reports.len(), "OrderStatusReport", cmd.log_receipt_level);
2841        Ok(reports)
2842    }
2843
2844    async fn collect_fill_reports(
2845        &self,
2846        cmd: GenerateFillReports,
2847    ) -> anyhow::Result<Vec<FillReport>> {
2848        let log_level = cmd.log_receipt_level;
2849        let reports = self
2850            .generate_fill_reports(cmd, false)
2851            .await?
2852            .into_complete("fill")?;
2853        log_report_receipt(reports.len(), "FillReport", log_level);
2854        Ok(reports)
2855    }
2856
2857    async fn collect_position_status_reports(
2858        &self,
2859        cmd: &GeneratePositionStatusReports,
2860    ) -> anyhow::Result<Vec<PositionStatusReport>> {
2861        let snapshot = self.generate_position_status_snapshot(cmd).await?;
2862        log_report_receipt(
2863            snapshot.reports.len(),
2864            "PositionStatusReport",
2865            cmd.log_receipt_level,
2866        );
2867        Ok(snapshot.reports)
2868    }
2869
2870    async fn generate_order_status_report(
2871        &self,
2872        cmd: &GenerateOrderStatusReport,
2873    ) -> anyhow::Result<Option<OrderStatusReport>> {
2874        self.ensure_order_context()?;
2875        self.resolve_pending_modifies(cmd.instrument_id).await?;
2876        if cmd.venue_order_id.is_none() && cmd.client_order_id.is_none() {
2877            anyhow::bail!(
2878                "Derive generate_order_status_report requires venue_order_id or client_order_id"
2879            );
2880        }
2881
2882        let order = self.resolve_order_record(cmd).await?;
2883
2884        let Some(mut order) = order else {
2885            return Ok(None);
2886        };
2887
2888        anyhow::ensure!(
2889            instrument_in_scope(order.instrument_name.as_str(), self.load_ids.as_deref()),
2890            "Derive order probe returned an instrument outside reconciliation scope",
2891        );
2892
2893        let client_order_id = ClientOrderId::new_checked(order.label)
2894            .ok()
2895            .or(cmd.client_order_id);
2896
2897        if let Ok(venue_order_id) = VenueOrderId::new_checked(&order.order_id) {
2898            self.validate_report_binding(
2899                client_order_id,
2900                venue_order_id,
2901                format_instrument_id(order.instrument_name)?,
2902            )?;
2903        }
2904
2905        if let Some(binding) = client_order_id.and_then(|cid| self.order_binding(cid))
2906            && binding.identity.instrument_id == format_instrument_id(order.instrument_name)?
2907            && let Some(current) = binding.venue_order_id
2908            && order.order_id != current.as_str()
2909        {
2910            anyhow::ensure!(
2911                binding
2912                    .venue_order_legs
2913                    .iter()
2914                    .any(|id| id.as_str() == order.order_id),
2915                "Unknown native Derive order binding"
2916            );
2917            order = fetch_order_record(
2918                &self.http_client,
2919                self.subaccount_id,
2920                current,
2921                Some(binding.identity.instrument_id),
2922            )
2923            .await?;
2924        }
2925
2926        if let Some(instrument_id) = cmd.instrument_id
2927            && format_instrument_id(order.instrument_name)? != instrument_id
2928        {
2929            anyhow::bail!(
2930                "Derive order {} is for {} but report requested {}",
2931                order.order_id,
2932                order.instrument_name.as_str(),
2933                instrument_id,
2934            );
2935        }
2936
2937        let instrument_id = format_instrument_id(order.instrument_name)?;
2938        let client_order_id = ClientOrderId::new_checked(order.label)
2939            .ok()
2940            .or(cmd.client_order_id);
2941
2942        if let Ok(venue_order_id) = VenueOrderId::new_checked(&order.order_id) {
2943            self.validate_report_binding(client_order_id, venue_order_id, instrument_id)?;
2944        }
2945
2946        if tracked_order_identity(client_order_id, instrument_id, &self.dispatch_state).is_some() {
2947            self.prime_order_bindings(instrument_id).await?;
2948        }
2949
2950        let (price_precision, size_precision) = self.order_precision(&order)?;
2951        let ts_init = self.clock.get_time_ns();
2952
2953        let mut report = parse_derive_order_to_report_with_precision(
2954            &order,
2955            self.account_id,
2956            price_precision,
2957            size_precision,
2958            ts_init,
2959        )?;
2960
2961        // Prefer the parsed label (the venue's source of truth); only stamp
2962        // the cmd's id when the venue label is absent or unrepresentable.
2963        if report.client_order_id.is_none()
2964            && let Some(client_order_id) = cmd.client_order_id
2965        {
2966            report = report.with_client_order_id(client_order_id);
2967        }
2968
2969        self.observe_trigger_order(&order, &report);
2970        self.project_order_report(&order, report, &[], false)
2971            .await
2972            .map(Some)
2973    }
2974
2975    async fn prime_order_bindings(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
2976        for open_only in [true, false] {
2977            let cmd = GenerateOrderStatusReports::new(
2978                UUID4::new(),
2979                self.clock.get_time_ns(),
2980                open_only,
2981                Some(instrument_id),
2982                None,
2983                (!open_only).then(|| self.clock.get_time_ns()),
2984                None,
2985                None,
2986            );
2987
2988            self.ensure_order_context()?;
2989            self.resolve_pending_modifies(cmd.instrument_id).await?;
2990            let orders = self.collect_order_records(&cmd).await?;
2991            self.generate_order_status_reports_from_records(
2992                &cmd,
2993                orders,
2994                &AHashSet::new(),
2995                false,
2996                &[],
2997                false,
2998            )
2999            .await?;
3000        }
3001
3002        Ok(())
3003    }
3004
3005    async fn resolve_order_record(
3006        &self,
3007        cmd: &GenerateOrderStatusReport,
3008    ) -> anyhow::Result<Option<DeriveOrder>> {
3009        let subaccount_id = self.subaccount_id;
3010
3011        if let Some(venue_order_id) = cmd.venue_order_id {
3012            return match fetch_order_record(
3013                &self.http_client,
3014                subaccount_id,
3015                venue_order_id,
3016                cmd.instrument_id,
3017            )
3018            .await
3019            {
3020                Ok(order) => Ok(Some(order)),
3021                Err(e) => {
3022                    let triggers = self
3023                        .http_client
3024                        .get_trigger_orders(&DeriveGetTriggerOrdersParams::new(subaccount_id))
3025                        .await?
3026                        .orders;
3027
3028                    match triggers
3029                        .into_iter()
3030                        .find(|order| order.order_id.as_str() == venue_order_id.as_str())
3031                    {
3032                        Some(order) => Ok(Some(order)),
3033                        None => Err(e),
3034                    }
3035                }
3036            };
3037        }
3038
3039        let label = cmd
3040            .client_order_id
3041            .expect("report target checked before resolution");
3042        let orders = self
3043            .http_client
3044            .get_open_orders(&DeriveGetOpenOrdersParams::new(subaccount_id))
3045            .await?
3046            .orders;
3047
3048        if let Some(order) = orders
3049            .into_iter()
3050            .find(|order| order.label == label.as_str())
3051        {
3052            return Ok(Some(order));
3053        }
3054
3055        let triggers = self
3056            .http_client
3057            .get_trigger_orders(&DeriveGetTriggerOrdersParams::new(subaccount_id))
3058            .await?
3059            .orders;
3060
3061        if let Some(order) = triggers
3062            .into_iter()
3063            .find(|order| order.label == label.as_str())
3064        {
3065            return Ok(Some(order));
3066        }
3067
3068        let instrument_name = cmd.instrument_id.map(|id| id.symbol.as_str().to_string());
3069        let mut pages = PaginationCursor::new();
3070
3071        loop {
3072            let mut params = DeriveGetOrderHistoryParams::new(
3073                subaccount_id,
3074                pages.page(),
3075                DERIVE_PRIVATE_PAGE_SIZE,
3076            );
3077
3078            if let Some(name) = instrument_name.as_deref() {
3079                params = params.with_instrument_name(name);
3080            }
3081
3082            let result = self.http_client.get_order_history(&params).await?;
3083            if pages.restart_if_changed(&result.pagination)? {
3084                continue;
3085            }
3086
3087            let more = pages.advance(
3088                &result.pagination,
3089                result.orders.iter().map(|order| order.order_id.as_str()),
3090            )?;
3091
3092            if let Some(order) = result
3093                .orders
3094                .into_iter()
3095                .find(|order| order.label == label.as_str())
3096            {
3097                return Ok(Some(order));
3098            }
3099
3100            if !more {
3101                return Ok(None);
3102            }
3103        }
3104    }
3105
3106    async fn generate_order_status_reports(
3107        &self,
3108        cmd: &GenerateOrderStatusReports,
3109    ) -> anyhow::Result<CollectedReports<OrderStatusReport>> {
3110        self.ensure_order_context()?;
3111        self.resolve_pending_modifies(cmd.instrument_id).await?;
3112        let orders = self.collect_scoped_order_records(cmd).await?;
3113
3114        let mut reports = self
3115            .generate_order_status_reports_from_records(
3116                cmd,
3117                orders,
3118                &AHashSet::new(),
3119                false,
3120                &[],
3121                false,
3122            )
3123            .await?;
3124        retain_order_status_reports(&mut reports.reports, cmd);
3125        Ok(reports)
3126    }
3127
3128    async fn generate_order_status_reports_from_records(
3129        &self,
3130        cmd: &GenerateOrderStatusReports,
3131        orders: Vec<DeriveOrder>,
3132        ambiguous_client_order_ids: &AHashSet<Ustr>,
3133        strict: bool,
3134        ancestors: &[DeriveOrder],
3135        recover_uncached: bool,
3136    ) -> anyhow::Result<CollectedReports<OrderStatusReport>> {
3137        self.ensure_order_context()?;
3138        let mut complete = true;
3139        let mut records_complete = true;
3140
3141        let ts_init = self.clock.get_time_ns();
3142
3143        let orders: Vec<DeriveOrder> = orders
3144            .into_iter()
3145            .filter(|order| {
3146                cmd.instrument_id.is_none_or(|instrument_id| {
3147                    format_instrument_id(order.instrument_name)
3148                        .map_or(true, |id| id == instrument_id)
3149                })
3150            })
3151            .collect();
3152
3153        let mut reports = Vec::with_capacity(orders.len());
3154
3155        let known_orders: Vec<_> = orders.iter().chain(ancestors).collect();
3156
3157        for order in &orders {
3158            self.observe_order_binding(order)?;
3159            ensure_bindings_resolved(&self.dispatch_state, cmd.instrument_id)?;
3160            let (price_precision, size_precision) = self.order_precision(order)?;
3161            complete &= price_precision.is_some();
3162
3163            match parse_derive_order_to_report_with_precision(
3164                order,
3165                self.account_id,
3166                price_precision,
3167                size_precision,
3168                ts_init,
3169            ) {
3170                Ok(mut report) => {
3171                    self.validate_report_binding(
3172                        report.client_order_id,
3173                        report.venue_order_id,
3174                        report.instrument_id,
3175                    )?;
3176                    self.observe_trigger_order(order, &report);
3177                    if report
3178                        .client_order_id
3179                        .and_then(|cid| self.order_binding(cid))
3180                        .is_none()
3181                        && report.client_order_id.is_some_and(|client_order_id| {
3182                            ambiguous_client_order_ids.contains(&client_order_id.inner())
3183                        })
3184                    {
3185                        anyhow::ensure!(
3186                            order.replaced_order_id.is_none() || report.order_status.is_closed(),
3187                            "Ambiguous native replacement chain for {}",
3188                            order.label,
3189                        );
3190                        report.client_order_id = None;
3191                    }
3192
3193                    reports.push(
3194                        self.project_order_report(order, report, &known_orders, recover_uncached)
3195                            .await?,
3196                    );
3197                }
3198                Err(e) if cmd.open_only => {
3199                    return Err(e.context(format!(
3200                        "failed to parse active Derive order {:?} on {}",
3201                        order.order_id, order.instrument_name,
3202                    )));
3203                }
3204                Err(e) if strict => return Err(e),
3205                Err(e) => {
3206                    records_complete = false;
3207                    log::warn!(
3208                        "Skipping Derive order {:?} on {:?} in status report: {:?}",
3209                        order.order_id,
3210                        order.instrument_name.as_str(),
3211                        format!("{e:#}"),
3212                    );
3213                }
3214            }
3215        }
3216
3217        self.ensure_order_context()?;
3218        let reports = deduplicate_order_status_reports(reports)?;
3219        Ok(CollectedReports {
3220            reports,
3221            complete: complete && records_complete,
3222            records_complete,
3223        })
3224    }
3225
3226    async fn resolve_pending_modifies(
3227        &self,
3228        instrument_id: Option<InstrumentId>,
3229    ) -> anyhow::Result<()> {
3230        if self.report_observations.is_some() {
3231            return ensure_bindings_resolved(&self.dispatch_state, instrument_id);
3232        }
3233
3234        while let Some(client_order_id) = {
3235            let _delivery = self.dispatch_state.delivery_guard();
3236            self.dispatch_state
3237                .unresolved_client_order_id(instrument_id)
3238        } {
3239            let identity = self
3240                .dispatch_state
3241                .identity(&client_order_id)
3242                .ok_or(UnresolvedOrderBinding(client_order_id))?;
3243            let parent = self
3244                .dispatch_state
3245                .pending_modify(&client_order_id)
3246                .ok_or(UnresolvedOrderBinding(client_order_id))?;
3247            let nonce = self
3248                .dispatch_state
3249                .modify_nonce(&client_order_id)
3250                .ok_or(UnresolvedOrderBinding(client_order_id))?;
3251            let ts_init = self.clock.get_time_ns();
3252            let mut candidate = None;
3253
3254            for open_only in [true, false] {
3255                let records = self
3256                    .collect_order_records(&GenerateOrderStatusReports::new(
3257                        UUID4::new(),
3258                        ts_init,
3259                        open_only,
3260                        Some(identity.instrument_id),
3261                        Some(UnixNanos::from(nonce.saturating_sub(NONCE_FUTURE_NS))),
3262                        None,
3263                        None,
3264                        None,
3265                    ))
3266                    .await?;
3267                candidate = records.into_iter().find(|order| {
3268                    order.label == client_order_id.as_str()
3269                        && order.replaced_order_id.as_deref() == Some(parent.as_str())
3270                        && order.nonce == nonce
3271                });
3272
3273                if candidate.is_some() {
3274                    break;
3275                }
3276            }
3277
3278            let order = candidate.ok_or(UnresolvedOrderBinding(client_order_id))?;
3279            let venue_order_id = VenueOrderId::new_checked(&order.order_id)?;
3280            validate_replacement_order(
3281                &order,
3282                client_order_id,
3283                identity,
3284                &self.dispatch_state,
3285                venue_order_id,
3286                venue_order_id,
3287            )?;
3288            let _delivery = self.dispatch_state.delivery_guard();
3289            self.ensure_order_context()?;
3290            dispatch_order_row(
3291                &order,
3292                &self.emitter,
3293                self.account_id,
3294                self.clock,
3295                &self.dispatch_state,
3296                ts_init,
3297            );
3298            ensure_order_binding_resolved(&self.dispatch_state, client_order_id)?;
3299        }
3300
3301        Ok(())
3302    }
3303
3304    async fn collect_scoped_order_records(
3305        &self,
3306        cmd: &GenerateOrderStatusReports,
3307    ) -> anyhow::Result<Vec<DeriveOrder>> {
3308        let mut orders = self.collect_order_records(cmd).await?;
3309        orders.retain(|order| {
3310            instrument_in_scope(order.instrument_name.as_str(), self.load_ids.as_deref())
3311        });
3312
3313        Ok(orders)
3314    }
3315
3316    async fn collect_order_records(
3317        &self,
3318        cmd: &GenerateOrderStatusReports,
3319    ) -> anyhow::Result<Vec<DeriveOrder>> {
3320        let instrument_name = cmd.instrument_id.map(|id| id.symbol.as_str().to_string());
3321
3322        let orders = if cmd.open_only {
3323            let mut orders = self
3324                .http_client
3325                .get_open_orders(&DeriveGetOpenOrdersParams::new(self.subaccount_id))
3326                .await?
3327                .orders;
3328            orders.extend(
3329                self.http_client
3330                    .get_trigger_orders(&DeriveGetTriggerOrdersParams::new(self.subaccount_id))
3331                    .await?
3332                    .orders,
3333            );
3334            orders
3335        } else {
3336            let start_ms = cmd.start.map(|t| t.as_millis() as i64);
3337            let end_ms = cmd.end.map(|t| t.as_millis() as i64);
3338            let mut pages = PaginationCursor::new();
3339            let mut collected = Vec::new();
3340
3341            loop {
3342                let mut params = DeriveGetOrderHistoryParams::new(
3343                    self.subaccount_id,
3344                    pages.page(),
3345                    DERIVE_PRIVATE_PAGE_SIZE,
3346                )
3347                .with_window(start_ms, end_ms);
3348
3349                if let Some(name) = instrument_name.as_deref() {
3350                    params = params.with_instrument_name(name);
3351                }
3352
3353                let result = self.http_client.get_order_history(&params).await?;
3354                if pages.restart_if_changed(&result.pagination)? {
3355                    collected.clear();
3356                    continue;
3357                }
3358
3359                let more = pages.advance(
3360                    &result.pagination,
3361                    result.orders.iter().map(|order| order.order_id.as_str()),
3362                )?;
3363                collected.extend(result.orders);
3364
3365                if !more {
3366                    anyhow::ensure!(pages.is_complete(), "incomplete Derive order history");
3367                    break;
3368                }
3369            }
3370
3371            collected
3372        };
3373
3374        Ok(orders)
3375    }
3376
3377    fn ensure_order_context(&self) -> anyhow::Result<()> {
3378        let _delivery = self.dispatch_state.delivery_guard();
3379        anyhow::ensure!(
3380            Arc::ptr_eq(
3381                &self.terminal_revision,
3382                &self.dispatch_state.terminal_revision()
3383            ),
3384            "Derive order context expired after terminal binding eviction; retry with a fresh cache snapshot",
3385        );
3386        Ok(())
3387    }
3388
3389    fn order_binding(&self, client_order_id: ClientOrderId) -> Option<OrderBinding> {
3390        let binding = self
3391            .dispatch_state
3392            .order_binding(&client_order_id)
3393            .or_else(|| self.orders.get(&client_order_id).cloned());
3394
3395        if let Some(observations) = &self.report_observations {
3396            observations
3397                .lock()
3398                .bindings
3399                .push((client_order_id, binding.clone()));
3400        }
3401
3402        binding
3403    }
3404
3405    async fn project_order_report(
3406        &self,
3407        order: &DeriveOrder,
3408        mut report: OrderStatusReport,
3409        known_orders: &[&DeriveOrder],
3410        recover_uncached: bool,
3411    ) -> anyhow::Result<OrderStatusReport> {
3412        self.ensure_order_context()?;
3413
3414        let Some(client_order_id) = report.client_order_id else {
3415            return Ok(report);
3416        };
3417
3418        let Some(binding) = self
3419            .order_binding(client_order_id)
3420            .filter(|binding| binding.identity.instrument_id == report.instrument_id)
3421        else {
3422            if recover_uncached
3423                && report.order_status.is_open()
3424                && order.replaced_order_id.is_some()
3425            {
3426                let identity = OrderIdentity {
3427                    instrument_id: report.instrument_id,
3428                    strategy_id: StrategyId::from("EXTERNAL"),
3429                    order_side: report
3430                        .order_side
3431                        .context("missing native replacement side")?,
3432                    order_type: report.order_type,
3433                };
3434
3435                let legs = replacement_orders(
3436                    &self.http_client,
3437                    &self.dispatch_state,
3438                    client_order_id,
3439                    identity,
3440                    order.clone(),
3441                    Vec::new(),
3442                    known_orders,
3443                )
3444                .await
3445                .context(UnresolvedOrderBinding(client_order_id))?;
3446                self.project_replacement_history(order, &legs, &mut report)
3447                    .context(UnresolvedOrderBinding(client_order_id))?;
3448                self.ensure_order_context()?;
3449                anyhow::ensure!(
3450                    self.order_binding(client_order_id).is_none(),
3451                    "Native replacement binding changed during report collection",
3452                );
3453            }
3454
3455            return Ok(report);
3456        };
3457
3458        let Some(current) = binding.venue_order_id else {
3459            return Err(UnresolvedOrderBinding(client_order_id).into());
3460        };
3461
3462        if report.venue_order_id != current {
3463            if !binding.venue_order_legs.contains(&report.venue_order_id) {
3464                return Err(UnresolvedOrderBinding(client_order_id).into());
3465            }
3466
3467            validate_replacement_order(
3468                order,
3469                client_order_id,
3470                binding.identity,
3471                &self.dispatch_state,
3472                report.venue_order_id,
3473                current,
3474            )?;
3475            return Ok(report);
3476        }
3477
3478        if binding.venue_order_legs.len() <= 1 && order.replaced_order_id.is_none() {
3479            return Ok(report);
3480        }
3481
3482        let legs = replacement_orders(
3483            &self.http_client,
3484            &self.dispatch_state,
3485            client_order_id,
3486            binding.identity,
3487            order.clone(),
3488            binding.venue_order_legs.clone(),
3489            &[],
3490        )
3491        .await?;
3492        self.project_replacement_history(order, &legs, &mut report)?;
3493        let _delivery = self.dispatch_state.delivery_guard();
3494        self.ensure_order_context()?;
3495        ensure_bindings_resolved(&self.dispatch_state, Some(report.instrument_id))?;
3496
3497        if self.order_binding(client_order_id).as_ref() != Some(&binding) {
3498            return Err(UnresolvedOrderBinding(client_order_id).into());
3499        }
3500
3501        Ok(report)
3502    }
3503
3504    fn project_replacement_history(
3505        &self,
3506        order: &DeriveOrder,
3507        legs: &[DeriveOrder],
3508        report: &mut OrderStatusReport,
3509    ) -> anyhow::Result<()> {
3510        let mut filled = Decimal::ZERO;
3511        let mut ancestor_filled = Decimal::ZERO;
3512        let mut notional = Decimal::ZERO;
3513        let mut average_complete = true;
3514
3515        for leg in legs {
3516            filled = filled
3517                .checked_add(leg.filled_amount)
3518                .context("native cumulative fills exceed decimal range")?;
3519
3520            if leg.order_id != order.order_id {
3521                ancestor_filled = ancestor_filled
3522                    .checked_add(leg.filled_amount)
3523                    .context("native ancestor fills exceed decimal range")?;
3524            }
3525
3526            if leg.filled_amount > Decimal::ZERO {
3527                if leg.average_price <= Decimal::ZERO {
3528                    average_complete = false;
3529                } else {
3530                    let value = leg
3531                        .filled_amount
3532                        .checked_mul(leg.average_price)
3533                        .context("native fill notional exceeds decimal range")?;
3534                    notional = notional
3535                        .checked_add(value)
3536                        .context("native cumulative notional exceeds decimal range")?;
3537                }
3538            }
3539        }
3540
3541        report.ts_accepted = crate::http::parse::ms_to_nanos(
3542            legs.iter()
3543                .map(|leg| leg.creation_timestamp)
3544                .min()
3545                .unwrap_or(order.creation_timestamp),
3546        );
3547        let quantity = order
3548            .amount
3549            .checked_add(ancestor_filled)
3550            .context("native logical quantity exceeds decimal range")?;
3551        let (_, size_precision) = self.order_precision(order)?;
3552        report.quantity = quantity_from_report_decimal(quantity, size_precision)?;
3553        report.filled_qty = quantity_from_report_decimal(filled, size_precision)?;
3554        report.avg_px = if filled > Decimal::ZERO && average_complete {
3555            Some(
3556                notional
3557                    .checked_div(filled)
3558                    .context("native cumulative average cannot be represented")?,
3559            )
3560        } else {
3561            None
3562        };
3563
3564        if report.order_status == OrderStatus::Accepted && filled > Decimal::ZERO {
3565            report.order_status = OrderStatus::PartiallyFilled;
3566        }
3567
3568        Ok(())
3569    }
3570
3571    async fn generate_fill_reports(
3572        &self,
3573        cmd: GenerateFillReports,
3574        retain_untracked: bool,
3575    ) -> anyhow::Result<CollectedReports<FillReport>> {
3576        self.resolve_pending_modifies(cmd.instrument_id).await?;
3577        let (all_trades, mut records_complete) = self.collect_trade_records(&cmd).await?;
3578        let mut complete = true;
3579
3580        let ts_init = self.clock.get_time_ns();
3581        let venue_order_id_filter = cmd
3582            .venue_order_id
3583            .as_ref()
3584            .map(|id| id.as_str().to_string());
3585
3586        let mut reports = Vec::with_capacity(all_trades.len());
3587        let mut seen_trade_ids = AHashSet::new();
3588
3589        for trade in all_trades {
3590            if !instrument_in_scope(trade.instrument_name.as_str(), self.load_ids.as_deref()) {
3591                continue;
3592            }
3593
3594            if let Some(target) = venue_order_id_filter.as_deref()
3595                && !trade.order_id.is_empty()
3596                && trade.order_id != target
3597            {
3598                continue;
3599            }
3600
3601            let (price_precision, size_precision) =
3602                self.report_precision(trade.instrument_name.as_str(), false)?;
3603            complete &= price_precision.is_some();
3604
3605            match parse_derive_trade_to_fill_report_with_precision(
3606                &trade,
3607                self.account_id,
3608                Currency::USDC(),
3609                price_precision,
3610                size_precision,
3611                ts_init,
3612            ) {
3613                Ok(Some(report)) => {
3614                    self.validate_report_binding(
3615                        report.client_order_id,
3616                        report.venue_order_id,
3617                        report.instrument_id,
3618                    )?;
3619                    self.observe_trigger_fill(&report);
3620                    let retain = retain_untracked
3621                        && report
3622                            .client_order_id
3623                            .is_some_and(|id| self.order_binding(id).is_none());
3624
3625                    if self.dispatch_state.contains_trade(&report.trade_id) && !retain
3626                        || !seen_trade_ids.insert(report.trade_id)
3627                    {
3628                        log::debug!(
3629                            "Skipping duplicate Derive fill (trade_id={}) in generate_fill_reports",
3630                            report.trade_id,
3631                        );
3632                        continue;
3633                    }
3634
3635                    reports.push(report);
3636                }
3637                Ok(None) => records_complete = false,
3638                Err(e) if e.is::<CommissionError>() => {
3639                    return Err(e.context(format!(
3640                        "failed to construct Derive fill {:?} for order {:?} on {:?}",
3641                        trade.trade_id,
3642                        trade.order_id,
3643                        trade.instrument_name.as_str(),
3644                    )));
3645                }
3646                Err(e) => {
3647                    records_complete = false;
3648                    log::warn!(
3649                        "Skipping Derive trade {:?} for order {:?} on {:?} in fill report: {:?}",
3650                        trade.trade_id,
3651                        trade.order_id,
3652                        trade.instrument_name.as_str(),
3653                        format!("{e:#}"),
3654                    );
3655                }
3656            }
3657        }
3658
3659        Ok(CollectedReports {
3660            reports,
3661            complete: complete && records_complete,
3662            records_complete,
3663        })
3664    }
3665
3666    async fn collect_trade_records(
3667        &self,
3668        cmd: &GenerateFillReports,
3669    ) -> anyhow::Result<(Vec<DeriveTrade>, bool)> {
3670        let mut records_complete = true;
3671        let instrument_name = cmd.instrument_id.map(|id| id.symbol.as_str().to_string());
3672        let mut pages = PaginationCursor::new();
3673        let mut all_trades: Vec<DeriveTrade> = Vec::new();
3674
3675        loop {
3676            let mut params = DeriveGetTradeHistoryParams::new(
3677                self.subaccount_id,
3678                pages.page(),
3679                DERIVE_PRIVATE_PAGE_SIZE,
3680            )
3681            .with_window(
3682                cmd.start.map(|t| t.as_millis() as i64),
3683                cmd.end.map(|t| t.as_millis() as i64),
3684            );
3685
3686            if let Some(name) = instrument_name.as_deref() {
3687                params = params.with_instrument_name(name);
3688            }
3689
3690            let result = self.http_client.get_private_trade_history(&params).await?;
3691            if pages.restart_if_changed(&result.pagination)? {
3692                all_trades.clear();
3693                records_complete = true;
3694                continue;
3695            }
3696
3697            records_complete &= result.records_complete;
3698            let more = pages.advance(
3699                &result.pagination,
3700                result.trades.iter().map(|trade| trade.trade_id.as_str()),
3701            )?;
3702            all_trades.extend(result.trades);
3703
3704            if !more {
3705                break;
3706            }
3707        }
3708
3709        Ok((all_trades, records_complete && pages.is_complete()))
3710    }
3711
3712    async fn generate_position_status_snapshot(
3713        &self,
3714        cmd: &GeneratePositionStatusReports,
3715    ) -> anyhow::Result<PositionStatusSnapshot> {
3716        let positions = self
3717            .http_client
3718            .get_positions(&DeriveGetPositionsParams::new(self.subaccount_id))
3719            .await?
3720            .positions;
3721        let ts_init = self.clock.get_time_ns();
3722        let mut reports = Vec::with_capacity(positions.len());
3723        let mut instruments = AHashSet::with_capacity(positions.len());
3724
3725        for position in positions {
3726            if !instrument_in_scope(position.instrument_name.as_str(), self.load_ids.as_deref()) {
3727                continue;
3728            }
3729
3730            let instrument_id = format_instrument_id(position.instrument_name)?;
3731
3732            if let Some(target) = cmd.instrument_id
3733                && instrument_id != target
3734            {
3735                continue;
3736            }
3737
3738            instruments.insert(instrument_id);
3739
3740            let (_, size_precision) =
3741                self.report_precision(position.instrument_name.as_str(), true)?;
3742            let report = parse_derive_position_to_report_with_precision(
3743                &position,
3744                self.account_id,
3745                size_precision,
3746                ts_init,
3747            )?;
3748            reports.push(report);
3749        }
3750
3751        Ok(PositionStatusSnapshot {
3752            reports,
3753            instruments,
3754        })
3755    }
3756
3757    async fn generate_mass_status(
3758        &self,
3759        lookback_mins: Option<u64>,
3760        ts_now: UnixNanos,
3761        recover_uncached: bool,
3762    ) -> anyhow::Result<ExecutionMassStatus> {
3763        self.ensure_order_context()?;
3764        log::info!("Generating ExecutionMassStatus (lookback_mins={lookback_mins:?})");
3765
3766        let start = lookback_mins
3767            .map(DurationNanos::try_from_mins)
3768            .transpose()?
3769            .map(|lookback| ts_now.saturating_sub(lookback));
3770
3771        let open_order_cmd = GenerateOrderStatusReports::new(
3772            UUID4::new(),
3773            ts_now,
3774            true,
3775            None,
3776            None,
3777            None,
3778            None,
3779            None,
3780        );
3781
3782        let history_order_cmd = GenerateOrderStatusReports::new(
3783            UUID4::new(),
3784            ts_now,
3785            false,
3786            None,
3787            start,
3788            None,
3789            None,
3790            None,
3791        );
3792        let fill_cmd =
3793            GenerateFillReports::new(UUID4::new(), ts_now, None, None, start, None, None, None);
3794        let position_cmd =
3795            GeneratePositionStatusReports::new(UUID4::new(), ts_now, None, None, None, None, None);
3796
3797        let (history, open, fills, positions) = tokio::join!(
3798            async {
3799                self.ensure_order_context()?;
3800                self.resolve_pending_modifies(None).await?;
3801                self.collect_scoped_order_records(&history_order_cmd)
3802                    .await
3803                    .map(|reports| CollectedReports {
3804                        reports,
3805                        complete: true,
3806                        records_complete: true,
3807                    })
3808            },
3809            async {
3810                self.ensure_order_context()?;
3811                self.resolve_pending_modifies(None).await?;
3812                self.collect_scoped_order_records(&open_order_cmd)
3813                    .await
3814                    .map(|reports| CollectedReports {
3815                        reports,
3816                        complete: true,
3817                        records_complete: true,
3818                    })
3819            },
3820            self.generate_fill_reports(fill_cmd, recover_uncached),
3821            self.generate_position_status_snapshot(&position_cmd),
3822        );
3823        let history = collect_mass_reports(history, "order history", start.is_some())?;
3824        let open = collect_mass_reports(open, "open orders", start.is_some())?;
3825
3826        let fills = match fills {
3827            Err(e)
3828                if e.downcast_ref::<DeriveHttpError>().is_some_and(|cause| {
3829                    matches!(
3830                        cause,
3831                        DeriveHttpError::Decode(_) | DeriveHttpError::Serde(_)
3832                    )
3833                }) =>
3834            {
3835                return Err(e);
3836            }
3837            other => collect_mass_reports(other, "fill history", start.is_some())?,
3838        };
3839
3840        let positions_complete = positions.is_ok();
3841
3842        let position_snapshot = match positions {
3843            Ok(snapshot) => snapshot,
3844            Err(e) if start.is_some() && e.is::<DeriveHttpError>() => {
3845                log::warn!("Derive position source failed: {e:#}");
3846
3847                PositionStatusSnapshot {
3848                    reports: Vec::new(),
3849                    instruments: AHashSet::new(),
3850                }
3851            }
3852            Err(e) => return Err(e),
3853        };
3854
3855        let mut records_complete = history.records_complete
3856            && open.records_complete
3857            && fills.records_complete
3858            && positions_complete;
3859        let mut reports_complete =
3860            history.complete && open.complete && fills.complete && positions_complete;
3861        let mut fill_reports = fills.reports;
3862        let fill_order_ids: AHashSet<_> = fill_reports
3863            .iter()
3864            .map(|report| report.venue_order_id)
3865            .collect();
3866        let companions = self
3867            .collect_companion_order_records(
3868                &history,
3869                &open.reports,
3870                &fill_reports,
3871                start.is_some(),
3872            )
3873            .await?;
3874        reports_complete &= companions.complete;
3875        records_complete &= companions.records_complete;
3876        let ambiguous_client_order_ids = ambiguous_history_client_order_ids(
3877            history
3878                .reports
3879                .iter()
3880                .chain(open.reports.iter())
3881                .chain(companions.reports.iter()),
3882        );
3883        let ambiguous_open_client_order_ids = AHashSet::new();
3884
3885        let replaced_order_ids: AHashSet<_> = history
3886            .reports
3887            .iter()
3888            .chain(open.reports.iter())
3889            .chain(companions.reports.iter())
3890            .filter_map(|order| {
3891                order
3892                    .replaced_order_id
3893                    .as_deref()
3894                    .map(|id| (order.label, id))
3895            })
3896            .collect();
3897
3898        anyhow::ensure!(
3899            !recover_uncached
3900                || !open.reports.iter().any(|order| {
3901                    (order.replaced_order_id.is_some()
3902                        && ambiguous_client_order_ids.contains(&order.label)
3903                        || replaced_order_ids.contains(&(order.label, order.order_id.as_str())))
3904                        && ClientOrderId::new_checked(order.label)
3905                            .is_ok_and(|cid| self.order_binding(cid).is_none())
3906                }),
3907            "Invalid native replacement head in open orders",
3908        );
3909        let ancestors: Vec<_> = history
3910            .reports
3911            .iter()
3912            .chain(open.reports.iter())
3913            .chain(companions.reports.iter())
3914            .cloned()
3915            .collect();
3916        let (history, open, companions) = tokio::join!(
3917            self.generate_order_status_reports_from_records(
3918                &history_order_cmd,
3919                history.reports,
3920                &ambiguous_client_order_ids,
3921                false,
3922                &ancestors,
3923                recover_uncached,
3924            ),
3925            self.generate_order_status_reports_from_records(
3926                &open_order_cmd,
3927                open.reports,
3928                &ambiguous_open_client_order_ids,
3929                false,
3930                &ancestors,
3931                recover_uncached,
3932            ),
3933            self.generate_order_status_reports_from_records(
3934                &history_order_cmd,
3935                companions.reports,
3936                &ambiguous_client_order_ids,
3937                true,
3938                &ancestors,
3939                recover_uncached,
3940            ),
3941        );
3942        let history = collect_mass_reports(history, "order history", start.is_some())?;
3943        let open = collect_mass_reports(open, "open orders", start.is_some())?;
3944        let companions = companions?;
3945        reports_complete &= history.complete && open.complete && companions.complete;
3946        records_complete &=
3947            history.records_complete && open.records_complete && companions.records_complete;
3948        anyhow::ensure!(
3949            !recover_uncached
3950                || records_complete
3951                || !ancestors.iter().any(|order| {
3952                    order.replaced_order_id.is_some()
3953                        && derive_status_to_nautilus(
3954                            order.order_status,
3955                            order.filled_amount,
3956                            order.amount,
3957                        )
3958                        .is_ok_and(|status| status.is_open())
3959                        && ClientOrderId::new_checked(order.label)
3960                            .is_ok_and(|id| self.order_binding(id).is_none())
3961                }),
3962            "Incomplete reports for uncached replacement",
3963        );
3964        let open_order_reports = open.reports;
3965
3966        if recover_uncached
3967            && let Some(earliest) =
3968                self.replacement_lookback_start(start, &open_order_reports, &ancestors)
3969        {
3970            let lookback = ts_now.saturating_duration_since(earliest).as_mins() + 1;
3971            return Box::pin(self.generate_mass_status(Some(lookback), ts_now, recover_uncached))
3972                .await;
3973        }
3974
3975        let (mut history_order_reports, retained_companion_reports): (Vec<_>, Vec<_>) = history
3976            .reports
3977            .into_iter()
3978            .partition(|report| !fill_order_ids.contains(&report.venue_order_id));
3979        retain_order_status_reports(&mut history_order_reports, &history_order_cmd);
3980        history_order_reports.extend(retained_companion_reports);
3981        history_order_reports.extend(companions.reports);
3982        history_order_reports.sort_by_key(|report| {
3983            let is_current = report
3984                .client_order_id
3985                .and_then(|cid| self.order_binding(cid))
3986                .is_some_and(|binding| binding.venue_order_id == Some(report.venue_order_id));
3987            (is_current, report.ts_last)
3988        });
3989
3990        let order_evidence: AHashSet<_> = history_order_reports
3991            .iter()
3992            .chain(open_order_reports.iter())
3993            .map(|report| (report.venue_order_id, report.instrument_id))
3994            .collect();
3995
3996        for report in &fill_reports {
3997            if !order_evidence.contains(&(report.venue_order_id, report.instrument_id)) {
3998                reports_complete = false;
3999                records_complete = false;
4000                log::warn!(
4001                    "Derive fill {} for order {} on {} has no matching order report; coverage is incomplete",
4002                    report.trade_id,
4003                    report.venue_order_id,
4004                    report.instrument_id,
4005                );
4006            }
4007        }
4008
4009        anyhow::ensure!(
4010            start.is_some() || records_complete,
4011            "incomplete unbounded Derive report coverage"
4012        );
4013
4014        let detached_order_ids: AHashSet<VenueOrderId> = history_order_reports
4015            .iter()
4016            .chain(open_order_reports.iter())
4017            .filter(|report| report.client_order_id.is_none())
4018            .map(|report| report.venue_order_id)
4019            .collect();
4020
4021        for report in &mut fill_reports {
4022            if detached_order_ids.contains(&report.venue_order_id) {
4023                report.client_order_id = None;
4024            }
4025        }
4026
4027        log::info!(
4028            "Received {} historical OrderStatusReports",
4029            history_order_reports.len()
4030        );
4031        log::info!(
4032            "Received {} open OrderStatusReports",
4033            open_order_reports.len()
4034        );
4035        log::info!("Received {} FillReports", fill_reports.len());
4036        log::info!(
4037            "Received {} PositionReports",
4038            position_snapshot.reports.len()
4039        );
4040
4041        let mut touched_instruments = AHashSet::new();
4042        for report in history_order_reports
4043            .iter()
4044            .chain(open_order_reports.iter())
4045        {
4046            touched_instruments.insert(report.instrument_id);
4047        }
4048
4049        for report in &fill_reports {
4050            touched_instruments.insert(report.instrument_id);
4051        }
4052
4053        let PositionStatusSnapshot {
4054            reports: position_reports,
4055            instruments: position_instruments,
4056        } = position_snapshot;
4057        let mut mass_status =
4058            ExecutionMassStatus::new(self.client_id, self.account_id, *DERIVE_VENUE, ts_now, None);
4059        mass_status.set_report_window(start, reports_complete || start.is_none());
4060
4061        let order_reports = deduplicate_order_status_reports(
4062            history_order_reports
4063                .into_iter()
4064                .chain(open_order_reports)
4065                .collect(),
4066        )?;
4067
4068        if recover_uncached {
4069            self.ensure_replacement_fills(&order_reports, &fill_reports, &ancestors)?;
4070        }
4071
4072        mass_status.add_order_reports(order_reports);
4073        mass_status.add_fill_reports(fill_reports);
4074        mass_status.add_position_reports(position_reports);
4075
4076        if positions_complete {
4077            add_missing_flat_position_reports(
4078                &mut mass_status,
4079                self.account_id,
4080                touched_instruments,
4081                &position_instruments,
4082                &self.instruments,
4083                ts_now,
4084            );
4085        }
4086
4087        self.ensure_order_context()?;
4088        Ok(mass_status)
4089    }
4090
4091    fn ensure_replacement_fills(
4092        &self,
4093        reports: &[OrderStatusReport],
4094        fills: &[FillReport],
4095        records: &[DeriveOrder],
4096    ) -> anyhow::Result<()> {
4097        for current in reports {
4098            if !current.order_status.is_open()
4099                || current
4100                    .client_order_id
4101                    .is_none_or(|id| self.order_binding(id).is_some())
4102                || !records.iter().any(|order| {
4103                    order.order_id == current.venue_order_id.as_str()
4104                        && order.replaced_order_id.is_some()
4105                })
4106            {
4107                continue;
4108            }
4109
4110            let mut filled = Decimal::ZERO;
4111
4112            for report in reports {
4113                if report.client_order_id != current.client_order_id {
4114                    continue;
4115                }
4116
4117                let native_filled: Decimal = fills
4118                    .iter()
4119                    .filter(|fill| fill.venue_order_id == report.venue_order_id)
4120                    .map(|fill| fill.last_qty.as_decimal())
4121                    .sum();
4122                anyhow::ensure!(
4123                    report.venue_order_id == current.venue_order_id
4124                        || native_filled == report.filled_qty.as_decimal(),
4125                    "Incomplete native fills for uncached replacement {} at {}",
4126                    current.venue_order_id,
4127                    report.venue_order_id,
4128                );
4129                filled += native_filled;
4130            }
4131
4132            anyhow::ensure!(
4133                filled == current.filled_qty.as_decimal(),
4134                "Incomplete native fills for uncached replacement {}",
4135                current.venue_order_id,
4136            );
4137        }
4138
4139        Ok(())
4140    }
4141
4142    fn replacement_lookback_start(
4143        &self,
4144        start: Option<UnixNanos>,
4145        open: &[OrderStatusReport],
4146        records: &[DeriveOrder],
4147    ) -> Option<UnixNanos> {
4148        let start = start?;
4149        open.iter()
4150            .filter(|report| {
4151                report.ts_accepted < start
4152                    && report
4153                        .client_order_id
4154                        .is_some_and(|id| self.order_binding(id).is_none())
4155                    && records.iter().any(|order| {
4156                        order.order_id == report.venue_order_id.as_str()
4157                            && order.replaced_order_id.is_some()
4158                    })
4159            })
4160            .map(|report| report.ts_accepted)
4161            .min()
4162    }
4163
4164    async fn collect_companion_order_records(
4165        &self,
4166        history: &CollectedReports<DeriveOrder>,
4167        open: &[DeriveOrder],
4168        fills: &[FillReport],
4169        allow_partial: bool,
4170    ) -> anyhow::Result<CollectedReports<DeriveOrder>> {
4171        if !history.records_complete {
4172            return Ok(CollectedReports {
4173                reports: Vec::new(),
4174                complete: false,
4175                records_complete: false,
4176            });
4177        }
4178
4179        let order_evidence: AHashSet<_> = history
4180            .reports
4181            .iter()
4182            .chain(open.iter())
4183            .filter_map(|order| VenueOrderId::new_checked(&order.order_id).ok())
4184            .collect();
4185        let mut queried_orders: AHashMap<VenueOrderId, Option<usize>> = AHashMap::new();
4186        let mut orders = Vec::new();
4187        let mut records_complete = true;
4188
4189        for fill in fills {
4190            if order_evidence.contains(&fill.venue_order_id) {
4191                continue;
4192            }
4193
4194            let client_order_id = self
4195                .orders
4196                .iter()
4197                .find(|(_, binding)| binding.venue_order_legs.contains(&fill.venue_order_id))
4198                .map(|(cid, _)| *cid)
4199                .or_else(|| {
4200                    fill.client_order_id.filter(|cid| {
4201                        self.order_binding(*cid).is_some_and(|binding| {
4202                            binding.venue_order_legs.contains(&fill.venue_order_id)
4203                        })
4204                    })
4205                });
4206
4207            let index = match queried_orders.get(&fill.venue_order_id) {
4208                Some(Some(index)) => *index,
4209                Some(None) => continue,
4210                None => {
4211                    let order = match fetch_order_record(
4212                        &self.http_client,
4213                        self.subaccount_id,
4214                        fill.venue_order_id,
4215                        Some(fill.instrument_id),
4216                    )
4217                    .await
4218                    {
4219                        Ok(order) => order,
4220                        Err(e)
4221                            if client_order_id.is_none()
4222                                && e.downcast_ref::<DeriveHttpError>().is_some_and(|cause| {
4223                                    matches!(cause, DeriveHttpError::JsonRpc { code: 11006, .. })
4224                                }) =>
4225                        {
4226                            if !allow_partial {
4227                                return Err(
4228                                    e.context("incomplete unbounded Derive report coverage")
4229                                );
4230                            }
4231
4232                            records_complete = false;
4233                            queried_orders.insert(fill.venue_order_id, None);
4234                            log::warn!(
4235                                "Derive fill companion {} on {} is unavailable: {e:#}",
4236                                fill.venue_order_id,
4237                                fill.instrument_id,
4238                            );
4239                            continue;
4240                        }
4241                        Err(e) => return Err(e),
4242                    };
4243
4244                    let index = orders.len();
4245                    orders.push(order);
4246                    queried_orders.insert(fill.venue_order_id, Some(index));
4247                    index
4248                }
4249            };
4250
4251            self.validate_companion_order(&orders[index], fill, client_order_id)?;
4252        }
4253
4254        Ok(CollectedReports {
4255            reports: orders,
4256            complete: records_complete,
4257            records_complete,
4258        })
4259    }
4260
4261    fn validate_companion_order(
4262        &self,
4263        order: &DeriveOrder,
4264        fill: &FillReport,
4265        client_order_id: Option<ClientOrderId>,
4266    ) -> anyhow::Result<()> {
4267        let order_side = match order.direction {
4268            DeriveOrderSide::Buy => OrderSide::Buy,
4269            DeriveOrderSide::Sell => OrderSide::Sell,
4270        };
4271
4272        anyhow::ensure!(
4273            order.order_id == fill.venue_order_id.as_str()
4274                && self.dispatch_state.owns_subaccount(order.subaccount_id)
4275                && format_instrument_id(order.instrument_name)? == fill.instrument_id
4276                && order_side == fill.order_side,
4277            "Native companion order identity does not match",
4278        );
4279
4280        if let Some(client_order_id) = client_order_id {
4281            let binding = self
4282                .order_binding(client_order_id)
4283                .ok_or(UnresolvedOrderBinding(client_order_id))?;
4284            anyhow::ensure!(
4285                order_response_matches(
4286                    order,
4287                    client_order_id,
4288                    binding.identity.instrument_id,
4289                    &self.dispatch_state,
4290                ) && fill
4291                    .client_order_id
4292                    .is_none_or(|cid| cid == client_order_id),
4293                "Native companion order identity does not match",
4294            );
4295            let current = binding
4296                .venue_order_id
4297                .ok_or(UnresolvedOrderBinding(client_order_id))?;
4298            validate_replacement_order(
4299                order,
4300                client_order_id,
4301                binding.identity,
4302                &self.dispatch_state,
4303                fill.venue_order_id,
4304                current,
4305            )?;
4306        }
4307
4308        Ok(())
4309    }
4310
4311    fn order_precision(&self, order: &DeriveOrder) -> anyhow::Result<(Option<u8>, Option<u8>)> {
4312        let active =
4313            derive_status_to_nautilus(order.order_status, order.filled_amount, order.amount)
4314                .is_ok_and(|status| !status.is_closed());
4315        self.report_precision(order.instrument_name.as_str(), active)
4316    }
4317
4318    fn report_precision(
4319        &self,
4320        instrument_name: &str,
4321        required: bool,
4322    ) -> anyhow::Result<(Option<u8>, Option<u8>)> {
4323        let precision = report_precision(&self.dispatch_state, instrument_name);
4324        if precision.0.is_some() {
4325            return Ok(precision);
4326        }
4327
4328        if required {
4329            let instrument_id = format_instrument_id(instrument_name)?;
4330            anyhow::bail!("missing Derive instrument metadata for {instrument_id}");
4331        }
4332
4333        log::warn!(
4334            "Missing Derive instrument metadata for historical record on {instrument_name}; coverage is incomplete"
4335        );
4336        Ok(precision)
4337    }
4338
4339    fn validate_report_binding(
4340        &self,
4341        client_order_id: Option<ClientOrderId>,
4342        venue_order_id: VenueOrderId,
4343        instrument_id: InstrumentId,
4344    ) -> anyhow::Result<()> {
4345        let _delivery = self.dispatch_state.delivery_guard();
4346
4347        if self.report_observations.is_none() {
4348            return validate_report_binding(
4349                &self.dispatch_state,
4350                client_order_id,
4351                venue_order_id,
4352                instrument_id,
4353            );
4354        }
4355
4356        if let Some(client_order_id) = client_order_id {
4357            self.order_binding(client_order_id);
4358        }
4359
4360        check_report_binding(
4361            &self.dispatch_state,
4362            client_order_id,
4363            venue_order_id,
4364            instrument_id,
4365        )
4366    }
4367
4368    fn observe_order_binding(&self, order: &DeriveOrder) -> anyhow::Result<()> {
4369        if self.report_observations.is_none() {
4370            observe_order_binding(&self.dispatch_state, order);
4371            return Ok(());
4372        }
4373
4374        let (Ok(client_order_id), Ok(instrument_id), Ok(venue_order_id)) = (
4375            ClientOrderId::new_checked(order.label),
4376            format_instrument_id(order.instrument_name),
4377            VenueOrderId::new_checked(&order.order_id),
4378        ) else {
4379            return Ok(());
4380        };
4381
4382        let _delivery = self.dispatch_state.delivery_guard();
4383        self.order_binding(client_order_id);
4384        if tracked_order_identity(Some(client_order_id), instrument_id, &self.dispatch_state)
4385            .is_some()
4386            && self
4387                .dispatch_state
4388                .bound_venue_order_id(&client_order_id)
4389                .is_some()
4390        {
4391            check_report_binding(
4392                &self.dispatch_state,
4393                Some(client_order_id),
4394                venue_order_id,
4395                instrument_id,
4396            )?;
4397        }
4398
4399        Ok(())
4400    }
4401
4402    fn observe_trigger_order(&self, order: &DeriveOrder, report: &OrderStatusReport) {
4403        if let Some(observations) = &self.report_observations {
4404            if tracked_order_identity(
4405                report.client_order_id,
4406                report.instrument_id,
4407                &self.dispatch_state,
4408            )
4409            .is_some_and(|(_, identity)| is_derive_trigger_order_type(identity.order_type))
4410            {
4411                observations
4412                    .lock()
4413                    .trigger_orders
4414                    .push((order.clone(), report.clone()));
4415            }
4416        } else {
4417            observe_trigger_order(&self.dispatch_state, order, report);
4418        }
4419    }
4420
4421    fn observe_trigger_fill(&self, report: &FillReport) {
4422        if let Some(observations) = &self.report_observations {
4423            if tracked_order_identity(
4424                report.client_order_id,
4425                report.instrument_id,
4426                &self.dispatch_state,
4427            )
4428            .is_some_and(|(_, identity)| is_derive_trigger_order_type(identity.order_type))
4429            {
4430                observations.lock().trigger_fills.push(report.clone());
4431            }
4432        } else {
4433            observe_trigger_fill(&self.dispatch_state, report);
4434        }
4435    }
4436}
4437
4438fn instrument_in_scope(instrument_name: &str, load_ids: Option<&[InstrumentId]>) -> bool {
4439    let included = load_ids
4440        .filter(|ids| !ids.is_empty())
4441        .is_none_or(|ids| ids.iter().any(|id| id.symbol.as_str() == instrument_name));
4442
4443    if !included {
4444        log::debug!("Skipping Derive record for out-of-scope instrument {instrument_name}");
4445    }
4446
4447    included
4448}
4449
4450#[derive(Debug, Default)]
4451struct ReportObservations {
4452    bindings: Vec<(ClientOrderId, Option<OrderBinding>)>,
4453    trigger_orders: Vec<(DeriveOrder, OrderStatusReport)>,
4454    trigger_fills: Vec<FillReport>,
4455}
4456
4457fn ambiguous_history_client_order_ids<'a>(
4458    orders: impl Iterator<Item = &'a DeriveOrder>,
4459) -> AHashSet<Ustr> {
4460    let mut orders_by_label: AHashMap<Ustr, AHashMap<&str, Option<&str>>> = AHashMap::new();
4461
4462    for order in orders {
4463        if order.label.is_empty() {
4464            continue;
4465        }
4466
4467        orders_by_label
4468            .entry(order.label)
4469            .or_default()
4470            .insert(order.order_id.as_str(), order.replaced_order_id.as_deref());
4471    }
4472
4473    let mut ambiguous_client_order_ids = AHashSet::new();
4474
4475    for (label, orders_by_id) in orders_by_label {
4476        if orders_by_id.len() < 2 {
4477            continue;
4478        }
4479
4480        let predecessors: AHashMap<&str, &str> = orders_by_id
4481            .iter()
4482            .filter_map(|(order_id, replaced_order_id)| {
4483                let replaced_order_id = (*replaced_order_id)?;
4484                orders_by_id
4485                    .contains_key(replaced_order_id)
4486                    .then_some((*order_id, replaced_order_id))
4487            })
4488            .collect();
4489
4490        let predecessor_ids: AHashSet<&str> = predecessors.values().copied().collect();
4491        let heads: Vec<&str> = orders_by_id
4492            .keys()
4493            .copied()
4494            .filter(|order_id| !predecessor_ids.contains(order_id))
4495            .collect();
4496
4497        // One client order may own several venue IDs only when they form one linear replace chain
4498        let is_linear_chain = predecessors.len() + 1 == orders_by_id.len()
4499            && predecessor_ids.len() == predecessors.len()
4500            && heads.len() == 1
4501            && {
4502                let mut visited = AHashSet::new();
4503                let mut current = Some(heads[0]);
4504                while let Some(order_id) = current {
4505                    if !visited.insert(order_id) {
4506                        break;
4507                    }
4508
4509                    current = predecessors.get(order_id).copied();
4510                }
4511
4512                visited.len() == orders_by_id.len()
4513            };
4514
4515        if !is_linear_chain {
4516            ambiguous_client_order_ids.insert(label);
4517        }
4518    }
4519
4520    ambiguous_client_order_ids
4521}
4522
4523#[derive(Debug, thiserror::Error)]
4524#[error("unresolved Derive venue binding for {0}")]
4525struct UnresolvedOrderBinding(ClientOrderId);
4526
4527fn validate_report_binding(
4528    dispatch_state: &WsDispatchState,
4529    client_order_id: Option<ClientOrderId>,
4530    venue_order_id: VenueOrderId,
4531    instrument_id: InstrumentId,
4532) -> anyhow::Result<()> {
4533    let _delivery = dispatch_state.delivery_guard();
4534    if let Some((client_order_id, _)) =
4535        tracked_order_identity(client_order_id, instrument_id, dispatch_state)
4536        && !dispatch_state.knows_venue_leg(&client_order_id, venue_order_id)
4537    {
4538        dispatch_state.defer_binding(client_order_id, venue_order_id);
4539    }
4540
4541    check_report_binding(
4542        dispatch_state,
4543        client_order_id,
4544        venue_order_id,
4545        instrument_id,
4546    )
4547}
4548
4549fn check_report_binding(
4550    dispatch_state: &WsDispatchState,
4551    client_order_id: Option<ClientOrderId>,
4552    venue_order_id: VenueOrderId,
4553    instrument_id: InstrumentId,
4554) -> anyhow::Result<()> {
4555    if let Some((client_order_id, _)) =
4556        tracked_order_identity(client_order_id, instrument_id, dispatch_state)
4557        && (!dispatch_state.knows_venue_leg(&client_order_id, venue_order_id)
4558            || dispatch_state.binding_unresolved(&client_order_id))
4559    {
4560        return Err(UnresolvedOrderBinding(client_order_id).into());
4561    }
4562
4563    Ok(())
4564}
4565
4566fn ensure_bindings_resolved(
4567    dispatch_state: &WsDispatchState,
4568    instrument_id: Option<InstrumentId>,
4569) -> anyhow::Result<()> {
4570    let _delivery = dispatch_state.delivery_guard();
4571    if let Some(client_order_id) = dispatch_state.unresolved_client_order_id(instrument_id) {
4572        return Err(UnresolvedOrderBinding(client_order_id).into());
4573    }
4574
4575    Ok(())
4576}
4577
4578fn ensure_order_binding_resolved(
4579    dispatch_state: &WsDispatchState,
4580    client_order_id: ClientOrderId,
4581) -> anyhow::Result<()> {
4582    let _delivery = dispatch_state.delivery_guard();
4583    if dispatch_state.binding_unresolved(&client_order_id)
4584        || dispatch_state.pending_modify(&client_order_id).is_some()
4585    {
4586        return Err(UnresolvedOrderBinding(client_order_id).into());
4587    }
4588
4589    Ok(())
4590}
4591
4592fn emit_trigger_cancel_result(
4593    canceled_order: &DeriveOrder,
4594    expected_cancel_id: Option<VenueOrderId>,
4595    cmd: &CancelOrder,
4596    emitter: &ExecutionEventEmitter,
4597    dispatch_state: &WsDispatchState,
4598    account_id: AccountId,
4599    clock: &'static AtomicTime,
4600) -> anyhow::Result<()> {
4601    let client_order_id = cmd.client_order_id;
4602
4603    if !order_response_matches(
4604        canceled_order,
4605        cmd.client_order_id,
4606        cmd.instrument_id,
4607        dispatch_state,
4608    ) || expected_cancel_id.is_none_or(|id| id.as_str() != canceled_order.order_id)
4609        || canceled_order.order_status != DeriveOrderStatus::Cancelled
4610    {
4611        log::warn!(
4612            "Derive trigger cancellation response does not match {client_order_id}, awaiting reconciliation"
4613        );
4614        return Ok(());
4615    }
4616
4617    let Ok(canceled_venue_order_id) = VenueOrderId::new_checked(canceled_order.order_id.as_str())
4618    else {
4619        log::warn!(
4620            "Derive cancel outcome for {:?} on {:?} has an invalid response order_id; awaiting reconciliation",
4621            cmd.client_order_id.as_str(),
4622            cmd.instrument_id.to_string(),
4623        );
4624        return Ok(());
4625    };
4626
4627    let ts = clock.get_time_ns();
4628
4629    if !ensure_canceled_emitted(
4630        emitter,
4631        dispatch_state,
4632        cmd.client_order_id,
4633        OrderIdentity {
4634            instrument_id: cmd.instrument_id,
4635            strategy_id: cmd.strategy_id,
4636            order_side: match canceled_order.direction {
4637                DeriveOrderSide::Buy => OrderSide::Buy,
4638                DeriveOrderSide::Sell => OrderSide::Sell,
4639            },
4640            order_type: derive_order_type_to_nautilus_for_order(
4641                canceled_order.order_type,
4642                canceled_order.trigger_type,
4643            )?,
4644        },
4645        canceled_venue_order_id,
4646        account_id,
4647        ts,
4648        ts,
4649    ) {
4650        return Ok(());
4651    }
4652
4653    dispatch_state.forget(&cmd.client_order_id);
4654    Ok(())
4655}
4656
4657async fn resolve_trigger_cancel_id(
4658    http_client: &DeriveHttpClient,
4659    dispatch_state: &WsDispatchState,
4660    subaccount_id: u64,
4661    client_order_id: ClientOrderId,
4662    venue_symbol: &str,
4663) -> Result<VenueOrderId, String> {
4664    let result = http_client
4665        .get_trigger_orders(&DeriveGetTriggerOrdersParams::new(subaccount_id))
4666        .await;
4667
4668    if let Some(venue_order_id) = dispatch_state.bound_venue_order_id(&client_order_id) {
4669        return Ok(venue_order_id);
4670    }
4671
4672    let orders = result
4673        .map_err(|e| format!("failed to resolve trigger order by label: {e}"))?
4674        .orders;
4675
4676    let order = orders
4677        .into_iter()
4678        .find(|order| {
4679            order.label == client_order_id.as_str() && order.instrument_name == venue_symbol
4680        })
4681        .ok_or_else(|| "trigger order not found for client_order_id".to_string())?;
4682
4683    VenueOrderId::new_checked(&order.order_id).map_err(|e| e.to_string())
4684}
4685
4686fn observe_order_binding(dispatch_state: &WsDispatchState, order: &DeriveOrder) {
4687    let _delivery = dispatch_state.delivery_guard();
4688
4689    let (Ok(client_order_id), Ok(instrument_id), Ok(venue_order_id)) = (
4690        ClientOrderId::new_checked(order.label),
4691        format_instrument_id(order.instrument_name),
4692        VenueOrderId::new_checked(&order.order_id),
4693    ) else {
4694        return;
4695    };
4696
4697    if tracked_order_identity(Some(client_order_id), instrument_id, dispatch_state).is_some()
4698        && dispatch_state
4699            .bound_venue_order_id(&client_order_id)
4700            .is_some()
4701        && !dispatch_state.knows_venue_leg(&client_order_id, venue_order_id)
4702    {
4703        dispatch_state.defer_binding(client_order_id, venue_order_id);
4704    }
4705}
4706
4707fn observe_trigger_order(
4708    dispatch_state: &WsDispatchState,
4709    order: &DeriveOrder,
4710    report: &OrderStatusReport,
4711) {
4712    let _delivery = dispatch_state.delivery_guard();
4713    if !dispatch_state.owns_subaccount(order.subaccount_id)
4714        || !matches!(
4715            order.order_status,
4716            DeriveOrderStatus::Open | DeriveOrderStatus::Filled
4717        )
4718    {
4719        return;
4720    }
4721
4722    if let Some((client_order_id, identity)) =
4723        tracked_order_identity(report.client_order_id, report.instrument_id, dispatch_state)
4724        && is_derive_trigger_order_type(identity.order_type)
4725        && report.order_type == identity.order_type
4726        && report.order_side == Some(identity.order_side)
4727        && dispatch_state
4728            .bound_venue_order_id(&client_order_id)
4729            .is_none_or(|id| id == report.venue_order_id)
4730    {
4731        dispatch_state.mark_trigger_active(client_order_id);
4732    }
4733}
4734
4735fn observe_trigger_fill(dispatch_state: &WsDispatchState, report: &FillReport) {
4736    let _delivery = dispatch_state.delivery_guard();
4737    if let Some((client_order_id, identity)) =
4738        tracked_order_identity(report.client_order_id, report.instrument_id, dispatch_state)
4739        && is_derive_trigger_order_type(identity.order_type)
4740        && report.order_side == identity.order_side
4741        && dispatch_state
4742            .bound_venue_order_id(&client_order_id)
4743            .is_none_or(|id| id == report.venue_order_id)
4744    {
4745        dispatch_state.mark_trigger_active(client_order_id);
4746    }
4747}
4748
4749struct CollectedReports<T> {
4750    reports: Vec<T>,
4751    complete: bool,
4752    records_complete: bool,
4753}
4754
4755impl<T> CollectedReports<T> {
4756    fn into_complete(self, source: &str) -> anyhow::Result<Vec<T>> {
4757        anyhow::ensure!(self.complete, "incomplete Derive {source} report coverage");
4758        Ok(self.reports)
4759    }
4760}
4761
4762fn collect_mass_reports<T>(
4763    result: anyhow::Result<CollectedReports<T>>,
4764    source: &str,
4765    allow_partial: bool,
4766) -> anyhow::Result<CollectedReports<T>> {
4767    match result {
4768        Ok(collection) => Ok(collection),
4769        Err(e)
4770            if !allow_partial || e.is::<CommissionError>() || e.is::<UnresolvedOrderBinding>() =>
4771        {
4772            Err(e)
4773        }
4774        Err(e) => {
4775            log::warn!("Derive {source} source failed: {e:#}");
4776            Ok(CollectedReports {
4777                reports: Vec::new(),
4778                complete: false,
4779                records_complete: false,
4780            })
4781        }
4782    }
4783}
4784
4785struct PositionStatusSnapshot {
4786    reports: Vec<PositionStatusReport>,
4787    instruments: AHashSet<InstrumentId>,
4788}
4789
4790fn ws_command_failure(error: &DeriveWsError) -> (CommandFailure, bool) {
4791    let (reason, due_post_only) = ws_rejection_reason(error);
4792    let failure = if is_write_outcome_ambiguous_ws(error) {
4793        CommandFailure::ambiguous(reason)
4794    } else if matches!(error, DeriveWsError::JsonRpc { .. }) {
4795        CommandFailure::venue_rejected(reason)
4796    } else {
4797        CommandFailure::not_sent(reason)
4798    };
4799
4800    log::warn!("Derive order command failed: {}", error.redacted_message());
4801    (failure, due_post_only)
4802}
4803
4804fn command_rejection_reason(failure: CommandFailure) -> Option<String> {
4805    match failure {
4806        CommandFailure::NotSent(reason) | CommandFailure::VenueRejected(reason) => {
4807            Some(strategy_rejection_reason(&reason))
4808        }
4809        CommandFailure::Ambiguous(_) => None,
4810    }
4811}
4812
4813fn emit_submit_failure(
4814    emitter: &ExecutionEventEmitter,
4815    order: &OrderAny,
4816    failure: CommandFailure,
4817    ts: UnixNanos,
4818    due_post_only: bool,
4819) {
4820    if let Some(reason) = command_rejection_reason(failure) {
4821        emitter.emit_order_rejected(order, &reason, ts, due_post_only);
4822    }
4823}
4824
4825#[expect(
4826    clippy::too_many_arguments,
4827    reason = "Failure emission retains order identity and command correlation"
4828)]
4829fn emit_cancel_failure(
4830    emitter: &ExecutionEventEmitter,
4831    strategy_id: StrategyId,
4832    instrument_id: InstrumentId,
4833    client_order_id: ClientOrderId,
4834    venue_order_id: Option<VenueOrderId>,
4835    failure: CommandFailure,
4836    ts: UnixNanos,
4837    causation_id: Option<UUID4>,
4838) {
4839    match failure {
4840        CommandFailure::NotSent(reason) => {
4841            emitter.emit_order_cancel_denied_event(
4842                strategy_id,
4843                instrument_id,
4844                client_order_id,
4845                venue_order_id,
4846                &strategy_rejection_reason(&reason),
4847                ts,
4848                causation_id,
4849            );
4850        }
4851        CommandFailure::VenueRejected(reason) => {
4852            emitter.emit_order_cancel_rejected_event(
4853                strategy_id,
4854                instrument_id,
4855                client_order_id,
4856                venue_order_id,
4857                &strategy_rejection_reason(&reason),
4858                ts,
4859                causation_id,
4860            );
4861        }
4862        CommandFailure::Ambiguous(_) => {}
4863    }
4864}
4865
4866#[expect(
4867    clippy::too_many_arguments,
4868    reason = "Failure emission retains order identity and command correlation"
4869)]
4870fn emit_modify_failure(
4871    emitter: &ExecutionEventEmitter,
4872    strategy_id: StrategyId,
4873    instrument_id: InstrumentId,
4874    client_order_id: ClientOrderId,
4875    venue_order_id: Option<VenueOrderId>,
4876    failure: CommandFailure,
4877    ts: UnixNanos,
4878    causation_id: Option<UUID4>,
4879) {
4880    match failure {
4881        CommandFailure::NotSent(reason) => {
4882            emitter.emit_order_modify_denied_event(
4883                strategy_id,
4884                instrument_id,
4885                client_order_id,
4886                venue_order_id,
4887                &strategy_rejection_reason(&reason),
4888                ts,
4889                causation_id,
4890            );
4891        }
4892        CommandFailure::VenueRejected(reason) => {
4893            emitter.emit_order_modify_rejected_event(
4894                strategy_id,
4895                instrument_id,
4896                client_order_id,
4897                venue_order_id,
4898                &strategy_rejection_reason(&reason),
4899                ts,
4900                causation_id,
4901            );
4902        }
4903        CommandFailure::Ambiguous(_) => {}
4904    }
4905}
4906
4907fn ws_rejection_reason(error: &DeriveWsError) -> (String, bool) {
4908    if let Some(reason) = error.session_key_expiry_reason() {
4909        return (reason, false);
4910    }
4911
4912    match error {
4913        DeriveWsError::JsonRpc { code, message, .. } => (
4914            format!("{code}: {}", strategy_rejection_reason(message))
4915                .chars()
4916                .take(STRATEGY_REASON_MAX_CHARS)
4917                .collect(),
4918            derive_rejection_due_post_only(Some(*code), message),
4919        ),
4920        DeriveWsError::NotConnected => ("WebSocket client is not connected".to_string(), false),
4921        DeriveWsError::Auth(_) | DeriveWsError::Authentication { .. } => {
4922            ("Session authentication failed".to_string(), false)
4923        }
4924        DeriveWsError::MissingCredentials { .. } => {
4925            ("Session credentials are missing".to_string(), false)
4926        }
4927        DeriveWsError::Subscription { .. } => ("Session subscription failed".to_string(), false),
4928        DeriveWsError::RateLimited { .. } => {
4929            ("Local pacing reservation expired".to_string(), false)
4930        }
4931        DeriveWsError::Transport(_) => ("Transport outcome is unconfirmed".to_string(), false),
4932        DeriveWsError::Serde(_) => ("Order response could not be decoded".to_string(), false),
4933        DeriveWsError::Timeout { .. } | DeriveWsError::RequestCancelled { .. } => {
4934            ("Order response is unconfirmed".to_string(), false)
4935        }
4936    }
4937}
4938
4939fn add_missing_flat_position_reports(
4940    mass_status: &mut ExecutionMassStatus,
4941    account_id: AccountId,
4942    touched_instruments: AHashSet<InstrumentId>,
4943    position_instruments: &AHashSet<InstrumentId>,
4944    instruments: &AtomicMap<InstrumentId, Arc<DeriveInstrument>>,
4945    ts_init: UnixNanos,
4946) {
4947    let mut flat_reports = Vec::new();
4948
4949    let mut touched_instruments = touched_instruments.into_iter().collect::<Vec<_>>();
4950    touched_instruments.sort();
4951    for instrument_id in touched_instruments {
4952        if position_instruments.contains(&instrument_id)
4953            || !instruments
4954                .get_cloned(&instrument_id)
4955                .is_some_and(|instrument| {
4956                    matches!(
4957                        instrument.instrument_type,
4958                        DeriveInstrumentType::Perp | DeriveInstrumentType::Option,
4959                    )
4960                })
4961        {
4962            continue;
4963        }
4964
4965        flat_reports.push(PositionStatusReport::new(
4966            account_id,
4967            instrument_id,
4968            PositionSide::Flat,
4969            Quantity::from("0"),
4970            ts_init,
4971            ts_init,
4972            Some(UUID4::new()),
4973            None,
4974            None,
4975        ));
4976    }
4977
4978    if !flat_reports.is_empty() {
4979        log::info!(
4980            "Added {} flat PositionReports for Derive instruments absent from current positions",
4981            flat_reports.len()
4982        );
4983        mass_status.add_position_reports(flat_reports);
4984    }
4985}
4986
4987fn report_precision(
4988    dispatch_state: &WsDispatchState,
4989    instrument_name: &str,
4990) -> (Option<u8>, Option<u8>) {
4991    let Ok(instrument_id) = format_instrument_id(instrument_name) else {
4992        return (None, None);
4993    };
4994
4995    dispatch_state
4996        .instrument_precision(&instrument_id)
4997        .map_or((None, None), |(price, size)| (Some(price), Some(size)))
4998}
4999
5000fn handle_ws_message(
5001    message: DeriveWsMessage,
5002    emitter: &ExecutionEventEmitter,
5003    account_id: AccountId,
5004    clock: &'static AtomicTime,
5005    dispatch_state: &WsDispatchState,
5006) {
5007    flush_pending_delivery(emitter, account_id, clock, dispatch_state);
5008
5009    let payload = match message {
5010        DeriveWsMessage::Subscription(payload) => payload,
5011        DeriveWsMessage::Authenticated
5012        | DeriveWsMessage::Reconnected
5013        | DeriveWsMessage::SessionRecoveryFailed(_)
5014        | DeriveWsMessage::BookSubscription { .. } => return,
5015    };
5016
5017    let channel = DeriveWsChannel::from(payload.channel.as_str());
5018
5019    if let DeriveWsChannel::Orders { subaccount_id }
5020    | DeriveWsChannel::PrivateTrades { subaccount_id }
5021    | DeriveWsChannel::Balances { subaccount_id } = &channel
5022        && *subaccount_id != dispatch_state.subaccount_id()
5023    {
5024        log::warn!("Ignoring Derive private frame for an unexpected subaccount");
5025        return;
5026    }
5027
5028    let is_orders_channel = matches!(channel, DeriveWsChannel::Orders { .. });
5029    let is_trades_channel = matches!(channel, DeriveWsChannel::PrivateTrades { .. });
5030
5031    if is_orders_channel {
5032        let data = match serde_json::from_str::<DeriveOrdersSubscriptionData>(payload.data.get()) {
5033            Ok(data) => data,
5034            Err(e) => {
5035                log::warn!(
5036                    "Failed to decode Derive orders frame on channel {}: {e}",
5037                    payload.channel,
5038                );
5039                return;
5040            }
5041        };
5042
5043        dispatch_orders_payload(data, emitter, account_id, clock, dispatch_state);
5044    } else if is_trades_channel {
5045        let data = match serde_json::from_str::<DeriveTradesSubscriptionData>(payload.data.get()) {
5046            Ok(data) => data,
5047            Err(e) => {
5048                log::warn!(
5049                    "Failed to decode Derive trades frame on channel {}: {e}",
5050                    payload.channel,
5051                );
5052                return;
5053            }
5054        };
5055
5056        dispatch_trades_payload(data, emitter, account_id, clock, dispatch_state);
5057    }
5058}
5059
5060/// Dispatches a parsed `{subaccount_id}.orders` payload to the execution event
5061/// emitter.
5062///
5063/// Emits tracked order events when an order's client order id resolves to a
5064/// registered identity in `dispatch_state`, and forwards a raw status report
5065/// otherwise.
5066pub fn dispatch_orders_payload(
5067    data: DeriveOrdersSubscriptionData,
5068    emitter: &ExecutionEventEmitter,
5069    account_id: AccountId,
5070    clock: &'static AtomicTime,
5071    dispatch_state: &WsDispatchState,
5072) {
5073    let _delivery = dispatch_state.delivery_guard();
5074    let ts_init = clock.get_time_ns();
5075    for order in data.orders {
5076        dispatch_order_row(&order, emitter, account_id, clock, dispatch_state, ts_init);
5077    }
5078}
5079
5080fn dispatch_order_row(
5081    order: &DeriveOrder,
5082    emitter: &ExecutionEventEmitter,
5083    account_id: AccountId,
5084    clock: &'static AtomicTime,
5085    dispatch_state: &WsDispatchState,
5086    ts_init: UnixNanos,
5087) {
5088    if !dispatch_state.owns_subaccount(order.subaccount_id) {
5089        log::warn!("Ignoring Derive order row for an unexpected subaccount");
5090        return;
5091    }
5092
5093    observe_order_binding(dispatch_state, order);
5094
5095    let (price_precision, size_precision) =
5096        report_precision(dispatch_state, order.instrument_name.as_str());
5097
5098    let mut report = match parse_derive_order_to_report_with_precision(
5099        order,
5100        account_id,
5101        price_precision,
5102        size_precision,
5103        ts_init,
5104    ) {
5105        Ok(report) => report,
5106        Err(e) => {
5107            log::warn!(
5108                "Failed to parse Derive order {:?} on {:?} in WS update: {:?}",
5109                order.order_id,
5110                order.instrument_name.as_str(),
5111                format!("{e:#}"),
5112            );
5113            return;
5114        }
5115    };
5116
5117    observe_trigger_order(dispatch_state, order, &report);
5118    if report
5119        .client_order_id
5120        .is_some_and(|cid| dispatch_state.is_terminal(&cid, report.instrument_id))
5121    {
5122        return;
5123    }
5124
5125    let identity =
5126        tracked_order_identity(report.client_order_id, report.instrument_id, dispatch_state);
5127
5128    match identity {
5129        Some((client_order_id, identity)) => {
5130            dispatch_tracked_order_report(
5131                order,
5132                &report,
5133                client_order_id,
5134                identity,
5135                emitter,
5136                account_id,
5137                clock,
5138                dispatch_state,
5139                ts_init,
5140            );
5141        }
5142        None => {
5143            if report.client_order_id.is_some_and(|cid| {
5144                dispatch_state
5145                    .known_instrument(&cid)
5146                    .is_some_and(|id| id != report.instrument_id)
5147            }) {
5148                report.client_order_id = None;
5149            }
5150
5151            emitter.send_order_status_report(report);
5152        }
5153    }
5154}
5155
5156#[expect(
5157    clippy::too_many_arguments,
5158    reason = "native tracked rows retain the frame identity and delivery context"
5159)]
5160fn dispatch_tracked_order_report(
5161    order: &DeriveOrder,
5162    report: &OrderStatusReport,
5163    client_order_id: ClientOrderId,
5164    identity: OrderIdentity,
5165    emitter: &ExecutionEventEmitter,
5166    account_id: AccountId,
5167    clock: &'static AtomicTime,
5168    dispatch_state: &WsDispatchState,
5169    ts_init: UnixNanos,
5170) {
5171    if dispatch_state
5172        .bound_venue_order_id(&client_order_id)
5173        .is_some_and(|bound| bound != report.venue_order_id)
5174    {
5175        if !dispatch_state.knows_venue_leg(&client_order_id, report.venue_order_id) {
5176            dispatch_state.defer_binding(client_order_id, report.venue_order_id);
5177        }
5178
5179        let Some(old_venue_order_id) = dispatch_state.pending_modify(&client_order_id) else {
5180            return;
5181        };
5182
5183        if order.replaced_order_id.as_deref() != Some(old_venue_order_id.as_str())
5184            || dispatch_state.modify_nonce(&client_order_id) != Some(order.nonce)
5185            || !matches!(
5186                order.order_status,
5187                DeriveOrderStatus::Open
5188                    | DeriveOrderStatus::Filled
5189                    | DeriveOrderStatus::Cancelled
5190                    | DeriveOrderStatus::Expired
5191            )
5192        {
5193            log::debug!(
5194                "Deferring uncorrelated Derive order leg {} for {client_order_id}",
5195                report.venue_order_id
5196            );
5197            return;
5198        }
5199
5200        if !emit_modify_target(
5201            emitter,
5202            dispatch_state,
5203            client_order_id,
5204            identity,
5205            report.venue_order_id,
5206            account_id,
5207            report.ts_last,
5208            ts_init,
5209        ) {
5210            return;
5211        }
5212
5213        dispatch_trades_payload(
5214            DeriveTradesSubscriptionData {
5215                trades: dispatch_state.take_deferred_trades(&client_order_id),
5216            },
5217            emitter,
5218            account_id,
5219            clock,
5220            dispatch_state,
5221        );
5222    }
5223
5224    emit_tracked_order_event(
5225        emitter,
5226        dispatch_state,
5227        client_order_id,
5228        identity,
5229        report,
5230        account_id,
5231        ts_init,
5232    );
5233
5234    if dispatch_state.identity(&client_order_id).is_none() {
5235        dispatch_trades_payload(
5236            DeriveTradesSubscriptionData {
5237                trades: dispatch_state.take_deferred_trades(&client_order_id),
5238            },
5239            emitter,
5240            account_id,
5241            clock,
5242            dispatch_state,
5243        );
5244    }
5245}
5246
5247/// Dispatches a parsed `{subaccount_id}.trades` payload to the execution event
5248/// emitter.
5249///
5250/// Deduplicates by trade id, then emits a tracked fill when the trade's client
5251/// order id resolves to a registered identity in `dispatch_state`, and forwards
5252/// a raw fill report otherwise.
5253pub fn dispatch_trades_payload(
5254    data: DeriveTradesSubscriptionData,
5255    emitter: &ExecutionEventEmitter,
5256    account_id: AccountId,
5257    clock: &'static AtomicTime,
5258    dispatch_state: &WsDispatchState,
5259) {
5260    let _delivery = dispatch_state.delivery_guard();
5261    let fee_currency = Currency::USDC();
5262    let ts_init = clock.get_time_ns();
5263
5264    for trade in data.trades {
5265        dispatch_trade_row(
5266            trade,
5267            emitter,
5268            account_id,
5269            clock,
5270            dispatch_state,
5271            ts_init,
5272            fee_currency,
5273        );
5274    }
5275}
5276
5277fn dispatch_trade_row(
5278    trade: DeriveTrade,
5279    emitter: &ExecutionEventEmitter,
5280    account_id: AccountId,
5281    clock: &'static AtomicTime,
5282    dispatch_state: &WsDispatchState,
5283    ts_init: UnixNanos,
5284    fee_currency: Currency,
5285) {
5286    if !dispatch_state.owns_subaccount(trade.subaccount_id) {
5287        log::warn!("Ignoring Derive trade row for an unexpected subaccount");
5288        return;
5289    }
5290
5291    let (price_precision, size_precision) =
5292        report_precision(dispatch_state, trade.instrument_name.as_str());
5293
5294    let mut report = match parse_derive_trade_to_fill_report_with_precision(
5295        &trade,
5296        account_id,
5297        fee_currency,
5298        price_precision,
5299        size_precision,
5300        ts_init,
5301    ) {
5302        Ok(Some(report)) => report,
5303        Ok(None) => return,
5304        Err(e) => {
5305            log::warn!(
5306                "Failed to parse Derive trade {:?} for order {:?} on {:?} in WS update: {:?}",
5307                trade.trade_id,
5308                trade.order_id,
5309                trade.instrument_name.as_str(),
5310                format!("{e:#}")
5311            );
5312            return;
5313        }
5314    };
5315
5316    if dispatch_state.contains_trade(&report.trade_id) {
5317        log::debug!(
5318            "Skipping duplicate Derive fill (trade_id={}) on WS dispatch",
5319            report.trade_id,
5320        );
5321        return;
5322    }
5323
5324    let identity =
5325        tracked_order_identity(report.client_order_id, report.instrument_id, dispatch_state);
5326
5327    let known_side = identity
5328        .map(|(_, identity)| identity.order_side)
5329        .or_else(|| {
5330            report
5331                .client_order_id
5332                .and_then(|cid| dispatch_state.order_binding(&cid))
5333                .filter(|binding| binding.identity.instrument_id == report.instrument_id)
5334                .map(|binding| binding.identity.order_side)
5335        });
5336
5337    if known_side.is_some_and(|side| side != report.order_side) {
5338        log::warn!(
5339            "Deferring Derive fill {} with a conflicting tracked order side",
5340            report.trade_id
5341        );
5342        dispatch_state.retain_trade(trade);
5343        return;
5344    }
5345
5346    if let Some((client_order_id, _)) = identity
5347        && dispatch_state
5348            .bound_venue_order_id(&client_order_id)
5349            .is_some()
5350        && !dispatch_state.knows_venue_leg(&client_order_id, report.venue_order_id)
5351    {
5352        dispatch_state.defer_binding(client_order_id, report.venue_order_id);
5353        dispatch_state.defer_trade(client_order_id, trade);
5354        return;
5355    }
5356
5357    if let Some((client_order_id, _)) = identity
5358        && dispatch_state
5359            .bound_venue_order_id(&client_order_id)
5360            .is_none()
5361    {
5362        dispatch_state.record_venue_order_id(client_order_id, report.venue_order_id);
5363    }
5364
5365    observe_trigger_fill(dispatch_state, &report);
5366
5367    let delivered = match identity {
5368        Some((client_order_id, identity)) => emit_tracked_fill(
5369            emitter,
5370            dispatch_state,
5371            client_order_id,
5372            identity,
5373            &report,
5374            account_id,
5375            ts_init,
5376        ),
5377        None => {
5378            if report.client_order_id.is_some_and(|cid| {
5379                dispatch_state
5380                    .known_instrument(&cid)
5381                    .is_some_and(|id| id != report.instrument_id)
5382            }) {
5383                report.client_order_id = None;
5384            }
5385
5386            match emitter.try_send_execution_report(ExecutionReport::Fill(Box::new(report.clone())))
5387            {
5388                Ok(()) => true,
5389                Err(e) => {
5390                    log::warn!(
5391                        "Failed to deliver Derive fill report {}: {e}",
5392                        report.trade_id
5393                    );
5394                    false
5395                }
5396            }
5397        }
5398    };
5399
5400    if delivered {
5401        dispatch_state.check_and_insert_trade(report.trade_id);
5402
5403        if let Some((client_order_id, _)) = identity
5404            && dispatch_state.identity(&client_order_id).is_none()
5405        {
5406            dispatch_trades_payload(
5407                DeriveTradesSubscriptionData {
5408                    trades: dispatch_state.take_deferred_trades(&client_order_id),
5409                },
5410                emitter,
5411                account_id,
5412                clock,
5413                dispatch_state,
5414            );
5415        }
5416    } else {
5417        dispatch_state.retain_trade(trade);
5418    }
5419}
5420
5421async fn replacement_amounts(
5422    http_client: &DeriveHttpClient,
5423    dispatch_state: &WsDispatchState,
5424    client_order_id: ClientOrderId,
5425    identity: OrderIdentity,
5426    current_venue_order_id: VenueOrderId,
5427    target_quantity: Decimal,
5428) -> anyhow::Result<(Decimal, Decimal)> {
5429    let current = fetch_order_record(
5430        http_client,
5431        dispatch_state.subaccount_id(),
5432        current_venue_order_id,
5433        Some(identity.instrument_id),
5434    )
5435    .await?;
5436    anyhow::ensure!(
5437        current.order_id == current_venue_order_id.as_str(),
5438        "Native replacement order identity does not match"
5439    );
5440    anyhow::ensure!(
5441        current.order_status == DeriveOrderStatus::Open,
5442        "Native replacement target is not open; current binding requires reconciliation"
5443    );
5444    let current_filled = current.filled_amount.normalize();
5445    let orders = replacement_orders(
5446        http_client,
5447        dispatch_state,
5448        client_order_id,
5449        identity,
5450        current,
5451        dispatch_state.venue_order_legs(&client_order_id),
5452        &[],
5453    )
5454    .await?;
5455    let mut filled = U256::ZERO;
5456
5457    for order in orders {
5458        let leg_filled = decimal_to_scaled_u256(order.filled_amount.normalize())
5459            .map_err(|e| anyhow::anyhow!(e))?;
5460        filled = filled
5461            .checked_add(leg_filled)
5462            .context("native cumulative fills exceed exact integer range")?;
5463    }
5464
5465    let target =
5466        decimal_to_scaled_u256(target_quantity.normalize()).map_err(|e| anyhow::anyhow!(e))?;
5467    let remaining = target
5468        .checked_sub(filled)
5469        .context("requested quantity is below native cumulative fills")?;
5470    anyhow::ensure!(
5471        remaining > U256::ZERO,
5472        "Requested quantity does not leave a positive native replacement amount"
5473    );
5474
5475    let remaining = if filled == U256::ZERO {
5476        target_quantity
5477    } else {
5478        decimal_from_scaled(remaining)?
5479    };
5480
5481    Ok((remaining, current_filled))
5482}
5483
5484async fn replacement_orders(
5485    http_client: &DeriveHttpClient,
5486    dispatch_state: &WsDispatchState,
5487    client_order_id: ClientOrderId,
5488    identity: OrderIdentity,
5489    current: DeriveOrder,
5490    mut proven_legs: Vec<VenueOrderId>,
5491    known_orders: &[&DeriveOrder],
5492) -> anyhow::Result<Vec<DeriveOrder>> {
5493    let current_venue_order_id = VenueOrderId::new_checked(&current.order_id)?;
5494    proven_legs.retain(|id| *id != current_venue_order_id);
5495    proven_legs.insert(0, current_venue_order_id);
5496    let mut visited = AHashSet::new();
5497    let mut orders = Vec::new();
5498
5499    for mut venue_order_id in proven_legs {
5500        let mut ancestry = AHashSet::new();
5501
5502        loop {
5503            anyhow::ensure!(
5504                ancestry.insert(venue_order_id),
5505                "Cyclic native replacement ancestry"
5506            );
5507
5508            if !visited.insert(venue_order_id) {
5509                break;
5510            }
5511
5512            let order = if venue_order_id == current_venue_order_id {
5513                current.clone()
5514            } else if let Some(order) = known_orders
5515                .iter()
5516                .filter(|order| order.order_id == venue_order_id.as_str())
5517                .max_by_key(|order| order.last_update_timestamp)
5518            {
5519                (**order).clone()
5520            } else {
5521                fetch_order_record(
5522                    http_client,
5523                    dispatch_state.subaccount_id(),
5524                    venue_order_id,
5525                    Some(identity.instrument_id),
5526                )
5527                .await?
5528            };
5529
5530            validate_replacement_order(
5531                &order,
5532                client_order_id,
5533                identity,
5534                dispatch_state,
5535                venue_order_id,
5536                current_venue_order_id,
5537            )?;
5538
5539            let previous = order.replaced_order_id.clone();
5540            orders.push(order);
5541
5542            let Some(previous) = previous else {
5543                break;
5544            };
5545
5546            venue_order_id = VenueOrderId::new_checked(previous)?;
5547        }
5548    }
5549
5550    Ok(orders)
5551}
5552
5553fn validate_replacement_order(
5554    order: &DeriveOrder,
5555    client_order_id: ClientOrderId,
5556    identity: OrderIdentity,
5557    dispatch_state: &WsDispatchState,
5558    venue_order_id: VenueOrderId,
5559    current_venue_order_id: VenueOrderId,
5560) -> anyhow::Result<()> {
5561    anyhow::ensure!(
5562        order_response_matches(
5563            order,
5564            client_order_id,
5565            identity.instrument_id,
5566            dispatch_state
5567        ) && order.order_id == venue_order_id.as_str(),
5568        "Native replacement order identity does not match"
5569    );
5570
5571    let side = match order.direction {
5572        DeriveOrderSide::Buy => OrderSide::Buy,
5573        DeriveOrderSide::Sell => OrderSide::Sell,
5574    };
5575
5576    anyhow::ensure!(
5577        side == identity.order_side,
5578        "Native replacement order side does not match"
5579    );
5580    anyhow::ensure!(
5581        derive_order_type_to_nautilus_for_order(order.order_type, order.trigger_type)?
5582            == identity.order_type,
5583        "Native replacement order type does not match"
5584    );
5585    anyhow::ensure!(
5586        order.amount > Decimal::ZERO
5587            && order.filled_amount >= Decimal::ZERO
5588            && order.filled_amount <= order.amount,
5589        "Invalid native replacement amount or filled amount"
5590    );
5591
5592    if venue_order_id != current_venue_order_id {
5593        anyhow::ensure!(
5594            matches!(
5595                order.order_status,
5596                DeriveOrderStatus::Cancelled
5597                    | DeriveOrderStatus::Filled
5598                    | DeriveOrderStatus::Expired
5599            ),
5600            "Native replacement ancestor is not closed"
5601        );
5602    }
5603
5604    Ok(())
5605}
5606
5607async fn fetch_order_record(
5608    http_client: &DeriveHttpClient,
5609    subaccount_id: u64,
5610    venue_order_id: VenueOrderId,
5611    instrument_id: Option<InstrumentId>,
5612) -> anyhow::Result<DeriveOrder> {
5613    let missing = match http_client
5614        .get_order(&DeriveGetOrderParams::new(
5615            subaccount_id,
5616            venue_order_id.as_str(),
5617        ))
5618        .await
5619    {
5620        Ok(order) => return Ok(order),
5621        Err(e) if matches!(e, DeriveHttpError::JsonRpc { code: 11006, .. }) => e,
5622        Err(e) => return Err(e.into()),
5623    };
5624
5625    let mut pages = PaginationCursor::new();
5626
5627    loop {
5628        let mut params =
5629            DeriveGetOrderHistoryParams::new(subaccount_id, pages.page(), DERIVE_PRIVATE_PAGE_SIZE);
5630
5631        if let Some(instrument_id) = instrument_id {
5632            params = params.with_instrument_name(format_venue_symbol(&instrument_id)?);
5633        }
5634
5635        let result = http_client.get_order_history(&params).await?;
5636        if pages.restart_if_changed(&result.pagination)? {
5637            continue;
5638        }
5639
5640        let more = pages.advance(
5641            &result.pagination,
5642            result.orders.iter().map(|order| order.order_id.as_str()),
5643        )?;
5644
5645        if let Some(order) = result
5646            .orders
5647            .into_iter()
5648            .find(|order| order.order_id == venue_order_id.as_str())
5649        {
5650            return Ok(order);
5651        }
5652
5653        if !more {
5654            return Err(missing.into());
5655        }
5656    }
5657}
5658
5659fn quantity_from_report_decimal(value: Decimal, precision: Option<u8>) -> anyhow::Result<Quantity> {
5660    let precision = precision.unwrap_or_else(|| value.normalize().scale() as u8);
5661    Quantity::from_decimal_dp(value, precision)
5662        .context("native cumulative report quantity cannot be represented")
5663}
5664
5665fn decimal_from_scaled(mut value: U256) -> anyhow::Result<Decimal> {
5666    let mut scale = DECIMAL_SCALE.ilog10();
5667    let ten = U256::from(10_u8);
5668    while scale > 0 && value % ten == U256::ZERO {
5669        value /= ten;
5670        scale -= 1;
5671    }
5672
5673    let coefficient =
5674        u128::try_from(value).context("native amount exceeds exact decimal coefficient range")?;
5675    let coefficient = i128::try_from(coefficient)
5676        .context("native amount exceeds signed decimal coefficient range")?;
5677    Decimal::try_from_i128_with_scale(coefficient, scale)
5678        .context("native amount cannot be represented exactly")
5679}
5680
5681fn flush_pending_delivery(
5682    emitter: &ExecutionEventEmitter,
5683    account_id: AccountId,
5684    clock: &'static AtomicTime,
5685    dispatch_state: &WsDispatchState,
5686) {
5687    let _delivery = dispatch_state.delivery_guard();
5688    for (client_order_id, completion) in dispatch_state.replace_completions() {
5689        if dispatch_replace_completion(
5690            client_order_id,
5691            &completion,
5692            emitter,
5693            account_id,
5694            clock,
5695            dispatch_state,
5696        ) {
5697            dispatch_state.clear_replace_completion(&client_order_id);
5698        }
5699    }
5700
5701    dispatch_trades_payload(
5702        DeriveTradesSubscriptionData {
5703            trades: dispatch_state.take_undelivered_trades(),
5704        },
5705        emitter,
5706        account_id,
5707        clock,
5708        dispatch_state,
5709    );
5710}
5711
5712fn dispatch_replace_completion(
5713    client_order_id: ClientOrderId,
5714    completion: &ReplaceCompletion,
5715    emitter: &ExecutionEventEmitter,
5716    account_id: AccountId,
5717    clock: &'static AtomicTime,
5718    dispatch_state: &WsDispatchState,
5719) -> bool {
5720    let identity = completion.identity;
5721    let old_venue_order_id = completion.old_venue_order_id;
5722    let ts_init = clock.get_time_ns();
5723    dispatch_trades_payload(
5724        DeriveTradesSubscriptionData {
5725            trades: completion.trades.clone(),
5726        },
5727        emitter,
5728        account_id,
5729        clock,
5730        dispatch_state,
5731    );
5732
5733    if dispatch_state.pending_modify(&client_order_id) != Some(old_venue_order_id)
5734        && (dispatch_state.identity(&client_order_id).is_none()
5735            || dispatch_state
5736                .bound_venue_order_id(&client_order_id)
5737                .is_some_and(|bound| bound != old_venue_order_id))
5738    {
5739        return true;
5740    }
5741
5742    let Some(outcome) = decode_replace_completion(client_order_id, completion, dispatch_state)
5743    else {
5744        return false;
5745    };
5746
5747    match &outcome {
5748        DeriveReplaceOutcome::Replaced(order) => {
5749            if order.nonce != completion.nonce {
5750                log::warn!(
5751                    "Derive replacement nonce does not match {client_order_id}; awaiting reconciliation"
5752                );
5753                return false;
5754            }
5755
5756            let Ok(new_venue_order_id) = VenueOrderId::new_checked(&order.order_id) else {
5757                log::warn!(
5758                    "Derive replacement response has an invalid order ID for {client_order_id}, awaiting reconciliation"
5759                );
5760                return false;
5761            };
5762
5763            if dispatch_state.pending_modify(&client_order_id) == Some(old_venue_order_id)
5764                && !emit_modify_target(
5765                    emitter,
5766                    dispatch_state,
5767                    client_order_id,
5768                    identity,
5769                    new_venue_order_id,
5770                    account_id,
5771                    ts_init,
5772                    ts_init,
5773                )
5774            {
5775                return false;
5776            }
5777
5778            dispatch_trades_payload(
5779                DeriveTradesSubscriptionData {
5780                    trades: dispatch_state.take_deferred_trades(&client_order_id),
5781                },
5782                emitter,
5783                account_id,
5784                clock,
5785                dispatch_state,
5786            );
5787
5788            dispatch_order_result(
5789                DeriveOrderResult {
5790                    order: order.clone(),
5791                    trades: vec![],
5792                },
5793                client_order_id,
5794                emitter,
5795                account_id,
5796                clock,
5797                dispatch_state,
5798            );
5799
5800            true
5801        }
5802        DeriveReplaceOutcome::Canceled {
5803            cancelled_order,
5804            create_order_error,
5805        } => {
5806            if dispatch_state.pending_modify(&client_order_id) != Some(old_venue_order_id) {
5807                return true;
5808            }
5809
5810            if !ensure_canceled_emitted(
5811                emitter,
5812                dispatch_state,
5813                client_order_id,
5814                identity,
5815                old_venue_order_id,
5816                account_id,
5817                ts_init,
5818                ts_init,
5819            ) {
5820                return false;
5821            }
5822
5823            log::warn!(
5824                "Derive cancels {client_order_id} ({}) without creating its replacement: JSON-RPC {}: {}",
5825                cancelled_order.order_id,
5826                create_order_error.code,
5827                create_order_error.message
5828            );
5829            dispatch_state.forget(&client_order_id);
5830            dispatch_trades_payload(
5831                DeriveTradesSubscriptionData {
5832                    trades: dispatch_state.take_deferred_trades(&client_order_id),
5833                },
5834                emitter,
5835                account_id,
5836                clock,
5837                dispatch_state,
5838            );
5839
5840            true
5841        }
5842    }
5843}
5844
5845fn decode_replace_completion(
5846    client_order_id: ClientOrderId,
5847    completion: &ReplaceCompletion,
5848    dispatch_state: &WsDispatchState,
5849) -> Option<DeriveReplaceOutcome> {
5850    let identity = completion.identity;
5851    let old_venue_order_id = completion.old_venue_order_id;
5852
5853    let Ok(expected_instrument) = format_venue_symbol(&identity.instrument_id) else {
5854        log::warn!("Cannot correlate Derive replacement instrument for {client_order_id}");
5855        return None;
5856    };
5857
5858    let result = match &completion.result {
5859        Ok(result) => result.clone(),
5860        Err(e) => {
5861            log::warn!(
5862                "Cannot decode Derive replacement authority for {client_order_id}: {e}; awaiting reconciliation"
5863            );
5864            return None;
5865        }
5866    };
5867
5868    match result.into_outcome(
5869        old_venue_order_id.as_str(),
5870        client_order_id.as_str(),
5871        dispatch_state.subaccount_id(),
5872        expected_instrument.as_str(),
5873    ) {
5874        Ok(outcome) => Some(outcome),
5875        Err(e) => {
5876            log::warn!(
5877                "Derive replacement response does not match {client_order_id}: {e}, awaiting reconciliation"
5878            );
5879            None
5880        }
5881    }
5882}
5883
5884fn dispatch_order_result(
5885    result: DeriveOrderResult,
5886    client_order_id: ClientOrderId,
5887    emitter: &ExecutionEventEmitter,
5888    account_id: AccountId,
5889    clock: &'static AtomicTime,
5890    dispatch_state: &WsDispatchState,
5891) {
5892    let _delivery = dispatch_state.delivery_guard();
5893    let mut is_current = false;
5894
5895    if let Some(identity) = dispatch_state.identity(&client_order_id) {
5896        if !order_response_matches(
5897            &result.order,
5898            client_order_id,
5899            identity.instrument_id,
5900            dispatch_state,
5901        ) {
5902            log::warn!(
5903                "Derive order response does not match {client_order_id}, awaiting reconciliation"
5904            );
5905        } else if let Ok(venue_order_id) = VenueOrderId::new_checked(&result.order.order_id) {
5906            is_current = dispatch_state
5907                .bound_venue_order_id(&client_order_id)
5908                .is_none_or(|bound| bound == venue_order_id);
5909            if is_current
5910                && !matches!(
5911                    result.order.order_status,
5912                    DeriveOrderStatus::Rejected | DeriveOrderStatus::Unknown
5913                )
5914            {
5915                dispatch_state.record_venue_order_id(client_order_id, venue_order_id);
5916                let ts = clock.get_time_ns();
5917                ensure_accepted_emitted(
5918                    emitter,
5919                    dispatch_state,
5920                    client_order_id,
5921                    identity,
5922                    venue_order_id,
5923                    account_id,
5924                    ts,
5925                    ts,
5926                );
5927            }
5928        } else {
5929            log::warn!(
5930                "Derive submit outcome for {:?} on {:?} has an invalid response order_id; awaiting reconciliation",
5931                client_order_id.as_str(),
5932                identity.instrument_id.to_string(),
5933            );
5934        }
5935    }
5936
5937    dispatch_trades_payload(
5938        DeriveTradesSubscriptionData {
5939            trades: result.trades,
5940        },
5941        emitter,
5942        account_id,
5943        clock,
5944        dispatch_state,
5945    );
5946
5947    if is_current {
5948        dispatch_orders_payload(
5949            DeriveOrdersSubscriptionData {
5950                orders: vec![result.order],
5951            },
5952            emitter,
5953            account_id,
5954            clock,
5955            dispatch_state,
5956        );
5957    }
5958}
5959
5960fn order_response_matches(
5961    order: &DeriveOrder,
5962    client_order_id: ClientOrderId,
5963    instrument_id: InstrumentId,
5964    dispatch_state: &WsDispatchState,
5965) -> bool {
5966    dispatch_state.owns_subaccount(order.subaccount_id)
5967        && order.label == client_order_id.as_str()
5968        && format_instrument_id(order.instrument_name).is_ok_and(|id| id == instrument_id)
5969}
5970
5971fn tracked_order_identity(
5972    client_order_id: Option<ClientOrderId>,
5973    instrument_id: InstrumentId,
5974    dispatch_state: &WsDispatchState,
5975) -> Option<(ClientOrderId, OrderIdentity)> {
5976    client_order_id.and_then(|cid| {
5977        dispatch_state
5978            .identity(&cid)
5979            .filter(|identity| identity.instrument_id == instrument_id)
5980            .map(|identity| (cid, identity))
5981    })
5982}
5983
5984// Preserve Submitted -> Accepted -> ... when a fill or terminal event precedes
5985// or replaces the venue's Open notice.
5986#[expect(clippy::too_many_arguments)]
5987fn ensure_accepted_emitted(
5988    emitter: &ExecutionEventEmitter,
5989    dispatch_state: &WsDispatchState,
5990    client_order_id: ClientOrderId,
5991    identity: OrderIdentity,
5992    venue_order_id: VenueOrderId,
5993    account_id: AccountId,
5994    ts_event: UnixNanos,
5995    ts_init: UnixNanos,
5996) -> bool {
5997    let _delivery = dispatch_state.delivery_guard();
5998    if dispatch_state.contains_accepted(&client_order_id) {
5999        return true;
6000    }
6001
6002    let accepted = OrderAccepted::new(
6003        emitter.trader_id(),
6004        identity.strategy_id,
6005        identity.instrument_id,
6006        client_order_id,
6007        venue_order_id,
6008        account_id,
6009        UUID4::new(),
6010        ts_event,
6011        ts_init,
6012        false,
6013    );
6014
6015    if let Err(e) = emitter.try_send_order_event(OrderEventAny::Accepted(accepted)) {
6016        log::warn!("Failed to deliver Derive accepted for {client_order_id}: {e}");
6017        return false;
6018    }
6019
6020    dispatch_state.mark_accepted(client_order_id);
6021    true
6022}
6023
6024#[expect(clippy::too_many_arguments)]
6025fn ensure_canceled_emitted(
6026    emitter: &ExecutionEventEmitter,
6027    dispatch_state: &WsDispatchState,
6028    client_order_id: ClientOrderId,
6029    identity: OrderIdentity,
6030    venue_order_id: VenueOrderId,
6031    account_id: AccountId,
6032    ts_event: UnixNanos,
6033    ts_init: UnixNanos,
6034) -> bool {
6035    let _delivery = dispatch_state.delivery_guard();
6036    if dispatch_state.contains_canceled(&client_order_id) {
6037        return true;
6038    }
6039
6040    let canceled = OrderCanceled::new(
6041        emitter.trader_id(),
6042        identity.strategy_id,
6043        identity.instrument_id,
6044        client_order_id,
6045        UUID4::new(),
6046        ts_event,
6047        ts_init,
6048        false,
6049        Some(venue_order_id),
6050        Some(account_id),
6051        None,
6052    );
6053
6054    if let Err(e) = emitter.try_send_order_event(OrderEventAny::Canceled(canceled)) {
6055        log::warn!("Failed to deliver Derive canceled for {client_order_id}: {e}");
6056        return false;
6057    }
6058
6059    dispatch_state.mark_canceled(client_order_id);
6060    true
6061}
6062
6063fn emit_tracked_order_event(
6064    emitter: &ExecutionEventEmitter,
6065    dispatch_state: &WsDispatchState,
6066    client_order_id: ClientOrderId,
6067    identity: OrderIdentity,
6068    report: &OrderStatusReport,
6069    account_id: AccountId,
6070    ts_init: UnixNanos,
6071) {
6072    let venue_order_id = report.venue_order_id;
6073    let ts_accepted = report.ts_accepted;
6074    let ts_event = report.ts_last;
6075
6076    // A `private/replace` cancels the old order and opens a new one under the
6077    // same label; suppress events for the superseded old venue order id so they
6078    // don't terminate the order that `modify_order` rebinds via `OrderUpdated`.
6079    // `pending_modify` covers the in-flight window; the bound-id check covers
6080    // after the rebind.
6081    if report.order_status == OrderStatus::Canceled
6082        && dispatch_state.pending_modify(&client_order_id) == Some(venue_order_id)
6083    {
6084        log::debug!(
6085            "Skipping cancel-replace leg for {client_order_id}: stale venue_order_id={venue_order_id}",
6086        );
6087        return;
6088    }
6089
6090    if let Some(bound) = dispatch_state.bound_venue_order_id(&client_order_id)
6091        && bound != venue_order_id
6092    {
6093        log::debug!(
6094            "Skipping stale {:?} for {client_order_id}: venue_order_id={venue_order_id} superseded by {bound}",
6095            report.order_status
6096        );
6097        return;
6098    }
6099
6100    if dispatch_state.binding_unresolved(&client_order_id) && report.order_status.is_closed() {
6101        log::debug!(
6102            "Deferring terminal Derive status for {client_order_id} while venue binding is unresolved"
6103        );
6104        return;
6105    }
6106
6107    if matches!(
6108        report.order_status,
6109        OrderStatus::Accepted | OrderStatus::PartiallyFilled
6110    ) && dispatch_state.contains_filled(&client_order_id)
6111    {
6112        log::debug!("Skipping stale Accepted for {client_order_id} (already filled)");
6113        return;
6114    }
6115
6116    if matches!(
6117        report.order_status,
6118        OrderStatus::Accepted | OrderStatus::PartiallyFilled | OrderStatus::Filled
6119    ) {
6120        dispatch_state.record_venue_order_id(client_order_id, venue_order_id);
6121    }
6122
6123    if matches!(
6124        report.order_status,
6125        OrderStatus::Accepted
6126            | OrderStatus::PartiallyFilled
6127            | OrderStatus::Filled
6128            | OrderStatus::Canceled
6129            | OrderStatus::Expired
6130    ) && !ensure_accepted_emitted(
6131        emitter,
6132        dispatch_state,
6133        client_order_id,
6134        identity,
6135        venue_order_id,
6136        account_id,
6137        ts_accepted,
6138        ts_init,
6139    ) {
6140        return;
6141    }
6142
6143    match report.order_status {
6144        OrderStatus::Accepted | OrderStatus::PartiallyFilled => {}
6145        OrderStatus::Filled => {
6146            // The final trades frame can follow the terminal order notice.
6147            dispatch_state.mark_filled(client_order_id);
6148        }
6149        OrderStatus::Canceled => {
6150            if !ensure_canceled_emitted(
6151                emitter,
6152                dispatch_state,
6153                client_order_id,
6154                identity,
6155                venue_order_id,
6156                account_id,
6157                ts_event,
6158                ts_init,
6159            ) {
6160                return;
6161            }
6162
6163            dispatch_state.record_canceled(client_order_id, report.quantity, report.filled_qty);
6164        }
6165        OrderStatus::Expired | OrderStatus::Rejected => {
6166            emit_expiry_or_rejection(
6167                emitter,
6168                dispatch_state,
6169                client_order_id,
6170                identity,
6171                report,
6172                account_id,
6173                ts_init,
6174            );
6175        }
6176        other => {
6177            log::debug!(
6178                "Unhandled tracked order status {other:?} for {client_order_id}, sending as report",
6179            );
6180            emitter.send_order_status_report(report.clone());
6181        }
6182    }
6183}
6184
6185fn emit_expiry_or_rejection(
6186    emitter: &ExecutionEventEmitter,
6187    dispatch_state: &WsDispatchState,
6188    client_order_id: ClientOrderId,
6189    identity: OrderIdentity,
6190    report: &OrderStatusReport,
6191    account_id: AccountId,
6192    ts_init: UnixNanos,
6193) {
6194    let venue_order_id = report.venue_order_id;
6195    let ts_event = report.ts_last;
6196
6197    let (event, status) = if report.order_status == OrderStatus::Rejected {
6198        if dispatch_state.identity(&client_order_id).is_none() {
6199            return;
6200        }
6201
6202        let reason = report
6203            .cancel_reason
6204            .as_deref()
6205            .unwrap_or("Order rejected by Derive");
6206        let due_post_only = derive_rejection_due_post_only(None, reason);
6207
6208        let event = OrderRejected::new(
6209            emitter.trader_id(),
6210            identity.strategy_id,
6211            identity.instrument_id,
6212            client_order_id,
6213            account_id,
6214            Ustr::from(&strategy_rejection_reason(reason)),
6215            UUID4::new(),
6216            ts_event,
6217            ts_init,
6218            false,
6219            due_post_only,
6220        );
6221        (OrderEventAny::Rejected(event), "rejected")
6222    } else {
6223        let event = OrderExpired::new(
6224            emitter.trader_id(),
6225            identity.strategy_id,
6226            identity.instrument_id,
6227            client_order_id,
6228            UUID4::new(),
6229            ts_event,
6230            ts_init,
6231            false,
6232            Some(venue_order_id),
6233            Some(account_id),
6234        );
6235        (OrderEventAny::Expired(event), "expired")
6236    };
6237
6238    if let Err(e) = emitter.try_send_order_event(event) {
6239        log::warn!("Failed to deliver Derive {status} for {client_order_id}: {e}");
6240        return;
6241    }
6242
6243    dispatch_state.forget(&client_order_id);
6244}
6245
6246#[expect(clippy::too_many_arguments)]
6247fn emit_modify_target(
6248    emitter: &ExecutionEventEmitter,
6249    dispatch_state: &WsDispatchState,
6250    client_order_id: ClientOrderId,
6251    identity: OrderIdentity,
6252    venue_order_id: VenueOrderId,
6253    account_id: AccountId,
6254    ts_event: UnixNanos,
6255    ts_init: UnixNanos,
6256) -> bool {
6257    if let Some((quantity, price)) = dispatch_state.modify_target(&client_order_id) {
6258        if let Err(e) = emitter.try_send_order_event(OrderEventAny::Updated(OrderUpdated::new(
6259            emitter.trader_id(),
6260            identity.strategy_id,
6261            identity.instrument_id,
6262            client_order_id,
6263            quantity,
6264            UUID4::new(),
6265            ts_event,
6266            ts_init,
6267            false,
6268            Some(venue_order_id),
6269            Some(account_id),
6270            price,
6271            None,
6272            None,
6273            false,
6274        ))) {
6275            log::warn!("Failed to deliver Derive modify for {client_order_id}: {e}");
6276            return false;
6277        }
6278
6279        dispatch_state.record_order_shape(client_order_id, quantity, price);
6280        dispatch_state.take_modify_target(&client_order_id);
6281    }
6282
6283    if let Some(old_venue_order_id) = dispatch_state.pending_modify(&client_order_id) {
6284        dispatch_state.take_pending_modify(
6285            &client_order_id,
6286            old_venue_order_id,
6287            Some(venue_order_id),
6288        );
6289    }
6290
6291    true
6292}
6293
6294fn emit_tracked_fill(
6295    emitter: &ExecutionEventEmitter,
6296    dispatch_state: &WsDispatchState,
6297    client_order_id: ClientOrderId,
6298    identity: OrderIdentity,
6299    report: &FillReport,
6300    account_id: AccountId,
6301    ts_init: UnixNanos,
6302) -> bool {
6303    if !ensure_accepted_emitted(
6304        emitter,
6305        dispatch_state,
6306        client_order_id,
6307        identity,
6308        report.venue_order_id,
6309        account_id,
6310        report.ts_event,
6311        ts_init,
6312    ) {
6313        return false;
6314    }
6315
6316    let filled = OrderFilled::new(
6317        emitter.trader_id(),
6318        identity.strategy_id,
6319        identity.instrument_id,
6320        client_order_id,
6321        report.venue_order_id,
6322        account_id,
6323        report.trade_id,
6324        identity.order_side,
6325        identity.order_type,
6326        report.last_qty,
6327        report.last_px,
6328        report.commission.currency,
6329        report.liquidity_side,
6330        UUID4::new(),
6331        report.ts_event,
6332        ts_init,
6333        false,
6334        report.venue_position_id,
6335        Some(report.commission),
6336        None,
6337    );
6338
6339    if let Err(e) = emitter.try_send_order_event(OrderEventAny::Filled(filled)) {
6340        log::warn!("Failed to deliver Derive fill for {client_order_id}: {e}");
6341        return false;
6342    }
6343
6344    dispatch_state.record_fill(client_order_id, report.last_qty);
6345    true
6346}
6347
6348// The EIP-712 limit_price bounds the market sweep; reject non-positive bounds
6349// so the caller rejects the order instead of signing an invalid limit.
6350fn market_order_limit_price(
6351    quote: &QuoteTick,
6352    side: OrderSide,
6353    slippage_bps: u32,
6354    tick_size: Decimal,
6355) -> Option<Decimal> {
6356    let bps = Decimal::from(slippage_bps);
6357    let scale = Decimal::from(10_000_u32);
6358    let one = Decimal::ONE;
6359    let raw = match side {
6360        OrderSide::Buy => quote.ask_price.as_decimal() * (one + bps / scale),
6361        OrderSide::Sell => quote.bid_price.as_decimal() * (one - bps / scale),
6362    };
6363
6364    let rounded = round_to_tick(raw, tick_size, side);
6365    if rounded <= Decimal::ZERO {
6366        return None;
6367    }
6368
6369    Some(rounded)
6370}
6371
6372fn trigger_market_limit_price(
6373    trigger_price: Decimal,
6374    side: OrderSide,
6375    slippage_bps: u32,
6376    tick_size: Decimal,
6377) -> Option<Decimal> {
6378    let bps = Decimal::from(slippage_bps);
6379    let scale = Decimal::from(10_000_u32);
6380    let one = Decimal::ONE;
6381    let raw = match side {
6382        OrderSide::Buy => trigger_price * (one + bps / scale),
6383        OrderSide::Sell => trigger_price * (one - bps / scale),
6384    };
6385
6386    let rounded = round_to_tick(raw, tick_size, side);
6387    if rounded <= Decimal::ZERO {
6388        return None;
6389    }
6390
6391    Some(rounded)
6392}
6393
6394fn is_derive_trigger_order_type(order_type: OrderType) -> bool {
6395    matches!(
6396        order_type,
6397        OrderType::StopMarket
6398            | OrderType::StopLimit
6399            | OrderType::MarketIfTouched
6400            | OrderType::LimitIfTouched
6401    )
6402}
6403
6404fn resolve_submit_nonce(
6405    nonce: Result<u64, NonceError>,
6406    emitter: &ExecutionEventEmitter,
6407    dispatch_state: &WsDispatchState,
6408    order: &OrderAny,
6409    clock: &'static AtomicTime,
6410) -> Option<u64> {
6411    match nonce {
6412        Ok(nonce) => Some(nonce),
6413        Err(e) => {
6414            let reason = format!("nonce allocation failed: {e}");
6415            log::warn!("Cannot submit order {}: {reason}", order.client_order_id());
6416            dispatch_state.forget(&order.client_order_id());
6417            emit_submit_failure(
6418                emitter,
6419                order,
6420                CommandFailure::not_sent(&reason),
6421                clock.get_time_ns(),
6422                false,
6423            );
6424            None
6425        }
6426    }
6427}
6428
6429#[expect(
6430    clippy::too_many_arguments,
6431    reason = "Failure emission retains order identity and command correlation"
6432)]
6433fn resolve_modify_nonce(
6434    nonce: Result<u64, NonceError>,
6435    emitter: &ExecutionEventEmitter,
6436    strategy_id: StrategyId,
6437    instrument_id: InstrumentId,
6438    client_order_id: ClientOrderId,
6439    venue_order_id: VenueOrderId,
6440    clock: &'static AtomicTime,
6441    causation_id: Option<UUID4>,
6442) -> Option<u64> {
6443    match nonce {
6444        Ok(nonce) => Some(nonce),
6445        Err(e) => {
6446            let reason = format!("nonce allocation failed: {e}");
6447            log::warn!("Cannot modify order {client_order_id}: {reason}");
6448            emit_modify_failure(
6449                emitter,
6450                strategy_id,
6451                instrument_id,
6452                client_order_id,
6453                Some(venue_order_id),
6454                CommandFailure::not_sent(&reason),
6455                clock.get_time_ns(),
6456                causation_id,
6457            );
6458            None
6459        }
6460    }
6461}
6462
6463fn normal_order_signature_expiry(
6464    clock: &'static AtomicTime,
6465    signature_expiry_secs: u64,
6466) -> anyhow::Result<i64> {
6467    let min_ttl_secs = MIN_SIGNATURE_TTL.as_secs();
6468    if signature_expiry_secs <= min_ttl_secs {
6469        anyhow::bail!(
6470            "signature_expiry_secs {signature_expiry_secs}s must be greater than the Derive minimum {min_ttl_secs}s"
6471        );
6472    }
6473
6474    if signature_expiry_secs > 120 * 24 * 60 * 60 {
6475        anyhow::bail!("signature_expiry_secs exceeds the Derive maximum of 120 days");
6476    }
6477
6478    let now_secs_u64 = clock.get_time_ns().as_u64() / 1_000_000_000;
6479
6480    let now_secs = i64::try_from(now_secs_u64).with_context(|| {
6481        format!("current UNIX time {now_secs_u64}s cannot fit in Derive signature_expiry_sec")
6482    })?;
6483
6484    let ttl_secs = i64::try_from(signature_expiry_secs).with_context(|| {
6485        format!(
6486            "signature_expiry_secs {signature_expiry_secs}s cannot fit in Derive signature_expiry_sec"
6487        )
6488    })?;
6489
6490    now_secs.checked_add(ttl_secs).ok_or_else(|| {
6491        anyhow::anyhow!(
6492            "signature expiry overflows Derive signature_expiry_sec: now {now_secs}s plus TTL {ttl_secs}s"
6493        )
6494    })
6495}
6496
6497async fn refresh_market_order_quote(
6498    http_client: &DeriveHttpClient,
6499    venue_symbol: &str,
6500    instrument: &DeriveInstrument,
6501    clock: &'static AtomicTime,
6502) -> anyhow::Result<QuoteTick> {
6503    let ticker = http_client.get_ticker(venue_symbol).await?;
6504    let price_precision =
6505        Price::from_decimal_dp(instrument.tick_size, instrument.tick_size.scale() as u8)
6506            .with_context(|| format!("invalid Derive tick_size for {venue_symbol}"))?
6507            .precision;
6508    let size_precision =
6509        Quantity::from_decimal_dp(instrument.amount_step, instrument.amount_step.scale() as u8)
6510            .with_context(|| format!("invalid Derive amount_step for {venue_symbol}"))?
6511            .precision;
6512
6513    parse_ticker_quote_from_rest(
6514        &ticker,
6515        price_precision,
6516        size_precision,
6517        clock.get_time_ns(),
6518    )
6519}
6520
6521// Round buys up and sells down so tick alignment does not tighten the signed bound
6522fn round_to_tick(value: Decimal, tick_size: Decimal, side: OrderSide) -> Decimal {
6523    if tick_size <= Decimal::ZERO {
6524        return value;
6525    }
6526
6527    let ratio = value / tick_size;
6528    let ticks = match side {
6529        OrderSide::Buy => ratio.ceil(),
6530        OrderSide::Sell => ratio.floor(),
6531    };
6532
6533    ticks * tick_size
6534}
6535
6536async fn cached_or_fetch_instrument(
6537    http_client: &DeriveHttpClient,
6538    instruments: &Arc<AtomicMap<InstrumentId, Arc<DeriveInstrument>>>,
6539    instrument_id: &InstrumentId,
6540    venue_symbol: &str,
6541) -> anyhow::Result<DeriveInstrument> {
6542    if let Some(cached) = instruments.get_cloned(instrument_id) {
6543        return Ok((*cached).clone());
6544    }
6545
6546    let instrument = http_client
6547        .get_instrument(venue_symbol)
6548        .await
6549        .with_context(|| format!("failed to fetch instrument {venue_symbol}"))?;
6550    instruments.insert(*instrument_id, Arc::new(instrument.clone()));
6551    Ok(instrument)
6552}
6553
6554#[cfg(test)]
6555mod tests {
6556    use std::{cell::RefCell, rc::Rc};
6557
6558    use nautilus_common::{
6559        cache::Cache,
6560        messages::{ExecutionEvent, ExecutionReport},
6561    };
6562    use nautilus_core::UnixNanos;
6563    use nautilus_live::ExecutionClientCore;
6564    use nautilus_model::{
6565        data::QuoteTick,
6566        enums::{AccountType, LiquiditySide, OmsType, TimeInForce},
6567        events::OrderFillVoided,
6568        identifiers::{AccountId, ClientId, InstrumentId, StrategyId, TradeId, TraderId},
6569        orders::OrderTestBuilder,
6570        types::{Money, Price, Quantity},
6571    };
6572    use rstest::rstest;
6573    use rust_decimal_macros::dec;
6574
6575    use super::*;
6576    use crate::{
6577        client_logging,
6578        common::{
6579            consts::DERIVE,
6580            enums::{DeriveEnvironment, DeriveOrderStatus, DeriveOrderType},
6581        },
6582        websocket::WsSubscriptionPayload,
6583    };
6584
6585    #[tokio::test]
6586    async fn test_report_precision_warns_for_historical_miss() {
6587        let client = DeriveExecutionClient::new(test_core(), test_config()).unwrap();
6588        let context = client.reconciliation_context();
6589        let _capture = client_logging::capture_logs().await;
6590        let precision = context.report_precision("EXPIRED-PERP", false).unwrap();
6591
6592        assert_eq!(precision, (None, None));
6593        assert_eq!(client_logging::messages(), vec![(
6594            log::Level::Warn,
6595            "Missing Derive instrument metadata for historical record on EXPIRED-PERP; coverage is incomplete".to_string(),
6596        )]);
6597    }
6598
6599    #[tokio::test]
6600    async fn test_instrument_scope_logs_only_excluded_records_at_debug() {
6601        let _capture = client_logging::capture_logs().await;
6602        let ids = [InstrumentId::from("ETH-PERP.DERIVE")];
6603        let included = instrument_in_scope("ETH-PERP", Some(&ids));
6604        let excluded = instrument_in_scope("BTC-PERP", Some(&ids));
6605        let unset = instrument_in_scope("BTC-PERP", None);
6606        let empty = instrument_in_scope("BTC-PERP", Some(&[]));
6607
6608        assert!(included);
6609        assert!(!excluded);
6610        assert!(unset);
6611        assert!(empty);
6612        assert_eq!(
6613            client_logging::messages(),
6614            vec![(
6615                log::Level::Debug,
6616                "Skipping Derive record for out-of-scope instrument BTC-PERP".to_string(),
6617            )]
6618        );
6619    }
6620
6621    #[derive(Debug)]
6622    struct ReconciliationTimeSender(tokio::sync::mpsc::UnboundedSender<TimeEventMessage>);
6623
6624    impl TimeEventSender for ReconciliationTimeSender {
6625        fn send(&self, message: TimeEventMessage) {
6626            let _ = self.0.send(message);
6627        }
6628    }
6629
6630    #[rstest]
6631    #[case::markup("<b>Insufficient</b>\n\tmargin\u{0}", "11008: Insufficient margin")]
6632    #[case::blank("<p>\u{0}\n</p>", "11008: Order command rejected")]
6633    #[case::unicode("  Échec   de\r budget  ", "11008: Échec de budget")]
6634    fn test_ws_rejection_reason_is_bounded_venue_text(
6635        #[case] message: &str,
6636        #[case] expected: &str,
6637    ) {
6638        let error = DeriveWsError::JsonRpc {
6639            code: 11008,
6640            message: message.to_string(),
6641            data: None,
6642        };
6643
6644        let (reason, due_post_only) = ws_rejection_reason(&error);
6645        assert_eq!(reason, expected);
6646        assert!(due_post_only);
6647        assert_eq!(
6648            match error {
6649                DeriveWsError::JsonRpc { message, .. } => message,
6650                _ => unreachable!(),
6651            },
6652            message
6653        );
6654    }
6655
6656    #[rstest]
6657    fn test_ws_rejection_reason_limits_unicode_characters() {
6658        let message = "é".repeat(300);
6659
6660        let error = DeriveWsError::JsonRpc {
6661            code: 11009,
6662            message,
6663            data: None,
6664        };
6665
6666        let (reason, due_post_only) = ws_rejection_reason(&error);
6667        assert_eq!(reason, format!("11009: {}", "é".repeat(249)));
6668        assert_eq!(reason.chars().count(), 256);
6669        assert!(!due_post_only);
6670    }
6671
6672    #[rstest]
6673    #[case::not_connected(
6674        DeriveWsError::NotConnected,
6675        CommandFailure::not_sent("WebSocket client is not connected"),
6676        false
6677    )]
6678    #[case::local_pacing(
6679        DeriveWsError::RateLimited { retry_after: Duration::from_millis(125) },
6680        CommandFailure::not_sent("Local pacing reservation expired"),
6681        false
6682    )]
6683    #[case::credentials(DeriveWsError::MissingCredentials { operation: "private/order".into() }, CommandFailure::not_sent("Session credentials are missing"), false)]
6684    #[case::authentication(DeriveWsError::Authentication { operation: "private/order".into(), reason: "opaque sensitive detail".into() }, CommandFailure::not_sent("Session authentication failed"), false)]
6685    #[case::transport(
6686        DeriveWsError::transport("opaque sensitive URL"),
6687        CommandFailure::ambiguous("Transport outcome is unconfirmed"),
6688        false
6689    )]
6690    #[case::timeout(DeriveWsError::Timeout { method: "private/order".into() }, CommandFailure::ambiguous("Order response is unconfirmed"), false)]
6691    #[case::cancelled(DeriveWsError::RequestCancelled { method: "private/order".into() }, CommandFailure::ambiguous("Order response is unconfirmed"), false)]
6692    #[case::venue(DeriveWsError::JsonRpc { code: 11008, message: "Post only order cannot cross the market".into(), data: None }, CommandFailure::venue_rejected("11008: Post only order cannot cross the market"), true)]
6693    #[case::internal(DeriveWsError::JsonRpc { code: -32603, message: "Internal error".into(), data: None }, CommandFailure::ambiguous("-32603: Internal error"), false)]
6694    fn test_ws_command_failure_keeps_evidence_separate_from_retry(
6695        #[case] error: DeriveWsError,
6696        #[case] expected: CommandFailure,
6697        #[case] due_post_only: bool,
6698    ) {
6699        assert_eq!(ws_command_failure(&error), (expected, due_post_only));
6700    }
6701
6702    const TEST_WALLET: &str = "0x0000000000000000000000000000000000001234";
6703    const TEST_SESSION_KEY: &str =
6704        "0x2ae8be44db8a590d20bffbe3b6872df9b569147d3bf6801a35a28281a4816bbd";
6705    const TEST_SUBACCOUNT: u64 = 30769;
6706
6707    #[rstest]
6708    #[case::newer(200, OrderStatus::Accepted, OrderStatus::Accepted, true)]
6709    #[case::older(50, OrderStatus::Canceled, OrderStatus::Accepted, false)]
6710    #[case::same_time_active(100, OrderStatus::Canceled, OrderStatus::Accepted, false)]
6711    #[case::same_time_terminal(100, OrderStatus::Accepted, OrderStatus::Canceled, true)]
6712    fn test_duplicate_reports_keep_latest_and_terminal_at_equal_time(
6713        #[case] timestamp: u64,
6714        #[case] previous_status: OrderStatus,
6715        #[case] status: OrderStatus,
6716        #[case] choose_next: bool,
6717    ) {
6718        let native: DeriveOrder = serde_json::from_str(include_str!(
6719            "../test_data/perps/http_order_eth_partially_filled.json"
6720        ))
6721        .unwrap();
6722        let mut previous = parse_derive_order_to_report_with_precision(
6723            &native,
6724            AccountId::from("DERIVE-001"),
6725            Some(2),
6726            Some(3),
6727            UnixNanos::from(77),
6728        )
6729        .unwrap();
6730        previous.ts_last = UnixNanos::from(100);
6731        previous.order_status = previous_status;
6732        let mut next = previous.clone();
6733        next.ts_last = UnixNanos::from(timestamp);
6734        next.order_status = status;
6735        next.report_id = UUID4::new();
6736        let expected = if choose_next {
6737            next.clone()
6738        } else {
6739            previous.clone()
6740        };
6741
6742        let actual = deduplicate_order_status_reports(vec![previous, next]).unwrap();
6743
6744        assert_eq!(actual, vec![expected]);
6745    }
6746
6747    #[rstest]
6748    fn test_duplicate_reports_reject_reopened_terminal_id(#[values(false, true)] reversed: bool) {
6749        let native: DeriveOrder = serde_json::from_str(include_str!(
6750            "../test_data/perps/http_order_eth_partially_filled.json"
6751        ))
6752        .unwrap();
6753        let mut terminal = parse_derive_order_to_report_with_precision(
6754            &native,
6755            AccountId::from("DERIVE-001"),
6756            Some(2),
6757            Some(3),
6758            UnixNanos::from(77),
6759        )
6760        .unwrap();
6761        terminal.order_status = OrderStatus::Canceled;
6762        terminal.ts_last = UnixNanos::from(100);
6763        let mut active = terminal.clone();
6764        active.order_status = OrderStatus::Accepted;
6765        active.ts_last = UnixNanos::from(200);
6766
6767        let reports = if reversed {
6768            vec![active, terminal]
6769        } else {
6770            vec![terminal, active]
6771        };
6772
6773        let result = deduplicate_order_status_reports(reports);
6774
6775        assert_eq!(
6776            result.unwrap_err().to_string(),
6777            format!("Conflicting Derive order status for {}", native.order_id)
6778        );
6779    }
6780
6781    #[rstest]
6782    #[case::account(0)]
6783    #[case::instrument(1)]
6784    #[case::side(2)]
6785    #[case::order_type(3)]
6786    #[case::client_order(4)]
6787    fn test_duplicate_reports_reject_conflicting_identity(#[case] field: u8) {
6788        let native: DeriveOrder = serde_json::from_str(include_str!(
6789            "../test_data/perps/http_order_eth_partially_filled.json"
6790        ))
6791        .unwrap();
6792        let previous = parse_derive_order_to_report_with_precision(
6793            &native,
6794            AccountId::from("DERIVE-001"),
6795            Some(2),
6796            Some(3),
6797            UnixNanos::from(77),
6798        )
6799        .unwrap();
6800        let mut next = previous.clone();
6801        next.ts_last = UnixNanos::from(previous.ts_last.as_u64() + 1);
6802        match field {
6803            0 => next.account_id = AccountId::from("DERIVE-002"),
6804            1 => next.instrument_id = InstrumentId::from("BTC-PERP.DERIVE"),
6805            2 => next.order_side = Some(OrderSide::Sell),
6806            3 => next.order_type = OrderType::Limit,
6807            4 => next.client_order_id = Some(ClientOrderId::from("OTHER-ORDER")),
6808            _ => unreachable!(),
6809        }
6810
6811        let result = deduplicate_order_status_reports(vec![previous, next]);
6812
6813        assert_eq!(
6814            result.unwrap_err().to_string(),
6815            format!("Conflicting Derive order identity for {}", native.order_id)
6816        );
6817    }
6818
6819    #[rstest]
6820    fn test_duplicate_reports_preserve_known_active_attribution(
6821        #[values(false, true)] reversed: bool,
6822    ) {
6823        let native: DeriveOrder = serde_json::from_str(include_str!(
6824            "../test_data/perps/http_order_eth_partially_filled.json"
6825        ))
6826        .unwrap();
6827        let mut known = parse_derive_order_to_report_with_precision(
6828            &native,
6829            AccountId::from("DERIVE-001"),
6830            Some(2),
6831            Some(3),
6832            UnixNanos::from(77),
6833        )
6834        .unwrap();
6835        known.order_status = OrderStatus::Accepted;
6836        known.client_order_id = Some(ClientOrderId::from("KNOWN-ORDER"));
6837        let mut unattributed = known.clone();
6838        unattributed.client_order_id = None;
6839        let expected = known.clone();
6840
6841        let reports = if reversed {
6842            vec![known, unattributed]
6843        } else {
6844            vec![unattributed, known]
6845        };
6846
6847        let actual = deduplicate_order_status_reports(reports).unwrap();
6848
6849        assert_eq!(actual, vec![expected]);
6850    }
6851
6852    #[rstest]
6853    #[case([0, 1, 2])]
6854    #[case([0, 2, 1])]
6855    #[case([1, 0, 2])]
6856    #[case([1, 2, 0])]
6857    #[case([2, 0, 1])]
6858    #[case([2, 1, 0])]
6859    fn test_duplicate_reports_retain_all_conflict_evidence(
6860        #[case] permutation: [usize; 3],
6861        #[values(false, true)] identity_conflict: bool,
6862    ) {
6863        let native: DeriveOrder = serde_json::from_str(include_str!(
6864            "../test_data/perps/http_order_eth_partially_filled.json"
6865        ))
6866        .unwrap();
6867        let report = parse_derive_order_to_report_with_precision(
6868            &native,
6869            AccountId::from("DERIVE-001"),
6870            Some(2),
6871            Some(3),
6872            UnixNanos::from(77),
6873        )
6874        .unwrap();
6875        let mut observations = [report.clone(), report.clone(), report];
6876
6877        let timestamps = if identity_conflict {
6878            [100, 200, 300]
6879        } else {
6880            [100, 300, 200]
6881        };
6882
6883        for (index, observation) in observations.iter_mut().enumerate() {
6884            observation.ts_last = UnixNanos::from(timestamps[index]);
6885            observation.order_status = if identity_conflict || index == 2 {
6886                OrderStatus::Accepted
6887            } else {
6888                OrderStatus::Canceled
6889            };
6890        }
6891
6892        if identity_conflict {
6893            observations[0].client_order_id = Some(ClientOrderId::from("FIRST-ORDER"));
6894            observations[1].client_order_id = None;
6895            observations[2].client_order_id = Some(ClientOrderId::from("OTHER-ORDER"));
6896        }
6897
6898        let reports = permutation
6899            .into_iter()
6900            .map(|index| observations[index].clone())
6901            .collect();
6902        let result = deduplicate_order_status_reports(reports);
6903
6904        let conflict = if identity_conflict {
6905            "identity"
6906        } else {
6907            "status"
6908        };
6909
6910        assert_eq!(
6911            result.unwrap_err().to_string(),
6912            format!(
6913                "Conflicting Derive order {conflict} for {}",
6914                native.order_id
6915            )
6916        );
6917    }
6918
6919    fn test_core() -> ExecutionClientCore {
6920        let cache = Rc::new(RefCell::new(Cache::default()));
6921
6922        ExecutionClientCore::new(
6923            TraderId::from("TRADER-001"),
6924            ClientId::from(DERIVE),
6925            *DERIVE_VENUE,
6926            OmsType::Netting,
6927            AccountId::from("DERIVE-001"),
6928            AccountType::Margin,
6929            None,
6930            cache,
6931        )
6932    }
6933
6934    fn test_config() -> DeriveExecutionClientConfig {
6935        DeriveExecutionClientConfig {
6936            wallet_address: Some(TEST_WALLET.to_string()),
6937            session_key: Some(TEST_SESSION_KEY.into()),
6938            subaccount_id: Some(TEST_SUBACCOUNT),
6939            environment: DeriveEnvironment::Testnet,
6940            domain_separator: Some(
6941                "0x2222222222222222222222222222222222222222222222222222222222222222".to_string(),
6942            ),
6943            action_typehash: Some(
6944                "0x1111111111111111111111111111111111111111111111111111111111111111".to_string(),
6945            ),
6946            trade_module_address: Some("0x000000000000000000000000000000000000bbbb".to_string()),
6947            max_fee_per_contract: Some(dec!(1000)),
6948            ..DeriveExecutionClientConfig::default()
6949        }
6950    }
6951
6952    #[tokio::test]
6953    async fn test_execution_task_log_omits_provider_error() {
6954        let _capture = client_logging::capture_logs().await;
6955        let (sender, _events) = tokio::sync::mpsc::unbounded_channel();
6956        nautilus_common::live::runner::replace_exec_event_sender(sender);
6957        let client = DeriveExecutionClient::new(test_core(), test_config()).unwrap();
6958        client.spawn_task("Synthetic order command PUB-ORDER".to_string(), async {
6959            anyhow::bail!("SYN-secret-provider-error")
6960        });
6961
6962        tokio::time::timeout(Duration::from_secs(2), async {
6963            while !client_logging::messages().contains(&(
6964                log::Level::Warn,
6965                "Synthetic order command PUB-ORDER failed".to_string(),
6966            )) {
6967                tokio::task::yield_now().await;
6968            }
6969        })
6970        .await
6971        .unwrap();
6972
6973        client.pending_tasks.begin_shutdown();
6974        client
6975            .pending_tasks
6976            .finish_shutdown(Duration::from_secs(1), Duration::from_secs(1))
6977            .await
6978            .unwrap();
6979        let messages = client_logging::messages();
6980        assert!(messages.contains(&(
6981            log::Level::Warn,
6982            "Synthetic order command PUB-ORDER failed".to_string()
6983        )));
6984        assert!(
6985            !messages
6986                .iter()
6987                .any(|(_, message)| message.contains("SYN-secret"))
6988        );
6989    }
6990
6991    #[tokio::test]
6992    async fn test_execution_session_failure_log_omits_provider_reason() {
6993        let _capture = client_logging::capture_logs().await;
6994        let (sender, mut events) = tokio::sync::mpsc::unbounded_channel();
6995        nautilus_common::live::runner::replace_exec_event_sender(sender);
6996        let client = DeriveExecutionClient::new(test_core(), test_config()).unwrap();
6997        let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
6998        client.is_connected.store(true, Ordering::Release);
6999        client.start_ws_dispatch(rx).unwrap();
7000        tx.send(DeriveWsMessage::SessionRecoveryFailed(
7001            "SYN-secret-provider-reason".to_string(),
7002        ))
7003        .unwrap();
7004
7005        tokio::time::timeout(Duration::from_secs(2), async {
7006            while client.is_connected() {
7007                tokio::task::yield_now().await;
7008            }
7009        })
7010        .await
7011        .unwrap();
7012
7013        drop(tx);
7014        client.session_tasks.begin_shutdown();
7015        client
7016            .session_tasks
7017            .finish_shutdown(Duration::from_secs(1), Duration::from_secs(1))
7018            .await
7019            .unwrap();
7020        let messages = client_logging::messages();
7021        assert!(!client.is_connected());
7022        assert!(events.try_recv().is_err());
7023        assert!(messages.contains(&(
7024            log::Level::Error,
7025            "Derive execution WebSocket recovery failed".to_string()
7026        )));
7027        assert!(
7028            !messages
7029                .iter()
7030                .any(|(_, message)| message.contains("SYN-secret"))
7031        );
7032    }
7033
7034    #[tokio::test]
7035    async fn test_private_stream_closure_marks_disconnected_without_terminal_events() {
7036        let (sender, mut events) = tokio::sync::mpsc::unbounded_channel();
7037        nautilus_common::live::runner::replace_exec_event_sender(sender);
7038        let client = DeriveExecutionClient::new(test_core(), test_config()).unwrap();
7039        let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
7040        client.is_connected.store(true, Ordering::Release);
7041        client.start_ws_dispatch(rx).unwrap();
7042        assert!(client.is_connected());
7043        drop(tx);
7044        client.session_tasks.begin_shutdown();
7045        client
7046            .session_tasks
7047            .finish_shutdown(Duration::from_secs(1), Duration::from_secs(1))
7048            .await
7049            .unwrap();
7050        assert!(!client.is_connected());
7051        assert!(events.try_recv().is_err());
7052    }
7053
7054    #[tokio::test]
7055    async fn test_reconnect_context_rejects_evicted_replacement_proof() {
7056        let cache = Rc::new(RefCell::new(Cache::default()));
7057
7058        let core = ExecutionClientCore::new(
7059            TraderId::from("TRADER-001"),
7060            ClientId::from(DERIVE),
7061            *DERIVE_VENUE,
7062            OmsType::Netting,
7063            AccountId::from("DERIVE-001"),
7064            AccountType::Margin,
7065            None,
7066            cache.clone(),
7067        );
7068        let client = DeriveExecutionClient::new(core, test_config()).unwrap();
7069        let stale = client.reconciliation_context();
7070        let (time_sender, mut time_events) = tokio::sync::mpsc::unbounded_channel();
7071        nautilus_common::runner::set_time_event_sender(Arc::new(ReconciliationTimeSender(
7072            time_sender,
7073        )));
7074        let request = ReconciliationSnapshotRequest::new(
7075            client.core.clone(),
7076            stale.clone(),
7077            client.cancellation_token.clone(),
7078            Duration::from_secs(1),
7079        )
7080        .unwrap();
7081        let cid = ClientOrderId::from("AFTER-CONNECT-REPLACEMENT");
7082        let instrument_id = InstrumentId::from("ETH-PERP.DERIVE");
7083        let parent = VenueOrderId::from("expired-proof-parent");
7084        let current = VenueOrderId::from("expired-proof-current");
7085        let account_id = AccountId::from("DERIVE-001");
7086        let mut order = OrderTestBuilder::new(OrderType::Limit)
7087            .trader_id(client.core.trader_id)
7088            .strategy_id(StrategyId::from("S-1"))
7089            .instrument_id(instrument_id)
7090            .client_order_id(cid)
7091            .side(OrderSide::Buy)
7092            .quantity(Quantity::from("1.000"))
7093            .price(Price::from("3500.00"))
7094            .build();
7095        order
7096            .apply(OrderEventAny::Accepted(OrderAccepted::new(
7097                order.trader_id(),
7098                order.strategy_id(),
7099                instrument_id,
7100                cid,
7101                parent,
7102                account_id,
7103                UUID4::new(),
7104                UnixNanos::from(1),
7105                UnixNanos::from(1),
7106                false,
7107            )))
7108            .unwrap();
7109        order
7110            .apply(OrderEventAny::Updated(OrderUpdated::new(
7111                order.trader_id(),
7112                order.strategy_id(),
7113                instrument_id,
7114                cid,
7115                Quantity::from("1.500"),
7116                UUID4::new(),
7117                UnixNanos::from(2),
7118                UnixNanos::from(2),
7119                false,
7120                Some(current),
7121                Some(account_id),
7122                Some(Price::from("3505.00")),
7123                None,
7124                None,
7125                false,
7126            )))
7127            .unwrap();
7128        client.dispatch_state.restore_order(&order);
7129        client.dispatch_state.forget(&cid);
7130        order
7131            .apply(OrderEventAny::Canceled(OrderCanceled::new(
7132                order.trader_id(),
7133                order.strategy_id(),
7134                instrument_id,
7135                cid,
7136                UUID4::new(),
7137                UnixNanos::from(3),
7138                UnixNanos::from(3),
7139                false,
7140                Some(current),
7141                Some(account_id),
7142                None,
7143            )))
7144            .unwrap();
7145        cache
7146            .borrow_mut()
7147            .add_order(order, None, Some(client.core.client_id), false)
7148            .unwrap();
7149
7150        let identity = OrderIdentity {
7151            instrument_id,
7152            strategy_id: StrategyId::from("S-1"),
7153            order_side: OrderSide::Buy,
7154            order_type: OrderType::Limit,
7155        };
7156
7157        for index in 0..crate::websocket::dispatch::ORDER_DEDUP_CAPACITY {
7158            let other = ClientOrderId::from(format!("EVICT-{index}").as_str());
7159            client.dispatch_state.register_identity(other, identity);
7160            client.dispatch_state.record_venue_order_id(
7161                other,
7162                VenueOrderId::from(format!("eviction-{index}").as_str()),
7163            );
7164            client.dispatch_state.forget(&other);
7165        }
7166
7167        let mut native: DeriveOrder = serde_json::from_str(include_str!(
7168            "../test_data/perps/http_order_eth_partially_filled.json"
7169        ))
7170        .unwrap();
7171        native.order_id = current.to_string();
7172        native.label = cid.inner();
7173        native.amount = dec!(1.2);
7174        native.filled_amount = dec!(0.2);
7175        native.average_price = dec!(3505);
7176        native.order_status = DeriveOrderStatus::Open;
7177        native.order_type = DeriveOrderType::Limit;
7178        native.time_in_force = crate::common::enums::DeriveTimeInForce::Gtc;
7179        native.replaced_order_id = None;
7180        let report = parse_derive_order_to_report_with_precision(
7181            &native,
7182            account_id,
7183            Some(2),
7184            Some(3),
7185            UnixNanos::from(4),
7186        )
7187        .unwrap();
7188        let result = stale.project_order_report(&native, report, &[], true).await;
7189        let fresh = client.reconciliation_context();
7190        let binding = fresh.order_binding(cid).unwrap();
7191        let mut legs = binding.venue_order_legs.clone();
7192        legs.sort_unstable();
7193        assert_eq!(stale.order_binding(cid), None);
7194        assert_eq!(binding.identity, identity);
7195        assert_eq!(binding.venue_order_id, Some(current));
7196        assert_eq!(legs, vec![current, parent]);
7197        assert_eq!(
7198            result.unwrap_err().to_string(),
7199            "Derive order context expired after terminal binding eviction; retry with a fresh cache snapshot"
7200        );
7201
7202        let worker_request = request.clone();
7203        let snapshot_task = tokio::spawn(async move { worker_request.snapshot().await });
7204        assert!(time_events.recv().await.unwrap().dispatch());
7205        let (snapshot, _) = snapshot_task.await.unwrap().unwrap();
7206        let refreshed = snapshot.order_binding(cid).unwrap();
7207        let mut refreshed_legs = refreshed.venue_order_legs.clone();
7208        refreshed_legs.sort_unstable();
7209
7210        assert_eq!(refreshed.identity, identity);
7211        assert_eq!(refreshed.venue_order_id, Some(current));
7212        assert_eq!(refreshed_legs, vec![current, parent]);
7213        snapshot.ensure_order_context().unwrap();
7214        request.close();
7215
7216        let empty_query = GenerateOrderStatusReport::new(
7217            UUID4::new(),
7218            UnixNanos::from(5),
7219            None,
7220            None,
7221            None,
7222            None,
7223            None,
7224        );
7225        let error = fresh
7226            .generate_order_status_report(&empty_query)
7227            .await
7228            .expect_err("missing order identity must not report venue absence");
7229        assert_eq!(
7230            error.to_string(),
7231            "Derive generate_order_status_report requires venue_order_id or client_order_id",
7232        );
7233    }
7234
7235    #[tokio::test]
7236    async fn test_canceled_reconciliation_callback_never_reads_or_rearms_cache() {
7237        let cache = Rc::new(RefCell::new(Cache::default()));
7238
7239        let core = ExecutionClientCore::new(
7240            TraderId::from("TRADER-001"),
7241            ClientId::from(DERIVE),
7242            *DERIVE_VENUE,
7243            OmsType::Netting,
7244            AccountId::from("DERIVE-001"),
7245            AccountType::Margin,
7246            None,
7247            cache.clone(),
7248        );
7249        let client = DeriveExecutionClient::new(core, test_config()).unwrap();
7250        let (sender, _events) = tokio::sync::mpsc::unbounded_channel();
7251        nautilus_common::runner::set_time_event_sender(Arc::new(ReconciliationTimeSender(sender)));
7252        let request = ReconciliationSnapshotRequest::new(
7253            client.core.clone(),
7254            client.reconciliation_context(),
7255            client.cancellation_token.clone(),
7256            Duration::from_secs(1),
7257        )
7258        .unwrap();
7259        let pending = request.next.lock().take().unwrap();
7260        client.cancellation_token.cancel();
7261        request.close();
7262        let cache_borrow = cache.borrow_mut();
7263        let dispatched = pending.message.dispatch();
7264        drop(cache_borrow);
7265
7266        assert!(dispatched);
7267        assert!(pending.result.await.is_err());
7268        assert!(request.next.lock().is_none());
7269        assert_eq!(Rc::strong_count(&cache), 2);
7270    }
7271
7272    #[rstest]
7273    fn test_market_order_limit_price_buy_lifts_ask_and_rounds_up_to_tick() {
7274        let quote = QuoteTick::new(
7275            InstrumentId::from("ETH-PERP.DERIVE"),
7276            Price::from("3500.00"),
7277            Price::from("3501.00"),
7278            Quantity::from("1.000"),
7279            Quantity::from("1.000"),
7280            UnixNanos::from(0),
7281            UnixNanos::from(0),
7282        );
7283        // 50 bps; raw = 3501 * 1.005 = 3518.505; tick 0.01 rounds up to 3518.51.
7284        let price = market_order_limit_price(&quote, OrderSide::Buy, 50, dec!(0.01)).unwrap();
7285        assert_eq!(price, dec!(3518.51));
7286    }
7287
7288    #[rstest]
7289    fn test_market_order_limit_price_sell_drops_bid_rounds_down_and_denies_non_positive() {
7290        let quote = QuoteTick::new(
7291            InstrumentId::from("ETH-PERP.DERIVE"),
7292            Price::from("3500.00"),
7293            Price::from("3501.00"),
7294            Quantity::from("1.000"),
7295            Quantity::from("1.000"),
7296            UnixNanos::from(0),
7297            UnixNanos::from(0),
7298        );
7299        // 50 bps; raw = 3500 * 0.995 = 3482.5; tick 0.01 stays at 3482.5.
7300        let price = market_order_limit_price(&quote, OrderSide::Sell, 50, dec!(0.01)).unwrap();
7301        assert_eq!(price, dec!(3482.5));
7302
7303        // 20_000 bps = 200% slippage drives the rounded bound below zero; deny.
7304        let zero = market_order_limit_price(&quote, OrderSide::Sell, 20_000, dec!(0.01));
7305        assert!(zero.is_none());
7306    }
7307
7308    #[rstest]
7309    fn test_trigger_market_limit_price_uses_trigger_price_bound() {
7310        let buy = trigger_market_limit_price(dec!(3600), OrderSide::Buy, 50, dec!(0.01)).unwrap();
7311        let sell = trigger_market_limit_price(dec!(3600), OrderSide::Sell, 50, dec!(0.01)).unwrap();
7312        let zero = trigger_market_limit_price(dec!(1), OrderSide::Sell, 20_000, dec!(0.01));
7313
7314        assert_eq!(buy, dec!(3618));
7315        assert_eq!(sell, dec!(3582));
7316        assert!(zero.is_none());
7317    }
7318
7319    #[rstest]
7320    fn test_normal_order_signature_expiry_accepts_ttl_above_minimum() {
7321        let clock = get_atomic_clock_realtime();
7322        let start_secs = (clock.get_time_ns().as_u64() / 1_000_000_000) as i64;
7323        let ttl_secs = MIN_SIGNATURE_TTL.as_secs() + 1;
7324
7325        let expiry = normal_order_signature_expiry(clock, ttl_secs).expect("expiry is valid");
7326
7327        assert!(expiry >= start_secs + ttl_secs as i64);
7328    }
7329
7330    #[rstest]
7331    #[case(MIN_SIGNATURE_TTL.as_secs(), "must be greater than the Derive minimum")]
7332    #[case(MIN_SIGNATURE_TTL.as_secs() - 1, "must be greater than the Derive minimum")]
7333    fn test_normal_order_signature_expiry_rejects_minimum_or_lower_ttl(
7334        #[case] ttl_secs: u64,
7335        #[case] reason_fragment: &str,
7336    ) {
7337        let clock = get_atomic_clock_realtime();
7338
7339        let err = normal_order_signature_expiry(clock, ttl_secs).expect_err("TTL is too short");
7340
7341        assert!(
7342            err.to_string().contains(reason_fragment),
7343            "unexpected error: {err}",
7344        );
7345    }
7346
7347    #[rstest]
7348    #[case(i64::MAX as u64, "exceeds the Derive maximum")]
7349    #[case(u64::MAX, "exceeds the Derive maximum")]
7350    fn test_normal_order_signature_expiry_rejects_extreme_ttl(
7351        #[case] ttl_secs: u64,
7352        #[case] reason_fragment: &str,
7353    ) {
7354        let clock = get_atomic_clock_realtime();
7355
7356        let err = normal_order_signature_expiry(clock, ttl_secs).expect_err("TTL is invalid");
7357
7358        assert!(
7359            err.to_string().contains(reason_fragment),
7360            "unexpected error: {err}",
7361        );
7362    }
7363
7364    #[rstest]
7365    #[case(None, "max_fee_per_contract is required")]
7366    #[case(Some(dec!(0)), "max_fee_per_contract must be greater than zero")]
7367    #[case(Some(dec!(-1)), "max_fee_per_contract must be greater than zero")]
7368    fn test_new_rejects_invalid_max_fee_per_contract(
7369        #[case] max_fee_per_contract: Option<Decimal>,
7370        #[case] expected: &str,
7371    ) {
7372        let mut config = test_config();
7373        config.max_fee_per_contract = max_fee_per_contract;
7374
7375        let err = DeriveExecutionClient::new(test_core(), config).expect_err("must reject");
7376
7377        assert_eq!(err.to_string(), expected);
7378    }
7379
7380    #[rstest]
7381    #[case(OrderType::StopMarket, true)]
7382    #[case(OrderType::StopLimit, true)]
7383    #[case(OrderType::MarketIfTouched, true)]
7384    #[case(OrderType::LimitIfTouched, true)]
7385    #[case(OrderType::Market, false)]
7386    #[case(OrderType::Limit, false)]
7387    #[case(OrderType::MarketToLimit, false)]
7388    #[case(OrderType::TrailingStopMarket, false)]
7389    fn test_is_derive_trigger_order_type(#[case] order_type: OrderType, #[case] expected: bool) {
7390        assert_eq!(is_derive_trigger_order_type(order_type), expected);
7391    }
7392
7393    #[rstest]
7394    fn test_resolve_submit_nonce_emits_rejection_and_forgets_identity() {
7395        let clock = get_atomic_clock_realtime();
7396        let instrument_id = InstrumentId::from("ETH-PERP.DERIVE");
7397        let strategy_id = StrategyId::from("S-1");
7398        let client_order_id = ClientOrderId::from("NONCE-SUBMIT-1");
7399        let order = OrderTestBuilder::new(OrderType::Limit)
7400            .trader_id(TraderId::from("TRADER-001"))
7401            .strategy_id(strategy_id)
7402            .instrument_id(instrument_id)
7403            .client_order_id(client_order_id)
7404            .side(OrderSide::Buy)
7405            .quantity(Quantity::from("1.000"))
7406            .price(Price::from("3500.00"))
7407            .build();
7408
7409        let identity = OrderIdentity {
7410            instrument_id,
7411            strategy_id,
7412            order_side: OrderSide::Buy,
7413            order_type: OrderType::Limit,
7414        };
7415
7416        let state = WsDispatchState::new(42);
7417        state.register_identity(client_order_id, identity);
7418        let (emitter, mut rx) = test_emitter(clock);
7419
7420        let nonce = resolve_submit_nonce(
7421            Err(NonceError::ClockBeforeEpoch),
7422            &emitter,
7423            &state,
7424            &order,
7425            clock,
7426        );
7427        let event = rx.try_recv().expect("OrderRejected event");
7428
7429        assert!(nonce.is_none());
7430        assert!(state.identity(&client_order_id).is_none());
7431
7432        if let ExecutionEvent::Order(OrderEventAny::Rejected(rejected)) = event {
7433            assert_eq!(rejected.client_order_id, client_order_id);
7434            assert_eq!(
7435                rejected.reason,
7436                "nonce allocation failed: system clock is before UNIX epoch",
7437            );
7438        } else {
7439            panic!("expected OrderRejected, event was {event:?}");
7440        }
7441    }
7442
7443    #[rstest]
7444    fn test_resolve_modify_nonce_emits_modify_rejection() {
7445        let clock = get_atomic_clock_realtime();
7446        let instrument_id = InstrumentId::from("ETH-PERP.DERIVE");
7447        let strategy_id = StrategyId::from("S-1");
7448        let client_order_id = ClientOrderId::from("NONCE-MODIFY-1");
7449        let venue_order_id = VenueOrderId::from("ord-nonce-modify-1");
7450        let (emitter, mut rx) = test_emitter(clock);
7451
7452        let nonce = resolve_modify_nonce(
7453            Err(NonceError::ClockBeforeEpoch),
7454            &emitter,
7455            strategy_id,
7456            instrument_id,
7457            client_order_id,
7458            venue_order_id,
7459            clock,
7460            Some(UUID4::default()),
7461        );
7462        let event = rx.try_recv().expect("OrderModifyDenied event");
7463
7464        assert!(nonce.is_none());
7465
7466        if let ExecutionEvent::Order(OrderEventAny::ModifyDenied(rejected)) = event {
7467            assert_eq!(rejected.client_order_id, client_order_id);
7468            assert_eq!(rejected.venue_order_id, Some(venue_order_id));
7469            assert_eq!(
7470                rejected.reason,
7471                "nonce allocation failed: system clock is before UNIX epoch",
7472            );
7473        } else {
7474            panic!("expected OrderModifyDenied, event was {event:?}");
7475        }
7476    }
7477
7478    #[rstest]
7479    #[case(dec!(0))]
7480    #[case(dec!(-1))]
7481    fn test_round_to_tick_treats_non_positive_tick_as_no_op(#[case] tick: Decimal) {
7482        // Non-positive tick must pass through both sides untouched so the
7483        // signing path does not divide by zero or amplify garbage tick data.
7484        assert_eq!(
7485            round_to_tick(dec!(3501.55), tick, OrderSide::Buy),
7486            dec!(3501.55)
7487        );
7488        assert_eq!(
7489            round_to_tick(dec!(3501.55), tick, OrderSide::Sell),
7490            dec!(3501.55)
7491        );
7492    }
7493
7494    #[rstest]
7495    fn test_resolve_signing_context_rejects_placeholder_domain_separator() {
7496        // The shipped mainnet defaults are real Protocol Constants, so force
7497        // an explicit placeholder via the config override to verify the
7498        // placeholder-detection path still refuses to construct.
7499        let mut config = test_config();
7500        config.environment = DeriveEnvironment::Mainnet;
7501        config.domain_separator =
7502            Some("0x<paste_from_docs.derive.xyz_protocol_constants>".to_string());
7503        let err = DeriveExecutionClient::new(test_core(), config).expect_err("must reject");
7504        let msg = err.to_string();
7505        assert!(msg.contains("placeholder"), "unexpected error: {msg}",);
7506    }
7507
7508    #[rstest]
7509    fn test_resolve_signing_context_uses_mainnet_defaults() {
7510        let mut config = test_config();
7511        config.environment = DeriveEnvironment::Mainnet;
7512        config.domain_separator = None;
7513        config.action_typehash = None;
7514        config.trade_module_address = None;
7515
7516        DeriveExecutionClient::new(test_core(), config).expect("mainnet defaults should parse");
7517    }
7518
7519    #[rstest]
7520    fn test_resolve_signing_context_uses_testnet_defaults() {
7521        let mut config = test_config();
7522        config.environment = DeriveEnvironment::Testnet;
7523        config.domain_separator = None;
7524        config.action_typehash = None;
7525        config.trade_module_address = None;
7526
7527        DeriveExecutionClient::new(test_core(), config).expect("testnet defaults should parse");
7528    }
7529
7530    #[rstest]
7531    fn test_market_order_limit_price_rounds_to_coarse_tick() {
7532        // Coarse tick = 1.0 (e.g. weekly option strikes); raw 3518.505 rounds
7533        // up to 3519, raw 3482.5 rounds down to 3482.
7534        let quote = QuoteTick::new(
7535            InstrumentId::from("ETH-20260627-3500-C.DERIVE"),
7536            Price::from("3500"),
7537            Price::from("3501"),
7538            Quantity::from("1.000"),
7539            Quantity::from("1.000"),
7540            UnixNanos::from(0),
7541            UnixNanos::from(0),
7542        );
7543        let buy = market_order_limit_price(&quote, OrderSide::Buy, 50, dec!(1)).unwrap();
7544        assert_eq!(buy, dec!(3519));
7545        let sell = market_order_limit_price(&quote, OrderSide::Sell, 50, dec!(1)).unwrap();
7546        assert_eq!(sell, dec!(3482));
7547    }
7548
7549    #[rstest]
7550    fn test_new_populates_identity() {
7551        let core = test_core();
7552        let client = DeriveExecutionClient::new(core, test_config()).unwrap();
7553
7554        assert_eq!(client.client_id(), ClientId::from(DERIVE));
7555        assert_eq!(client.account_id(), AccountId::from("DERIVE-001"));
7556        assert_eq!(client.venue(), *DERIVE_VENUE);
7557        assert_eq!(client.oms_type(), OmsType::Netting);
7558        assert_eq!(client.subaccount_id(), TEST_SUBACCOUNT);
7559        assert!(!client.is_connected());
7560    }
7561
7562    #[rstest]
7563    fn test_cache_instrument_registers_report_precision() {
7564        let client = DeriveExecutionClient::new(test_core(), test_config()).unwrap();
7565        let instrument = sample_derive_instrument();
7566        let instrument_id = format_instrument_id(instrument.instrument_name).unwrap();
7567
7568        client.cache_instrument(instrument).unwrap();
7569
7570        assert_eq!(
7571            client.dispatch_state.instrument_precision(&instrument_id),
7572            Some((2, 3)),
7573        );
7574    }
7575
7576    #[rstest]
7577    #[case("tick_size")]
7578    #[case("amount_step")]
7579    fn test_cache_instrument_rejects_excess_precision(#[case] field: &str) {
7580        let client = DeriveExecutionClient::new(test_core(), test_config()).unwrap();
7581        let mut instrument = sample_derive_instrument();
7582        let instrument_id = format_instrument_id(instrument.instrument_name).unwrap();
7583        let value = Decimal::new(1, 28);
7584        match field {
7585            "tick_size" => instrument.tick_size = value,
7586            "amount_step" => instrument.amount_step = value,
7587            _ => unreachable!(),
7588        }
7589
7590        let error = client.cache_instrument(instrument).unwrap_err();
7591
7592        assert_eq!(error.to_string(), format!("invalid Derive {field}"));
7593        assert!(client.instruments.is_empty());
7594        assert_eq!(
7595            client.dispatch_state.instrument_precision(&instrument_id),
7596            None
7597        );
7598    }
7599
7600    #[rstest]
7601    fn test_quantity_from_report_decimal_rejects_excess_precision() {
7602        let value = Decimal::new(1, 28);
7603        let expected = Quantity::from_decimal_dp(value, 28).unwrap_err();
7604
7605        let error = quantity_from_report_decimal(value, None).unwrap_err();
7606
7607        assert_eq!(
7608            format!("{error:#}"),
7609            format!("native cumulative report quantity cannot be represented: {expected}")
7610        );
7611    }
7612
7613    #[rstest]
7614    fn test_native_instrument_retains_signing_metadata() {
7615        let client = test_client_with_instrument();
7616        let expected = sample_derive_instrument();
7617        let instrument_id = format_instrument_id(expected.instrument_name).unwrap();
7618        let actual = client.instruments.get_cloned(&instrument_id).unwrap();
7619        assert_eq!(
7620            serde_json::to_value(actual).unwrap(),
7621            serde_json::to_value(expected).unwrap()
7622        );
7623        assert_eq!(
7624            client.dispatch_state.instrument_precision(&instrument_id),
7625            Some((2, 3))
7626        );
7627    }
7628
7629    #[rstest]
7630    fn test_cache_instrument_shares_metadata_across_snapshots() {
7631        let client = DeriveExecutionClient::new(test_core(), test_config()).unwrap();
7632        let perp = sample_derive_instrument();
7633        let option: DeriveInstrument =
7634            serde_json::from_str(include_str!("../test_data/options/instrument_eth.json")).unwrap();
7635        let perp_id = format_instrument_id(perp.instrument_name).unwrap();
7636        let option_id = format_instrument_id(option.instrument_name).unwrap();
7637
7638        client.cache_instrument(perp.clone()).unwrap();
7639        let before = client.instruments.load();
7640        client.cache_instrument(option.clone()).unwrap();
7641        let after = client.instruments.load();
7642
7643        assert_eq!(before.len(), 1);
7644        assert_eq!(after.len(), 2);
7645        assert!(Arc::ptr_eq(&before[&perp_id], &after[&perp_id]));
7646
7647        for (id, expected) in [(perp_id, perp), (option_id, option)] {
7648            assert_eq!(
7649                serde_json::to_value(&after[&id]).unwrap(),
7650                serde_json::to_value(&expected).unwrap()
7651            );
7652            assert_eq!(after[&id].raw, expected.raw);
7653        }
7654
7655        assert_eq!(
7656            client.dispatch_state.instrument_precision(&perp_id),
7657            Some((2, 3))
7658        );
7659        assert_eq!(
7660            client.dispatch_state.instrument_precision(&option_id),
7661            Some((1, 2))
7662        );
7663    }
7664
7665    #[rstest]
7666    #[tokio::test]
7667    async fn test_bootstrap_restores_cached_instrument_context() {
7668        let cache = Rc::new(RefCell::new(Cache::default()));
7669
7670        let core = ExecutionClientCore::new(
7671            TraderId::from("TRADER-001"),
7672            ClientId::from(DERIVE),
7673            *DERIVE_VENUE,
7674            OmsType::Netting,
7675            AccountId::from("DERIVE-001"),
7676            AccountType::Margin,
7677            None,
7678            cache.clone(),
7679        );
7680        let client = DeriveExecutionClient::new(core, test_config()).unwrap();
7681        let expected = sample_derive_instrument();
7682        let instrument_id = format_instrument_id(expected.instrument_name).unwrap();
7683        let native = parse_derive_instrument_any(&expected, UnixNanos::default())
7684            .unwrap()
7685            .unwrap();
7686        cache.borrow_mut().add_instrument(native).unwrap();
7687        client.ensure_instruments_initialized().await.unwrap();
7688        let actual = client.instruments.get_cloned(&instrument_id).unwrap();
7689        assert_eq!(
7690            serde_json::to_value(actual).unwrap(),
7691            serde_json::to_value(expected).unwrap()
7692        );
7693        assert_eq!(
7694            client.dispatch_state.instrument_precision(&instrument_id),
7695            Some((2, 3))
7696        );
7697        assert!(client.core.instruments_initialized());
7698    }
7699
7700    #[tokio::test]
7701    async fn test_bootstrap_validation_failure_retains_successful_prefix() {
7702        let cache = Rc::new(RefCell::new(Cache::default()));
7703
7704        let core = ExecutionClientCore::new(
7705            TraderId::from("TRADER-001"),
7706            ClientId::from(DERIVE),
7707            *DERIVE_VENUE,
7708            OmsType::Netting,
7709            AccountId::from("DERIVE-001"),
7710            AccountType::Margin,
7711            None,
7712            cache.clone(),
7713        );
7714        let client = DeriveExecutionClient::new(core, test_config()).unwrap();
7715        let perp = sample_derive_instrument();
7716        let option: DeriveInstrument =
7717            serde_json::from_str(include_str!("../test_data/options/instrument_eth.json")).unwrap();
7718        let retained: DeriveInstrument =
7719            serde_json::from_str(include_str!("../test_data/spot/instrument_eth.json")).unwrap();
7720        let retained_id = format_instrument_id(retained.instrument_name).unwrap();
7721        client.cache_instrument(retained.clone()).unwrap();
7722        let before = client.instruments.load();
7723
7724        for definition in [&perp, &option] {
7725            let instrument = parse_derive_instrument_any(definition, UnixNanos::default())
7726                .unwrap()
7727                .unwrap();
7728            cache.borrow_mut().add_instrument(instrument).unwrap();
7729        }
7730
7731        let ordered: Vec<_> = cache
7732            .borrow()
7733            .instruments(&DERIVE_VENUE, None)
7734            .iter()
7735            .map(|instrument| instrument.id())
7736            .collect();
7737        let invalid_id = ordered[1];
7738        let mut invalid = cache.borrow().instrument(&invalid_id).unwrap().clone();
7739        match &mut invalid {
7740            InstrumentAny::CryptoPerpetual(instrument) => instrument.info = None,
7741            InstrumentAny::CryptoOption(instrument) => instrument.info = None,
7742            _ => unreachable!(),
7743        }
7744
7745        cache.borrow_mut().add_instrument(invalid).unwrap();
7746
7747        let error = client.ensure_instruments_initialized().await.unwrap_err();
7748
7749        assert_eq!(error.to_string(), "Derive instrument has no venue metadata");
7750        assert_eq!(
7751            cache
7752                .borrow()
7753                .instruments(&DERIVE_VENUE, None)
7754                .iter()
7755                .map(|instrument| instrument.id())
7756                .collect::<Vec<_>>(),
7757            ordered
7758        );
7759        assert_eq!(client.instruments.len(), 2);
7760        assert!(!client.core.instruments_initialized());
7761        assert!(!client.instruments.contains_key(&invalid_id));
7762        assert_eq!(
7763            client.dispatch_state.instrument_precision(&invalid_id),
7764            None
7765        );
7766        let after = client.instruments.load();
7767        assert!(Arc::ptr_eq(&before[&retained_id], &after[&retained_id]));
7768
7769        for expected in [&perp, &option, &retained] {
7770            let id = format_instrument_id(expected.instrument_name).unwrap();
7771            if id == invalid_id {
7772                continue;
7773            }
7774
7775            assert_eq!(
7776                serde_json::to_value(&after[&id]).unwrap(),
7777                serde_json::to_value(expected).unwrap()
7778            );
7779        }
7780
7781        let precision = if ordered[0] == format_instrument_id(perp.instrument_name).unwrap() {
7782            (2, 3)
7783        } else {
7784            (1, 2)
7785        };
7786
7787        assert_eq!(
7788            client.dispatch_state.instrument_precision(&ordered[0]),
7789            Some(precision)
7790        );
7791    }
7792
7793    #[rstest]
7794    fn test_order_dispatch_uses_registered_instrument_precision() {
7795        let clock = get_atomic_clock_realtime();
7796        let client = test_client_with_instrument();
7797
7798        let mut order: DeriveOrder = serde_json::from_str(include_str!(
7799            "../test_data/perps/http_order_eth_partially_filled.json"
7800        ))
7801        .unwrap();
7802        order.subaccount_id = client.subaccount_id() as i64;
7803        order.amount = Decimal::from_str_exact("25.000").unwrap();
7804        order.filled_amount = Decimal::from_str_exact("5.000").unwrap();
7805        order.limit_price = Decimal::from_str_exact("25.000").unwrap();
7806        order.order_status = DeriveOrderStatus::Open;
7807        order.order_type = DeriveOrderType::Limit;
7808
7809        let (emitter, mut rx) = test_emitter(clock);
7810        dispatch_orders_payload(
7811            DeriveOrdersSubscriptionData {
7812                orders: vec![order],
7813            },
7814            &emitter,
7815            AccountId::from("DERIVE-001"),
7816            clock,
7817            &client.dispatch_state,
7818        );
7819
7820        let event = rx.try_recv().unwrap();
7821
7822        let ExecutionEvent::Report(ExecutionReport::Order(report)) = event else {
7823            panic!("Expected OrderStatusReport");
7824        };
7825
7826        assert_eq!(report.price, Some(Price::from("25.00")));
7827        assert_eq!(report.price.unwrap().precision, 2);
7828        assert_eq!(report.quantity, Quantity::from("25.000"));
7829        assert_eq!(report.quantity.precision, 3);
7830        assert_eq!(report.filled_qty, Quantity::from("5.000"));
7831        assert_eq!(report.filled_qty.precision, 3);
7832    }
7833
7834    #[rstest]
7835    fn test_trade_dispatch_uses_registered_instrument_precision() {
7836        let clock = get_atomic_clock_realtime();
7837        let client = test_client_with_instrument();
7838        let mut trade: DeriveTrade = serde_json::from_str(include_str!(
7839            "../test_data/perps/http_private_trade_eth.json"
7840        ))
7841        .unwrap();
7842        trade.subaccount_id = client.subaccount_id() as i64;
7843        trade.trade_amount = Decimal::from_str_exact("25.000").unwrap();
7844        trade.trade_price = Decimal::from_str_exact("25.000").unwrap();
7845
7846        let (emitter, mut rx) = test_emitter(clock);
7847        dispatch_trades_payload(
7848            DeriveTradesSubscriptionData {
7849                trades: vec![trade],
7850            },
7851            &emitter,
7852            AccountId::from("DERIVE-001"),
7853            clock,
7854            &client.dispatch_state,
7855        );
7856
7857        let event = rx.try_recv().unwrap();
7858
7859        let ExecutionEvent::Report(ExecutionReport::Fill(report)) = event else {
7860            panic!("Expected FillReport");
7861        };
7862
7863        assert_eq!(report.last_px, Price::from("25.00"));
7864        assert_eq!(report.last_px.precision, 2);
7865        assert_eq!(report.last_qty, Quantity::from("25.000"));
7866        assert_eq!(report.last_qty.precision, 3);
7867    }
7868
7869    #[rstest]
7870    fn test_emit_tracked_event_suppresses_in_flight_replace_cancel_leg() {
7871        // Derive's `private/replace` cancels the old order; the `.orders`
7872        // cancel-of-old leg can arrive before `modify_order` rebinds the order,
7873        // i.e. while the replace is in flight. In that window only the
7874        // `pending_modify` marker (not the bound-id check) can suppress it. The
7875        // integration suite covers the post-rebind bound-id branch; this covers
7876        // the in-flight branch, which is otherwise unexercised end to end.
7877        let clock = get_atomic_clock_realtime();
7878        let account_id = AccountId::from("DERIVE-001");
7879        let instrument_id = InstrumentId::from("ETH-PERP.DERIVE");
7880        let cid = ClientOrderId::from("STRAT-MOD-INFLIGHT");
7881        let stale_voi = VenueOrderId::from("ord-stale-1");
7882
7883        let identity = OrderIdentity {
7884            instrument_id,
7885            strategy_id: StrategyId::from("S-1"),
7886            order_side: OrderSide::Buy,
7887            order_type: OrderType::Limit,
7888        };
7889
7890        // A `cancelled` report for the stale leg, identical across both cases:
7891        // only the dispatch-state marker differs.
7892        let report = OrderStatusReport::new(
7893            account_id,
7894            instrument_id,
7895            Some(cid),
7896            stale_voi,
7897            OrderSide::Buy.into(),
7898            OrderType::Limit,
7899            TimeInForce::Gtc,
7900            OrderStatus::Canceled,
7901            Quantity::from("1.000"),
7902            Quantity::from("0.000"),
7903            UnixNanos::from(1_000),
7904            UnixNanos::from(2_000),
7905            UnixNanos::from(3_000),
7906            None,
7907        );
7908
7909        // Marker targets the cancel's venue order id and no bound id is
7910        // recorded, so suppression can only come from the in-flight branch.
7911        let (emitter, mut rx) = test_emitter(clock);
7912        let state = WsDispatchState::new(42);
7913        state.mark_pending_modify(cid, stale_voi);
7914        emit_tracked_order_event(
7915            &emitter,
7916            &state,
7917            cid,
7918            identity,
7919            &report,
7920            account_id,
7921            UnixNanos::from(0),
7922        );
7923        let suppressed = rx.try_recv().is_err();
7924
7925        // A marker for a different venue order id must not suppress: the guard
7926        // keys on the specific id, so the cancel-of-old still terminates.
7927        let (emitter, mut rx) = test_emitter(clock);
7928        let state = WsDispatchState::new(42);
7929        state.mark_pending_modify(cid, VenueOrderId::from("ord-other"));
7930        emit_tracked_order_event(
7931            &emitter,
7932            &state,
7933            cid,
7934            identity,
7935            &report,
7936            account_id,
7937            UnixNanos::from(0),
7938        );
7939        let mut saw_canceled = false;
7940
7941        while let Ok(event) = rx.try_recv() {
7942            if matches!(event, ExecutionEvent::Order(OrderEventAny::Canceled(_))) {
7943                saw_canceled = true;
7944            }
7945        }
7946
7947        assert!(
7948            suppressed,
7949            "in-flight cancel-of-old leg must be suppressed by the pending-modify marker",
7950        );
7951        assert!(
7952            saw_canceled,
7953            "a pending-modify marker for a different venue order id must not suppress",
7954        );
7955    }
7956
7957    #[rstest]
7958    fn test_ensure_canceled_emitted_is_idempotent() {
7959        let clock = get_atomic_clock_realtime();
7960        let account_id = AccountId::from("DERIVE-001");
7961        let client_order_id = ClientOrderId::from("TRIGGER-CANCEL-1");
7962
7963        let identity = OrderIdentity {
7964            instrument_id: InstrumentId::from("ETH-PERP.DERIVE"),
7965            strategy_id: StrategyId::from("S-1"),
7966            order_side: OrderSide::Buy,
7967            order_type: OrderType::StopMarket,
7968        };
7969
7970        let venue_order_id = VenueOrderId::from("trigger-cancel-1");
7971        let state = WsDispatchState::new(42);
7972        let (emitter, mut rx) = test_emitter(clock);
7973
7974        for _ in 0..2 {
7975            ensure_canceled_emitted(
7976                &emitter,
7977                &state,
7978                client_order_id,
7979                identity,
7980                venue_order_id,
7981                account_id,
7982                UnixNanos::from(1_000),
7983                UnixNanos::from(1_000),
7984            );
7985        }
7986
7987        assert!(matches!(
7988            rx.try_recv(),
7989            Ok(ExecutionEvent::Order(OrderEventAny::Canceled(_)))
7990        ));
7991        assert!(rx.try_recv().is_err(), "duplicate OrderCanceled emitted");
7992    }
7993
7994    fn test_emitter(
7995        clock: &'static AtomicTime,
7996    ) -> (
7997        ExecutionEventEmitter,
7998        tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
7999    ) {
8000        let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
8001
8002        let mut emitter = ExecutionEventEmitter::new(
8003            clock,
8004            TraderId::from("TRADER-001"),
8005            AccountId::from("DERIVE-001"),
8006            AccountType::Margin,
8007            Some(Currency::USDC()),
8008        );
8009        emitter.set_sender(tx);
8010        (emitter, rx)
8011    }
8012
8013    #[rstest]
8014    #[case(DeriveOrderStatus::Cancelled)]
8015    #[case(DeriveOrderStatus::Expired)]
8016    #[case(DeriveOrderStatus::Rejected)]
8017    fn test_terminal_delivery_failure_preserves_identity(#[case] status: DeriveOrderStatus) {
8018        let clock = get_atomic_clock_realtime();
8019        let state = WsDispatchState::new(42);
8020        let client_order_id = ClientOrderId::from("TERMINAL-DELIVERY-1");
8021
8022        let identity = OrderIdentity {
8023            instrument_id: InstrumentId::from("ETH-PERP.DERIVE"),
8024            strategy_id: StrategyId::from("S-1"),
8025            order_side: OrderSide::Buy,
8026            order_type: OrderType::Limit,
8027        };
8028
8029        state.register_identity(client_order_id, identity);
8030        let mut order: DeriveOrder = serde_json::from_str(include_str!(
8031            "../test_data/perps/http_order_eth_partially_filled.json"
8032        ))
8033        .unwrap();
8034        order.label = client_order_id.as_str().into();
8035        order.order_status = status;
8036        let (emitter, rx) = test_emitter(clock);
8037        drop(rx);
8038        dispatch_orders_payload(
8039            DeriveOrdersSubscriptionData {
8040                orders: vec![order],
8041            },
8042            &emitter,
8043            AccountId::from("DERIVE-001"),
8044            clock,
8045            &state,
8046        );
8047
8048        assert_eq!(state.identity(&client_order_id), Some(identity));
8049        assert!(!state.contains_accepted(&client_order_id));
8050        assert!(!state.contains_canceled(&client_order_id));
8051    }
8052
8053    #[rstest]
8054    #[case::stop(0)]
8055    #[case::reset(1)]
8056    #[case::dispose(2)]
8057    #[tokio::test]
8058    async fn test_lifecycle_shutdown_closes_owned_generations(#[case] operation: u8) {
8059        let mut client = DeriveExecutionClient::new(test_core(), test_config()).unwrap();
8060        client.core.set_connected();
8061        client.is_connected.store(true, Ordering::Release);
8062        let session_spawner = client.session_tasks.spawner().unwrap();
8063        let pending_spawner = client.pending_tasks.spawner().unwrap();
8064        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
8065
8066        for group in [&client.session_tasks, &client.pending_tasks] {
8067            let cancellation = group.cancellation_token();
8068            let tx = tx.clone();
8069            group
8070                .spawn(async move {
8071                    tx.send(()).unwrap();
8072                    cancellation.cancelled().await;
8073                })
8074                .unwrap();
8075        }
8076
8077        for _ in 0..2 {
8078            tokio::time::timeout(Duration::from_secs(1), rx.recv())
8079                .await
8080                .unwrap()
8081                .unwrap();
8082        }
8083
8084        for _ in 0..2 {
8085            match operation {
8086                0 => client.stop().unwrap(),
8087                1 => client.reset().unwrap(),
8088                2 => client.dispose().unwrap(),
8089                _ => unreachable!(),
8090            }
8091        }
8092
8093        let closed = (
8094            !client.session_tasks.is_open(),
8095            !client.pending_tasks.is_open(),
8096            client.cancellation_token.is_cancelled(),
8097            client.core.is_disconnected(),
8098            !client.is_connected(),
8099        );
8100
8101        let stale_session_rejected = session_spawner.spawn(async {}).is_err();
8102
8103        let stale_pending_rejected = pending_spawner.spawn(async {}).is_err();
8104        client.disconnect().await.unwrap();
8105
8106        assert_eq!(closed, (true, true, true, true, true));
8107        assert!(stale_session_rejected);
8108        assert!(stale_pending_rejected);
8109        assert!(client.session_tasks.is_empty());
8110        assert!(client.pending_tasks.is_empty());
8111    }
8112
8113    #[rstest]
8114    #[case(Some(ClientId::from(DERIVE)), "DERIVE-001", false, true)]
8115    #[case(Some(ClientId::from("OTHER")), "DERIVE-001", false, false)]
8116    #[case(None, "DERIVE-001", false, false)]
8117    #[case(Some(ClientId::from(DERIVE)), "DERIVE-OTHER", false, false)]
8118    #[case(Some(ClientId::from(DERIVE)), "DERIVE-001", true, false)]
8119    fn test_restores_only_owned_active_orders(
8120        #[case] assigned_client: Option<ClientId>,
8121        #[case] account: &str,
8122        #[case] closed: bool,
8123        #[case] restored: bool,
8124        #[values(false, true)] voided: bool,
8125        #[values(false, true)] register_external: bool,
8126        #[values(false, true)] replacement: bool,
8127    ) {
8128        use nautilus_common::live::runner::replace_exec_event_sender;
8129
8130        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
8131        replace_exec_event_sender(tx);
8132        let cache = Rc::new(RefCell::new(Cache::default()));
8133
8134        let core = ExecutionClientCore::new(
8135            TraderId::from("TRADER-001"),
8136            ClientId::from(DERIVE),
8137            *DERIVE_VENUE,
8138            OmsType::Netting,
8139            AccountId::from("DERIVE-001"),
8140            AccountType::Margin,
8141            None,
8142            cache.clone(),
8143        );
8144        let cid = ClientOrderId::from("RESTORED-1");
8145        let instrument_id = InstrumentId::from("ETH-PERP.DERIVE");
8146        let account_id = AccountId::from(account);
8147        let mut order = OrderTestBuilder::new(OrderType::Limit)
8148            .trader_id(core.trader_id)
8149            .strategy_id(StrategyId::from("RESTORED-STRATEGY"))
8150            .instrument_id(instrument_id)
8151            .client_order_id(cid)
8152            .side(OrderSide::Buy)
8153            .quantity(Quantity::from("1.500"))
8154            .price(Price::from("3499.00"))
8155            .build();
8156        let mut trade: DeriveTrade = serde_json::from_str(include_str!(
8157            "../test_data/perps/http_private_trade_eth.json"
8158        ))
8159        .unwrap();
8160        trade.subaccount_id = TEST_SUBACCOUNT as i64;
8161        trade.label = cid.as_str().into();
8162
8163        trade.trade_amount = if closed { dec!(1.5) } else { dec!(0.3) };
8164        let report = parse_derive_trade_to_fill_report_with_precision(
8165            &trade,
8166            account_id,
8167            Currency::USDC(),
8168            Some(2),
8169            Some(3),
8170            UnixNanos::from(3),
8171        )
8172        .unwrap()
8173        .unwrap();
8174        order
8175            .apply(OrderEventAny::Accepted(OrderAccepted::new(
8176                order.trader_id(),
8177                order.strategy_id(),
8178                instrument_id,
8179                cid,
8180                report.venue_order_id,
8181                account_id,
8182                UUID4::new(),
8183                UnixNanos::from(1),
8184                UnixNanos::from(2),
8185                false,
8186            )))
8187            .unwrap();
8188        order
8189            .apply(OrderEventAny::Filled(OrderFilled::new(
8190                order.trader_id(),
8191                order.strategy_id(),
8192                instrument_id,
8193                cid,
8194                report.venue_order_id,
8195                account_id,
8196                report.trade_id,
8197                order.order_side(),
8198                order.order_type(),
8199                report.last_qty,
8200                report.last_px,
8201                Currency::USDC(),
8202                report.liquidity_side,
8203                UUID4::new(),
8204                report.ts_event,
8205                report.ts_init,
8206                false,
8207                None,
8208                Some(report.commission),
8209                None,
8210            )))
8211            .unwrap();
8212
8213        if voided {
8214            order
8215                .apply(OrderEventAny::FillVoided(OrderFillVoided::new(
8216                    order.trader_id(),
8217                    order.strategy_id(),
8218                    instrument_id,
8219                    cid,
8220                    report.venue_order_id,
8221                    account_id,
8222                    Ustr::from("restore-correction"),
8223                    report.trade_id,
8224                    report.last_qty,
8225                    Some(report.commission),
8226                    order.order_side(),
8227                    order.order_type(),
8228                    report.last_px,
8229                    Currency::USDC(),
8230                    report.liquidity_side,
8231                    None,
8232                    None,
8233                    None,
8234                    UUID4::new(),
8235                    UnixNanos::from(4),
8236                    UnixNanos::from(5),
8237                    false,
8238                    false,
8239                )))
8240                .unwrap();
8241            assert!(order.trade_ids().is_empty());
8242        }
8243
8244        let current = if replacement && !closed {
8245            let current = VenueOrderId::from("restored-current-child");
8246            order
8247                .apply(OrderEventAny::Updated(OrderUpdated::new(
8248                    order.trader_id(),
8249                    order.strategy_id(),
8250                    instrument_id,
8251                    cid,
8252                    order.quantity(),
8253                    UUID4::new(),
8254                    UnixNanos::from(6),
8255                    UnixNanos::from(7),
8256                    false,
8257                    Some(current),
8258                    Some(account_id),
8259                    order.price(),
8260                    None,
8261                    None,
8262                    false,
8263                )))
8264                .unwrap();
8265            current
8266        } else {
8267            report.venue_order_id
8268        };
8269
8270        let identity = OrderIdentity {
8271            instrument_id,
8272            strategy_id: order.strategy_id(),
8273            order_side: order.order_side(),
8274            order_type: order.order_type(),
8275        };
8276
8277        let mut client = DeriveExecutionClient::new(core, test_config()).unwrap();
8278        if register_external {
8279            client.start().unwrap();
8280        }
8281
8282        cache
8283            .borrow_mut()
8284            .add_order(order, None, assigned_client, false)
8285            .unwrap();
8286
8287        if register_external {
8288            client.register_external_order(
8289                cid,
8290                current,
8291                instrument_id,
8292                identity.strategy_id,
8293                UnixNanos::from(8),
8294            );
8295        } else {
8296            client.start().unwrap();
8297        }
8298
8299        assert_eq!(
8300            client.dispatch_state.identity(&cid),
8301            restored.then_some(identity)
8302        );
8303        assert_eq!(
8304            client.dispatch_state.bound_venue_order_id(&cid),
8305            restored.then_some(current)
8306        );
8307        let expected_legs = restored
8308            .then_some(report.venue_order_id)
8309            .into_iter()
8310            .chain((restored && replacement).then_some(current))
8311            .collect::<AHashSet<_>>();
8312        assert_eq!(
8313            client
8314                .dispatch_state
8315                .venue_order_legs(&cid)
8316                .into_iter()
8317                .collect::<AHashSet<_>>(),
8318            expected_legs,
8319        );
8320        assert_eq!(client.dispatch_state.contains_accepted(&cid), restored);
8321        assert_eq!(
8322            client.dispatch_state.contains_trade(&report.trade_id),
8323            restored
8324        );
8325        assert!(rx.try_recv().is_err());
8326
8327        if restored {
8328            dispatch_trades_payload(
8329                DeriveTradesSubscriptionData {
8330                    trades: vec![trade.clone()],
8331                },
8332                &client.emitter,
8333                account_id,
8334                client.clock,
8335                &client.dispatch_state,
8336            );
8337
8338            assert!(rx.try_recv().is_err());
8339            let current_venue_order_id = VenueOrderId::from("restored-current-child");
8340            client
8341                .dispatch_state
8342                .record_venue_order_id(cid, current_venue_order_id);
8343            client.start().unwrap();
8344            assert_eq!(
8345                client.dispatch_state.bound_venue_order_id(&cid),
8346                Some(current_venue_order_id)
8347            );
8348            trade.order_id = current_venue_order_id.as_str().into();
8349            trade.trade_id = "restored-final-fill".into();
8350            trade.trade_amount = dec!(1.2);
8351            dispatch_trades_payload(
8352                DeriveTradesSubscriptionData {
8353                    trades: vec![trade],
8354                },
8355                &client.emitter,
8356                account_id,
8357                client.clock,
8358                &client.dispatch_state,
8359            );
8360
8361            let ExecutionEvent::Order(OrderEventAny::Filled(fill)) = rx.try_recv().unwrap() else {
8362                panic!("Expected only the unapplied fill");
8363            };
8364
8365            assert_eq!(fill.client_order_id, cid);
8366            assert_eq!(fill.instrument_id, instrument_id);
8367            assert_eq!(fill.strategy_id, identity.strategy_id);
8368            assert_eq!(fill.venue_order_id, current_venue_order_id);
8369            assert_eq!(fill.last_qty, Quantity::from("1.200"));
8370            assert_eq!(fill.last_px, Price::from("3499.00"));
8371            assert!(rx.try_recv().is_err());
8372            assert_eq!(client.dispatch_state.identity(&cid), None);
8373            assert!(client.dispatch_state.is_terminal(&cid, instrument_id));
8374        }
8375    }
8376
8377    #[rstest]
8378    #[case(false)]
8379    #[case(true)]
8380    fn test_authoritative_sender_installed_before_start_and_reinstalled(#[case] restart: bool) {
8381        use nautilus_common::live::runner::replace_exec_event_sender;
8382
8383        let (first_tx, mut first_rx) = tokio::sync::mpsc::unbounded_channel();
8384        replace_exec_event_sender(first_tx);
8385        let mut client = DeriveExecutionClient::new(test_core(), test_config()).unwrap();
8386        let (second_tx, mut second_rx) = tokio::sync::mpsc::unbounded_channel();
8387
8388        if restart {
8389            client.start().unwrap();
8390            replace_exec_event_sender(second_tx);
8391            client.start().unwrap();
8392        }
8393
8394        let trade: DeriveTrade = serde_json::from_str(include_str!(
8395            "../test_data/perps/http_private_trade_eth.json"
8396        ))
8397        .unwrap();
8398        let report = parse_derive_trade_to_fill_report_with_precision(
8399            &trade,
8400            client.account_id(),
8401            Currency::USDC(),
8402            None,
8403            None,
8404            UnixNanos::from(23),
8405        )
8406        .unwrap()
8407        .unwrap();
8408        client
8409            .emitter
8410            .try_send_execution_report(ExecutionReport::Fill(Box::new(report.clone())))
8411            .unwrap();
8412
8413        let event = if restart {
8414            second_rx.try_recv().unwrap()
8415        } else {
8416            first_rx.try_recv().unwrap()
8417        };
8418
8419        let ExecutionEvent::Report(ExecutionReport::Fill(actual)) = event else {
8420            panic!("authoritative sender must receive the report");
8421        };
8422
8423        assert_eq!(*actual, report);
8424        assert!(first_rx.try_recv().is_err());
8425        assert!(second_rx.try_recv().is_err());
8426    }
8427
8428    #[rstest]
8429    fn test_acceptance_delivery_failure_preserves_replay() {
8430        let clock = get_atomic_clock_realtime();
8431        let state = WsDispatchState::new(42);
8432        let client_order_id = ClientOrderId::from("DELIVERY-1");
8433        let venue_order_id = VenueOrderId::from("venue-delivery-1");
8434        let account_id = AccountId::from("DERIVE-001");
8435
8436        let identity = OrderIdentity {
8437            instrument_id: InstrumentId::from("ETH-PERP.DERIVE"),
8438            strategy_id: StrategyId::from("S-1"),
8439            order_side: OrderSide::Buy,
8440            order_type: OrderType::Limit,
8441        };
8442
8443        state.register_identity(client_order_id, identity);
8444        let (emitter, rx) = test_emitter(clock);
8445        drop(rx);
8446        ensure_accepted_emitted(
8447            &emitter,
8448            &state,
8449            client_order_id,
8450            identity,
8451            venue_order_id,
8452            account_id,
8453            UnixNanos::from(11),
8454            UnixNanos::from(17),
8455        );
8456        assert!(!state.contains_accepted(&client_order_id));
8457        let (emitter, mut rx) = test_emitter(clock);
8458        ensure_accepted_emitted(
8459            &emitter,
8460            &state,
8461            client_order_id,
8462            identity,
8463            venue_order_id,
8464            account_id,
8465            UnixNanos::from(11),
8466            UnixNanos::from(17),
8467        );
8468
8469        let ExecutionEvent::Order(OrderEventAny::Accepted(event)) = rx.try_recv().unwrap() else {
8470            panic!("acceptance must remain deliverable");
8471        };
8472
8473        assert_eq!(event.trader_id, TraderId::from("TRADER-001"));
8474        assert_eq!(event.strategy_id, identity.strategy_id);
8475        assert_eq!(event.instrument_id, identity.instrument_id);
8476        assert_eq!(event.client_order_id, client_order_id);
8477        assert_eq!(event.venue_order_id, venue_order_id);
8478        assert_eq!(event.account_id, account_id);
8479        assert_eq!(event.ts_event, UnixNanos::from(11));
8480        assert_eq!(event.ts_init, UnixNanos::from(17));
8481        assert!(!event.reconciliation);
8482        assert!(state.contains_accepted(&client_order_id));
8483        assert_eq!(state.identity(&client_order_id), Some(identity));
8484        assert!(rx.try_recv().is_err());
8485    }
8486
8487    #[rstest]
8488    #[case("valid")]
8489    #[case("foreign_account")]
8490    #[case("foreign_instrument")]
8491    #[case("wrong_side")]
8492    #[case("unknown_child")]
8493    #[case("old_leg")]
8494    #[case("terminal")]
8495    fn test_trigger_activation_requires_current_native_ownership(
8496        #[case] scope: &str,
8497        #[values(false, true)] fill: bool,
8498    ) {
8499        let clock = get_atomic_clock_realtime();
8500        let state = WsDispatchState::new(42);
8501        let cid = ClientOrderId::from("ACTIVATION-SCOPE");
8502        let native_id = VenueOrderId::from("activation-current");
8503
8504        let identity = OrderIdentity {
8505            instrument_id: InstrumentId::from("ETH-PERP.DERIVE"),
8506            strategy_id: StrategyId::from("S-1"),
8507            order_side: OrderSide::Buy,
8508            order_type: OrderType::StopLimit,
8509        };
8510
8511        state.register_identity(cid, identity);
8512        state.record_venue_order_id(cid, native_id);
8513        state.record_order_shape(cid, Quantity::from("2.000"), None);
8514        if scope == "old_leg" {
8515            state.record_venue_leg(cid, VenueOrderId::from("activation-old"));
8516        }
8517
8518        if scope == "terminal" {
8519            state.forget(&cid);
8520        }
8521
8522        let (emitter, rx) = test_emitter(clock);
8523        drop(rx);
8524
8525        if fill {
8526            let mut trade: DeriveTrade = serde_json::from_str(include_str!(
8527                "../test_data/perps/http_private_trade_eth.json"
8528            ))
8529            .unwrap();
8530            trade.label = cid.to_string().into();
8531            trade.order_id = native_id.to_string();
8532            match scope {
8533                "foreign_account" => trade.subaccount_id = 43,
8534                "foreign_instrument" => trade.instrument_name = "BTC-PERP".into(),
8535                "wrong_side" => trade.direction = DeriveOrderSide::Sell,
8536                "unknown_child" => trade.order_id = "activation-unknown".into(),
8537                "old_leg" => trade.order_id = "activation-old".into(),
8538                _ => {}
8539            }
8540
8541            dispatch_trades_payload(
8542                DeriveTradesSubscriptionData {
8543                    trades: vec![trade],
8544                },
8545                &emitter,
8546                AccountId::from("DERIVE-001"),
8547                clock,
8548                &state,
8549            );
8550        } else {
8551            let mut order: DeriveOrder = serde_json::from_str(include_str!(
8552                "../test_data/perps/http_order_eth_partially_filled.json"
8553            ))
8554            .unwrap();
8555            order.label = cid.to_string().into();
8556            order.order_id = native_id.to_string();
8557            order.order_type = crate::common::enums::DeriveOrderType::Limit;
8558            order.order_status = DeriveOrderStatus::Open;
8559            order.trigger_type = Some(crate::common::enums::DeriveTriggerType::Stoploss);
8560            match scope {
8561                "foreign_account" => order.subaccount_id = 43,
8562                "foreign_instrument" => order.instrument_name = "BTC-PERP".into(),
8563                "wrong_side" => order.direction = DeriveOrderSide::Sell,
8564                "unknown_child" => order.order_id = "activation-unknown".into(),
8565                "old_leg" => order.order_id = "activation-old".into(),
8566                _ => {}
8567            }
8568
8569            dispatch_orders_payload(
8570                DeriveOrdersSubscriptionData {
8571                    orders: vec![order],
8572                },
8573                &emitter,
8574                AccountId::from("DERIVE-001"),
8575                clock,
8576                &state,
8577            );
8578        }
8579
8580        assert_eq!(state.trigger_active(&cid), scope == "valid");
8581        assert_eq!(
8582            state.bound_venue_order_id(&cid),
8583            (scope != "terminal").then_some(native_id)
8584        );
8585        state.forget(&cid);
8586        assert!(!state.trigger_active(&cid));
8587    }
8588
8589    #[rstest]
8590    #[case(0, false)]
8591    #[case(1, false)]
8592    #[case(2, false)]
8593    #[case(0, true)]
8594    #[case(1, true)]
8595    #[case(2, true)]
8596    fn test_canceled_partial_fill_retains_identity_until_trades_arrive(
8597        #[case] fills_before_cancel: usize,
8598        #[case] submit_response: bool,
8599    ) {
8600        let clock = get_atomic_clock_realtime();
8601        let state = WsDispatchState::new(42);
8602        let client_order_id = ClientOrderId::from("PARTIAL-IOC-1");
8603        let account_id = AccountId::from("DERIVE-001");
8604
8605        let identity = OrderIdentity {
8606            instrument_id: InstrumentId::from("ETH-PERP.DERIVE"),
8607            strategy_id: StrategyId::from("S-1"),
8608            order_side: OrderSide::Buy,
8609            order_type: OrderType::Limit,
8610        };
8611
8612        state.register_identity(client_order_id, identity);
8613        state.record_order_shape(client_order_id, Quantity::from("1.000"), None);
8614        let mut order: DeriveOrder = serde_json::from_str(include_str!(
8615            "../test_data/perps/http_order_eth_partially_filled.json"
8616        ))
8617        .unwrap();
8618        order.label = client_order_id.as_str().into();
8619        order.order_id = "order-abc".into();
8620        order.amount = dec!(1.0);
8621        order.filled_amount = dec!(0.5);
8622        order.order_status = DeriveOrderStatus::Cancelled;
8623        order.order_type = DeriveOrderType::Limit;
8624        let trade: DeriveTrade = serde_json::from_str(include_str!(
8625            "../test_data/perps/http_private_trade_eth.json"
8626        ))
8627        .unwrap();
8628
8629        let trades: Vec<_> = [dec!(0.2), dec!(0.3)]
8630            .into_iter()
8631            .enumerate()
8632            .map(|(i, qty)| {
8633                let mut trade = trade.clone();
8634                trade.label = client_order_id.as_str().into();
8635                trade.trade_id = format!("partial-ioc-{i}");
8636                trade.trade_amount = qty;
8637                trade
8638            })
8639            .collect();
8640
8641        let (emitter, mut rx) = test_emitter(clock);
8642        dispatch_trades_payload(
8643            DeriveTradesSubscriptionData {
8644                trades: trades[..fills_before_cancel].to_vec(),
8645            },
8646            &emitter,
8647            account_id,
8648            clock,
8649            &state,
8650        );
8651
8652        for _ in 0..2 {
8653            dispatch_orders_payload(
8654                DeriveOrdersSubscriptionData {
8655                    orders: vec![order.clone()],
8656                },
8657                &emitter,
8658                account_id,
8659                clock,
8660                &state,
8661            );
8662        }
8663
8664        assert_eq!(
8665            state.identity(&client_order_id),
8666            (fills_before_cancel < trades.len()).then_some(identity),
8667        );
8668
8669        for _ in 0..2 {
8670            if submit_response {
8671                dispatch_order_result(
8672                    DeriveOrderResult {
8673                        order: order.clone(),
8674                        trades: trades.clone(),
8675                    },
8676                    client_order_id,
8677                    &emitter,
8678                    account_id,
8679                    clock,
8680                    &state,
8681                );
8682            } else {
8683                for trade in &trades {
8684                    dispatch_trades_payload(
8685                        DeriveTradesSubscriptionData {
8686                            trades: vec![trade.clone()],
8687                        },
8688                        &emitter,
8689                        account_id,
8690                        clock,
8691                        &state,
8692                    );
8693
8694                    dispatch_orders_payload(
8695                        DeriveOrdersSubscriptionData {
8696                            orders: vec![order.clone()],
8697                        },
8698                        &emitter,
8699                        account_id,
8700                        clock,
8701                        &state,
8702                    );
8703                }
8704            }
8705        }
8706
8707        let mut accepted = 0;
8708        let mut canceled = 0;
8709        let mut fills = Vec::new();
8710        let mut events = Vec::new();
8711
8712        while let Ok(event) = rx.try_recv() {
8713            match event {
8714                ExecutionEvent::Order(OrderEventAny::Accepted(event)) => {
8715                    assert_eq!(event.client_order_id, client_order_id);
8716                    accepted += 1;
8717                    events.push("accepted");
8718                }
8719                ExecutionEvent::Order(OrderEventAny::Canceled(event)) => {
8720                    assert_eq!(event.client_order_id, client_order_id);
8721                    canceled += 1;
8722                    events.push("canceled");
8723                }
8724                ExecutionEvent::Order(OrderEventAny::Filled(fill)) => {
8725                    fills.push(fill);
8726                    events.push("filled");
8727                }
8728                other => panic!("Expected tracked order events, received {other:?}"),
8729            }
8730        }
8731
8732        let expected_events: Vec<_> = std::iter::once("accepted")
8733            .chain(std::iter::repeat_n("filled", fills_before_cancel))
8734            .chain(std::iter::once("canceled"))
8735            .chain(std::iter::repeat_n(
8736                "filled",
8737                trades.len() - fills_before_cancel,
8738            ))
8739            .collect();
8740        assert_eq!(events, expected_events);
8741        assert_eq!(accepted, 1);
8742        assert_eq!(canceled, 1);
8743        assert_eq!(fills.len(), trades.len());
8744
8745        for (fill, trade) in fills.iter().zip(&trades) {
8746            assert_eq!(fill.trader_id, emitter.trader_id());
8747            assert_eq!(fill.strategy_id, identity.strategy_id);
8748            assert_eq!(fill.instrument_id, identity.instrument_id);
8749            assert_eq!(fill.client_order_id, client_order_id);
8750            assert_eq!(fill.venue_order_id, VenueOrderId::from("order-abc"));
8751            assert_eq!(fill.account_id, account_id);
8752            assert_eq!(fill.trade_id.as_str(), trade.trade_id);
8753            assert_eq!(fill.order_side, identity.order_side);
8754            assert_eq!(fill.order_type, identity.order_type);
8755            assert_eq!(fill.last_qty.as_decimal(), trade.trade_amount);
8756            assert_eq!(fill.last_px.as_decimal(), dec!(3499));
8757            assert_eq!(fill.currency, Currency::USDC());
8758            assert_eq!(fill.liquidity_side, LiquiditySide::Maker);
8759            assert_eq!(fill.ts_event, UnixNanos::from(1_700_000_000_000_000_000));
8760            assert_eq!(fill.position_id, None);
8761            assert_eq!(
8762                fill.commission,
8763                Some(Money::from_decimal(dec!(0.02), Currency::USDC()).unwrap())
8764            );
8765            assert_eq!(fill.info, None);
8766            assert_eq!(fill.causation_id, None);
8767            assert!(!fill.reconciliation);
8768        }
8769
8770        assert_eq!(state.identity(&client_order_id), None);
8771        assert!(state.is_terminal(&client_order_id, identity.instrument_id));
8772    }
8773
8774    #[rstest]
8775    fn test_completed_tracked_fill_retires_identity_and_preserves_late_fill_report() {
8776        let clock = get_atomic_clock_realtime();
8777        let state = WsDispatchState::new(42);
8778        let client_order_id = ClientOrderId::from("FILL-RETIRE-1");
8779        let account_id = AccountId::from("DERIVE-001");
8780
8781        let identity = OrderIdentity {
8782            instrument_id: InstrumentId::from("ETH-PERP.DERIVE"),
8783            strategy_id: StrategyId::from("S-1"),
8784            order_side: OrderSide::Buy,
8785            order_type: OrderType::Limit,
8786        };
8787
8788        state.register_identity(client_order_id, identity);
8789        state.record_order_shape(client_order_id, Quantity::from("0.500"), None);
8790        let mut trade: DeriveTrade = serde_json::from_str(include_str!(
8791            "../test_data/perps/http_private_trade_eth.json"
8792        ))
8793        .unwrap();
8794        trade.label = client_order_id.as_str().into();
8795        let (emitter, mut rx) = test_emitter(clock);
8796        dispatch_trades_payload(
8797            DeriveTradesSubscriptionData {
8798                trades: vec![trade.clone()],
8799            },
8800            &emitter,
8801            account_id,
8802            clock,
8803            &state,
8804        );
8805
8806        assert!(matches!(
8807            rx.try_recv(),
8808            Ok(ExecutionEvent::Order(OrderEventAny::Accepted(_)))
8809        ));
8810        assert!(matches!(
8811            rx.try_recv(),
8812            Ok(ExecutionEvent::Order(OrderEventAny::Filled(_)))
8813        ));
8814        assert_eq!(state.identity(&client_order_id), None);
8815        assert!(state.is_terminal(&client_order_id, identity.instrument_id));
8816        dispatch_trades_payload(
8817            DeriveTradesSubscriptionData {
8818                trades: vec![trade.clone()],
8819            },
8820            &emitter,
8821            account_id,
8822            clock,
8823            &state,
8824        );
8825
8826        assert!(rx.try_recv().is_err());
8827        trade.trade_id = "late-fill-2".to_string();
8828        trade.trade_amount = dec!(0.2);
8829        dispatch_trades_payload(
8830            DeriveTradesSubscriptionData {
8831                trades: vec![trade],
8832            },
8833            &emitter,
8834            account_id,
8835            clock,
8836            &state,
8837        );
8838
8839        let ExecutionEvent::Report(ExecutionReport::Fill(report)) = rx.try_recv().unwrap() else {
8840            panic!("a distinct late fill must reach reconciliation");
8841        };
8842
8843        assert_eq!(report.account_id, account_id);
8844        assert_eq!(report.instrument_id, identity.instrument_id);
8845        assert_eq!(report.client_order_id, Some(client_order_id));
8846        assert_eq!(report.venue_order_id, VenueOrderId::from("order-abc"));
8847        assert_eq!(report.trade_id.as_str(), "late-fill-2");
8848        assert_eq!(report.order_side, OrderSide::Buy);
8849        assert_eq!(report.last_qty.as_decimal(), dec!(0.2));
8850        assert_eq!(report.last_px.as_decimal(), dec!(3499));
8851        assert_eq!(
8852            report.commission,
8853            Money::from_decimal(dec!(0.02), Currency::USDC()).unwrap()
8854        );
8855        assert_eq!(report.liquidity_side, LiquiditySide::Maker);
8856        assert_eq!(report.ts_event, UnixNanos::from(1_700_000_000_000_000_000));
8857        assert_eq!(report.avg_px, None);
8858        assert_eq!(report.venue_position_id, None);
8859        assert!(rx.try_recv().is_err());
8860    }
8861
8862    #[rstest]
8863    #[case(false, false)]
8864    #[case(false, true)]
8865    #[case(true, false)]
8866    #[case(true, true)]
8867    fn test_foreign_instrument_label_preserves_external_identity(
8868        #[case] terminal: bool,
8869        #[case] fill: bool,
8870    ) {
8871        let clock = get_atomic_clock_realtime();
8872        let state = WsDispatchState::new(42);
8873        let cid = ClientOrderId::from("FOREIGN-LABEL-1");
8874
8875        let identity = OrderIdentity {
8876            instrument_id: InstrumentId::from("ETH-PERP.DERIVE"),
8877            strategy_id: StrategyId::from("S-1"),
8878            order_side: OrderSide::Buy,
8879            order_type: OrderType::Limit,
8880        };
8881
8882        state.register_identity(cid, identity);
8883        if terminal {
8884            state.forget(&cid);
8885        }
8886
8887        let (emitter, mut rx) = test_emitter(clock);
8888        let account_id = AccountId::from("DERIVE-001");
8889        let instrument_id = InstrumentId::from("BTC-PERP.DERIVE");
8890
8891        if fill {
8892            let mut trade: DeriveTrade = serde_json::from_str(include_str!(
8893                "../test_data/perps/http_private_trade_eth.json"
8894            ))
8895            .unwrap();
8896            trade.label = cid.as_str().into();
8897            trade.instrument_name = "BTC-PERP".into();
8898            dispatch_trades_payload(
8899                DeriveTradesSubscriptionData {
8900                    trades: vec![trade],
8901                },
8902                &emitter,
8903                account_id,
8904                clock,
8905                &state,
8906            );
8907
8908            let ExecutionEvent::Report(ExecutionReport::Fill(report)) = rx.try_recv().unwrap()
8909            else {
8910                panic!("Expected external fill report");
8911            };
8912
8913            assert_eq!(report.client_order_id, None);
8914            assert_eq!(report.instrument_id, instrument_id);
8915            assert_eq!(report.account_id, account_id);
8916            assert_eq!(report.venue_order_id, VenueOrderId::from("order-abc"));
8917            assert_eq!(report.trade_id.as_str(), "trade-xyz");
8918            assert_eq!(report.last_qty.as_decimal(), dec!(0.5));
8919            assert_eq!(report.last_px.as_decimal(), dec!(3499));
8920            assert_eq!(report.commission.as_decimal(), dec!(0.02));
8921        } else {
8922            let mut order: DeriveOrder = serde_json::from_str(include_str!(
8923                "../test_data/perps/http_order_eth_partially_filled.json"
8924            ))
8925            .unwrap();
8926            order.label = cid.as_str().into();
8927            order.instrument_name = "BTC-PERP".into();
8928            let venue_order_id = VenueOrderId::from(order.order_id.as_str());
8929            dispatch_orders_payload(
8930                DeriveOrdersSubscriptionData {
8931                    orders: vec![order],
8932                },
8933                &emitter,
8934                account_id,
8935                clock,
8936                &state,
8937            );
8938
8939            let ExecutionEvent::Report(ExecutionReport::Order(report)) = rx.try_recv().unwrap()
8940            else {
8941                panic!("Expected external order report");
8942            };
8943
8944            assert_eq!(report.client_order_id, None);
8945            assert_eq!(report.instrument_id, instrument_id);
8946            assert_eq!(report.account_id, account_id);
8947            assert_eq!(report.venue_order_id, venue_order_id);
8948        }
8949
8950        assert_eq!(state.identity(&cid), (!terminal).then_some(identity));
8951        assert_eq!(state.is_terminal(&cid, identity.instrument_id), terminal);
8952        assert!(rx.try_recv().is_err());
8953    }
8954
8955    #[rstest]
8956    fn test_order_result_retired_identity_preserves_distinct_trades() {
8957        let clock = get_atomic_clock_realtime();
8958        let state = WsDispatchState::new(42);
8959        let account_id = AccountId::from("DERIVE-001");
8960        let client_order_id = ClientOrderId::from("STRAT-RETIRED-RPC");
8961        let instrument_id = InstrumentId::from("ETH-PERP.DERIVE");
8962        state.register_identity(
8963            client_order_id,
8964            OrderIdentity {
8965                instrument_id,
8966                strategy_id: StrategyId::from("S-1"),
8967                order_side: OrderSide::Buy,
8968                order_type: OrderType::Limit,
8969            },
8970        );
8971
8972        state.forget(&client_order_id);
8973        let mut order: DeriveOrder = serde_json::from_str(include_str!(
8974            "../test_data/perps/http_order_eth_partially_filled.json"
8975        ))
8976        .unwrap();
8977        order.label = client_order_id.as_str().into();
8978        let mut trade: DeriveTrade = serde_json::from_str(include_str!(
8979            "../test_data/perps/http_private_trade_eth.json"
8980        ))
8981        .unwrap();
8982        trade.label = client_order_id.as_str().into();
8983        trade.trade_id = "rpc-distinct-late-fill".to_string();
8984        trade.trade_amount = dec!(0.23);
8985
8986        let result = DeriveOrderResult {
8987            order,
8988            trades: vec![trade],
8989        };
8990
8991        let (emitter, mut rx) = test_emitter(clock);
8992
8993        dispatch_order_result(
8994            result.clone(),
8995            client_order_id,
8996            &emitter,
8997            account_id,
8998            clock,
8999            &state,
9000        );
9001        dispatch_order_result(result, client_order_id, &emitter, account_id, clock, &state);
9002
9003        let ExecutionEvent::Report(ExecutionReport::Fill(report)) = rx.try_recv().unwrap() else {
9004            panic!("a distinct late RPC fill must reach reconciliation");
9005        };
9006
9007        assert_eq!(report.account_id, account_id);
9008        assert_eq!(report.instrument_id, instrument_id);
9009        assert_eq!(report.client_order_id, Some(client_order_id));
9010        assert_eq!(report.venue_order_id, VenueOrderId::from("order-abc"));
9011        assert_eq!(report.trade_id.as_str(), "rpc-distinct-late-fill");
9012        assert_eq!(report.order_side, OrderSide::Buy);
9013        assert_eq!(report.last_qty.as_decimal(), dec!(0.23));
9014        assert_eq!(report.last_px.as_decimal(), dec!(3499));
9015        assert_eq!(
9016            report.commission,
9017            Money::from_decimal(dec!(0.02), Currency::USDC()).unwrap()
9018        );
9019        assert_eq!(report.liquidity_side, LiquiditySide::Maker);
9020        assert_eq!(report.ts_event, UnixNanos::from(1_700_000_000_000_000_000));
9021        assert_eq!(report.avg_px, None);
9022        assert_eq!(report.venue_position_id, None);
9023        assert_eq!(state.identity(&client_order_id), None);
9024        assert!(state.is_terminal(&client_order_id, instrument_id));
9025        assert!(rx.try_recv().is_err());
9026    }
9027
9028    #[rstest]
9029    #[case("orders")]
9030    #[case("trades")]
9031    #[case("rpc")]
9032    fn test_private_rows_require_native_account_identity(#[case] source: &str) {
9033        let clock = get_atomic_clock_realtime();
9034        let state = WsDispatchState::new(42);
9035        let account_id = AccountId::from("DERIVE-001");
9036        let client_order_id = ClientOrderId::from("STRAT-O-1");
9037
9038        let identity = OrderIdentity {
9039            instrument_id: InstrumentId::from("ETH-PERP.DERIVE"),
9040            strategy_id: StrategyId::from("S-1"),
9041            order_side: OrderSide::Buy,
9042            order_type: OrderType::Limit,
9043        };
9044
9045        state.register_identity(client_order_id, identity);
9046        let order: DeriveOrder = serde_json::from_str(include_str!(
9047            "../test_data/perps/http_order_eth_partially_filled.json"
9048        ))
9049        .unwrap();
9050        let trade: DeriveTrade = serde_json::from_str(include_str!(
9051            "../test_data/perps/http_private_trade_eth.json"
9052        ))
9053        .unwrap();
9054        let trade_id = TradeId::new(&trade.trade_id);
9055        let mut foreign_order = order.clone();
9056        foreign_order.subaccount_id = 43;
9057        let mut foreign_trade = trade.clone();
9058        foreign_trade.subaccount_id = 43;
9059        let (emitter, mut rx) = test_emitter(clock);
9060
9061        match source {
9062            "orders" => dispatch_orders_payload(
9063                DeriveOrdersSubscriptionData {
9064                    orders: vec![foreign_order],
9065                },
9066                &emitter,
9067                account_id,
9068                clock,
9069                &state,
9070            ),
9071            "trades" => dispatch_trades_payload(
9072                DeriveTradesSubscriptionData {
9073                    trades: vec![foreign_trade],
9074                },
9075                &emitter,
9076                account_id,
9077                clock,
9078                &state,
9079            ),
9080            "rpc" => dispatch_order_result(
9081                DeriveOrderResult {
9082                    order: foreign_order,
9083                    trades: vec![foreign_trade],
9084                },
9085                client_order_id,
9086                &emitter,
9087                account_id,
9088                clock,
9089                &state,
9090            ),
9091            _ => unreachable!(),
9092        }
9093
9094        assert!(
9095            rx.try_recv().is_err(),
9096            "foreign-account evidence must emit nothing"
9097        );
9098        assert_eq!(state.bound_venue_order_id(&client_order_id), None);
9099        assert_eq!(state.identity(&client_order_id), Some(identity));
9100        assert!(!state.contains_trade(&trade_id));
9101
9102        match source {
9103            "orders" => dispatch_orders_payload(
9104                DeriveOrdersSubscriptionData {
9105                    orders: vec![order],
9106                },
9107                &emitter,
9108                account_id,
9109                clock,
9110                &state,
9111            ),
9112            "trades" => dispatch_trades_payload(
9113                DeriveTradesSubscriptionData {
9114                    trades: vec![trade],
9115                },
9116                &emitter,
9117                account_id,
9118                clock,
9119                &state,
9120            ),
9121            "rpc" => dispatch_order_result(
9122                DeriveOrderResult {
9123                    order,
9124                    trades: vec![trade],
9125                },
9126                client_order_id,
9127                &emitter,
9128                account_id,
9129                clock,
9130                &state,
9131            ),
9132            _ => unreachable!(),
9133        }
9134
9135        assert!(rx.try_recv().is_ok(), "matching native evidence must emit");
9136    }
9137
9138    #[rstest]
9139    #[case("orders")]
9140    #[case("trades")]
9141    fn test_private_channel_requires_native_account_identity(#[case] channel: &str) {
9142        let clock = get_atomic_clock_realtime();
9143        let state = WsDispatchState::new(42);
9144
9145        let data = if channel == "orders" {
9146            serde_json::json!([serde_json::from_str::<serde_json::Value>(include_str!(
9147                "../test_data/perps/http_order_eth_partially_filled.json"
9148            ))
9149            .unwrap()])
9150        } else {
9151            serde_json::json!([serde_json::from_str::<serde_json::Value>(include_str!(
9152                "../test_data/perps/http_private_trade_eth.json"
9153            ))
9154            .unwrap()])
9155        };
9156
9157        let payload = WsSubscriptionPayload {
9158            channel: format!("43.{channel}").into(),
9159            data: serde_json::value::to_raw_value(&data).unwrap(),
9160        };
9161
9162        let (emitter, mut rx) = test_emitter(clock);
9163        handle_ws_message(
9164            DeriveWsMessage::Subscription(payload.clone()),
9165            &emitter,
9166            AccountId::from("DERIVE-001"),
9167            clock,
9168            &state,
9169        );
9170        assert!(
9171            rx.try_recv().is_err(),
9172            "foreign channel must emit nothing even with own rows"
9173        );
9174
9175        let payload = WsSubscriptionPayload {
9176            channel: format!("42.{channel}").into(),
9177            ..payload
9178        };
9179
9180        handle_ws_message(
9181            DeriveWsMessage::Subscription(payload),
9182            &emitter,
9183            AccountId::from("DERIVE-001"),
9184            clock,
9185            &state,
9186        );
9187        assert!(rx.try_recv().is_ok(), "matching channel must emit");
9188    }
9189
9190    #[rstest]
9191    #[case(None)]
9192    #[case(Some("unrelated-leg"))]
9193    #[case(Some("original-leg"))]
9194    fn test_replacement_order_requires_native_link_before_binding(
9195        #[case] replaced_id: Option<&str>,
9196    ) {
9197        let clock = get_atomic_clock_realtime();
9198        let state = WsDispatchState::new(42);
9199        let cid = ClientOrderId::from("REPLACE-AUTHORITY");
9200        let instrument_id = InstrumentId::from("ETH-PERP.DERIVE");
9201        let old_id = VenueOrderId::from("original-leg");
9202        let new_id = VenueOrderId::from("replacement-leg");
9203
9204        let identity = OrderIdentity {
9205            instrument_id,
9206            strategy_id: StrategyId::from("S-1"),
9207            order_side: OrderSide::Buy,
9208            order_type: OrderType::Limit,
9209        };
9210
9211        state.register_identity(cid, identity);
9212        state.record_venue_order_id(cid, old_id);
9213        state.mark_accepted(cid);
9214        state.mark_pending_modify(cid, old_id);
9215        state.record_modify_target(cid, Quantity::from("2.000"), Some(Price::from("3505.00")));
9216        let mut order: DeriveOrder = serde_json::from_str(include_str!(
9217            "../test_data/perps/http_order_eth_partially_filled.json"
9218        ))
9219        .unwrap();
9220        order.label = cid.as_str().into();
9221        order.order_id = new_id.to_string();
9222        order.order_status = DeriveOrderStatus::Open;
9223        order.replaced_order_id = replaced_id.map(str::to_owned);
9224        state.record_modify_nonce(cid, order.nonce);
9225        let (emitter, mut rx) = test_emitter(clock);
9226        dispatch_orders_payload(
9227            DeriveOrdersSubscriptionData {
9228                orders: vec![order],
9229            },
9230            &emitter,
9231            AccountId::from("DERIVE-001"),
9232            clock,
9233            &state,
9234        );
9235
9236        if replaced_id == Some(old_id.as_str()) {
9237            let ExecutionEvent::Order(OrderEventAny::Updated(updated)) = rx.try_recv().unwrap()
9238            else {
9239                panic!("expected authoritative update");
9240            };
9241
9242            assert_eq!(updated.client_order_id, cid);
9243            assert_eq!(updated.instrument_id, instrument_id);
9244            assert_eq!(updated.venue_order_id, Some(new_id));
9245            assert_eq!(updated.quantity, Quantity::from("2.000"));
9246            assert_eq!(updated.price, Some(Price::from("3505.00")));
9247            assert_eq!(state.bound_venue_order_id(&cid), Some(new_id));
9248        } else {
9249            assert!(
9250                rx.try_recv().is_err(),
9251                "a label without a matching replaced_order_id is not replacement authority"
9252            );
9253            assert_eq!(state.bound_venue_order_id(&cid), Some(old_id));
9254            assert_eq!(state.pending_modify(&cid), Some(old_id));
9255            assert_eq!(
9256                state.modify_target(&cid),
9257                Some((Quantity::from("2.000"), Some(Price::from("3505.00"))))
9258            );
9259        }
9260
9261        assert!(rx.try_recv().is_err());
9262    }
9263
9264    #[rstest]
9265    #[case(None)]
9266    #[case(Some(101))]
9267    #[case(Some(202))]
9268    fn test_replacement_requires_prepared_request_nonce(#[case] prepared_nonce: Option<u64>) {
9269        let clock = get_atomic_clock_realtime();
9270        let state = WsDispatchState::new(42);
9271        let cid = ClientOrderId::from("REPLACE-NOT-PREPARED");
9272        let instrument_id = InstrumentId::from("ETH-PERP.DERIVE");
9273        let old_id = VenueOrderId::from("original-leg");
9274
9275        let identity = OrderIdentity {
9276            instrument_id,
9277            strategy_id: StrategyId::from("S-1"),
9278            order_side: OrderSide::Buy,
9279            order_type: OrderType::Limit,
9280        };
9281
9282        state.register_identity(cid, identity);
9283        state.record_venue_order_id(cid, old_id);
9284        state.mark_accepted(cid);
9285        state.mark_pending_modify(cid, old_id);
9286        state.record_modify_target(cid, Quantity::from("2.000"), Some(Price::from("3505.00")));
9287        let mut order: DeriveOrder = serde_json::from_str(include_str!(
9288            "../test_data/perps/http_order_eth_partially_filled.json"
9289        ))
9290        .unwrap();
9291        order.label = cid.as_str().into();
9292        order.order_id = "prior-replacement-leg".to_string();
9293        order.nonce = 202;
9294
9295        if let Some(nonce) = prepared_nonce {
9296            state.record_modify_nonce(cid, nonce);
9297        }
9298
9299        order.order_status = DeriveOrderStatus::Open;
9300        order.replaced_order_id = Some(old_id.to_string());
9301        let (emitter, mut rx) = test_emitter(clock);
9302        dispatch_orders_payload(
9303            DeriveOrdersSubscriptionData {
9304                orders: vec![order],
9305            },
9306            &emitter,
9307            AccountId::from("DERIVE-001"),
9308            clock,
9309            &state,
9310        );
9311
9312        if prepared_nonce == Some(202) {
9313            let ExecutionEvent::Order(OrderEventAny::Updated(updated)) = rx.try_recv().unwrap()
9314            else {
9315                panic!("expected matching command update");
9316            };
9317
9318            assert_eq!(updated.client_order_id, cid);
9319            assert_eq!(updated.instrument_id, instrument_id);
9320            assert_eq!(updated.quantity, Quantity::from("2.000"));
9321            assert_eq!(updated.price, Some(Price::from("3505.00")));
9322            assert_eq!(
9323                updated.venue_order_id,
9324                Some(VenueOrderId::from("prior-replacement-leg"))
9325            );
9326            assert_eq!(state.bound_venue_order_id(&cid), updated.venue_order_id);
9327            assert_eq!(state.pending_modify(&cid), None);
9328            assert_eq!(state.modify_target(&cid), None);
9329            assert_eq!(state.modify_nonce(&cid), None);
9330        } else {
9331            assert!(
9332                rx.try_recv().is_err(),
9333                "a linked child cannot claim an unprepared or different request"
9334            );
9335            assert_eq!(state.bound_venue_order_id(&cid), Some(old_id));
9336            assert_eq!(state.pending_modify(&cid), Some(old_id));
9337            assert_eq!(
9338                state.modify_target(&cid),
9339                Some((Quantity::from("2.000"), Some(Price::from("3505.00"))))
9340            );
9341            assert_eq!(state.modify_nonce(&cid), prepared_nonce);
9342        }
9343
9344        assert!(rx.try_recv().is_err());
9345    }
9346
9347    #[rstest]
9348    fn test_replacement_trade_defers_until_native_order_authority() {
9349        let clock = get_atomic_clock_realtime();
9350        let state = WsDispatchState::new(42);
9351        let cid = ClientOrderId::from("REPLACE-DEFERRED-FILL");
9352        let instrument_id = InstrumentId::from("ETH-PERP.DERIVE");
9353        let old_id = VenueOrderId::from("original-leg");
9354        let new_id = VenueOrderId::from("replacement-leg");
9355
9356        let identity = OrderIdentity {
9357            instrument_id,
9358            strategy_id: StrategyId::from("S-1"),
9359            order_side: OrderSide::Buy,
9360            order_type: OrderType::Limit,
9361        };
9362
9363        state.register_identity(cid, identity);
9364        state.record_venue_order_id(cid, old_id);
9365        state.mark_accepted(cid);
9366        state.record_order_shape(cid, Quantity::from("2.000"), None);
9367        state.mark_pending_modify(cid, old_id);
9368        state.record_modify_target(cid, Quantity::from("2.000"), Some(Price::from("3505.00")));
9369        let mut trade: DeriveTrade = serde_json::from_str(include_str!(
9370            "../test_data/perps/http_private_trade_eth.json"
9371        ))
9372        .unwrap();
9373        trade.label = cid.as_str().into();
9374        trade.order_id = new_id.to_string();
9375        trade.trade_id = "deferred-fill".to_owned();
9376        trade.trade_amount = dec!(0.3);
9377        let (emitter, mut rx) = test_emitter(clock);
9378        dispatch_trades_payload(
9379            DeriveTradesSubscriptionData {
9380                trades: vec![trade],
9381            },
9382            &emitter,
9383            AccountId::from("DERIVE-001"),
9384            clock,
9385            &state,
9386        );
9387
9388        assert!(
9389            rx.try_recv().is_err(),
9390            "trade label cannot authorize Updated or Filled"
9391        );
9392        assert_eq!(state.bound_venue_order_id(&cid), Some(old_id));
9393        assert_eq!(state.pending_modify(&cid), Some(old_id));
9394        assert!(!state.contains_trade(&TradeId::from("deferred-fill")));
9395        let mut order: DeriveOrder = serde_json::from_str(include_str!(
9396            "../test_data/perps/http_order_eth_partially_filled.json"
9397        ))
9398        .unwrap();
9399        order.label = cid.as_str().into();
9400        order.order_id = new_id.to_string();
9401        order.order_status = DeriveOrderStatus::Open;
9402        order.replaced_order_id = Some(old_id.to_string());
9403        state.record_modify_nonce(cid, order.nonce);
9404        dispatch_orders_payload(
9405            DeriveOrdersSubscriptionData {
9406                orders: vec![order],
9407            },
9408            &emitter,
9409            AccountId::from("DERIVE-001"),
9410            clock,
9411            &state,
9412        );
9413
9414        let ExecutionEvent::Order(OrderEventAny::Updated(updated)) = rx.try_recv().unwrap() else {
9415            panic!("expected update before fill");
9416        };
9417
9418        let ExecutionEvent::Order(OrderEventAny::Filled(fill)) = rx.try_recv().unwrap() else {
9419            panic!("expected deferred fill");
9420        };
9421
9422        assert_eq!(updated.venue_order_id, Some(new_id));
9423        assert_eq!(fill.client_order_id, cid);
9424        assert_eq!(fill.venue_order_id, new_id);
9425        assert_eq!(fill.trade_id, TradeId::from("deferred-fill"));
9426        assert_eq!(fill.last_qty, Quantity::from("0.300000"));
9427        assert!(rx.try_recv().is_err());
9428    }
9429
9430    #[rstest]
9431    #[case("rpc")]
9432    #[case("stream")]
9433    fn test_undelivered_trade_survives_authoritative_sender_reinstallation(#[case] source: &str) {
9434        use nautilus_common::live::runner::replace_exec_event_sender;
9435        let (first_tx, first_rx) = tokio::sync::mpsc::unbounded_channel();
9436        replace_exec_event_sender(first_tx);
9437        let mut client = DeriveExecutionClient::new(test_core(), test_config()).unwrap();
9438        drop(first_rx);
9439        let cid = ClientOrderId::from("UNDELIVERED-FINANCIAL");
9440        let instrument_id = InstrumentId::from("ETH-PERP.DERIVE");
9441        let venue_order_id = VenueOrderId::from("owned-financial-leg");
9442
9443        let identity = OrderIdentity {
9444            instrument_id,
9445            strategy_id: StrategyId::from("S-1"),
9446            order_side: OrderSide::Buy,
9447            order_type: OrderType::Limit,
9448        };
9449
9450        client.dispatch_state.register_identity(cid, identity);
9451        client
9452            .dispatch_state
9453            .register_instrument_precision(instrument_id, 2, 3);
9454        client
9455            .dispatch_state
9456            .record_order_shape(cid, Quantity::from("2.000"), None);
9457        client
9458            .dispatch_state
9459            .record_venue_order_id(cid, venue_order_id);
9460        client.dispatch_state.mark_accepted(cid);
9461        let mut trade: DeriveTrade = serde_json::from_str(include_str!(
9462            "../test_data/perps/http_private_trade_eth.json"
9463        ))
9464        .unwrap();
9465        trade.subaccount_id = client.subaccount_id() as i64;
9466        trade.label = cid.as_str().into();
9467        trade.order_id = venue_order_id.to_string();
9468        trade.trade_id = "undelivered-financial".to_owned();
9469
9470        if source == "rpc" {
9471            let mut order: DeriveOrder = serde_json::from_str(include_str!(
9472                "../test_data/perps/http_order_eth_partially_filled.json"
9473            ))
9474            .unwrap();
9475            order.subaccount_id = client.subaccount_id() as i64;
9476            order.label = cid.as_str().into();
9477            order.order_id = venue_order_id.to_string();
9478            order.order_status = DeriveOrderStatus::Open;
9479            dispatch_order_result(
9480                DeriveOrderResult {
9481                    order,
9482                    trades: vec![trade],
9483                },
9484                cid,
9485                &client.emitter,
9486                client.account_id(),
9487                client.clock,
9488                &client.dispatch_state,
9489            );
9490        } else {
9491            dispatch_trades_payload(
9492                DeriveTradesSubscriptionData {
9493                    trades: vec![trade],
9494                },
9495                &client.emitter,
9496                client.account_id(),
9497                client.clock,
9498                &client.dispatch_state,
9499            );
9500        }
9501
9502        let (second_tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
9503        replace_exec_event_sender(second_tx);
9504        client.start().unwrap();
9505
9506        let ExecutionEvent::Order(OrderEventAny::Filled(fill)) = rx
9507            .try_recv()
9508            .expect("undelivered raw trade must survive without venue replay")
9509        else {
9510            panic!("expected retained fill");
9511        };
9512
9513        assert_eq!(fill.client_order_id, cid);
9514        assert_eq!(fill.instrument_id, instrument_id);
9515        assert_eq!(fill.strategy_id, identity.strategy_id);
9516        assert_eq!(fill.venue_order_id, venue_order_id);
9517        assert_eq!(fill.trade_id, TradeId::from("undelivered-financial"));
9518        assert_eq!(fill.last_qty, Quantity::from("0.500"));
9519        assert_eq!(fill.last_px, Price::from("3499.00"));
9520        assert_eq!(fill.commission, Some(Money::from("0.02 USDC")));
9521        client.start().unwrap();
9522        assert!(rx.try_recv().is_err());
9523    }
9524
9525    #[rstest]
9526    fn test_first_native_partial_fill_binds_before_delivery(
9527        #[values(false, true)] failed_delivery: bool,
9528    ) {
9529        let clock = get_atomic_clock_realtime();
9530        let state = WsDispatchState::new(42);
9531        let client_order_id = ClientOrderId::from("NATIVE-FIRST-FILL");
9532
9533        let identity = OrderIdentity {
9534            instrument_id: InstrumentId::from("ETH-PERP.DERIVE"),
9535            strategy_id: StrategyId::from("S-1"),
9536            order_side: OrderSide::Buy,
9537            order_type: OrderType::Limit,
9538        };
9539
9540        state.register_identity(client_order_id, identity);
9541        state.record_order_shape(
9542            client_order_id,
9543            Quantity::from("1.0"),
9544            Some(Price::from("3500")),
9545        );
9546        let mut trade: DeriveTrade = serde_json::from_str(include_str!(
9547            "../test_data/perps/http_private_trade_eth.json"
9548        ))
9549        .unwrap();
9550        trade.label = client_order_id.to_string().into();
9551        let venue_order_id = VenueOrderId::from(trade.order_id.as_str());
9552        let trade_id = TradeId::from(trade.trade_id.as_str());
9553        let account_id = AccountId::from("DERIVE-001");
9554        let (emitter, rx) = test_emitter(clock);
9555        let mut rx = if failed_delivery {
9556            drop(rx);
9557            None
9558        } else {
9559            Some(rx)
9560        };
9561
9562        dispatch_trades_payload(
9563            DeriveTradesSubscriptionData {
9564                trades: vec![trade],
9565            },
9566            &emitter,
9567            account_id,
9568            clock,
9569            &state,
9570        );
9571
9572        assert_eq!(
9573            state.bound_venue_order_id(&client_order_id),
9574            Some(venue_order_id)
9575        );
9576        assert_eq!(state.identity(&client_order_id), Some(identity));
9577        assert_eq!(state.contains_trade(&trade_id), !failed_delivery);
9578        assert_eq!(state.contains_accepted(&client_order_id), !failed_delivery);
9579
9580        if let Some(rx) = rx.as_mut() {
9581            let ExecutionEvent::Order(OrderEventAny::Accepted(accepted)) = rx.try_recv().unwrap()
9582            else {
9583                panic!("Expected acceptance before fill");
9584            };
9585
9586            let ExecutionEvent::Order(OrderEventAny::Filled(fill)) = rx.try_recv().unwrap() else {
9587                panic!("Expected native partial fill");
9588            };
9589
9590            assert_eq!(accepted.trader_id, TraderId::from("TRADER-001"));
9591            assert_eq!(accepted.strategy_id, identity.strategy_id);
9592            assert_eq!(accepted.instrument_id, identity.instrument_id);
9593            assert_eq!(accepted.client_order_id, client_order_id);
9594            assert_eq!(accepted.venue_order_id, venue_order_id);
9595            assert_eq!(accepted.account_id, account_id);
9596            assert_eq!(fill.trader_id, TraderId::from("TRADER-001"));
9597            assert_eq!(fill.strategy_id, identity.strategy_id);
9598            assert_eq!(fill.instrument_id, identity.instrument_id);
9599            assert_eq!(fill.client_order_id, client_order_id);
9600            assert_eq!(fill.venue_order_id, venue_order_id);
9601            assert_eq!(fill.account_id, account_id);
9602            assert_eq!(fill.trade_id, trade_id);
9603            assert_eq!(fill.order_side, OrderSide::Buy);
9604            assert_eq!(fill.order_type, OrderType::Limit);
9605            assert_eq!(fill.last_qty.as_decimal(), dec!(0.5));
9606            assert_eq!(fill.last_px.as_decimal(), dec!(3499));
9607            assert_eq!(fill.currency, Currency::USDC());
9608            assert_eq!(
9609                fill.commission,
9610                Some(Money::from_decimal(dec!(0.02), Currency::USDC()).unwrap())
9611            );
9612            assert_eq!(fill.liquidity_side, LiquiditySide::Maker);
9613            assert_eq!(fill.ts_event, UnixNanos::from(1_700_000_000_000_000_000));
9614            assert_eq!(fill.position_id, None);
9615            assert!(rx.try_recv().is_err());
9616        }
9617    }
9618
9619    #[rstest]
9620    fn test_native_fill_side_conflict_preserves_authority(
9621        #[values(false, true)] failed_delivery: bool,
9622        #[values(false, true)] bound: bool,
9623        #[values(OrderSide::Buy, OrderSide::Sell)] side: OrderSide,
9624    ) {
9625        let clock = get_atomic_clock_realtime();
9626        let state = WsDispatchState::new(42);
9627        let client_order_id = ClientOrderId::from("NATIVE-SIDE-CONFLICT");
9628
9629        let identity = OrderIdentity {
9630            instrument_id: InstrumentId::from("ETH-PERP.DERIVE"),
9631            strategy_id: StrategyId::from("S-1"),
9632            order_side: side,
9633            order_type: OrderType::Limit,
9634        };
9635
9636        let venue_order_id = VenueOrderId::from("native-owned");
9637        state.register_identity(client_order_id, identity);
9638        if bound {
9639            state.record_venue_order_id(client_order_id, venue_order_id);
9640        }
9641
9642        let mut trade: DeriveTrade = serde_json::from_str(include_str!(
9643            "../test_data/perps/http_private_trade_eth.json"
9644        ))
9645        .unwrap();
9646        trade.label = client_order_id.to_string().into();
9647        trade.order_id = "native-contradictory".into();
9648
9649        trade.direction = match side {
9650            OrderSide::Buy => DeriveOrderSide::Sell,
9651            OrderSide::Sell => DeriveOrderSide::Buy,
9652        };
9653
9654        let trade_id = TradeId::from(trade.trade_id.as_str());
9655        let (emitter, rx) = test_emitter(clock);
9656        let mut rx = if failed_delivery {
9657            drop(rx);
9658            None
9659        } else {
9660            Some(rx)
9661        };
9662
9663        dispatch_trades_payload(
9664            DeriveTradesSubscriptionData {
9665                trades: vec![trade.clone()],
9666            },
9667            &emitter,
9668            AccountId::from("DERIVE-001"),
9669            clock,
9670            &state,
9671        );
9672
9673        assert_eq!(
9674            state.bound_venue_order_id(&client_order_id),
9675            bound.then_some(venue_order_id)
9676        );
9677        assert_eq!(state.identity(&client_order_id), Some(identity));
9678        assert!(!state.knows_venue_leg(
9679            &client_order_id,
9680            VenueOrderId::from(trade.order_id.as_str())
9681        ));
9682        assert!(!state.contains_trade(&trade_id));
9683        assert!(!state.contains_accepted(&client_order_id));
9684        assert_eq!(
9685            serde_json::to_value(state.take_undelivered_trades()).unwrap(),
9686            serde_json::to_value(vec![trade]).unwrap()
9687        );
9688
9689        if let Some(rx) = rx.as_mut() {
9690            assert!(rx.try_recv().is_err());
9691        }
9692    }
9693
9694    #[rstest]
9695    fn test_native_fill_side_conflict_stays_deferred_after_terminal(
9696        #[values(OrderSide::Buy, OrderSide::Sell)] side: OrderSide,
9697    ) {
9698        let clock = get_atomic_clock_realtime();
9699        let state = WsDispatchState::new(42);
9700        let client_order_id = ClientOrderId::from("NATIVE-TERMINAL-SIDE-CONFLICT");
9701
9702        let identity = OrderIdentity {
9703            instrument_id: InstrumentId::from("ETH-PERP.DERIVE"),
9704            strategy_id: StrategyId::from("S-1"),
9705            order_side: side,
9706            order_type: OrderType::Limit,
9707        };
9708
9709        state.register_identity(client_order_id, identity);
9710        state.record_order_shape(client_order_id, Quantity::from("0.5"), None);
9711        let mut trade: DeriveTrade = serde_json::from_str(include_str!(
9712            "../test_data/perps/http_private_trade_eth.json"
9713        ))
9714        .unwrap();
9715        trade.label = client_order_id.to_string().into();
9716
9717        trade.direction = match side {
9718            OrderSide::Buy => DeriveOrderSide::Sell,
9719            OrderSide::Sell => DeriveOrderSide::Buy,
9720        };
9721
9722        let mut complete = trade.clone();
9723        complete.order_id = "native-complete".into();
9724        complete.trade_id = "native-complete-trade".into();
9725
9726        complete.direction = match side {
9727            OrderSide::Buy => DeriveOrderSide::Buy,
9728            OrderSide::Sell => DeriveOrderSide::Sell,
9729        };
9730
9731        let (emitter, mut rx) = test_emitter(clock);
9732        let account_id = AccountId::from("DERIVE-001");
9733        dispatch_trades_payload(
9734            DeriveTradesSubscriptionData {
9735                trades: vec![trade.clone(), complete],
9736            },
9737            &emitter,
9738            account_id,
9739            clock,
9740            &state,
9741        );
9742
9743        dispatch_trades_payload(
9744            DeriveTradesSubscriptionData {
9745                trades: state.take_undelivered_trades(),
9746            },
9747            &emitter,
9748            account_id,
9749            clock,
9750            &state,
9751        );
9752
9753        let ExecutionEvent::Order(OrderEventAny::Accepted(accepted)) = rx.try_recv().unwrap()
9754        else {
9755            panic!("Expected acceptance before the completing fill");
9756        };
9757
9758        let ExecutionEvent::Order(OrderEventAny::Filled(fill)) = rx.try_recv().unwrap() else {
9759            panic!("Expected the native completing fill");
9760        };
9761
9762        assert_eq!(accepted.client_order_id, client_order_id);
9763        assert_eq!(
9764            accepted.venue_order_id,
9765            VenueOrderId::from("native-complete")
9766        );
9767        assert_eq!(fill.client_order_id, client_order_id);
9768        assert_eq!(fill.venue_order_id, VenueOrderId::from("native-complete"));
9769        assert_eq!(fill.order_side, side);
9770        assert_eq!(fill.last_qty.as_decimal(), dec!(0.5));
9771        assert_eq!(state.identity(&client_order_id), None);
9772        assert!(state.is_terminal(&client_order_id, identity.instrument_id));
9773        assert!(!state.contains_trade(&TradeId::from(trade.trade_id.as_str())));
9774        assert_eq!(
9775            serde_json::to_value(state.take_undelivered_trades()).unwrap(),
9776            serde_json::to_value(vec![trade]).unwrap()
9777        );
9778        assert!(rx.try_recv().is_err());
9779    }
9780
9781    #[rstest]
9782    fn test_trade_delivery_failure_preserves_replay() {
9783        let clock = get_atomic_clock_realtime();
9784        let state = WsDispatchState::new(42);
9785        let trade: DeriveTrade = serde_json::from_str(include_str!(
9786            "../test_data/perps/http_private_trade_eth.json"
9787        ))
9788        .unwrap();
9789        let trade_id = TradeId::new(&trade.trade_id);
9790        let (emitter, rx) = test_emitter(clock);
9791        drop(rx);
9792        dispatch_trades_payload(
9793            DeriveTradesSubscriptionData {
9794                trades: vec![trade],
9795            },
9796            &emitter,
9797            AccountId::from("DERIVE-001"),
9798            clock,
9799            &state,
9800        );
9801
9802        assert!(!state.contains_trade(&trade_id));
9803    }
9804
9805    #[rstest]
9806    #[case::accept(0)]
9807    #[case::discard(1)]
9808    #[case::cancel(2)]
9809    #[case::pending_modify(3)]
9810    #[case::changed_binding(4)]
9811    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
9812    async fn test_report_task_defers_trigger_delivery(
9813        #[case] disposition: u8,
9814        #[values(false, true)] fills: bool,
9815    ) {
9816        let client = test_client_with_instrument();
9817        let cid = ClientOrderId::from("TRIGGER-REPORT");
9818        let instrument_id = InstrumentId::from("ETH-PERP.DERIVE");
9819        let venue_order_id = VenueOrderId::from("trigger-native");
9820        client.dispatch_state.register_identity(
9821            cid,
9822            OrderIdentity {
9823                instrument_id,
9824                strategy_id: StrategyId::from("TRIGGER-001"),
9825                order_side: OrderSide::Buy,
9826                order_type: OrderType::StopLimit,
9827            },
9828        );
9829
9830        client
9831            .dispatch_state
9832            .record_venue_order_id(cid, venue_order_id);
9833        let mut native: DeriveOrder = serde_json::from_str(include_str!(
9834            "../test_data/perps/http_order_eth_partially_filled.json"
9835        ))
9836        .unwrap();
9837        native.subaccount_id = client.credential.subaccount_id() as i64;
9838        native.order_status = DeriveOrderStatus::Open;
9839        native.order_id = venue_order_id.to_string();
9840        native.label = cid.inner();
9841        let mut order = parse_derive_order_to_report_with_precision(
9842            &native,
9843            client.core.account_id,
9844            Some(2),
9845            Some(3),
9846            UnixNanos::from(123),
9847        )
9848        .unwrap();
9849        order.order_type = OrderType::StopLimit;
9850        order.order_side = Some(OrderSide::Buy);
9851        let trade: DeriveTrade = serde_json::from_str(include_str!(
9852            "../test_data/perps/http_private_trade_eth.json"
9853        ))
9854        .unwrap();
9855        let mut fill = parse_derive_trade_to_fill_report_with_precision(
9856            &trade,
9857            client.core.account_id,
9858            Currency::USDC(),
9859            Some(2),
9860            Some(3),
9861            UnixNanos::from(456),
9862        )
9863        .unwrap()
9864        .unwrap();
9865        fill.client_order_id = Some(cid);
9866        fill.venue_order_id = venue_order_id;
9867        fill.instrument_id = instrument_id;
9868        fill.order_side = OrderSide::Buy;
9869        let (ready, collected) = tokio::sync::oneshot::channel();
9870        let (release, released) = tokio::sync::oneshot::channel();
9871
9872        let task = client
9873            .report_task(
9874                Some(instrument_id),
9875                move |context| async move {
9876                    context.validate_report_binding(Some(cid), venue_order_id, instrument_id)?;
9877                    if fills {
9878                        context.observe_trigger_fill(&fill);
9879                    } else {
9880                        context.observe_trigger_order(&native, &order);
9881                    }
9882
9883                    ready.send(()).unwrap();
9884                    released.await.unwrap();
9885                    Ok(())
9886                },
9887                |(), _| Ok(()),
9888            )
9889            .unwrap();
9890
9891        let worker = tokio::spawn(task.collection);
9892        collected.await.unwrap();
9893        assert!(!client.dispatch_state.trigger_active(&cid));
9894
9895        if disposition == 2 {
9896            worker.abort();
9897            assert!(worker.await.unwrap_err().is_cancelled());
9898            drop(task.finish);
9899        } else {
9900            release.send(()).unwrap();
9901            worker.await.unwrap();
9902            assert!(!client.dispatch_state.trigger_active(&cid));
9903
9904            match disposition {
9905                0 => (task.finish)().unwrap(),
9906                1 => drop(task.finish),
9907                3 => {
9908                    client
9909                        .dispatch_state
9910                        .mark_pending_modify(cid, venue_order_id);
9911                    assert_eq!(
9912                        (task.finish)().unwrap_err().to_string(),
9913                        "unresolved Derive venue binding for TRIGGER-REPORT"
9914                    );
9915                }
9916                4 => {
9917                    client
9918                        .dispatch_state
9919                        .record_venue_order_id(cid, VenueOrderId::from("changed-native"));
9920                    assert_eq!(
9921                        (task.finish)().unwrap_err().to_string(),
9922                        "Derive order binding changed during report collection for TRIGGER-REPORT"
9923                    );
9924                }
9925                _ => unreachable!(),
9926            }
9927        }
9928
9929        assert_eq!(client.dispatch_state.trigger_active(&cid), disposition == 0);
9930    }
9931
9932    #[rstest]
9933    fn test_report_tasks_keep_pending_replacement_inline() {
9934        let client = test_client_with_instrument();
9935        let instrument_id = InstrumentId::from("ETH-PERP.DERIVE");
9936        let cid = ClientOrderId::from("PENDING-REPORT");
9937        client.dispatch_state.register_identity(
9938            cid,
9939            OrderIdentity {
9940                instrument_id,
9941                strategy_id: StrategyId::from("REPORT-001"),
9942                order_side: OrderSide::Buy,
9943                order_type: OrderType::Limit,
9944            },
9945        );
9946
9947        client
9948            .dispatch_state
9949            .mark_pending_modify(cid, VenueOrderId::from("pending-native"));
9950
9951        let single = GenerateOrderStatusReport::new(
9952            UUID4::new(),
9953            UnixNanos::default(),
9954            Some(instrument_id),
9955            Some(cid),
9956            None,
9957            None,
9958            None,
9959        );
9960
9961        let orders = GenerateOrderStatusReports::new(
9962            UUID4::new(),
9963            UnixNanos::default(),
9964            true,
9965            Some(instrument_id),
9966            None,
9967            None,
9968            None,
9969            None,
9970        );
9971
9972        let fills = GenerateFillReports::new(
9973            UUID4::new(),
9974            UnixNanos::default(),
9975            Some(instrument_id),
9976            None,
9977            None,
9978            None,
9979            None,
9980            None,
9981        );
9982
9983        let positions = GeneratePositionStatusReports::new(
9984            UUID4::new(),
9985            UnixNanos::default(),
9986            Some(instrument_id),
9987            None,
9988            None,
9989            None,
9990            None,
9991        );
9992        assert!(client.generate_order_status_report_task(&single).is_none());
9993        assert!(client.generate_order_status_reports_task(&orders).is_none());
9994        assert!(client.generate_fill_reports_task(&fills).is_none());
9995        assert!(
9996            client
9997                .generate_position_status_reports_task(&positions)
9998                .is_some()
9999        );
10000    }
10001
10002    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
10003    async fn test_report_task_does_not_defer_unproved_binding() {
10004        let client = test_client_with_instrument();
10005        let instrument_id = InstrumentId::from("ETH-PERP.DERIVE");
10006        let cid = ClientOrderId::from("UNPROVED-REPORT");
10007        let current = VenueOrderId::from("proved-native");
10008        client.dispatch_state.register_identity(
10009            cid,
10010            OrderIdentity {
10011                instrument_id,
10012                strategy_id: StrategyId::from("REPORT-001"),
10013                order_side: OrderSide::Buy,
10014                order_type: OrderType::Limit,
10015            },
10016        );
10017
10018        client.dispatch_state.record_venue_order_id(cid, current);
10019
10020        let task = client
10021            .report_task(
10022                Some(instrument_id),
10023                move |context| async move {
10024                    context.validate_report_binding(
10025                        Some(cid),
10026                        VenueOrderId::from("unproved-native"),
10027                        instrument_id,
10028                    )
10029                },
10030                |(), _| Ok(()),
10031            )
10032            .unwrap();
10033
10034        tokio::spawn(task.collection).await.unwrap();
10035        let error = (task.finish)().unwrap_err();
10036        assert_eq!(
10037            error.to_string(),
10038            "unresolved Derive venue binding for UNPROVED-REPORT"
10039        );
10040        assert!(!client.dispatch_state.binding_unresolved(&cid));
10041        assert_eq!(
10042            client.dispatch_state.bound_venue_order_id(&cid),
10043            Some(current)
10044        );
10045        assert_eq!(client.dispatch_state.venue_order_legs(&cid), vec![current]);
10046    }
10047
10048    fn sample_derive_instrument() -> DeriveInstrument {
10049        serde_json::from_str(include_str!("../test_data/perps/instrument_eth.json")).unwrap()
10050    }
10051
10052    fn test_client_with_instrument() -> DeriveExecutionClient {
10053        let mut client = DeriveExecutionClient::new(test_core(), test_config()).unwrap();
10054        let instrument =
10055            parse_derive_instrument_any(&sample_derive_instrument(), UnixNanos::default())
10056                .unwrap()
10057                .unwrap();
10058        client.on_instrument(instrument);
10059        client
10060    }
10061
10062    #[rstest]
10063    #[case(" ")]
10064    #[case("external-\u{03bb}")]
10065    fn test_order_result_invalid_id_preserves_identity_without_binding_or_events(
10066        #[case] invalid_id: &str,
10067    ) {
10068        let clock = get_atomic_clock_realtime();
10069        let account_id = AccountId::from("DERIVE-001");
10070        let client_order_id = ClientOrderId::from("STRAT-SUBMIT-BAD-ID");
10071        let instrument_id = InstrumentId::from("ETH-PERP.DERIVE");
10072        let strategy_id = StrategyId::from("S-1");
10073
10074        let identity = OrderIdentity {
10075            instrument_id,
10076            strategy_id,
10077            order_side: OrderSide::Buy,
10078            order_type: OrderType::Limit,
10079        };
10080
10081        let state = WsDispatchState::new(42);
10082        state.register_identity(client_order_id, identity);
10083        let (emitter, mut rx) = test_emitter(clock);
10084        let mut order: DeriveOrder = serde_json::from_str(include_str!(
10085            "../test_data/perps/http_order_eth_partially_filled.json"
10086        ))
10087        .unwrap();
10088        order.label = client_order_id.as_str().into();
10089        order.order_id = invalid_id.to_string();
10090        order.direction = crate::common::enums::DeriveOrderSide::Buy;
10091        order.order_status = DeriveOrderStatus::Open;
10092        order.filled_amount = Decimal::ZERO;
10093        dispatch_order_result(
10094            DeriveOrderResult {
10095                order: order.clone(),
10096                trades: vec![],
10097            },
10098            client_order_id,
10099            &emitter,
10100            account_id,
10101            clock,
10102            &state,
10103        );
10104
10105        assert!(
10106            rx.try_recv().is_err(),
10107            "invalid response must emit no lifecycle event"
10108        );
10109        assert_eq!(state.bound_venue_order_id(&client_order_id), None);
10110        let retained = state
10111            .identity(&client_order_id)
10112            .expect("identity retained for reconciliation");
10113        assert_eq!(retained.instrument_id, instrument_id);
10114        assert_eq!(retained.strategy_id, strategy_id);
10115        assert_eq!(retained.order_side, OrderSide::Buy);
10116        assert_eq!(retained.order_type, OrderType::Limit);
10117        let venue_order_id = VenueOrderId::from("ord-valid-submit-result");
10118        order.order_id = venue_order_id.to_string();
10119        dispatch_order_result(
10120            DeriveOrderResult {
10121                order,
10122                trades: vec![],
10123            },
10124            client_order_id,
10125            &emitter,
10126            account_id,
10127            clock,
10128            &state,
10129        );
10130
10131        let event = rx
10132            .try_recv()
10133            .expect("valid response accepts retained identity");
10134
10135        let ExecutionEvent::Order(OrderEventAny::Accepted(accepted)) = event else {
10136            panic!("expected tracked acceptance, was {event:?}");
10137        };
10138
10139        assert_eq!(accepted.client_order_id, client_order_id);
10140        assert_eq!(accepted.instrument_id, instrument_id);
10141        assert_eq!(accepted.strategy_id, strategy_id);
10142        assert_eq!(accepted.account_id, account_id);
10143        assert_eq!(accepted.venue_order_id, venue_order_id);
10144        assert_eq!(
10145            state.bound_venue_order_id(&client_order_id),
10146            Some(venue_order_id)
10147        );
10148        assert!(rx.try_recv().is_err(), "valid response must accept once");
10149    }
10150}