1use 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#[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 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 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 #[must_use]
282 pub const fn subaccount_id(&self) -> u64 {
283 self.credential.subaccount_id()
284 }
285
286 #[must_use]
288 pub fn config(&self) -> &DeriveExecutionClientConfig {
289 &self.config
290 }
291
292 #[must_use]
294 pub fn http_client(&self) -> &DeriveHttpClient {
295 &self.http_client
296 }
297
298 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 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, ¤t)?;
612 for (order, report) in &observations.trigger_orders {
613 observe_trigger_order(¤t.dispatch_state, order, report);
614 }
615
616 for report in &observations.trigger_fills {
617 observe_trigger_fill(¤t.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 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 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 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 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 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 "e,
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 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 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 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 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(¶ms).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(¶ms).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(¶ms).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 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
5060pub 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
5247pub 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(¤t.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(¶ms).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#[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 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 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
6348fn 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
6521fn 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 let price = market_order_limit_price("e, 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 let price = market_order_limit_price("e, OrderSide::Sell, 50, dec!(0.01)).unwrap();
7301 assert_eq!(price, dec!(3482.5));
7302
7303 let zero = market_order_limit_price("e, 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 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 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 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("e, OrderSide::Buy, 50, dec!(1)).unwrap();
7544 assert_eq!(buy, dec!(3519));
7545 let sell = market_order_limit_price("e, 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 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 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 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 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}