1use std::collections::HashSet;
36
37use bytes::Bytes;
38use nautilus_common::{
39 messages::{
40 data::{
41 BarsResponse, BookDeltasResponse, BookDepthResponse, BookResponse, CustomDataResponse,
42 DataCommand, DataResponse, DataResponseEnvelope, FundingRatesResponse,
43 InstrumentResponse, InstrumentsResponse, OptionChainReferencePriceResponse,
44 QuotesResponse, TradesResponse,
45 },
46 execution::{
47 BatchCancelOrders, BatchModifyOrders, CancelAllOrders, CancelOrder, ExecutionReport,
48 ModifyOrder, QueryAccount, QueryOrder, SubmitOrder, SubmitOrderList, TradingCommand,
49 },
50 },
51 timer::TimeEvent,
52};
53use nautilus_core::{Params, UUID4, UnixNanos};
54use nautilus_model::{
55 data::{DataType, InstrumentClose},
56 events::{
57 AccountState, OrderAccepted, OrderCancelDenied, OrderCancelRejected, OrderCanceled,
58 OrderDenied, OrderEmulated, OrderEventAny, OrderExpired, OrderFillVoided, OrderFilled,
59 OrderInitialized, OrderModifyDenied, OrderModifyRejected, OrderPendingCancel,
60 OrderPendingUpdate, OrderRejected, OrderReleased, OrderSubmitted, OrderTriggered,
61 OrderUpdated, PositionAdjusted, PositionChanged, PositionClosed, PositionEvent,
62 PositionOpened,
63 },
64 identifiers::{ClientId, InstrumentId, Venue},
65 reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
66};
67use serde::Serialize;
68use ustr::Ustr;
69
70use crate::{
71 backend::{IndexKey, IndexKind},
72 capture::{
73 encoder::{EncodeError, EncodedPayload},
74 registry::EncoderRegistry,
75 },
76 entry::PayloadType,
77 headers::Headers,
78};
79
80pub const PAYLOAD_TYPE_SUBMIT_ORDER: &str = "SubmitOrder";
82pub const PAYLOAD_TYPE_SUBMIT_ORDER_LIST: &str = "SubmitOrderList";
84pub const PAYLOAD_TYPE_MODIFY_ORDER: &str = "ModifyOrder";
86pub const PAYLOAD_TYPE_BATCH_MODIFY_ORDERS: &str = "BatchModifyOrders";
88pub const PAYLOAD_TYPE_CANCEL_ORDER: &str = "CancelOrder";
90pub const PAYLOAD_TYPE_CANCEL_ALL_ORDERS: &str = "CancelAllOrders";
92pub const PAYLOAD_TYPE_BATCH_CANCEL_ORDERS: &str = "BatchCancelOrders";
94pub const PAYLOAD_TYPE_QUERY_ORDER: &str = "QueryOrder";
96pub const PAYLOAD_TYPE_QUERY_ACCOUNT: &str = "QueryAccount";
98
99pub const PAYLOAD_TYPE_ORDER_INITIALIZED: &str = "OrderInitialized";
101pub const PAYLOAD_TYPE_ORDER_DENIED: &str = "OrderDenied";
103pub const PAYLOAD_TYPE_ORDER_EMULATED: &str = "OrderEmulated";
105pub const PAYLOAD_TYPE_ORDER_RELEASED: &str = "OrderReleased";
107pub const PAYLOAD_TYPE_ORDER_SUBMITTED: &str = "OrderSubmitted";
109pub const PAYLOAD_TYPE_ORDER_ACCEPTED: &str = "OrderAccepted";
111pub const PAYLOAD_TYPE_ORDER_REJECTED: &str = "OrderRejected";
113pub const PAYLOAD_TYPE_ORDER_CANCELED: &str = "OrderCanceled";
115pub const PAYLOAD_TYPE_ORDER_EXPIRED: &str = "OrderExpired";
117pub const PAYLOAD_TYPE_ORDER_TRIGGERED: &str = "OrderTriggered";
119pub const PAYLOAD_TYPE_ORDER_PENDING_UPDATE: &str = "OrderPendingUpdate";
121pub const PAYLOAD_TYPE_ORDER_PENDING_CANCEL: &str = "OrderPendingCancel";
123pub const PAYLOAD_TYPE_ORDER_MODIFY_DENIED: &str = "OrderModifyDenied";
125pub const PAYLOAD_TYPE_ORDER_MODIFY_REJECTED: &str = "OrderModifyRejected";
127
128pub const PAYLOAD_TYPE_ORDER_CANCEL_DENIED: &str = "OrderCancelDenied";
130pub const PAYLOAD_TYPE_ORDER_CANCEL_REJECTED: &str = "OrderCancelRejected";
132
133pub const PAYLOAD_TYPE_ORDER_UPDATED: &str = "OrderUpdated";
135pub const PAYLOAD_TYPE_ORDER_FILLED: &str = "OrderFilled";
137pub const PAYLOAD_TYPE_ORDER_FILL_VOIDED: &str = "OrderFillVoided";
139pub const PAYLOAD_TYPE_ORDER_STATUS_REPORT: &str = "OrderStatusReport";
141pub const PAYLOAD_TYPE_FILL_REPORT: &str = "FillReport";
143pub const PAYLOAD_TYPE_ORDER_WITH_FILLS: &str = "OrderWithFills";
145pub const PAYLOAD_TYPE_POSITION_STATUS_REPORT: &str = "PositionStatusReport";
147pub const PAYLOAD_TYPE_EXECUTION_MASS_STATUS: &str = "ExecutionMassStatus";
149pub const PAYLOAD_TYPE_POSITION_OPENED: &str = "PositionOpened";
151pub const PAYLOAD_TYPE_POSITION_CHANGED: &str = "PositionChanged";
153pub const PAYLOAD_TYPE_POSITION_CLOSED: &str = "PositionClosed";
155pub const PAYLOAD_TYPE_POSITION_ADJUSTED: &str = "PositionAdjusted";
157pub const PAYLOAD_TYPE_ACCOUNT_STATE: &str = "AccountState";
159pub const PAYLOAD_TYPE_INSTRUMENT_CLOSE: &str = "InstrumentClose";
161pub const PAYLOAD_TYPE_TIME_EVENT: &str = "TimeEvent";
163
164pub const PAYLOAD_TYPE_REQUEST_COMMAND: &str = "RequestCommand";
166pub const PAYLOAD_TYPE_SUBSCRIBE_COMMAND: &str = "SubscribeCommand";
168pub const PAYLOAD_TYPE_UNSUBSCRIBE_COMMAND: &str = "UnsubscribeCommand";
170#[cfg(feature = "defi")]
171pub const PAYLOAD_TYPE_DEFI_REQUEST_COMMAND: &str = "DefiRequestCommand";
173#[cfg(feature = "defi")]
174pub const PAYLOAD_TYPE_DEFI_SUBSCRIBE_COMMAND: &str = "DefiSubscribeCommand";
176#[cfg(feature = "defi")]
177pub const PAYLOAD_TYPE_DEFI_UNSUBSCRIBE_COMMAND: &str = "DefiUnsubscribeCommand";
179
180pub const PAYLOAD_TYPE_CUSTOM_DATA_RESPONSE: &str = "CustomDataResponse";
182pub const PAYLOAD_TYPE_INSTRUMENT_RESPONSE: &str = "InstrumentResponse";
184pub const PAYLOAD_TYPE_INSTRUMENTS_RESPONSE: &str = "InstrumentsResponse";
186pub const PAYLOAD_TYPE_BOOK_RESPONSE: &str = "BookResponse";
188pub const PAYLOAD_TYPE_BOOK_DELTAS_RESPONSE: &str = "BookDeltasResponse";
190pub const PAYLOAD_TYPE_BOOK_DEPTH_RESPONSE: &str = "BookDepthResponse";
192pub const PAYLOAD_TYPE_QUOTES_RESPONSE: &str = "QuotesResponse";
194pub const PAYLOAD_TYPE_TRADES_RESPONSE: &str = "TradesResponse";
196pub const PAYLOAD_TYPE_FUNDING_RATES_RESPONSE: &str = "FundingRatesResponse";
198pub const PAYLOAD_TYPE_OPTION_CHAIN_REFERENCE_PRICE_RESPONSE: &str =
200 "OptionChainReferencePriceResponse";
201pub const PAYLOAD_TYPE_BARS_RESPONSE: &str = "BarsResponse";
203pub const PAYLOAD_TYPE_DATA_RESPONSE_ENVELOPE: &str = "DataResponseEnvelope";
205
206const PAYLOAD_TYPE_TRADING_COMMAND: &str = "TradingCommand";
211
212const PAYLOAD_TYPE_ORDER_EVENT_ANY: &str = "OrderEventAny";
213
214const PAYLOAD_TYPE_EXECUTION_REPORT: &str = "ExecutionReport";
215
216const PAYLOAD_TYPE_POSITION_EVENT: &str = "PositionEvent";
217
218const PAYLOAD_TYPE_DATA_COMMAND: &str = "DataCommand";
219
220const PAYLOAD_TYPE_DATA_RESPONSE: &str = "DataResponse";
221
222#[cfg(test)]
223pub(crate) const DEFAULT_CAPTURE_PAYLOAD_TYPES: &[&str] = &[
224 PAYLOAD_TYPE_SUBMIT_ORDER,
225 PAYLOAD_TYPE_SUBMIT_ORDER_LIST,
226 PAYLOAD_TYPE_MODIFY_ORDER,
227 PAYLOAD_TYPE_BATCH_MODIFY_ORDERS,
228 PAYLOAD_TYPE_CANCEL_ORDER,
229 PAYLOAD_TYPE_CANCEL_ALL_ORDERS,
230 PAYLOAD_TYPE_BATCH_CANCEL_ORDERS,
231 PAYLOAD_TYPE_QUERY_ORDER,
232 PAYLOAD_TYPE_QUERY_ACCOUNT,
233 PAYLOAD_TYPE_ORDER_INITIALIZED,
234 PAYLOAD_TYPE_ORDER_DENIED,
235 PAYLOAD_TYPE_ORDER_EMULATED,
236 PAYLOAD_TYPE_ORDER_RELEASED,
237 PAYLOAD_TYPE_ORDER_SUBMITTED,
238 PAYLOAD_TYPE_ORDER_ACCEPTED,
239 PAYLOAD_TYPE_ORDER_REJECTED,
240 PAYLOAD_TYPE_ORDER_CANCELED,
241 PAYLOAD_TYPE_ORDER_EXPIRED,
242 PAYLOAD_TYPE_ORDER_TRIGGERED,
243 PAYLOAD_TYPE_ORDER_PENDING_UPDATE,
244 PAYLOAD_TYPE_ORDER_PENDING_CANCEL,
245 PAYLOAD_TYPE_ORDER_MODIFY_DENIED,
246 PAYLOAD_TYPE_ORDER_MODIFY_REJECTED,
247 PAYLOAD_TYPE_ORDER_CANCEL_DENIED,
248 PAYLOAD_TYPE_ORDER_CANCEL_REJECTED,
249 PAYLOAD_TYPE_ORDER_UPDATED,
250 PAYLOAD_TYPE_ORDER_FILLED,
251 PAYLOAD_TYPE_ORDER_FILL_VOIDED,
252 PAYLOAD_TYPE_ORDER_STATUS_REPORT,
253 PAYLOAD_TYPE_FILL_REPORT,
254 PAYLOAD_TYPE_ORDER_WITH_FILLS,
255 PAYLOAD_TYPE_POSITION_STATUS_REPORT,
256 PAYLOAD_TYPE_EXECUTION_MASS_STATUS,
257 PAYLOAD_TYPE_POSITION_OPENED,
258 PAYLOAD_TYPE_POSITION_CHANGED,
259 PAYLOAD_TYPE_POSITION_CLOSED,
260 PAYLOAD_TYPE_POSITION_ADJUSTED,
261 PAYLOAD_TYPE_ACCOUNT_STATE,
262 PAYLOAD_TYPE_INSTRUMENT_CLOSE,
263 PAYLOAD_TYPE_TIME_EVENT,
264 PAYLOAD_TYPE_REQUEST_COMMAND,
265 PAYLOAD_TYPE_SUBSCRIBE_COMMAND,
266 PAYLOAD_TYPE_UNSUBSCRIBE_COMMAND,
267 #[cfg(feature = "defi")]
268 PAYLOAD_TYPE_DEFI_REQUEST_COMMAND,
269 #[cfg(feature = "defi")]
270 PAYLOAD_TYPE_DEFI_SUBSCRIBE_COMMAND,
271 #[cfg(feature = "defi")]
272 PAYLOAD_TYPE_DEFI_UNSUBSCRIBE_COMMAND,
273 PAYLOAD_TYPE_CUSTOM_DATA_RESPONSE,
274 PAYLOAD_TYPE_INSTRUMENT_RESPONSE,
275 PAYLOAD_TYPE_INSTRUMENTS_RESPONSE,
276 PAYLOAD_TYPE_BOOK_RESPONSE,
277 PAYLOAD_TYPE_BOOK_DELTAS_RESPONSE,
278 PAYLOAD_TYPE_BOOK_DEPTH_RESPONSE,
279 PAYLOAD_TYPE_QUOTES_RESPONSE,
280 PAYLOAD_TYPE_TRADES_RESPONSE,
281 PAYLOAD_TYPE_FUNDING_RATES_RESPONSE,
282 PAYLOAD_TYPE_OPTION_CHAIN_REFERENCE_PRICE_RESPONSE,
283 PAYLOAD_TYPE_BARS_RESPONSE,
284 PAYLOAD_TYPE_DATA_RESPONSE_ENVELOPE,
285];
286
287#[must_use]
292pub fn default_registry() -> EncoderRegistry {
293 let mut registry = EncoderRegistry::new();
294 register_default(&mut registry);
295 registry
296}
297
298pub fn register_default(registry: &mut EncoderRegistry) {
319 registry
320 .register::<SubmitOrder, _>(payload_type(PAYLOAD_TYPE_SUBMIT_ORDER), encode_submit_order);
321 registry
322 .register::<OrderFilled, _>(payload_type(PAYLOAD_TYPE_ORDER_FILLED), encode_order_filled);
323 registry.register::<OrderStatusReport, _>(
324 payload_type(PAYLOAD_TYPE_ORDER_STATUS_REPORT),
325 encode_order_status_report,
326 );
327 registry.register::<FillReport, _>(payload_type(PAYLOAD_TYPE_FILL_REPORT), encode_fill_report);
328 registry.register::<PositionStatusReport, _>(
329 payload_type(PAYLOAD_TYPE_POSITION_STATUS_REPORT),
330 encode_position_status_report,
331 );
332 registry.register::<TradingCommand, _>(
333 payload_type(PAYLOAD_TYPE_TRADING_COMMAND),
334 encode_trading_command,
335 );
336 registry.register::<OrderEventAny, _>(
337 payload_type(PAYLOAD_TYPE_ORDER_EVENT_ANY),
338 encode_order_event_any,
339 );
340 registry.register::<ExecutionReport, _>(
341 payload_type(PAYLOAD_TYPE_EXECUTION_REPORT),
342 encode_execution_report,
343 );
344 registry.register::<PositionEvent, _>(
345 payload_type(PAYLOAD_TYPE_POSITION_EVENT),
346 encode_position_event,
347 );
348 registry.register::<AccountState, _>(
349 payload_type(PAYLOAD_TYPE_ACCOUNT_STATE),
350 encode_account_state,
351 );
352 registry.register::<InstrumentClose, _>(
353 payload_type(PAYLOAD_TYPE_INSTRUMENT_CLOSE),
354 encode_instrument_close,
355 );
356 registry.register::<TimeEvent, _>(payload_type(PAYLOAD_TYPE_TIME_EVENT), encode_time_event);
357 registry
358 .register::<DataCommand, _>(payload_type(PAYLOAD_TYPE_DATA_COMMAND), encode_data_command);
359 registry.register::<DataResponse, _>(
360 payload_type(PAYLOAD_TYPE_DATA_RESPONSE),
361 encode_data_response,
362 );
363
364 registry.register::<DataResponseEnvelope, _>(
365 payload_type(PAYLOAD_TYPE_DATA_RESPONSE_ENVELOPE),
366 encode_response_envelope,
367 );
368 register_default_headers(registry);
369 register_default_identities(registry);
370}
371
372fn register_default_headers(registry: &mut EncoderRegistry) {
373 registry.register_headers::<SubmitOrder, _>(extract_submit_order_headers);
374 registry.register_headers::<SubmitOrderList, _>(extract_submit_order_list_headers);
375 registry.register_headers::<ModifyOrder, _>(extract_modify_order_headers);
376 registry.register_headers::<BatchModifyOrders, _>(extract_batch_modify_orders_headers);
377 registry.register_headers::<CancelOrder, _>(extract_cancel_order_headers);
378 registry.register_headers::<CancelAllOrders, _>(extract_cancel_all_orders_headers);
379 registry.register_headers::<BatchCancelOrders, _>(extract_batch_cancel_orders_headers);
380 registry.register_headers::<QueryOrder, _>(extract_query_order_headers);
381 registry.register_headers::<QueryAccount, _>(extract_query_account_headers);
382 registry.register_headers::<TradingCommand, _>(extract_trading_command_headers);
383 registry.register_headers::<DataCommand, _>(extract_data_command_headers);
384 registry.register_headers::<DataResponse, _>(extract_data_response_headers);
385 registry.register_headers::<DataResponseEnvelope, _>(|response| {
386 headers_from_fields(Some(*response.correlation_id()), None)
387 });
388}
389
390fn register_default_identities(registry: &mut EncoderRegistry) {
398 registry.register_identity::<SubmitOrder, _>(|command| Some(command.command_id));
399 registry.register_identity::<OrderFilled, _>(|event| Some(event.event_id));
400 registry.register_identity::<TradingCommand, _>(|c| Some(extract_trading_command_identity(c)));
401 registry.register_identity::<OrderEventAny, _>(|e| Some(extract_order_event_any_identity(e)));
402 registry.register_identity::<AccountState, _>(|state| Some(state.event_id));
403 registry.register_identity::<DataCommand, _>(extract_data_command_identity);
404}
405
406fn extract_data_command_identity(command: &DataCommand) -> Option<UUID4> {
407 match command {
408 DataCommand::Request(cmd) => Some(*cmd.request_id()),
409 DataCommand::Subscribe(cmd) => Some(cmd.command_id()),
410 DataCommand::Unsubscribe(cmd) => Some(cmd.command_id()),
411 #[cfg(feature = "defi")]
412 DataCommand::DefiRequest(cmd) => Some(*cmd.request_id()),
413 #[cfg(feature = "defi")]
414 DataCommand::DefiSubscribe(cmd) => Some(cmd.command_id()),
415 #[cfg(feature = "defi")]
416 DataCommand::DefiUnsubscribe(cmd) => Some(cmd.command_id()),
417 _ => None,
419 }
420}
421
422fn extract_trading_command_identity(command: &TradingCommand) -> UUID4 {
423 match command {
424 TradingCommand::SubmitOrder(c) => c.command_id,
425 TradingCommand::SubmitOrderList(c) => c.command_id,
426 TradingCommand::ModifyOrder(c) => c.command_id,
427 TradingCommand::ModifyOrders(c) => c.command_id,
428 TradingCommand::CancelOrder(c) => c.command_id,
429 TradingCommand::CancelOrders(c) => c.command_id,
430 TradingCommand::CancelAllOrders(c) => c.command_id,
431 TradingCommand::QueryOrder(c) => c.command_id,
432 TradingCommand::QueryAccount(c) => c.command_id,
433 }
434}
435
436fn extract_order_event_any_identity(event: &OrderEventAny) -> UUID4 {
437 match event {
438 OrderEventAny::Initialized(e) => e.event_id,
439 OrderEventAny::Denied(e) => e.event_id,
440 OrderEventAny::Emulated(e) => e.event_id,
441 OrderEventAny::Released(e) => e.event_id,
442 OrderEventAny::Submitted(e) => e.event_id,
443 OrderEventAny::Accepted(e) => e.event_id,
444 OrderEventAny::Rejected(e) => e.event_id,
445 OrderEventAny::Canceled(e) => e.event_id,
446 OrderEventAny::Expired(e) => e.event_id,
447 OrderEventAny::Triggered(e) => e.event_id,
448 OrderEventAny::PendingUpdate(e) => e.event_id,
449 OrderEventAny::PendingCancel(e) => e.event_id,
450 OrderEventAny::ModifyDenied(e) => e.event_id,
451 OrderEventAny::ModifyRejected(e) => e.event_id,
452 OrderEventAny::CancelDenied(e) => e.event_id,
453 OrderEventAny::CancelRejected(e) => e.event_id,
454 OrderEventAny::Updated(e) => e.event_id,
455 OrderEventAny::Filled(e) => e.event_id,
456 OrderEventAny::FillVoided(e) => e.event_id,
457 }
458}
459
460fn headers_from_fields(correlation_id: Option<UUID4>, causation_id: Option<UUID4>) -> Headers {
461 Headers {
462 correlation_id,
463 causation_id,
464 }
465}
466
467fn extract_submit_order_headers(cmd: &SubmitOrder) -> Headers {
468 headers_from_fields(cmd.correlation_id, cmd.causation_id)
469}
470
471fn extract_submit_order_list_headers(cmd: &SubmitOrderList) -> Headers {
472 headers_from_fields(cmd.correlation_id, cmd.causation_id)
473}
474
475fn extract_modify_order_headers(cmd: &ModifyOrder) -> Headers {
476 headers_from_fields(cmd.correlation_id, cmd.causation_id)
477}
478
479fn extract_batch_modify_orders_headers(cmd: &BatchModifyOrders) -> Headers {
480 headers_from_fields(cmd.correlation_id, cmd.causation_id)
481}
482
483fn extract_cancel_order_headers(cmd: &CancelOrder) -> Headers {
484 headers_from_fields(cmd.correlation_id, cmd.causation_id)
485}
486
487fn extract_cancel_all_orders_headers(cmd: &CancelAllOrders) -> Headers {
488 headers_from_fields(cmd.correlation_id, cmd.causation_id)
489}
490
491fn extract_batch_cancel_orders_headers(cmd: &BatchCancelOrders) -> Headers {
492 headers_from_fields(cmd.correlation_id, cmd.causation_id)
493}
494
495fn extract_query_order_headers(cmd: &QueryOrder) -> Headers {
496 headers_from_fields(cmd.correlation_id, cmd.causation_id)
497}
498
499fn extract_query_account_headers(cmd: &QueryAccount) -> Headers {
500 headers_from_fields(cmd.correlation_id, cmd.causation_id)
501}
502
503fn extract_trading_command_headers(command: &TradingCommand) -> Headers {
507 match command {
508 TradingCommand::SubmitOrder(cmd) => extract_submit_order_headers(cmd),
509 TradingCommand::SubmitOrderList(cmd) => extract_submit_order_list_headers(cmd),
510 TradingCommand::ModifyOrder(cmd) => extract_modify_order_headers(cmd),
511 TradingCommand::ModifyOrders(cmd) => extract_batch_modify_orders_headers(cmd),
512 TradingCommand::CancelOrder(cmd) => extract_cancel_order_headers(cmd),
513 TradingCommand::CancelOrders(cmd) => extract_batch_cancel_orders_headers(cmd),
514 TradingCommand::CancelAllOrders(cmd) => extract_cancel_all_orders_headers(cmd),
515 TradingCommand::QueryOrder(cmd) => extract_query_order_headers(cmd),
516 TradingCommand::QueryAccount(cmd) => extract_query_account_headers(cmd),
517 }
518}
519
520fn extract_data_command_headers(command: &DataCommand) -> Headers {
528 match command {
529 DataCommand::Request(cmd) => headers_from_fields(Some(*cmd.request_id()), None),
530 DataCommand::Subscribe(cmd) => headers_from_fields(cmd.correlation_id(), None),
531 DataCommand::Unsubscribe(cmd) => headers_from_fields(cmd.correlation_id(), None),
532 _ => Headers::empty(),
536 }
537}
538
539fn extract_data_response_headers(response: &DataResponse) -> Headers {
542 headers_from_fields(Some(*response.correlation_id()), None)
543}
544
545fn payload_type(tag: &str) -> PayloadType {
546 Ustr::from(tag)
547}
548
549fn encode_serde<T: Serialize>(value: &T) -> Result<Bytes, EncodeError> {
550 rmp_serde::to_vec_named(value)
551 .map(Bytes::from)
552 .map_err(|e| EncodeError::Serialize(e.to_string()))
553}
554
555pub fn encode_submit_order(message: &SubmitOrder) -> Result<EncodedPayload, EncodeError> {
563 let payload = encode_serde(message)?;
564 let index_keys = vec![IndexKey::new(
565 IndexKind::ClientOrderId,
566 message.client_order_id.to_string(),
567 )];
568 Ok(EncodedPayload::new(payload, index_keys))
569}
570
571pub fn encode_order_filled(message: &OrderFilled) -> Result<EncodedPayload, EncodeError> {
578 let payload = encode_serde(message)?;
579 let index_keys = vec![
580 IndexKey::new(
581 IndexKind::ClientOrderId,
582 message.client_order_id.to_string(),
583 ),
584 IndexKey::new(IndexKind::VenueOrderId, message.venue_order_id.to_string()),
585 ];
586 Ok(EncodedPayload::new(payload, index_keys))
587}
588
589pub fn encode_trading_command(command: &TradingCommand) -> Result<EncodedPayload, EncodeError> {
601 match command {
602 TradingCommand::SubmitOrder(cmd) => {
603 Ok(retag(encode_submit_order(cmd)?, PAYLOAD_TYPE_SUBMIT_ORDER))
604 }
605 TradingCommand::SubmitOrderList(cmd) => encode_submit_order_list(cmd),
606 TradingCommand::ModifyOrder(cmd) => encode_modify_order(cmd),
607 TradingCommand::ModifyOrders(cmd) => encode_batch_modify_orders(cmd),
608 TradingCommand::CancelOrder(cmd) => encode_cancel_order(cmd),
609 TradingCommand::CancelOrders(cmd) => encode_batch_cancel_orders(cmd),
610 TradingCommand::CancelAllOrders(cmd) => encode_cancel_all_orders(cmd),
611 TradingCommand::QueryOrder(cmd) => encode_query_order(cmd),
612 TradingCommand::QueryAccount(cmd) => encode_query_account(cmd),
613 }
614}
615
616pub fn encode_order_event_any(event: &OrderEventAny) -> Result<EncodedPayload, EncodeError> {
626 match event {
627 OrderEventAny::Initialized(e) => encode_order_initialized(e),
628 OrderEventAny::Denied(e) => encode_order_denied(e),
629 OrderEventAny::Emulated(e) => encode_order_emulated(e),
630 OrderEventAny::Released(e) => encode_order_released(e),
631 OrderEventAny::Submitted(e) => encode_order_submitted(e),
632 OrderEventAny::Accepted(e) => encode_order_accepted(e),
633 OrderEventAny::Rejected(e) => encode_order_rejected(e),
634 OrderEventAny::Canceled(e) => encode_order_canceled(e),
635 OrderEventAny::Expired(e) => encode_order_expired(e),
636 OrderEventAny::Triggered(e) => encode_order_triggered(e),
637 OrderEventAny::PendingUpdate(e) => encode_order_pending_update(e),
638 OrderEventAny::PendingCancel(e) => encode_order_pending_cancel(e),
639 OrderEventAny::ModifyDenied(e) => encode_order_modify_denied(e),
640 OrderEventAny::ModifyRejected(e) => encode_order_modify_rejected(e),
641 OrderEventAny::CancelDenied(e) => encode_order_cancel_denied(e),
642 OrderEventAny::CancelRejected(e) => encode_order_cancel_rejected(e),
643 OrderEventAny::Updated(e) => encode_order_updated(e),
644 OrderEventAny::Filled(e) => Ok(retag(encode_order_filled(e)?, PAYLOAD_TYPE_ORDER_FILLED)),
645 OrderEventAny::FillVoided(e) => encode_order_fill_voided(e),
646 }
647}
648
649pub fn encode_execution_report(report: &ExecutionReport) -> Result<EncodedPayload, EncodeError> {
665 match report {
666 ExecutionReport::Order(r) => Ok(retag(
667 encode_order_status_report(r)?,
668 PAYLOAD_TYPE_ORDER_STATUS_REPORT,
669 )),
670 ExecutionReport::Fill(r) => encode_fill_report(r),
671 ExecutionReport::OrderWithFills(order, fills) => encode_order_with_fills(order, fills),
672 ExecutionReport::Position(r) => encode_position_status_report(r),
673 ExecutionReport::MassStatus(s) => encode_execution_mass_status(s),
674 }
675}
676
677pub fn encode_fill_report(report: &FillReport) -> Result<EncodedPayload, EncodeError> {
684 let payload = encode_serde(report)?;
685 let mut index_keys = Vec::with_capacity(2);
686 index_keys.push(IndexKey::new(
687 IndexKind::VenueOrderId,
688 report.venue_order_id.to_string(),
689 ));
690
691 if let Some(client_order_id) = &report.client_order_id {
692 index_keys.push(IndexKey::new(
693 IndexKind::ClientOrderId,
694 client_order_id.to_string(),
695 ));
696 }
697
698 Ok(EncodedPayload::with_payload_type(
699 payload_type(PAYLOAD_TYPE_FILL_REPORT),
700 payload,
701 index_keys,
702 ))
703}
704
705pub fn encode_position_status_report(
716 report: &PositionStatusReport,
717) -> Result<EncodedPayload, EncodeError> {
718 let payload = encode_serde(report)?;
719 Ok(EncodedPayload::with_payload_type(
720 payload_type(PAYLOAD_TYPE_POSITION_STATUS_REPORT),
721 payload,
722 Vec::new(),
723 ))
724}
725
726fn encode_order_with_fills(
727 order: &OrderStatusReport,
728 fills: &[FillReport],
729) -> Result<EncodedPayload, EncodeError> {
730 #[derive(Serialize)]
731 struct OrderWithFillsRef<'a> {
732 order_report: &'a OrderStatusReport,
733 fill_reports: &'a [FillReport],
734 }
735
736 let payload = encode_serde(&OrderWithFillsRef {
737 order_report: order,
738 fill_reports: fills,
739 })?;
740 let mut index_keys = Vec::new();
741 let mut seen = HashSet::new();
742 push_unique_index_key(
743 &mut index_keys,
744 &mut seen,
745 IndexKind::VenueOrderId,
746 order.venue_order_id.to_string(),
747 );
748
749 if let Some(client_order_id) = &order.client_order_id {
750 push_unique_index_key(
751 &mut index_keys,
752 &mut seen,
753 IndexKind::ClientOrderId,
754 client_order_id.to_string(),
755 );
756 }
757
758 for fill in fills {
759 push_unique_index_key(
760 &mut index_keys,
761 &mut seen,
762 IndexKind::VenueOrderId,
763 fill.venue_order_id.to_string(),
764 );
765
766 if let Some(client_order_id) = &fill.client_order_id {
767 push_unique_index_key(
768 &mut index_keys,
769 &mut seen,
770 IndexKind::ClientOrderId,
771 client_order_id.to_string(),
772 );
773 }
774 }
775
776 Ok(EncodedPayload::with_payload_type(
777 payload_type(PAYLOAD_TYPE_ORDER_WITH_FILLS),
778 payload,
779 index_keys,
780 ))
781}
782
783fn encode_execution_mass_status(
784 status: &ExecutionMassStatus,
785) -> Result<EncodedPayload, EncodeError> {
786 let payload = encode_serde(status)?;
787 let mut index_keys = Vec::new();
788 let mut seen = HashSet::new();
789
790 let order_reports = status.order_reports();
791
792 for (venue_order_id, report) in &order_reports {
793 push_unique_index_key(
794 &mut index_keys,
795 &mut seen,
796 IndexKind::VenueOrderId,
797 venue_order_id.to_string(),
798 );
799
800 if let Some(client_order_id) = &report.client_order_id {
801 push_unique_index_key(
802 &mut index_keys,
803 &mut seen,
804 IndexKind::ClientOrderId,
805 client_order_id.to_string(),
806 );
807 }
808 }
809
810 let fill_reports = status.fill_reports();
811
812 for (venue_order_id, fills) in &fill_reports {
813 push_unique_index_key(
814 &mut index_keys,
815 &mut seen,
816 IndexKind::VenueOrderId,
817 venue_order_id.to_string(),
818 );
819
820 for fill in fills {
821 if let Some(client_order_id) = &fill.client_order_id {
822 push_unique_index_key(
823 &mut index_keys,
824 &mut seen,
825 IndexKind::ClientOrderId,
826 client_order_id.to_string(),
827 );
828 }
829 }
830 }
831 Ok(EncodedPayload::with_payload_type(
834 payload_type(PAYLOAD_TYPE_EXECUTION_MASS_STATUS),
835 payload,
836 index_keys,
837 ))
838}
839
840fn push_unique_index_key(
841 index_keys: &mut Vec<IndexKey>,
842 seen: &mut HashSet<(IndexKind, String)>,
843 kind: IndexKind,
844 key: String,
845) {
846 if seen.insert((kind, key.clone())) {
847 index_keys.push(IndexKey::new(kind, key));
848 }
849}
850
851pub fn encode_position_event(event: &PositionEvent) -> Result<EncodedPayload, EncodeError> {
863 match event {
864 PositionEvent::PositionOpened(e) => encode_position_opened(e),
865 PositionEvent::PositionChanged(e) => encode_position_changed(e),
866 PositionEvent::PositionClosed(e) => encode_position_closed(e),
867 PositionEvent::PositionAdjusted(e) => encode_position_adjusted(e),
868 }
869}
870
871fn encode_position_opened(event: &PositionOpened) -> Result<EncodedPayload, EncodeError> {
872 let payload = encode_serde(event)?;
873 let index_keys = vec![IndexKey::new(
874 IndexKind::ClientOrderId,
875 event.opening_order_id.to_string(),
876 )];
877 Ok(EncodedPayload::with_payload_type(
878 payload_type(PAYLOAD_TYPE_POSITION_OPENED),
879 payload,
880 index_keys,
881 ))
882}
883
884fn encode_position_changed(event: &PositionChanged) -> Result<EncodedPayload, EncodeError> {
885 let payload = encode_serde(event)?;
886 let index_keys = vec![IndexKey::new(
887 IndexKind::ClientOrderId,
888 event.opening_order_id.to_string(),
889 )];
890 Ok(EncodedPayload::with_payload_type(
891 payload_type(PAYLOAD_TYPE_POSITION_CHANGED),
892 payload,
893 index_keys,
894 ))
895}
896
897fn encode_position_closed(event: &PositionClosed) -> Result<EncodedPayload, EncodeError> {
898 let payload = encode_serde(event)?;
899 let mut index_keys = Vec::new();
900 let mut seen = HashSet::new();
901
902 push_unique_index_key(
903 &mut index_keys,
904 &mut seen,
905 IndexKind::ClientOrderId,
906 event.opening_order_id.to_string(),
907 );
908
909 if let Some(closing_order_id) = &event.closing_order_id {
912 push_unique_index_key(
913 &mut index_keys,
914 &mut seen,
915 IndexKind::ClientOrderId,
916 closing_order_id.to_string(),
917 );
918 }
919
920 Ok(EncodedPayload::with_payload_type(
921 payload_type(PAYLOAD_TYPE_POSITION_CLOSED),
922 payload,
923 index_keys,
924 ))
925}
926
927fn encode_position_adjusted(event: &PositionAdjusted) -> Result<EncodedPayload, EncodeError> {
928 let payload = encode_serde(event)?;
931 Ok(EncodedPayload::with_payload_type(
932 payload_type(PAYLOAD_TYPE_POSITION_ADJUSTED),
933 payload,
934 Vec::new(),
935 ))
936}
937
938fn encode_submit_order_list(cmd: &SubmitOrderList) -> Result<EncodedPayload, EncodeError> {
939 let payload = encode_serde(cmd)?;
940 let index_keys = cmd
941 .order_list
942 .client_order_ids
943 .iter()
944 .map(|cid| IndexKey::new(IndexKind::ClientOrderId, cid.to_string()))
945 .collect();
946 Ok(EncodedPayload::with_payload_type(
947 payload_type(PAYLOAD_TYPE_SUBMIT_ORDER_LIST),
948 payload,
949 index_keys,
950 ))
951}
952
953fn encode_modify_order(cmd: &ModifyOrder) -> Result<EncodedPayload, EncodeError> {
954 encode_with_order_ids(
955 cmd,
956 PAYLOAD_TYPE_MODIFY_ORDER,
957 cmd.client_order_id.to_string(),
958 cmd.venue_order_id.map(|v| v.to_string()),
959 )
960}
961
962fn encode_batch_modify_orders(cmd: &BatchModifyOrders) -> Result<EncodedPayload, EncodeError> {
963 let payload = encode_serde(cmd)?;
964 let mut index_keys = Vec::with_capacity(cmd.modifies.len() * 2);
965 for c in &cmd.modifies {
966 index_keys.push(IndexKey::new(
967 IndexKind::ClientOrderId,
968 c.client_order_id.to_string(),
969 ));
970
971 if let Some(venue) = c.venue_order_id {
972 index_keys.push(IndexKey::new(IndexKind::VenueOrderId, venue.to_string()));
973 }
974 }
975 Ok(EncodedPayload::with_payload_type(
976 payload_type(PAYLOAD_TYPE_BATCH_MODIFY_ORDERS),
977 payload,
978 index_keys,
979 ))
980}
981
982fn encode_cancel_order(cmd: &CancelOrder) -> Result<EncodedPayload, EncodeError> {
983 encode_with_order_ids(
984 cmd,
985 PAYLOAD_TYPE_CANCEL_ORDER,
986 cmd.client_order_id.to_string(),
987 cmd.venue_order_id.map(|v| v.to_string()),
988 )
989}
990
991fn encode_cancel_all_orders(cmd: &CancelAllOrders) -> Result<EncodedPayload, EncodeError> {
992 let payload = encode_serde(cmd)?;
993 Ok(EncodedPayload::with_payload_type(
994 payload_type(PAYLOAD_TYPE_CANCEL_ALL_ORDERS),
995 payload,
996 Vec::new(),
997 ))
998}
999
1000fn encode_batch_cancel_orders(cmd: &BatchCancelOrders) -> Result<EncodedPayload, EncodeError> {
1001 let payload = encode_serde(cmd)?;
1002 let mut index_keys = Vec::with_capacity(cmd.cancels.len() * 2);
1003 for c in &cmd.cancels {
1004 index_keys.push(IndexKey::new(
1005 IndexKind::ClientOrderId,
1006 c.client_order_id.to_string(),
1007 ));
1008
1009 if let Some(venue) = c.venue_order_id {
1010 index_keys.push(IndexKey::new(IndexKind::VenueOrderId, venue.to_string()));
1011 }
1012 }
1013 Ok(EncodedPayload::with_payload_type(
1014 payload_type(PAYLOAD_TYPE_BATCH_CANCEL_ORDERS),
1015 payload,
1016 index_keys,
1017 ))
1018}
1019
1020fn encode_query_order(cmd: &QueryOrder) -> Result<EncodedPayload, EncodeError> {
1021 encode_with_order_ids(
1022 cmd,
1023 PAYLOAD_TYPE_QUERY_ORDER,
1024 cmd.client_order_id.to_string(),
1025 cmd.venue_order_id.map(|v| v.to_string()),
1026 )
1027}
1028
1029fn encode_query_account(cmd: &QueryAccount) -> Result<EncodedPayload, EncodeError> {
1030 let payload = encode_serde(cmd)?;
1031 Ok(EncodedPayload::with_payload_type(
1032 payload_type(PAYLOAD_TYPE_QUERY_ACCOUNT),
1033 payload,
1034 Vec::new(),
1035 ))
1036}
1037
1038fn encode_order_initialized(e: &OrderInitialized) -> Result<EncodedPayload, EncodeError> {
1039 encode_with_order_ids(
1040 e,
1041 PAYLOAD_TYPE_ORDER_INITIALIZED,
1042 e.client_order_id.to_string(),
1043 None,
1044 )
1045}
1046
1047fn encode_order_denied(e: &OrderDenied) -> Result<EncodedPayload, EncodeError> {
1048 encode_with_order_ids(
1049 e,
1050 PAYLOAD_TYPE_ORDER_DENIED,
1051 e.client_order_id.to_string(),
1052 None,
1053 )
1054}
1055
1056fn encode_order_emulated(e: &OrderEmulated) -> Result<EncodedPayload, EncodeError> {
1057 encode_with_order_ids(
1058 e,
1059 PAYLOAD_TYPE_ORDER_EMULATED,
1060 e.client_order_id.to_string(),
1061 None,
1062 )
1063}
1064
1065fn encode_order_released(e: &OrderReleased) -> Result<EncodedPayload, EncodeError> {
1066 encode_with_order_ids(
1067 e,
1068 PAYLOAD_TYPE_ORDER_RELEASED,
1069 e.client_order_id.to_string(),
1070 None,
1071 )
1072}
1073
1074fn encode_order_submitted(e: &OrderSubmitted) -> Result<EncodedPayload, EncodeError> {
1075 encode_with_order_ids(
1076 e,
1077 PAYLOAD_TYPE_ORDER_SUBMITTED,
1078 e.client_order_id.to_string(),
1079 None,
1080 )
1081}
1082
1083fn encode_order_accepted(e: &OrderAccepted) -> Result<EncodedPayload, EncodeError> {
1084 encode_with_order_ids(
1085 e,
1086 PAYLOAD_TYPE_ORDER_ACCEPTED,
1087 e.client_order_id.to_string(),
1088 Some(e.venue_order_id.to_string()),
1089 )
1090}
1091
1092fn encode_order_rejected(e: &OrderRejected) -> Result<EncodedPayload, EncodeError> {
1093 encode_with_order_ids(
1094 e,
1095 PAYLOAD_TYPE_ORDER_REJECTED,
1096 e.client_order_id.to_string(),
1097 None,
1098 )
1099}
1100
1101fn encode_order_canceled(e: &OrderCanceled) -> Result<EncodedPayload, EncodeError> {
1102 encode_with_order_ids(
1103 e,
1104 PAYLOAD_TYPE_ORDER_CANCELED,
1105 e.client_order_id.to_string(),
1106 e.venue_order_id.map(|v| v.to_string()),
1107 )
1108}
1109
1110fn encode_order_expired(e: &OrderExpired) -> Result<EncodedPayload, EncodeError> {
1111 encode_with_order_ids(
1112 e,
1113 PAYLOAD_TYPE_ORDER_EXPIRED,
1114 e.client_order_id.to_string(),
1115 e.venue_order_id.map(|v| v.to_string()),
1116 )
1117}
1118
1119fn encode_order_triggered(e: &OrderTriggered) -> Result<EncodedPayload, EncodeError> {
1120 encode_with_order_ids(
1121 e,
1122 PAYLOAD_TYPE_ORDER_TRIGGERED,
1123 e.client_order_id.to_string(),
1124 e.venue_order_id.map(|v| v.to_string()),
1125 )
1126}
1127
1128fn encode_order_pending_update(e: &OrderPendingUpdate) -> Result<EncodedPayload, EncodeError> {
1129 encode_with_order_ids(
1130 e,
1131 PAYLOAD_TYPE_ORDER_PENDING_UPDATE,
1132 e.client_order_id.to_string(),
1133 e.venue_order_id.map(|v| v.to_string()),
1134 )
1135}
1136
1137fn encode_order_pending_cancel(e: &OrderPendingCancel) -> Result<EncodedPayload, EncodeError> {
1138 encode_with_order_ids(
1139 e,
1140 PAYLOAD_TYPE_ORDER_PENDING_CANCEL,
1141 e.client_order_id.to_string(),
1142 e.venue_order_id.map(|v| v.to_string()),
1143 )
1144}
1145
1146fn encode_order_modify_denied(e: &OrderModifyDenied) -> Result<EncodedPayload, EncodeError> {
1147 encode_with_order_ids(
1148 e,
1149 PAYLOAD_TYPE_ORDER_MODIFY_DENIED,
1150 e.client_order_id.to_string(),
1151 e.venue_order_id.map(|v| v.to_string()),
1152 )
1153}
1154
1155fn encode_order_modify_rejected(e: &OrderModifyRejected) -> Result<EncodedPayload, EncodeError> {
1156 encode_with_order_ids(
1157 e,
1158 PAYLOAD_TYPE_ORDER_MODIFY_REJECTED,
1159 e.client_order_id.to_string(),
1160 e.venue_order_id.map(|v| v.to_string()),
1161 )
1162}
1163
1164fn encode_order_cancel_denied(e: &OrderCancelDenied) -> Result<EncodedPayload, EncodeError> {
1165 encode_with_order_ids(
1166 e,
1167 PAYLOAD_TYPE_ORDER_CANCEL_DENIED,
1168 e.client_order_id.to_string(),
1169 e.venue_order_id.map(|v| v.to_string()),
1170 )
1171}
1172
1173fn encode_order_cancel_rejected(e: &OrderCancelRejected) -> Result<EncodedPayload, EncodeError> {
1174 encode_with_order_ids(
1175 e,
1176 PAYLOAD_TYPE_ORDER_CANCEL_REJECTED,
1177 e.client_order_id.to_string(),
1178 e.venue_order_id.map(|v| v.to_string()),
1179 )
1180}
1181
1182fn encode_order_updated(e: &OrderUpdated) -> Result<EncodedPayload, EncodeError> {
1183 encode_with_order_ids(
1184 e,
1185 PAYLOAD_TYPE_ORDER_UPDATED,
1186 e.client_order_id.to_string(),
1187 e.venue_order_id.map(|v| v.to_string()),
1188 )
1189}
1190
1191fn encode_order_fill_voided(e: &OrderFillVoided) -> Result<EncodedPayload, EncodeError> {
1192 encode_with_order_ids(
1193 e,
1194 PAYLOAD_TYPE_ORDER_FILL_VOIDED,
1195 e.client_order_id.to_string(),
1196 Some(e.venue_order_id.to_string()),
1197 )
1198}
1199
1200fn encode_with_order_ids<T: Serialize>(
1201 value: &T,
1202 tag: &str,
1203 client_order_id: String,
1204 venue_order_id: Option<String>,
1205) -> Result<EncodedPayload, EncodeError> {
1206 let payload = encode_serde(value)?;
1207 let mut index_keys = Vec::with_capacity(2);
1208 index_keys.push(IndexKey::new(IndexKind::ClientOrderId, client_order_id));
1209 if let Some(venue) = venue_order_id {
1210 index_keys.push(IndexKey::new(IndexKind::VenueOrderId, venue));
1211 }
1212 Ok(EncodedPayload::with_payload_type(
1213 payload_type(tag),
1214 payload,
1215 index_keys,
1216 ))
1217}
1218
1219fn retag(mut encoded: EncodedPayload, tag: &str) -> EncodedPayload {
1220 encoded.payload_type = Some(payload_type(tag));
1221 encoded
1222}
1223
1224pub fn encode_order_status_report(
1234 message: &OrderStatusReport,
1235) -> Result<EncodedPayload, EncodeError> {
1236 let payload = encode_serde(message)?;
1237 let mut index_keys = Vec::with_capacity(2);
1238 index_keys.push(IndexKey::new(
1239 IndexKind::VenueOrderId,
1240 message.venue_order_id.to_string(),
1241 ));
1242
1243 if let Some(client_order_id) = &message.client_order_id {
1244 index_keys.push(IndexKey::new(
1245 IndexKind::ClientOrderId,
1246 client_order_id.to_string(),
1247 ));
1248 }
1249 Ok(EncodedPayload::new(payload, index_keys))
1250}
1251
1252pub fn encode_account_state(message: &AccountState) -> Result<EncodedPayload, EncodeError> {
1263 let payload = encode_serde(message)?;
1264 Ok(EncodedPayload::new(payload, Vec::new()))
1265}
1266
1267pub fn encode_instrument_close(message: &InstrumentClose) -> Result<EncodedPayload, EncodeError> {
1276 let payload = encode_serde(message)?;
1277 Ok(EncodedPayload::new(payload, Vec::new()))
1278}
1279
1280#[derive(Serialize)]
1281struct TimeEventPayload<'a> {
1282 name: &'a str,
1283 event_id: UUID4,
1284 ts_event: UnixNanos,
1285 ts_init: UnixNanos,
1286}
1287
1288pub fn encode_time_event(event: &TimeEvent) -> Result<EncodedPayload, EncodeError> {
1298 let payload = TimeEventPayload {
1299 name: event.name.as_str(),
1300 event_id: event.event_id,
1301 ts_event: event.ts_event,
1302 ts_init: event.ts_init,
1303 };
1304 Ok(EncodedPayload::new(encode_serde(&payload)?, Vec::new()))
1305}
1306
1307#[rustfmt::skip]
1324pub fn encode_data_command(command: &DataCommand) -> Result<EncodedPayload, EncodeError> {
1325 match command {
1326 DataCommand::Request(cmd) => encode_data_command_category(cmd, PAYLOAD_TYPE_REQUEST_COMMAND),
1327 DataCommand::Subscribe(cmd) => encode_data_command_category(cmd, PAYLOAD_TYPE_SUBSCRIBE_COMMAND),
1328 DataCommand::Unsubscribe(cmd) => encode_data_command_category(cmd, PAYLOAD_TYPE_UNSUBSCRIBE_COMMAND),
1329 #[cfg(feature = "defi")]
1330 DataCommand::DefiRequest(cmd) => encode_data_command_category(cmd, PAYLOAD_TYPE_DEFI_REQUEST_COMMAND),
1331 #[cfg(feature = "defi")]
1332 DataCommand::DefiSubscribe(cmd) => encode_data_command_category(cmd, PAYLOAD_TYPE_DEFI_SUBSCRIBE_COMMAND),
1333 #[cfg(feature = "defi")]
1334 DataCommand::DefiUnsubscribe(cmd) => encode_data_command_category(cmd, PAYLOAD_TYPE_DEFI_UNSUBSCRIBE_COMMAND),
1335 _ => Err(EncodeError::Serialize(
1336 "unsupported DataCommand variant".to_string(),
1337 )),
1338 }
1339}
1340
1341fn encode_data_command_category<T: Serialize>(
1342 command: &T,
1343 tag: &str,
1344) -> Result<EncodedPayload, EncodeError> {
1345 let payload = encode_serde(command)?;
1346 Ok(EncodedPayload::with_payload_type(
1347 payload_type(tag),
1348 payload,
1349 Vec::new(),
1350 ))
1351}
1352
1353pub fn encode_data_response(response: &DataResponse) -> Result<EncodedPayload, EncodeError> {
1380 match response {
1381 DataResponse::Data(resp) => encode_custom_data_response(resp),
1382 DataResponse::Instrument(resp) => encode_instrument_response(resp),
1383 DataResponse::Instruments(resp) => encode_instruments_response(resp),
1384 DataResponse::Book(resp) => encode_book_response(resp),
1385 DataResponse::BookDeltas(resp) => encode_book_deltas_response(resp),
1386 DataResponse::BookDepth(resp) => encode_book_depth_response(resp),
1387 DataResponse::Quotes(resp) => encode_quotes_response(resp),
1388 DataResponse::Trades(resp) => encode_trades_response(resp),
1389 DataResponse::FundingRates(resp) => encode_funding_rates_response(resp),
1390 DataResponse::OptionChainReferencePrice(resp) => {
1391 encode_option_chain_reference_price_response(resp)
1392 }
1393 DataResponse::Bars(resp) => encode_bars_response(resp),
1394 }
1395}
1396
1397#[derive(serde::Serialize, serde::Deserialize)]
1398pub(crate) struct ResponseEnvelopeCapture {
1399 pub(crate) correlation_id: UUID4,
1400 pub(crate) completed: bool,
1401 pub(crate) sub_correlation_id: Option<UUID4>,
1402 pub(crate) failure_reason: Option<String>,
1403 pub(crate) payload_type: Option<PayloadType>,
1404 pub(crate) payload: Option<Bytes>,
1405}
1406
1407fn encode_response_envelope(
1408 response: &DataResponseEnvelope,
1409) -> Result<EncodedPayload, EncodeError> {
1410 let payload = response.response().map(encode_data_response).transpose()?;
1411
1412 let capture = ResponseEnvelopeCapture {
1413 correlation_id: *response.correlation_id(),
1414 completed: response.completed(),
1415 sub_correlation_id: response.sub_correlation_id(),
1416 failure_reason: response.failure_reason().map(str::to_owned),
1417 payload_type: payload.as_ref().and_then(|value| value.payload_type),
1418 payload: payload.map(|value| value.payload),
1419 };
1420
1421 Ok(EncodedPayload::without_indices(encode_serde(&capture)?))
1422}
1423
1424fn encode_custom_data_response(
1425 response: &CustomDataResponse,
1426) -> Result<EncodedPayload, EncodeError> {
1427 #[derive(Serialize)]
1432 struct CustomDataResponseRef<'a> {
1433 correlation_id: &'a UUID4,
1434 client_id: &'a ClientId,
1435 venue: &'a Option<Venue>,
1436 data_type: &'a DataType,
1437 start: &'a Option<UnixNanos>,
1438 end: &'a Option<UnixNanos>,
1439 ts_init: &'a UnixNanos,
1440 params: &'a Option<Params>,
1441 }
1442
1443 let payload = encode_serde(&CustomDataResponseRef {
1444 correlation_id: &response.correlation_id,
1445 client_id: &response.client_id,
1446 venue: &response.venue,
1447 data_type: &response.data_type,
1448 start: &response.start,
1449 end: &response.end,
1450 ts_init: &response.ts_init,
1451 params: &response.params,
1452 })?;
1453 Ok(EncodedPayload::with_payload_type(
1454 payload_type(PAYLOAD_TYPE_CUSTOM_DATA_RESPONSE),
1455 payload,
1456 Vec::new(),
1457 ))
1458}
1459
1460fn encode_instrument_response(
1461 response: &InstrumentResponse,
1462) -> Result<EncodedPayload, EncodeError> {
1463 let payload = encode_serde(response)?;
1464 Ok(EncodedPayload::with_payload_type(
1465 payload_type(PAYLOAD_TYPE_INSTRUMENT_RESPONSE),
1466 payload,
1467 Vec::new(),
1468 ))
1469}
1470
1471fn encode_instruments_response(
1472 response: &InstrumentsResponse,
1473) -> Result<EncodedPayload, EncodeError> {
1474 let payload = encode_serde(response)?;
1475 Ok(EncodedPayload::with_payload_type(
1476 payload_type(PAYLOAD_TYPE_INSTRUMENTS_RESPONSE),
1477 payload,
1478 Vec::new(),
1479 ))
1480}
1481
1482fn encode_book_response(response: &BookResponse) -> Result<EncodedPayload, EncodeError> {
1483 #[derive(Serialize)]
1488 struct BookResponseRef<'a> {
1489 correlation_id: &'a UUID4,
1490 client_id: &'a ClientId,
1491 instrument_id: &'a InstrumentId,
1492 start: &'a Option<UnixNanos>,
1493 end: &'a Option<UnixNanos>,
1494 ts_init: &'a UnixNanos,
1495 params: &'a Option<Params>,
1496 }
1497
1498 let payload = encode_serde(&BookResponseRef {
1499 correlation_id: &response.correlation_id,
1500 client_id: &response.client_id,
1501 instrument_id: &response.instrument_id,
1502 start: &response.start,
1503 end: &response.end,
1504 ts_init: &response.ts_init,
1505 params: &response.params,
1506 })?;
1507 Ok(EncodedPayload::with_payload_type(
1508 payload_type(PAYLOAD_TYPE_BOOK_RESPONSE),
1509 payload,
1510 Vec::new(),
1511 ))
1512}
1513
1514fn encode_quotes_response(response: &QuotesResponse) -> Result<EncodedPayload, EncodeError> {
1515 let payload = encode_serde(response)?;
1516 Ok(EncodedPayload::with_payload_type(
1517 payload_type(PAYLOAD_TYPE_QUOTES_RESPONSE),
1518 payload,
1519 Vec::new(),
1520 ))
1521}
1522
1523fn encode_book_deltas_response(
1524 response: &BookDeltasResponse,
1525) -> Result<EncodedPayload, EncodeError> {
1526 let payload = encode_serde(response)?;
1527 Ok(EncodedPayload::with_payload_type(
1528 payload_type(PAYLOAD_TYPE_BOOK_DELTAS_RESPONSE),
1529 payload,
1530 Vec::new(),
1531 ))
1532}
1533
1534fn encode_book_depth_response(response: &BookDepthResponse) -> Result<EncodedPayload, EncodeError> {
1535 let payload = encode_serde(response)?;
1536 Ok(EncodedPayload::with_payload_type(
1537 payload_type(PAYLOAD_TYPE_BOOK_DEPTH_RESPONSE),
1538 payload,
1539 Vec::new(),
1540 ))
1541}
1542
1543fn encode_trades_response(response: &TradesResponse) -> Result<EncodedPayload, EncodeError> {
1544 let payload = encode_serde(response)?;
1545 Ok(EncodedPayload::with_payload_type(
1546 payload_type(PAYLOAD_TYPE_TRADES_RESPONSE),
1547 payload,
1548 Vec::new(),
1549 ))
1550}
1551
1552fn encode_funding_rates_response(
1553 response: &FundingRatesResponse,
1554) -> Result<EncodedPayload, EncodeError> {
1555 let payload = encode_serde(response)?;
1556 Ok(EncodedPayload::with_payload_type(
1557 payload_type(PAYLOAD_TYPE_FUNDING_RATES_RESPONSE),
1558 payload,
1559 Vec::new(),
1560 ))
1561}
1562
1563fn encode_option_chain_reference_price_response(
1564 response: &OptionChainReferencePriceResponse,
1565) -> Result<EncodedPayload, EncodeError> {
1566 let payload = encode_serde(response)?;
1567 Ok(EncodedPayload::with_payload_type(
1568 payload_type(PAYLOAD_TYPE_OPTION_CHAIN_REFERENCE_PRICE_RESPONSE),
1569 payload,
1570 Vec::new(),
1571 ))
1572}
1573
1574fn encode_bars_response(response: &BarsResponse) -> Result<EncodedPayload, EncodeError> {
1575 let payload = encode_serde(response)?;
1576 Ok(EncodedPayload::with_payload_type(
1577 payload_type(PAYLOAD_TYPE_BARS_RESPONSE),
1578 payload,
1579 Vec::new(),
1580 ))
1581}
1582
1583#[cfg(test)]
1584mod tests {
1585 use nautilus_common::messages::data::{
1586 RequestCommand, RequestQuotes, SubscribeCommand, SubscribeQuotes, UnsubscribeCommand,
1587 UnsubscribeQuotes,
1588 };
1589 #[cfg(feature = "defi")]
1590 use nautilus_common::messages::defi::{
1591 DefiRequestCommand, DefiSubscribeCommand, DefiUnsubscribeCommand, RequestPoolSnapshot,
1592 SubscribeBlocks, UnsubscribeBlocks,
1593 };
1594 use nautilus_core::{DurationNanos, UUID4, UnixNanos};
1595 #[cfg(feature = "defi")]
1596 use nautilus_model::defi::Blockchain;
1597 use nautilus_model::{
1598 data::{Bar, BarType, stubs::stub_depth10},
1599 enums::{
1600 AccountType, BookType, InstrumentCloseType, LiquiditySide, OrderSide, OrderStatus,
1601 OrderType, PositionAdjustmentType, PositionSide, TimeInForce,
1602 },
1603 events::{
1604 PositionAdjusted, PositionChanged, PositionClosed, PositionOpened,
1605 order::spec::{
1606 OrderFillVoidedSpec, OrderFilledSpec, OrderInitializedSpec, OrderSubmittedSpec,
1607 },
1608 },
1609 identifiers::{
1610 AccountId, ClientId, ClientOrderId, InstrumentId, OptionSeriesId, OrderListId,
1611 PositionId, StrategyId, TradeId, TraderId, Venue, VenueOrderId,
1612 },
1613 instruments::{InstrumentAny, stubs::currency_pair_ethusdt},
1614 orderbook::OrderBook,
1615 orders::OrderList,
1616 reports::{ExecutionMassStatus, FillReport, PositionStatusReport},
1617 types::{AccountBalance, Currency, Money, Price, Quantity},
1618 };
1619 use rstest::rstest;
1620 use serde::Deserialize;
1621 use ustr::Ustr;
1622
1623 use super::*;
1624
1625 fn trader_id() -> TraderId {
1626 TraderId::from("TRADER-001")
1627 }
1628
1629 fn strategy_id() -> StrategyId {
1630 StrategyId::from("S-001")
1631 }
1632
1633 fn instrument_id() -> InstrumentId {
1634 InstrumentId::from("ETHUSDT-PERP.BINANCE")
1635 }
1636
1637 fn client_order_id() -> ClientOrderId {
1638 ClientOrderId::from("O-20260510-000001")
1639 }
1640
1641 fn venue_order_id() -> VenueOrderId {
1642 VenueOrderId::from("V-12345")
1643 }
1644
1645 fn make_submit_order() -> SubmitOrder {
1646 let order_init = OrderInitializedSpec::builder()
1647 .instrument_id(instrument_id())
1648 .client_order_id(client_order_id())
1649 .quantity(Quantity::from("1"))
1650 .time_in_force(TimeInForce::Gtc)
1651 .ts_event(UnixNanos::from(1))
1652 .ts_init(UnixNanos::from(2))
1653 .build();
1654 SubmitOrder::new(
1655 trader_id(),
1656 Some(ClientId::from("BINANCE")),
1657 strategy_id(),
1658 instrument_id(),
1659 client_order_id(),
1660 order_init,
1661 None,
1662 None,
1663 None,
1664 UUID4::new(),
1665 UnixNanos::from(3),
1666 None, )
1668 }
1669
1670 fn make_order_filled() -> OrderFilled {
1671 OrderFilledSpec::builder()
1672 .instrument_id(instrument_id())
1673 .client_order_id(client_order_id())
1674 .venue_order_id(venue_order_id())
1675 .account_id(AccountId::from("BINANCE-001"))
1676 .trade_id(TradeId::from("T-9999"))
1677 .last_qty(Quantity::from("1"))
1678 .last_px(Price::from("100.00"))
1679 .currency(Currency::USDT())
1680 .ts_event(UnixNanos::from(10))
1681 .ts_init(UnixNanos::from(11))
1682 .commission(Money::new(0.10, Currency::USDT()))
1683 .build()
1684 }
1685
1686 fn make_order_status_report() -> OrderStatusReport {
1687 OrderStatusReport::new(
1688 AccountId::from("BINANCE-001"),
1689 instrument_id(),
1690 Some(client_order_id()),
1691 venue_order_id(),
1692 OrderSide::Buy.into(),
1693 OrderType::Market,
1694 TimeInForce::Gtc,
1695 OrderStatus::Filled,
1696 Quantity::from("1"),
1697 Quantity::from("1"),
1698 UnixNanos::from(20),
1699 UnixNanos::from(21),
1700 UnixNanos::from(22),
1701 Some(UUID4::new()),
1702 )
1703 }
1704
1705 #[rstest]
1706 fn submit_order_encoder_emits_client_order_id_index() {
1707 let cmd = make_submit_order();
1708 let encoded = encode_submit_order(&cmd).expect("encode");
1709
1710 assert!(!encoded.payload.is_empty());
1711 assert_eq!(encoded.index_keys.len(), 1);
1712 assert_eq!(encoded.index_keys[0].kind, IndexKind::ClientOrderId);
1713 assert_eq!(encoded.index_keys[0].key, cmd.client_order_id.to_string());
1714 }
1715
1716 #[rstest]
1717 fn order_filled_encoder_emits_client_and_venue_order_id_indices() {
1718 let event = make_order_filled();
1719 let encoded = encode_order_filled(&event).expect("encode");
1720
1721 assert!(!encoded.payload.is_empty());
1722 assert_eq!(encoded.index_keys.len(), 2);
1723 assert_eq!(encoded.index_keys[0].kind, IndexKind::ClientOrderId);
1724 assert_eq!(encoded.index_keys[0].key, event.client_order_id.to_string());
1725 assert_eq!(encoded.index_keys[1].kind, IndexKind::VenueOrderId);
1726 assert_eq!(encoded.index_keys[1].key, event.venue_order_id.to_string());
1727 }
1728
1729 #[rstest]
1730 fn order_status_report_encoder_includes_client_order_id_when_present() {
1731 let report = make_order_status_report();
1732 let encoded = encode_order_status_report(&report).expect("encode");
1733
1734 assert_eq!(encoded.index_keys.len(), 2);
1735 assert_eq!(encoded.index_keys[0].kind, IndexKind::VenueOrderId);
1736 assert_eq!(encoded.index_keys[1].kind, IndexKind::ClientOrderId);
1737 }
1738
1739 #[rstest]
1740 fn order_status_report_encoder_omits_client_order_id_when_absent() {
1741 let mut report = make_order_status_report();
1742 report.client_order_id = None;
1743 let encoded = encode_order_status_report(&report).expect("encode");
1744
1745 assert_eq!(encoded.index_keys.len(), 1);
1746 assert_eq!(encoded.index_keys[0].kind, IndexKind::VenueOrderId);
1747 }
1748
1749 #[rstest]
1750 fn default_registry_covers_published_state_affecting_surface() {
1751 let registry = default_registry();
1752 let expected = [
1753 (
1754 "send_any_value(SubmitOrder) / bare SubmitOrder",
1755 registry.contains::<SubmitOrder>(),
1756 ),
1757 (
1758 "publish_order_event(OrderFilled) / bare OrderFilled",
1759 registry.contains::<OrderFilled>(),
1760 ),
1761 (
1762 "reconciliation.raw.order_status / OrderStatusReport",
1763 registry.contains::<OrderStatusReport>(),
1764 ),
1765 (
1766 "reconciliation.raw.fill / FillReport",
1767 registry.contains::<FillReport>(),
1768 ),
1769 (
1770 "reconciliation.raw.position / PositionStatusReport",
1771 registry.contains::<PositionStatusReport>(),
1772 ),
1773 (
1774 "send_trading_command / TradingCommand",
1775 registry.contains::<TradingCommand>(),
1776 ),
1777 (
1778 "publish_order_event / OrderEventAny",
1779 registry.contains::<OrderEventAny>(),
1780 ),
1781 (
1782 "send_execution_report / ExecutionReport",
1783 registry.contains::<ExecutionReport>(),
1784 ),
1785 (
1786 "publish_position_event / PositionEvent",
1787 registry.contains::<PositionEvent>(),
1788 ),
1789 (
1790 "publish_account_state and send_account_state / AccountState",
1791 registry.contains::<AccountState>(),
1792 ),
1793 (
1794 "data.close.* publish_any / InstrumentClose",
1795 registry.contains::<InstrumentClose>(),
1796 ),
1797 (
1798 "time event handler firing / TimeEvent",
1799 registry.contains::<TimeEvent>(),
1800 ),
1801 (
1802 "send_data_command / DataCommand",
1803 registry.contains::<DataCommand>(),
1804 ),
1805 (
1806 "send_data_response / DataResponse",
1807 registry.contains::<DataResponse>(),
1808 ),
1809 (
1810 "send_response_envelope / DataResponseEnvelope",
1811 registry.contains::<DataResponseEnvelope>(),
1812 ),
1813 ];
1814 let missing: Vec<&str> = expected
1815 .iter()
1816 .filter_map(|(name, registered)| (!*registered).then_some(*name))
1817 .collect();
1818
1819 assert!(
1820 missing.is_empty(),
1821 "missing default event-store encoder registrations for {missing:?}",
1822 );
1823 assert_eq!(
1824 registry.len(),
1825 expected.len(),
1826 "default registry must match the audited state-affecting surface",
1827 );
1828 }
1829
1830 #[rstest]
1831 fn submit_order_payload_round_trips_through_msgpack() {
1832 let cmd = make_submit_order();
1833 let encoded = encode_submit_order(&cmd).expect("encode");
1834
1835 let decoded: SubmitOrder = rmp_serde::from_slice(&encoded.payload).expect("decode");
1836 assert_eq!(decoded, cmd);
1837 }
1838
1839 #[rstest]
1840 fn default_registry_data_command_identity_dedupes_dispatch_hops() {
1841 let registry = default_registry();
1845
1846 let request = make_request_command();
1847 let expected_request = *request.request_id();
1848 let subscribe = make_subscribe_command();
1849 let expected_subscribe = subscribe.command_id();
1850 let unsubscribe = make_unsubscribe_command();
1851 let expected_unsubscribe = unsubscribe.command_id();
1852
1853 let cases = [
1854 (DataCommand::Request(request), expected_request),
1855 (DataCommand::Subscribe(subscribe), expected_subscribe),
1856 (DataCommand::Unsubscribe(unsubscribe), expected_unsubscribe),
1857 ];
1858
1859 for (command, expected) in cases {
1860 assert_eq!(registry.identity_for_any(&command), Some(expected));
1861 }
1862 }
1863
1864 #[cfg(feature = "defi")]
1865 #[rstest]
1866 fn default_registry_defi_data_command_identity_dedupes_dispatch_hops() {
1867 let registry = default_registry();
1868
1869 let request = make_defi_request_command();
1870 let expected_request = *request.request_id();
1871 let subscribe = make_defi_subscribe_command();
1872 let expected_subscribe = subscribe.command_id();
1873 let unsubscribe = make_defi_unsubscribe_command();
1874 let expected_unsubscribe = unsubscribe.command_id();
1875
1876 let cases = [
1877 (DataCommand::DefiRequest(request), expected_request),
1878 (DataCommand::DefiSubscribe(subscribe), expected_subscribe),
1879 (
1880 DataCommand::DefiUnsubscribe(unsubscribe),
1881 expected_unsubscribe,
1882 ),
1883 ];
1884
1885 for (command, expected) in cases {
1886 assert_eq!(registry.identity_for_any(&command), Some(expected));
1887 }
1888 }
1889
1890 #[rstest]
1891 fn order_filled_payload_round_trips_through_msgpack() {
1892 let event = make_order_filled();
1893 let encoded = encode_order_filled(&event).expect("encode");
1894
1895 let decoded: OrderFilled = rmp_serde::from_slice(&encoded.payload).expect("decode");
1896 assert_eq!(decoded, event);
1897 }
1898
1899 #[rstest]
1900 fn order_status_report_payload_round_trips_through_msgpack() {
1901 let report = make_order_status_report();
1902 let encoded = encode_order_status_report(&report).expect("encode");
1903
1904 let decoded: OrderStatusReport = rmp_serde::from_slice(&encoded.payload).expect("decode");
1905 assert_eq!(decoded, report);
1906 }
1907
1908 fn make_cancel_order() -> CancelOrder {
1909 CancelOrder::new(
1910 trader_id(),
1911 Some(ClientId::from("BINANCE")),
1912 strategy_id(),
1913 instrument_id(),
1914 client_order_id(),
1915 Some(venue_order_id()),
1916 UUID4::new(),
1917 UnixNanos::from(4),
1918 None,
1919 None, )
1921 }
1922
1923 fn make_query_account() -> QueryAccount {
1924 QueryAccount::new(
1925 trader_id(),
1926 Some(ClientId::from("BINANCE")),
1927 AccountId::from("BINANCE-001"),
1928 UUID4::new(),
1929 UnixNanos::from(5),
1930 None,
1931 None, )
1933 }
1934
1935 fn make_order_submitted() -> OrderSubmitted {
1936 OrderSubmittedSpec::builder()
1937 .instrument_id(instrument_id())
1938 .client_order_id(client_order_id())
1939 .account_id(AccountId::from("BINANCE-001"))
1940 .ts_event(UnixNanos::from(30))
1941 .ts_init(UnixNanos::from(31))
1942 .build()
1943 }
1944
1945 fn make_modify_order(venue: Option<VenueOrderId>) -> ModifyOrder {
1946 ModifyOrder::new(
1947 trader_id(),
1948 Some(ClientId::from("BINANCE")),
1949 strategy_id(),
1950 instrument_id(),
1951 client_order_id(),
1952 venue,
1953 Some(Quantity::from("2")),
1954 Some(Price::from("100.00")),
1955 None,
1956 UUID4::new(),
1957 UnixNanos::from(6),
1958 None,
1959 None, )
1961 }
1962
1963 fn make_batch_modify_orders(modifies: Vec<ModifyOrder>) -> BatchModifyOrders {
1964 BatchModifyOrders::new(
1965 trader_id(),
1966 Some(ClientId::from("BINANCE")),
1967 strategy_id(),
1968 instrument_id(),
1969 modifies,
1970 UUID4::new(),
1971 UnixNanos::from(7),
1972 None,
1973 None, )
1975 }
1976
1977 fn make_cancel_all_orders() -> CancelAllOrders {
1978 CancelAllOrders::new(
1979 trader_id(),
1980 Some(ClientId::from("BINANCE")),
1981 strategy_id(),
1982 instrument_id(),
1983 Some(OrderSide::Buy),
1984 UUID4::new(),
1985 UnixNanos::from(7),
1986 None,
1987 None, )
1989 }
1990
1991 fn make_query_order(venue: Option<VenueOrderId>) -> QueryOrder {
1992 QueryOrder::new(
1993 trader_id(),
1994 Some(ClientId::from("BINANCE")),
1995 strategy_id(),
1996 instrument_id(),
1997 client_order_id(),
1998 venue,
1999 UUID4::new(),
2000 UnixNanos::from(8),
2001 None,
2002 None, )
2004 }
2005
2006 fn make_batch_cancel_orders(cancels: Vec<CancelOrder>) -> BatchCancelOrders {
2007 BatchCancelOrders::new(
2008 trader_id(),
2009 Some(ClientId::from("BINANCE")),
2010 strategy_id(),
2011 instrument_id(),
2012 cancels,
2013 UUID4::new(),
2014 UnixNanos::from(9),
2015 None,
2016 None, )
2018 }
2019
2020 fn make_submit_order_list(client_order_ids: Vec<ClientOrderId>) -> SubmitOrderList {
2021 let order_inits: Vec<OrderInitialized> = client_order_ids
2024 .iter()
2025 .copied()
2026 .map(make_order_initialized_with_id)
2027 .collect();
2028 let order_list = OrderList::new(
2029 OrderListId::from("OL-1"),
2030 instrument_id(),
2031 strategy_id(),
2032 client_order_ids,
2033 UnixNanos::from(10),
2034 );
2035 SubmitOrderList::new(
2036 trader_id(),
2037 Some(ClientId::from("BINANCE")),
2038 strategy_id(),
2039 order_list,
2040 order_inits,
2041 None,
2042 None,
2043 None,
2044 UUID4::new(),
2045 UnixNanos::from(11),
2046 None, )
2048 }
2049
2050 fn make_order_initialized_with_id(client_order_id: ClientOrderId) -> OrderInitialized {
2051 OrderInitialized {
2052 client_order_id,
2053 ..OrderInitialized::default()
2054 }
2055 }
2056
2057 fn ev_initialized() -> OrderEventAny {
2058 OrderEventAny::Initialized(make_order_initialized_with_id(client_order_id()))
2059 }
2060
2061 fn ev_denied() -> OrderEventAny {
2062 OrderEventAny::Denied(OrderDenied {
2063 client_order_id: client_order_id(),
2064 ..Default::default()
2065 })
2066 }
2067
2068 fn ev_emulated() -> OrderEventAny {
2069 OrderEventAny::Emulated(OrderEmulated {
2070 client_order_id: client_order_id(),
2071 ..Default::default()
2072 })
2073 }
2074
2075 fn ev_released() -> OrderEventAny {
2076 OrderEventAny::Released(OrderReleased {
2077 client_order_id: client_order_id(),
2078 ..Default::default()
2079 })
2080 }
2081
2082 fn ev_submitted() -> OrderEventAny {
2083 OrderEventAny::Submitted(make_order_submitted())
2084 }
2085
2086 fn ev_accepted_with_venue(venue: VenueOrderId) -> OrderEventAny {
2087 OrderEventAny::Accepted(OrderAccepted {
2088 client_order_id: client_order_id(),
2089 venue_order_id: venue,
2090 ..Default::default()
2091 })
2092 }
2093
2094 fn ev_rejected() -> OrderEventAny {
2095 OrderEventAny::Rejected(OrderRejected {
2096 client_order_id: client_order_id(),
2097 ..Default::default()
2098 })
2099 }
2100
2101 fn ev_canceled(venue: Option<VenueOrderId>) -> OrderEventAny {
2102 OrderEventAny::Canceled(OrderCanceled {
2103 client_order_id: client_order_id(),
2104 venue_order_id: venue,
2105 ..Default::default()
2106 })
2107 }
2108
2109 fn ev_expired(venue: Option<VenueOrderId>) -> OrderEventAny {
2110 OrderEventAny::Expired(OrderExpired {
2111 client_order_id: client_order_id(),
2112 venue_order_id: venue,
2113 ..Default::default()
2114 })
2115 }
2116
2117 fn ev_triggered(venue: Option<VenueOrderId>) -> OrderEventAny {
2118 OrderEventAny::Triggered(OrderTriggered {
2119 client_order_id: client_order_id(),
2120 venue_order_id: venue,
2121 ..Default::default()
2122 })
2123 }
2124
2125 fn ev_pending_update(venue: Option<VenueOrderId>) -> OrderEventAny {
2126 OrderEventAny::PendingUpdate(OrderPendingUpdate {
2127 client_order_id: client_order_id(),
2128 venue_order_id: venue,
2129 ..Default::default()
2130 })
2131 }
2132
2133 fn ev_pending_cancel(venue: Option<VenueOrderId>) -> OrderEventAny {
2134 OrderEventAny::PendingCancel(OrderPendingCancel {
2135 client_order_id: client_order_id(),
2136 venue_order_id: venue,
2137 ..Default::default()
2138 })
2139 }
2140
2141 fn ev_modify_denied(venue: Option<VenueOrderId>) -> OrderEventAny {
2142 OrderEventAny::ModifyDenied(OrderModifyDenied {
2143 client_order_id: client_order_id(),
2144 venue_order_id: venue,
2145 ..Default::default()
2146 })
2147 }
2148
2149 fn ev_modify_rejected(venue: Option<VenueOrderId>) -> OrderEventAny {
2150 OrderEventAny::ModifyRejected(OrderModifyRejected {
2151 client_order_id: client_order_id(),
2152 venue_order_id: venue,
2153 ..Default::default()
2154 })
2155 }
2156
2157 fn ev_cancel_denied(venue: Option<VenueOrderId>) -> OrderEventAny {
2158 OrderEventAny::CancelDenied(OrderCancelDenied {
2159 client_order_id: client_order_id(),
2160 venue_order_id: venue,
2161 ..Default::default()
2162 })
2163 }
2164
2165 fn ev_cancel_rejected(venue: Option<VenueOrderId>) -> OrderEventAny {
2166 OrderEventAny::CancelRejected(OrderCancelRejected {
2167 client_order_id: client_order_id(),
2168 venue_order_id: venue,
2169 ..Default::default()
2170 })
2171 }
2172
2173 fn ev_updated(venue: Option<VenueOrderId>) -> OrderEventAny {
2174 OrderEventAny::Updated(OrderUpdated {
2175 client_order_id: client_order_id(),
2176 venue_order_id: venue,
2177 ..Default::default()
2178 })
2179 }
2180
2181 fn ev_filled() -> OrderEventAny {
2182 OrderEventAny::Filled(make_order_filled())
2183 }
2184
2185 fn ev_fill_voided() -> OrderEventAny {
2186 OrderEventAny::FillVoided(
2187 OrderFillVoidedSpec::builder()
2188 .client_order_id(client_order_id())
2189 .venue_order_id(venue_order_id())
2190 .build(),
2191 )
2192 }
2193
2194 #[rstest]
2195 fn trading_command_envelope_stamps_inner_submit_order_payload_type() {
2196 let cmd = make_submit_order();
2201 let bare = encode_submit_order(&cmd).expect("bare");
2202
2203 let envelope = TradingCommand::SubmitOrder(cmd);
2204 let wrapped = encode_trading_command(&envelope).expect("envelope");
2205
2206 assert_eq!(wrapped.payload, bare.payload);
2207 assert_eq!(wrapped.index_keys, bare.index_keys);
2208 assert_eq!(
2209 wrapped.payload_type.expect("override").as_str(),
2210 PAYLOAD_TYPE_SUBMIT_ORDER,
2211 );
2212 }
2213
2214 #[rstest]
2215 fn trading_command_cancel_order_envelope_emits_client_and_venue_indices() {
2216 let cancel = make_cancel_order();
2217 let envelope = TradingCommand::CancelOrder(cancel.clone());
2218 let wrapped = encode_trading_command(&envelope).expect("envelope");
2219
2220 assert_eq!(
2221 wrapped.payload_type.expect("override").as_str(),
2222 PAYLOAD_TYPE_CANCEL_ORDER,
2223 );
2224 assert_eq!(wrapped.index_keys.len(), 2);
2225 assert_eq!(wrapped.index_keys[0].kind, IndexKind::ClientOrderId);
2226 assert_eq!(
2227 wrapped.index_keys[0].key,
2228 cancel.client_order_id.to_string(),
2229 );
2230 assert_eq!(wrapped.index_keys[1].kind, IndexKind::VenueOrderId);
2231 assert_eq!(
2232 wrapped.index_keys[1].key,
2233 cancel.venue_order_id.expect("set").to_string(),
2234 );
2235
2236 let decoded: CancelOrder = rmp_serde::from_slice(&wrapped.payload).expect("decode");
2237 assert_eq!(decoded, cancel);
2238 }
2239
2240 #[rstest]
2241 fn trading_command_query_account_envelope_records_no_order_indices() {
2242 let envelope = TradingCommand::QueryAccount(make_query_account());
2245 let wrapped = encode_trading_command(&envelope).expect("envelope");
2246
2247 assert_eq!(
2248 wrapped.payload_type.expect("override").as_str(),
2249 PAYLOAD_TYPE_QUERY_ACCOUNT,
2250 );
2251 assert!(wrapped.index_keys.is_empty());
2252 }
2253
2254 #[rstest]
2255 fn order_event_any_envelope_stamps_inner_filled_payload_type() {
2256 let filled = make_order_filled();
2257 let bare = encode_order_filled(&filled).expect("bare");
2258
2259 let envelope = OrderEventAny::Filled(filled);
2260 let wrapped = encode_order_event_any(&envelope).expect("envelope");
2261
2262 assert_eq!(wrapped.payload, bare.payload);
2263 assert_eq!(wrapped.index_keys, bare.index_keys);
2264 assert_eq!(
2265 wrapped.payload_type.expect("override").as_str(),
2266 PAYLOAD_TYPE_ORDER_FILLED,
2267 );
2268 }
2269
2270 #[rstest]
2271 fn order_event_any_submitted_envelope_emits_client_order_id_index() {
2272 let submitted = make_order_submitted();
2273 let envelope = OrderEventAny::Submitted(submitted);
2274 let wrapped = encode_order_event_any(&envelope).expect("envelope");
2275
2276 assert_eq!(
2277 wrapped.payload_type.expect("override").as_str(),
2278 PAYLOAD_TYPE_ORDER_SUBMITTED,
2279 );
2280 assert_eq!(wrapped.index_keys.len(), 1);
2281 assert_eq!(wrapped.index_keys[0].kind, IndexKind::ClientOrderId);
2282 assert_eq!(
2283 wrapped.index_keys[0].key,
2284 submitted.client_order_id.to_string(),
2285 );
2286
2287 let decoded: OrderSubmitted = rmp_serde::from_slice(&wrapped.payload).expect("decode");
2288 assert_eq!(decoded, submitted);
2289 }
2290
2291 #[rstest]
2296 #[case::submit_order(
2297 TradingCommand::SubmitOrder(make_submit_order()),
2298 PAYLOAD_TYPE_SUBMIT_ORDER,
2299 1
2300 )]
2301 #[case::submit_order_list(
2302 TradingCommand::SubmitOrderList(make_submit_order_list(vec![
2303 ClientOrderId::from("O-A"),
2304 ClientOrderId::from("O-B"),
2305 ])),
2306 PAYLOAD_TYPE_SUBMIT_ORDER_LIST,
2307 2,
2308 )]
2309 #[case::modify_order(
2310 TradingCommand::ModifyOrder(make_modify_order(Some(venue_order_id()))),
2311 PAYLOAD_TYPE_MODIFY_ORDER,
2312 2
2313 )]
2314 #[case::batch_modify_orders(
2315 TradingCommand::ModifyOrders(make_batch_modify_orders(vec![
2316 make_modify_order(Some(venue_order_id())),
2317 ])),
2318 PAYLOAD_TYPE_BATCH_MODIFY_ORDERS,
2319 2,
2320 )]
2321 #[case::cancel_order(
2322 TradingCommand::CancelOrder(make_cancel_order()),
2323 PAYLOAD_TYPE_CANCEL_ORDER,
2324 2
2325 )]
2326 #[case::batch_cancel_orders(
2327 TradingCommand::CancelOrders(make_batch_cancel_orders(vec![make_cancel_order()])),
2328 PAYLOAD_TYPE_BATCH_CANCEL_ORDERS,
2329 2,
2330 )]
2331 #[case::cancel_all_orders(
2332 TradingCommand::CancelAllOrders(make_cancel_all_orders()),
2333 PAYLOAD_TYPE_CANCEL_ALL_ORDERS,
2334 0
2335 )]
2336 #[case::query_order(
2337 TradingCommand::QueryOrder(make_query_order(Some(venue_order_id()))),
2338 PAYLOAD_TYPE_QUERY_ORDER,
2339 2
2340 )]
2341 #[case::query_account(
2342 TradingCommand::QueryAccount(make_query_account()),
2343 PAYLOAD_TYPE_QUERY_ACCOUNT,
2344 0
2345 )]
2346 fn trading_command_envelope_stamps_inner_tag_for_every_variant(
2347 #[case] command: TradingCommand,
2348 #[case] expected_tag: &str,
2349 #[case] expected_index_count: usize,
2350 ) {
2351 let encoded = encode_trading_command(&command).expect("encode");
2352 let tag = encoded.payload_type.expect("override").as_str().to_string();
2353
2354 assert_eq!(tag, expected_tag);
2355 assert_ne!(
2356 tag, PAYLOAD_TYPE_TRADING_COMMAND,
2357 "wrapper fallback tag must never reach the writer",
2358 );
2359 assert_eq!(encoded.index_keys.len(), expected_index_count);
2360 }
2361
2362 #[rstest]
2366 #[case::initialized(ev_initialized(), PAYLOAD_TYPE_ORDER_INITIALIZED, false)]
2367 #[case::denied(ev_denied(), PAYLOAD_TYPE_ORDER_DENIED, false)]
2368 #[case::emulated(ev_emulated(), PAYLOAD_TYPE_ORDER_EMULATED, false)]
2369 #[case::released(ev_released(), PAYLOAD_TYPE_ORDER_RELEASED, false)]
2370 #[case::submitted(ev_submitted(), PAYLOAD_TYPE_ORDER_SUBMITTED, false)]
2371 #[case::accepted(
2372 ev_accepted_with_venue(venue_order_id()),
2373 PAYLOAD_TYPE_ORDER_ACCEPTED,
2374 true
2375 )]
2376 #[case::rejected(ev_rejected(), PAYLOAD_TYPE_ORDER_REJECTED, false)]
2377 #[case::canceled(ev_canceled(Some(venue_order_id())), PAYLOAD_TYPE_ORDER_CANCELED, true)]
2378 #[case::expired(ev_expired(Some(venue_order_id())), PAYLOAD_TYPE_ORDER_EXPIRED, true)]
2379 #[case::triggered(
2380 ev_triggered(Some(venue_order_id())),
2381 PAYLOAD_TYPE_ORDER_TRIGGERED,
2382 true
2383 )]
2384 #[case::pending_update(
2385 ev_pending_update(Some(venue_order_id())),
2386 PAYLOAD_TYPE_ORDER_PENDING_UPDATE,
2387 true
2388 )]
2389 #[case::pending_cancel(
2390 ev_pending_cancel(Some(venue_order_id())),
2391 PAYLOAD_TYPE_ORDER_PENDING_CANCEL,
2392 true
2393 )]
2394 #[case::modify_denied(
2395 ev_modify_denied(Some(venue_order_id())),
2396 PAYLOAD_TYPE_ORDER_MODIFY_DENIED,
2397 true
2398 )]
2399 #[case::modify_rejected(
2400 ev_modify_rejected(Some(venue_order_id())),
2401 PAYLOAD_TYPE_ORDER_MODIFY_REJECTED,
2402 true
2403 )]
2404 #[case::cancel_denied(
2405 ev_cancel_denied(Some(venue_order_id())),
2406 PAYLOAD_TYPE_ORDER_CANCEL_DENIED,
2407 true
2408 )]
2409 #[case::cancel_rejected(
2410 ev_cancel_rejected(Some(venue_order_id())),
2411 PAYLOAD_TYPE_ORDER_CANCEL_REJECTED,
2412 true
2413 )]
2414 #[case::updated(ev_updated(Some(venue_order_id())), PAYLOAD_TYPE_ORDER_UPDATED, true)]
2415 #[case::filled(ev_filled(), PAYLOAD_TYPE_ORDER_FILLED, true)]
2416 #[case::fill_voided(ev_fill_voided(), PAYLOAD_TYPE_ORDER_FILL_VOIDED, true)]
2417 fn order_event_any_envelope_stamps_inner_tag_for_every_variant(
2418 #[case] event: OrderEventAny,
2419 #[case] expected_tag: &str,
2420 #[case] expects_venue_index: bool,
2421 ) {
2422 let encoded = encode_order_event_any(&event).expect("encode");
2423 let tag = encoded.payload_type.expect("override").as_str().to_string();
2424
2425 assert_eq!(tag, expected_tag);
2426 assert_ne!(
2427 tag, PAYLOAD_TYPE_ORDER_EVENT_ANY,
2428 "wrapper fallback tag must never reach the writer",
2429 );
2430 assert_eq!(
2431 encoded.index_keys[0].kind,
2432 IndexKind::ClientOrderId,
2433 "first index must always be ClientOrderId for every order event",
2434 );
2435 assert_eq!(encoded.index_keys[0].key, client_order_id().to_string(),);
2436 if expects_venue_index {
2437 assert_eq!(encoded.index_keys.len(), 2);
2438 assert_eq!(encoded.index_keys[1].kind, IndexKind::VenueOrderId);
2439 } else {
2440 assert_eq!(encoded.index_keys.len(), 1);
2441 }
2442 }
2443
2444 #[rstest]
2447 #[case::cancel_order_some(TradingCommand::CancelOrder(make_cancel_order()), 2)]
2448 #[case::cancel_order_none(
2449 TradingCommand::CancelOrder(CancelOrder {
2450 venue_order_id: None,
2451 ..make_cancel_order()
2452 }),
2453 1,
2454 )]
2455 #[case::modify_order_some(
2456 TradingCommand::ModifyOrder(make_modify_order(Some(venue_order_id()))),
2457 2
2458 )]
2459 #[case::modify_order_none(TradingCommand::ModifyOrder(make_modify_order(None)), 1)]
2460 #[case::batch_modify_orders(
2461 TradingCommand::ModifyOrders(make_batch_modify_orders(vec![
2462 make_modify_order(Some(venue_order_id())),
2463 make_modify_order(None),
2464 ])),
2465 3,
2466 )]
2467 #[case::query_order_some(
2468 TradingCommand::QueryOrder(make_query_order(Some(venue_order_id()))),
2469 2
2470 )]
2471 #[case::query_order_none(TradingCommand::QueryOrder(make_query_order(None)), 1)]
2472 fn trading_command_envelope_index_count_matches_venue_optionality(
2473 #[case] command: TradingCommand,
2474 #[case] expected_index_count: usize,
2475 ) {
2476 let encoded = encode_trading_command(&command).expect("encode");
2477 assert_eq!(encoded.index_keys.len(), expected_index_count);
2478 assert_eq!(encoded.index_keys[0].kind, IndexKind::ClientOrderId);
2479 if expected_index_count == 2 {
2480 assert_eq!(encoded.index_keys[1].kind, IndexKind::VenueOrderId);
2481 }
2482 }
2483
2484 #[rstest]
2485 #[case::canceled_some(ev_canceled(Some(venue_order_id())), 2)]
2486 #[case::canceled_none(ev_canceled(None), 1)]
2487 #[case::updated_some(ev_updated(Some(venue_order_id())), 2)]
2488 #[case::updated_none(ev_updated(None), 1)]
2489 #[case::pending_update_some(ev_pending_update(Some(venue_order_id())), 2)]
2490 #[case::pending_update_none(ev_pending_update(None), 1)]
2491 fn order_event_any_envelope_index_count_matches_venue_optionality(
2492 #[case] event: OrderEventAny,
2493 #[case] expected_index_count: usize,
2494 ) {
2495 let encoded = encode_order_event_any(&event).expect("encode");
2496 assert_eq!(encoded.index_keys.len(), expected_index_count);
2497 }
2498
2499 #[rstest]
2500 fn batch_cancel_orders_envelope_indexes_each_child_with_optional_venue() {
2501 let with_venue = make_cancel_order();
2505 let mut without_venue = make_cancel_order();
2506 without_venue.venue_order_id = None;
2507 without_venue.client_order_id = ClientOrderId::from("O-NOVENUE");
2508 let batch = make_batch_cancel_orders(vec![with_venue.clone(), without_venue.clone()]);
2509
2510 let encoded = encode_trading_command(&TradingCommand::CancelOrders(batch)).expect("encode");
2511
2512 assert_eq!(
2513 encoded.payload_type.expect("override").as_str(),
2514 PAYLOAD_TYPE_BATCH_CANCEL_ORDERS,
2515 );
2516 assert_eq!(encoded.index_keys.len(), 3);
2517 assert_eq!(encoded.index_keys[0].kind, IndexKind::ClientOrderId);
2518 assert_eq!(
2519 encoded.index_keys[0].key,
2520 with_venue.client_order_id.to_string(),
2521 );
2522 assert_eq!(encoded.index_keys[1].kind, IndexKind::VenueOrderId);
2523 assert_eq!(
2524 encoded.index_keys[1].key,
2525 with_venue.venue_order_id.expect("set").to_string(),
2526 );
2527 assert_eq!(encoded.index_keys[2].kind, IndexKind::ClientOrderId);
2528 assert_eq!(
2529 encoded.index_keys[2].key,
2530 without_venue.client_order_id.to_string(),
2531 );
2532 }
2533
2534 #[rstest]
2535 fn batch_modify_orders_envelope_indexes_each_child_with_optional_venue() {
2536 let with_venue = make_modify_order(Some(venue_order_id()));
2537 let mut without_venue = make_modify_order(None);
2538 without_venue.client_order_id = ClientOrderId::from("O-NOVENUE");
2539 let batch = make_batch_modify_orders(vec![with_venue.clone(), without_venue.clone()]);
2540
2541 let encoded = encode_trading_command(&TradingCommand::ModifyOrders(batch)).expect("encode");
2542
2543 assert_eq!(
2544 encoded.payload_type.expect("override").as_str(),
2545 PAYLOAD_TYPE_BATCH_MODIFY_ORDERS,
2546 );
2547 assert_eq!(encoded.index_keys.len(), 3);
2548 assert_eq!(encoded.index_keys[0].kind, IndexKind::ClientOrderId);
2549 assert_eq!(
2550 encoded.index_keys[0].key,
2551 with_venue.client_order_id.to_string(),
2552 );
2553 assert_eq!(encoded.index_keys[1].kind, IndexKind::VenueOrderId);
2554 assert_eq!(
2555 encoded.index_keys[1].key,
2556 with_venue.venue_order_id.expect("set").to_string(),
2557 );
2558 assert_eq!(encoded.index_keys[2].kind, IndexKind::ClientOrderId);
2559 assert_eq!(
2560 encoded.index_keys[2].key,
2561 without_venue.client_order_id.to_string(),
2562 );
2563 }
2564
2565 #[rstest]
2566 fn submit_order_list_envelope_indexes_each_client_order_id() {
2567 let ids = vec![
2571 ClientOrderId::from("O-LIST-1"),
2572 ClientOrderId::from("O-LIST-2"),
2573 ClientOrderId::from("O-LIST-3"),
2574 ];
2575 let cmd = make_submit_order_list(ids.clone());
2576 let encoded =
2577 encode_trading_command(&TradingCommand::SubmitOrderList(cmd)).expect("encode");
2578
2579 assert_eq!(
2580 encoded.payload_type.expect("override").as_str(),
2581 PAYLOAD_TYPE_SUBMIT_ORDER_LIST,
2582 );
2583 assert_eq!(encoded.index_keys.len(), ids.len());
2584 for (idx, expected_id) in ids.iter().enumerate() {
2585 assert_eq!(encoded.index_keys[idx].kind, IndexKind::ClientOrderId);
2586 assert_eq!(encoded.index_keys[idx].key, expected_id.to_string());
2587 }
2588 }
2589
2590 fn make_fill_report() -> FillReport {
2591 FillReport::new(
2592 AccountId::from("BINANCE-001"),
2593 instrument_id(),
2594 venue_order_id(),
2595 TradeId::from("T-1111"),
2596 OrderSide::Buy,
2597 Quantity::from("1"),
2598 Price::from("100.00"),
2599 Money::new(0.10, Currency::USDT()),
2600 LiquiditySide::Taker,
2601 Some(client_order_id()),
2602 None,
2603 UnixNanos::from(40),
2604 UnixNanos::from(41),
2605 None,
2606 )
2607 }
2608
2609 fn make_position_status_report() -> PositionStatusReport {
2610 PositionStatusReport::new(
2611 AccountId::from("BINANCE-001"),
2612 instrument_id(),
2613 PositionSide::Long,
2614 Quantity::from("1"),
2615 UnixNanos::from(50),
2616 UnixNanos::from(51),
2617 None,
2618 Some(PositionId::from("P-001")),
2619 None,
2620 )
2621 }
2622
2623 fn make_execution_mass_status_with_reports() -> ExecutionMassStatus {
2624 let mut status = ExecutionMassStatus::new(
2625 ClientId::from("BINANCE"),
2626 AccountId::from("BINANCE-001"),
2627 Venue::from("BINANCE"),
2628 UnixNanos::from(60),
2629 None,
2630 );
2631 status.add_order_reports(vec![make_order_status_report()]);
2632 status.add_fill_reports(vec![make_fill_report()]);
2633 status.add_position_reports(vec![make_position_status_report()]);
2634 status
2635 }
2636
2637 #[rstest]
2638 fn execution_report_order_envelope_reuses_bare_status_encoder() {
2639 let report = make_order_status_report();
2644 let bare = encode_order_status_report(&report).expect("bare");
2645
2646 let envelope = ExecutionReport::Order(Box::new(report));
2647 let wrapped = encode_execution_report(&envelope).expect("envelope");
2648
2649 assert_eq!(wrapped.payload, bare.payload);
2650 assert_eq!(wrapped.index_keys, bare.index_keys);
2651 assert_eq!(
2652 wrapped.payload_type.expect("override").as_str(),
2653 PAYLOAD_TYPE_ORDER_STATUS_REPORT,
2654 );
2655 }
2656
2657 #[rstest]
2658 fn execution_report_fill_envelope_emits_venue_and_client_order_id_indices() {
2659 let fill = make_fill_report();
2660 let envelope = ExecutionReport::Fill(Box::new(fill.clone()));
2661 let encoded = encode_execution_report(&envelope).expect("encode");
2662
2663 assert_eq!(
2664 encoded.payload_type.expect("override").as_str(),
2665 PAYLOAD_TYPE_FILL_REPORT,
2666 );
2667 assert_eq!(encoded.index_keys.len(), 2);
2668 assert_eq!(encoded.index_keys[0].kind, IndexKind::VenueOrderId);
2669 assert_eq!(encoded.index_keys[0].key, fill.venue_order_id.to_string());
2670 assert_eq!(encoded.index_keys[1].kind, IndexKind::ClientOrderId);
2671 assert_eq!(
2672 encoded.index_keys[1].key,
2673 fill.client_order_id.expect("set").to_string(),
2674 );
2675
2676 let decoded: FillReport = rmp_serde::from_slice(&encoded.payload).expect("decode");
2677 assert_eq!(decoded, fill);
2678 }
2679
2680 #[rstest]
2681 fn execution_report_fill_envelope_omits_client_order_id_when_absent() {
2682 let mut fill = make_fill_report();
2683 fill.client_order_id = None;
2684 let envelope = ExecutionReport::Fill(Box::new(fill));
2685 let encoded = encode_execution_report(&envelope).expect("encode");
2686
2687 assert_eq!(encoded.index_keys.len(), 1);
2688 assert_eq!(encoded.index_keys[0].kind, IndexKind::VenueOrderId);
2689 }
2690
2691 #[rstest]
2692 fn execution_report_position_envelope_records_no_indices() {
2693 let position = make_position_status_report();
2697 let envelope = ExecutionReport::Position(Box::new(position.clone()));
2698 let encoded = encode_execution_report(&envelope).expect("encode");
2699
2700 assert_eq!(
2701 encoded.payload_type.expect("override").as_str(),
2702 PAYLOAD_TYPE_POSITION_STATUS_REPORT,
2703 );
2704 assert!(encoded.index_keys.is_empty());
2705
2706 let decoded: PositionStatusReport =
2707 rmp_serde::from_slice(&encoded.payload).expect("decode");
2708 assert_eq!(decoded, position);
2709 }
2710
2711 #[rstest]
2712 fn execution_report_order_with_fills_envelope_dedupes_shared_order_ids() {
2713 let order = make_order_status_report();
2717 let fills = vec![make_fill_report()];
2718 let envelope = ExecutionReport::OrderWithFills(Box::new(order.clone()), fills);
2719 let encoded = encode_execution_report(&envelope).expect("encode");
2720
2721 assert_eq!(
2722 encoded.payload_type.expect("override").as_str(),
2723 PAYLOAD_TYPE_ORDER_WITH_FILLS,
2724 );
2725 assert_eq!(encoded.index_keys.len(), 2);
2726 assert_eq!(encoded.index_keys[0].kind, IndexKind::VenueOrderId);
2727 assert_eq!(encoded.index_keys[0].key, order.venue_order_id.to_string());
2728 assert_eq!(encoded.index_keys[1].kind, IndexKind::ClientOrderId);
2729 assert_eq!(
2730 encoded.index_keys[1].key,
2731 order.client_order_id.expect("set").to_string(),
2732 );
2733 }
2734
2735 #[rstest]
2736 fn execution_report_order_with_fills_envelope_indexes_distinct_fill_ids() {
2737 let order = make_order_status_report();
2742 let mut fill = make_fill_report();
2743 fill.client_order_id = Some(ClientOrderId::from("O-EXTRA-001"));
2744 let envelope = ExecutionReport::OrderWithFills(Box::new(order), vec![fill.clone()]);
2745 let encoded = encode_execution_report(&envelope).expect("encode");
2746
2747 assert_eq!(encoded.index_keys.len(), 3);
2748 assert_eq!(encoded.index_keys[2].kind, IndexKind::ClientOrderId);
2749 assert_eq!(
2750 encoded.index_keys[2].key,
2751 fill.client_order_id.expect("set").to_string(),
2752 );
2753 }
2754
2755 #[rstest]
2756 fn execution_report_order_with_fills_payload_round_trips() {
2757 #[derive(serde::Deserialize)]
2758 struct OrderWithFillsOwned {
2759 order_report: OrderStatusReport,
2760 fill_reports: Vec<FillReport>,
2761 }
2762
2763 let order = make_order_status_report();
2764 let fills = vec![make_fill_report()];
2765 let envelope = ExecutionReport::OrderWithFills(Box::new(order.clone()), fills.clone());
2766 let encoded = encode_execution_report(&envelope).expect("encode");
2767
2768 let decoded: OrderWithFillsOwned = rmp_serde::from_slice(&encoded.payload).expect("decode");
2769 assert_eq!(decoded.order_report, order);
2770 assert_eq!(decoded.fill_reports, fills);
2771 }
2772
2773 #[rstest]
2774 fn execution_report_mass_status_envelope_indexes_orders_and_fills() {
2775 let status = make_execution_mass_status_with_reports();
2776 let envelope = ExecutionReport::MassStatus(Box::new(status.clone()));
2777 let encoded = encode_execution_report(&envelope).expect("encode");
2778
2779 assert_eq!(
2780 encoded.payload_type.expect("override").as_str(),
2781 PAYLOAD_TYPE_EXECUTION_MASS_STATUS,
2782 );
2783 assert_eq!(encoded.index_keys.len(), 2);
2786 assert_eq!(encoded.index_keys[0].kind, IndexKind::VenueOrderId);
2787 assert_eq!(encoded.index_keys[0].key, venue_order_id().to_string());
2788 assert_eq!(encoded.index_keys[1].kind, IndexKind::ClientOrderId);
2789 assert_eq!(encoded.index_keys[1].key, client_order_id().to_string());
2790
2791 let decoded: ExecutionMassStatus = rmp_serde::from_slice(&encoded.payload).expect("decode");
2792 assert_eq!(decoded, status);
2793 }
2794
2795 #[rstest]
2796 fn execution_report_mass_status_envelope_indexes_distinct_children() {
2797 let mut status = ExecutionMassStatus::new(
2801 ClientId::from("BINANCE"),
2802 AccountId::from("BINANCE-001"),
2803 Venue::from("BINANCE"),
2804 UnixNanos::from(60),
2805 None,
2806 );
2807 let order_a = make_order_status_report();
2808 let order_b = OrderStatusReport {
2809 client_order_id: Some(ClientOrderId::from("O-B")),
2810 venue_order_id: VenueOrderId::from("V-B"),
2811 ..make_order_status_report()
2812 };
2813 let fill_c = FillReport {
2814 venue_order_id: VenueOrderId::from("V-C"),
2815 client_order_id: Some(ClientOrderId::from("O-C")),
2816 ..make_fill_report()
2817 };
2818 status.add_order_reports(vec![order_a, order_b]);
2819 status.add_fill_reports(vec![fill_c]);
2820
2821 let encoded = encode_execution_report(&ExecutionReport::MassStatus(Box::new(status)))
2822 .expect("encode");
2823
2824 assert_eq!(encoded.index_keys.len(), 6);
2826 let venue_keys: Vec<&str> = encoded
2827 .index_keys
2828 .iter()
2829 .filter(|k| k.kind == IndexKind::VenueOrderId)
2830 .map(|k| k.key.as_str())
2831 .collect();
2832 let client_keys: Vec<&str> = encoded
2833 .index_keys
2834 .iter()
2835 .filter(|k| k.kind == IndexKind::ClientOrderId)
2836 .map(|k| k.key.as_str())
2837 .collect();
2838 assert!(venue_keys.contains(&venue_order_id().to_string().as_str()));
2839 assert!(venue_keys.contains(&"V-B"));
2840 assert!(venue_keys.contains(&"V-C"));
2841 assert!(client_keys.contains(&client_order_id().to_string().as_str()));
2842 assert!(client_keys.contains(&"O-B"));
2843 assert!(client_keys.contains(&"O-C"));
2844 }
2845
2846 #[rstest]
2850 #[case::order(
2851 ExecutionReport::Order(Box::new(make_order_status_report())),
2852 PAYLOAD_TYPE_ORDER_STATUS_REPORT
2853 )]
2854 #[case::fill(
2855 ExecutionReport::Fill(Box::new(make_fill_report())),
2856 PAYLOAD_TYPE_FILL_REPORT
2857 )]
2858 #[case::order_with_fills(
2859 ExecutionReport::OrderWithFills(
2860 Box::new(make_order_status_report()),
2861 vec![make_fill_report()],
2862 ),
2863 PAYLOAD_TYPE_ORDER_WITH_FILLS,
2864 )]
2865 #[case::position(
2866 ExecutionReport::Position(Box::new(make_position_status_report())),
2867 PAYLOAD_TYPE_POSITION_STATUS_REPORT
2868 )]
2869 #[case::mass_status(
2870 ExecutionReport::MassStatus(Box::new(make_execution_mass_status_with_reports())),
2871 PAYLOAD_TYPE_EXECUTION_MASS_STATUS
2872 )]
2873 fn execution_report_envelope_stamps_inner_tag_for_every_variant(
2874 #[case] report: ExecutionReport,
2875 #[case] expected_tag: &str,
2876 ) {
2877 let encoded = encode_execution_report(&report).expect("encode");
2878 let tag = encoded.payload_type.expect("override").as_str().to_string();
2879
2880 assert_eq!(tag, expected_tag);
2881 assert_ne!(
2882 tag, PAYLOAD_TYPE_EXECUTION_REPORT,
2883 "wrapper fallback tag must never reach the writer",
2884 );
2885 }
2886
2887 fn opening_order_id() -> ClientOrderId {
2888 ClientOrderId::from("O-OPEN-001")
2889 }
2890
2891 fn closing_order_id() -> ClientOrderId {
2892 ClientOrderId::from("O-CLOSE-001")
2893 }
2894
2895 fn position_id() -> PositionId {
2896 PositionId::from("P-001")
2897 }
2898
2899 fn make_position_opened() -> PositionOpened {
2900 PositionOpened {
2901 trader_id: trader_id(),
2902 strategy_id: strategy_id(),
2903 instrument_id: instrument_id(),
2904 position_id: position_id(),
2905 account_id: AccountId::from("BINANCE-001"),
2906 opening_order_id: opening_order_id(),
2907 entry: OrderSide::Buy,
2908 side: PositionSide::Long,
2909 signed_qty: 1.into(),
2910 quantity: Quantity::from("1"),
2911 last_qty: Quantity::from("1"),
2912 last_px: Price::from("100.00"),
2913 currency: Currency::USDT(),
2914 avg_px_open: 100.into(),
2915 realized_pnl: Some(Money::new(-0.1, Currency::USDT())),
2916 event_id: UUID4::new(),
2917 ts_event: UnixNanos::from(70),
2918 ts_init: UnixNanos::from(71),
2919 }
2920 }
2921
2922 fn make_position_changed() -> PositionChanged {
2923 PositionChanged {
2924 trader_id: trader_id(),
2925 strategy_id: strategy_id(),
2926 instrument_id: instrument_id(),
2927 position_id: position_id(),
2928 account_id: AccountId::from("BINANCE-001"),
2929 opening_order_id: opening_order_id(),
2930 entry: OrderSide::Buy,
2931 side: PositionSide::Long,
2932 signed_qty: 2.into(),
2933 quantity: Quantity::from("2"),
2934 peak_quantity: Quantity::from("2"),
2935 last_qty: Quantity::from("1"),
2936 last_px: Price::from("101.00"),
2937 currency: Currency::USDT(),
2938 avg_px_open: "100.5".parse().unwrap(),
2939 avg_px_close: None,
2940 realized_return: 0.0,
2941 realized_pnl: None,
2942 unrealized_pnl: Money::new(1.0, Currency::USDT()),
2943 event_id: UUID4::new(),
2944 ts_opened: UnixNanos::from(70),
2945 ts_event: UnixNanos::from(80),
2946 ts_init: UnixNanos::from(81),
2947 }
2948 }
2949
2950 fn make_position_closed() -> PositionClosed {
2951 PositionClosed {
2952 trader_id: trader_id(),
2953 strategy_id: strategy_id(),
2954 instrument_id: instrument_id(),
2955 position_id: position_id(),
2956 account_id: AccountId::from("BINANCE-001"),
2957 opening_order_id: opening_order_id(),
2958 closing_order_id: Some(closing_order_id()),
2959 entry: OrderSide::Buy,
2960 side: PositionSide::Flat,
2961 signed_qty: 0.into(),
2962 quantity: Quantity::from("0"),
2963 peak_quantity: Quantity::from("2"),
2964 last_qty: Quantity::from("2"),
2965 last_px: Price::from("102.00"),
2966 currency: Currency::USDT(),
2967 avg_px_open: "100.5".parse().unwrap(),
2968 avg_px_close: Some(102.into()),
2969 realized_return: 0.015,
2970 realized_pnl: Some(Money::new(3.0, Currency::USDT())),
2971 unrealized_pnl: Money::new(0.0, Currency::USDT()),
2972 duration: DurationNanos::from_hours(1),
2973 event_id: UUID4::new(),
2974 ts_opened: UnixNanos::from(70),
2975 ts_closed: Some(UnixNanos::from(90)),
2976 ts_event: UnixNanos::from(90),
2977 ts_init: UnixNanos::from(91),
2978 }
2979 }
2980
2981 fn make_position_adjusted() -> PositionAdjusted {
2982 PositionAdjusted::new(
2983 trader_id(),
2984 strategy_id(),
2985 instrument_id(),
2986 position_id(),
2987 AccountId::from("BINANCE-001"),
2988 PositionAdjustmentType::Commission,
2989 None,
2990 None,
2991 None,
2992 UUID4::new(),
2993 UnixNanos::from(100),
2994 UnixNanos::from(101),
2995 )
2996 }
2997
2998 #[rstest]
2999 fn position_event_opened_envelope_emits_opening_order_id_index() {
3000 let opened = make_position_opened();
3001 let envelope = PositionEvent::PositionOpened(opened.clone());
3002 let encoded = encode_position_event(&envelope).expect("encode");
3003
3004 assert_eq!(
3005 encoded.payload_type.expect("override").as_str(),
3006 PAYLOAD_TYPE_POSITION_OPENED,
3007 );
3008 assert_eq!(encoded.index_keys.len(), 1);
3009 assert_eq!(encoded.index_keys[0].kind, IndexKind::ClientOrderId);
3010 assert_eq!(
3011 encoded.index_keys[0].key,
3012 opened.opening_order_id.to_string(),
3013 );
3014
3015 let decoded: PositionOpened = rmp_serde::from_slice(&encoded.payload).expect("decode");
3016 assert_eq!(decoded, opened);
3017 }
3018
3019 #[rstest]
3020 fn position_event_changed_envelope_emits_opening_order_id_index() {
3021 let changed = make_position_changed();
3022 let envelope = PositionEvent::PositionChanged(changed.clone());
3023 let encoded = encode_position_event(&envelope).expect("encode");
3024
3025 assert_eq!(
3026 encoded.payload_type.expect("override").as_str(),
3027 PAYLOAD_TYPE_POSITION_CHANGED,
3028 );
3029 assert_eq!(encoded.index_keys.len(), 1);
3030 assert_eq!(encoded.index_keys[0].kind, IndexKind::ClientOrderId);
3031 assert_eq!(
3032 encoded.index_keys[0].key,
3033 changed.opening_order_id.to_string(),
3034 );
3035
3036 let decoded: PositionChanged = rmp_serde::from_slice(&encoded.payload).expect("decode");
3037 assert_eq!(decoded, changed);
3038 }
3039
3040 #[rstest]
3041 fn position_event_closed_envelope_indexes_both_opening_and_closing_order_ids() {
3042 let closed = make_position_closed();
3043 let envelope = PositionEvent::PositionClosed(closed.clone());
3044 let encoded = encode_position_event(&envelope).expect("encode");
3045
3046 assert_eq!(
3047 encoded.payload_type.expect("override").as_str(),
3048 PAYLOAD_TYPE_POSITION_CLOSED,
3049 );
3050 assert_eq!(encoded.index_keys.len(), 2);
3051 assert_eq!(encoded.index_keys[0].kind, IndexKind::ClientOrderId);
3052 assert_eq!(
3053 encoded.index_keys[0].key,
3054 closed.opening_order_id.to_string(),
3055 );
3056 assert_eq!(encoded.index_keys[1].kind, IndexKind::ClientOrderId);
3057 assert_eq!(
3058 encoded.index_keys[1].key,
3059 closed.closing_order_id.expect("set").to_string(),
3060 );
3061
3062 let decoded: PositionClosed = rmp_serde::from_slice(&encoded.payload).expect("decode");
3063 assert_eq!(decoded, closed);
3064 }
3065
3066 #[rstest]
3067 fn position_event_closed_envelope_omits_closing_order_id_when_absent() {
3068 let mut closed = make_position_closed();
3069 closed.closing_order_id = None;
3070 let envelope = PositionEvent::PositionClosed(closed);
3071 let encoded = encode_position_event(&envelope).expect("encode");
3072
3073 assert_eq!(encoded.index_keys.len(), 1);
3074 assert_eq!(encoded.index_keys[0].kind, IndexKind::ClientOrderId);
3075 assert_eq!(encoded.index_keys[0].key, opening_order_id().to_string());
3076 }
3077
3078 #[rstest]
3079 fn position_event_closed_envelope_dedupes_when_open_and_close_match() {
3080 let mut closed = make_position_closed();
3084 closed.closing_order_id = Some(closed.opening_order_id);
3085 let envelope = PositionEvent::PositionClosed(closed);
3086 let encoded = encode_position_event(&envelope).expect("encode");
3087
3088 assert_eq!(encoded.index_keys.len(), 1);
3089 assert_eq!(encoded.index_keys[0].key, opening_order_id().to_string());
3090 }
3091
3092 #[rstest]
3093 fn position_event_adjusted_envelope_records_no_indices() {
3094 let adjusted = make_position_adjusted();
3099 let envelope = PositionEvent::PositionAdjusted(adjusted);
3100 let encoded = encode_position_event(&envelope).expect("encode");
3101
3102 assert_eq!(
3103 encoded.payload_type.expect("override").as_str(),
3104 PAYLOAD_TYPE_POSITION_ADJUSTED,
3105 );
3106 assert!(encoded.index_keys.is_empty());
3107
3108 let decoded: PositionAdjusted = rmp_serde::from_slice(&encoded.payload).expect("decode");
3109 assert_eq!(decoded, adjusted);
3110 }
3111
3112 #[rstest]
3113 #[case::opened(
3114 PositionEvent::PositionOpened(make_position_opened()),
3115 PAYLOAD_TYPE_POSITION_OPENED
3116 )]
3117 #[case::changed(
3118 PositionEvent::PositionChanged(make_position_changed()),
3119 PAYLOAD_TYPE_POSITION_CHANGED
3120 )]
3121 #[case::closed(
3122 PositionEvent::PositionClosed(make_position_closed()),
3123 PAYLOAD_TYPE_POSITION_CLOSED
3124 )]
3125 #[case::adjusted(
3126 PositionEvent::PositionAdjusted(make_position_adjusted()),
3127 PAYLOAD_TYPE_POSITION_ADJUSTED
3128 )]
3129 fn position_event_envelope_stamps_inner_tag_for_every_variant(
3130 #[case] event: PositionEvent,
3131 #[case] expected_tag: &str,
3132 ) {
3133 let encoded = encode_position_event(&event).expect("encode");
3134 let tag = encoded.payload_type.expect("override").as_str().to_string();
3135
3136 assert_eq!(tag, expected_tag);
3137 assert_ne!(
3138 tag, PAYLOAD_TYPE_POSITION_EVENT,
3139 "wrapper fallback tag must never reach the writer",
3140 );
3141 }
3142
3143 fn make_account_state() -> AccountState {
3144 AccountState::new(
3145 AccountId::from("BINANCE-001"),
3146 AccountType::Cash,
3147 vec![AccountBalance::new(
3148 Money::from("1000000 USD"),
3149 Money::from("0 USD"),
3150 Money::from("1000000 USD"),
3151 )],
3152 vec![],
3153 true,
3154 UUID4::new(),
3155 UnixNanos::from(110),
3156 UnixNanos::from(111),
3157 Some(Currency::USD()),
3158 )
3159 }
3160
3161 #[rstest]
3162 fn account_state_encoder_records_no_indices() {
3163 let state = make_account_state();
3168 let encoded = encode_account_state(&state).expect("encode");
3169
3170 assert!(!encoded.payload.is_empty());
3171 assert!(encoded.index_keys.is_empty());
3172 assert!(
3173 encoded.payload_type.is_none(),
3174 "bare-type encoders inherit the registry's registered tag",
3175 );
3176 }
3177
3178 #[rstest]
3179 fn account_state_payload_round_trips_through_msgpack() {
3180 let state = make_account_state();
3181 let encoded = encode_account_state(&state).expect("encode");
3182
3183 let decoded: AccountState = rmp_serde::from_slice(&encoded.payload).expect("decode");
3184 assert_eq!(decoded, state);
3185 }
3186
3187 #[rstest]
3188 fn account_state_registered_under_canonical_payload_type() {
3189 let registry = default_registry();
3193 let state = make_account_state();
3194 let (tag, encoded) = registry
3195 .encode(&state)
3196 .expect("encode")
3197 .expect("registered");
3198
3199 assert_eq!(tag.as_str(), PAYLOAD_TYPE_ACCOUNT_STATE);
3200 assert!(encoded.index_keys.is_empty());
3201 }
3202
3203 #[rstest]
3204 fn instrument_close_registered_under_canonical_payload_type() {
3205 let registry = default_registry();
3206
3207 let close = InstrumentClose::new(
3208 InstrumentId::from("TOKEN-YES.POLYMARKET"),
3209 Price::from("1.000"),
3210 InstrumentCloseType::ContractExpired,
3211 UnixNanos::from(300),
3212 UnixNanos::from(301),
3213 );
3214
3215 let (tag, encoded) = registry
3216 .encode(&close)
3217 .expect("encode")
3218 .expect("registered");
3219 let decoded: InstrumentClose = rmp_serde::from_slice(&encoded.payload).expect("decode");
3220
3221 assert_eq!(tag.as_str(), PAYLOAD_TYPE_INSTRUMENT_CLOSE);
3222 assert!(encoded.index_keys.is_empty());
3223 assert_eq!(decoded, close);
3224 }
3225
3226 #[derive(Debug, Deserialize, PartialEq, Eq)]
3227 struct DecodedTimeEventPayload {
3228 name: String,
3229 event_id: UUID4,
3230 ts_event: UnixNanos,
3231 ts_init: UnixNanos,
3232 }
3233
3234 #[rstest]
3235 fn time_event_payload_round_trips_through_msgpack() {
3236 let event = TimeEvent::new(
3237 Ustr::from("heartbeat"),
3238 UUID4::new(),
3239 UnixNanos::from(100),
3240 UnixNanos::from(99),
3241 );
3242 let encoded = encode_time_event(&event).expect("encode");
3243
3244 let decoded: DecodedTimeEventPayload =
3245 rmp_serde::from_slice(&encoded.payload).expect("decode");
3246 assert_eq!(
3247 decoded,
3248 DecodedTimeEventPayload {
3249 name: event.name.to_string(),
3250 event_id: event.event_id,
3251 ts_event: event.ts_event,
3252 ts_init: event.ts_init,
3253 },
3254 );
3255 assert!(encoded.index_keys.is_empty());
3256 }
3257
3258 #[rstest]
3259 fn time_event_registered_under_canonical_payload_type() {
3260 let registry = default_registry();
3261 let event = TimeEvent::new(
3262 Ustr::from("heartbeat"),
3263 UUID4::new(),
3264 UnixNanos::from(100),
3265 UnixNanos::from(99),
3266 );
3267 let (tag, encoded) = registry
3268 .encode(&event)
3269 .expect("encode")
3270 .expect("registered");
3271
3272 assert_eq!(tag.as_str(), PAYLOAD_TYPE_TIME_EVENT);
3273 assert!(encoded.index_keys.is_empty());
3274 }
3275
3276 #[rstest]
3277 fn data_command_request_envelope_stamps_request_command_payload_type() {
3278 let request = make_request_command();
3282 let envelope = DataCommand::Request(request.clone());
3283 let encoded = encode_data_command(&envelope).expect("encode");
3284
3285 assert_eq!(
3286 encoded.payload_type.expect("override").as_str(),
3287 PAYLOAD_TYPE_REQUEST_COMMAND,
3288 );
3289 assert!(encoded.index_keys.is_empty());
3290
3291 let decoded: RequestCommand = rmp_serde::from_slice(&encoded.payload).expect("decode");
3292 match (decoded, request) {
3293 (RequestCommand::Quotes(decoded), RequestCommand::Quotes(expected)) => {
3294 assert_eq!(decoded.request_id, expected.request_id);
3295 assert_eq!(decoded.instrument_ids, expected.instrument_ids);
3296 }
3297 other => panic!("expected RequestCommand::Quotes round trip, was {other:?}"),
3298 }
3299 }
3300
3301 #[rstest]
3302 fn data_command_subscribe_envelope_stamps_subscribe_command_payload_type() {
3303 let subscribe = make_subscribe_command();
3304 let envelope = DataCommand::Subscribe(subscribe.clone());
3305 let encoded = encode_data_command(&envelope).expect("encode");
3306
3307 assert_eq!(
3308 encoded.payload_type.expect("override").as_str(),
3309 PAYLOAD_TYPE_SUBSCRIBE_COMMAND,
3310 );
3311 assert!(encoded.index_keys.is_empty());
3312
3313 let decoded: SubscribeCommand = rmp_serde::from_slice(&encoded.payload).expect("decode");
3314 match (decoded, subscribe) {
3315 (SubscribeCommand::Quotes(decoded), SubscribeCommand::Quotes(expected)) => {
3316 assert_eq!(decoded.command_id, expected.command_id);
3317 assert_eq!(decoded.instrument_ids, expected.instrument_ids);
3318 }
3319 other => panic!("expected SubscribeCommand::Quotes round trip, was {other:?}"),
3320 }
3321 }
3322
3323 #[rstest]
3324 fn data_command_unsubscribe_envelope_stamps_unsubscribe_command_payload_type() {
3325 let unsubscribe = make_unsubscribe_command();
3326 let envelope = DataCommand::Unsubscribe(unsubscribe.clone());
3327 let encoded = encode_data_command(&envelope).expect("encode");
3328
3329 assert_eq!(
3330 encoded.payload_type.expect("override").as_str(),
3331 PAYLOAD_TYPE_UNSUBSCRIBE_COMMAND,
3332 );
3333 assert!(encoded.index_keys.is_empty());
3334
3335 let decoded: UnsubscribeCommand = rmp_serde::from_slice(&encoded.payload).expect("decode");
3336 match (decoded, unsubscribe) {
3337 (UnsubscribeCommand::Quotes(decoded), UnsubscribeCommand::Quotes(expected)) => {
3338 assert_eq!(decoded.command_id, expected.command_id);
3339 assert_eq!(decoded.instrument_ids, expected.instrument_ids);
3340 }
3341 other => panic!("expected UnsubscribeCommand::Quotes round trip, was {other:?}"),
3342 }
3343 }
3344
3345 #[rstest]
3346 fn data_command_registered_under_category_payload_type() {
3347 let registry = default_registry();
3350 let envelope = DataCommand::Subscribe(make_subscribe_command());
3351 let (tag, encoded) = registry
3352 .encode(&envelope)
3353 .expect("encode")
3354 .expect("registered");
3355
3356 assert_eq!(tag.as_str(), PAYLOAD_TYPE_SUBSCRIBE_COMMAND);
3357 assert!(encoded.index_keys.is_empty());
3358 }
3359
3360 #[cfg(feature = "defi")]
3361 #[rstest]
3362 fn data_command_defi_request_envelope_stamps_defi_request_command_payload_type() {
3363 let request = make_defi_request_command();
3364 let envelope = DataCommand::DefiRequest(request.clone());
3365 let encoded = encode_data_command(&envelope).expect("encode");
3366
3367 assert_eq!(
3368 encoded.payload_type.expect("override").as_str(),
3369 PAYLOAD_TYPE_DEFI_REQUEST_COMMAND,
3370 );
3371 assert!(encoded.index_keys.is_empty());
3372
3373 let decoded: DefiRequestCommand = rmp_serde::from_slice(&encoded.payload).expect("decode");
3374 match (decoded, request) {
3375 (
3376 DefiRequestCommand::PoolSnapshot(decoded),
3377 DefiRequestCommand::PoolSnapshot(expected),
3378 ) => {
3379 assert_eq!(decoded.request_id, expected.request_id);
3380 assert_eq!(decoded.instrument_id, expected.instrument_id);
3381 assert_eq!(decoded.client_id, expected.client_id);
3382 assert_eq!(decoded.ts_init, expected.ts_init);
3383 }
3384 }
3385 }
3386
3387 #[cfg(feature = "defi")]
3388 #[rstest]
3389 fn data_command_defi_subscribe_envelope_stamps_defi_subscribe_command_payload_type() {
3390 let subscribe = make_defi_subscribe_command();
3391 let envelope = DataCommand::DefiSubscribe(subscribe.clone());
3392 let encoded = encode_data_command(&envelope).expect("encode");
3393
3394 assert_eq!(
3395 encoded.payload_type.expect("override").as_str(),
3396 PAYLOAD_TYPE_DEFI_SUBSCRIBE_COMMAND,
3397 );
3398 assert!(encoded.index_keys.is_empty());
3399
3400 let decoded: DefiSubscribeCommand =
3401 rmp_serde::from_slice(&encoded.payload).expect("decode");
3402
3403 match (decoded, subscribe) {
3404 (DefiSubscribeCommand::Blocks(decoded), DefiSubscribeCommand::Blocks(expected)) => {
3405 assert_eq!(decoded.command_id, expected.command_id);
3406 assert_eq!(decoded.chain, expected.chain);
3407 assert_eq!(decoded.client_id, expected.client_id);
3408 assert_eq!(decoded.ts_init, expected.ts_init);
3409 }
3410 other => panic!("expected DefiSubscribeCommand::Blocks round trip, was {other:?}"),
3411 }
3412 }
3413
3414 #[cfg(feature = "defi")]
3415 #[rstest]
3416 fn data_command_defi_unsubscribe_envelope_stamps_defi_unsubscribe_command_payload_type() {
3417 let unsubscribe = make_defi_unsubscribe_command();
3418 let envelope = DataCommand::DefiUnsubscribe(unsubscribe.clone());
3419 let encoded = encode_data_command(&envelope).expect("encode");
3420
3421 assert_eq!(
3422 encoded.payload_type.expect("override").as_str(),
3423 PAYLOAD_TYPE_DEFI_UNSUBSCRIBE_COMMAND,
3424 );
3425 assert!(encoded.index_keys.is_empty());
3426
3427 let decoded: DefiUnsubscribeCommand =
3428 rmp_serde::from_slice(&encoded.payload).expect("decode");
3429
3430 match (decoded, unsubscribe) {
3431 (DefiUnsubscribeCommand::Blocks(decoded), DefiUnsubscribeCommand::Blocks(expected)) => {
3432 assert_eq!(decoded.command_id, expected.command_id);
3433 assert_eq!(decoded.chain, expected.chain);
3434 assert_eq!(decoded.client_id, expected.client_id);
3435 assert_eq!(decoded.ts_init, expected.ts_init);
3436 }
3437 other => panic!("expected DefiUnsubscribeCommand::Blocks round trip, was {other:?}"),
3438 }
3439 }
3440
3441 fn client_id() -> ClientId {
3442 ClientId::from("BINANCE")
3443 }
3444
3445 fn venue() -> Venue {
3446 Venue::from("BINANCE")
3447 }
3448
3449 fn correlation_id() -> UUID4 {
3450 UUID4::new()
3451 }
3452
3453 fn bar_type() -> BarType {
3454 BarType::from("ETHUSDT-PERP.BINANCE-1-MINUTE-LAST-EXTERNAL")
3455 }
3456
3457 fn data_type() -> DataType {
3458 DataType::new("Bar", None, None)
3459 }
3460
3461 fn make_request_command() -> RequestCommand {
3462 RequestCommand::Quotes(RequestQuotes::new(
3463 instrument_id(),
3464 None,
3465 None,
3466 None,
3467 Some(client_id()),
3468 correlation_id(),
3469 UnixNanos::from(197),
3470 None,
3471 ))
3472 }
3473
3474 fn make_subscribe_command() -> SubscribeCommand {
3475 SubscribeCommand::Quotes(SubscribeQuotes::new(
3476 instrument_id(),
3477 Some(client_id()),
3478 Some(venue()),
3479 correlation_id(),
3480 UnixNanos::from(198),
3481 Some(correlation_id()),
3482 None,
3483 ))
3484 }
3485
3486 fn make_unsubscribe_command() -> UnsubscribeCommand {
3487 UnsubscribeCommand::Quotes(UnsubscribeQuotes::new(
3488 instrument_id(),
3489 Some(client_id()),
3490 Some(venue()),
3491 correlation_id(),
3492 UnixNanos::from(199),
3493 Some(correlation_id()),
3494 None,
3495 ))
3496 }
3497
3498 #[cfg(feature = "defi")]
3499 fn make_defi_request_command() -> DefiRequestCommand {
3500 DefiRequestCommand::PoolSnapshot(RequestPoolSnapshot::new(
3501 instrument_id(),
3502 Some(client_id()),
3503 correlation_id(),
3504 UnixNanos::from(196),
3505 None,
3506 ))
3507 }
3508
3509 #[cfg(feature = "defi")]
3510 fn make_defi_subscribe_command() -> DefiSubscribeCommand {
3511 DefiSubscribeCommand::Blocks(SubscribeBlocks::new(
3512 Blockchain::Ethereum,
3513 Some(client_id()),
3514 correlation_id(),
3515 UnixNanos::from(195),
3516 None,
3517 ))
3518 }
3519
3520 #[cfg(feature = "defi")]
3521 fn make_defi_unsubscribe_command() -> DefiUnsubscribeCommand {
3522 DefiUnsubscribeCommand::Blocks(UnsubscribeBlocks::new(
3523 Blockchain::Ethereum,
3524 Some(client_id()),
3525 correlation_id(),
3526 UnixNanos::from(194),
3527 None,
3528 ))
3529 }
3530
3531 fn make_custom_data_response() -> CustomDataResponse {
3532 CustomDataResponse::new(
3533 correlation_id(),
3534 client_id(),
3535 Some(venue()),
3536 data_type(),
3537 (),
3538 None,
3539 None,
3540 UnixNanos::from(200),
3541 None,
3542 )
3543 }
3544
3545 fn make_instrument_response() -> InstrumentResponse {
3546 InstrumentResponse::new(
3547 correlation_id(),
3548 client_id(),
3549 instrument_id(),
3550 InstrumentAny::CurrencyPair(currency_pair_ethusdt()),
3551 None,
3552 None,
3553 UnixNanos::from(201),
3554 None,
3555 )
3556 }
3557
3558 fn make_instruments_response() -> InstrumentsResponse {
3559 InstrumentsResponse::new(
3560 correlation_id(),
3561 client_id(),
3562 venue(),
3563 vec![InstrumentAny::CurrencyPair(currency_pair_ethusdt())],
3564 None,
3565 None,
3566 UnixNanos::from(202),
3567 None,
3568 )
3569 }
3570
3571 fn make_book_response() -> BookResponse {
3572 BookResponse::new(
3573 correlation_id(),
3574 client_id(),
3575 instrument_id(),
3576 OrderBook::new(instrument_id(), BookType::L2_MBP),
3577 None,
3578 None,
3579 UnixNanos::from(203),
3580 None,
3581 )
3582 }
3583
3584 fn make_book_deltas_response() -> BookDeltasResponse {
3585 BookDeltasResponse::new(
3586 correlation_id(),
3587 client_id(),
3588 instrument_id(),
3589 Vec::new(),
3590 None,
3591 None,
3592 UnixNanos::from(204),
3593 None,
3594 )
3595 }
3596
3597 fn make_book_depth_response() -> BookDepthResponse {
3598 let mut depth = stub_depth10();
3599 depth.instrument_id = instrument_id();
3600 BookDepthResponse::new(
3601 correlation_id(),
3602 client_id(),
3603 instrument_id(),
3604 vec![depth],
3605 None,
3606 None,
3607 UnixNanos::from(205),
3608 None,
3609 )
3610 }
3611
3612 fn make_quotes_response() -> QuotesResponse {
3613 QuotesResponse::new(
3614 correlation_id(),
3615 client_id(),
3616 instrument_id(),
3617 Vec::new(),
3618 None,
3619 None,
3620 UnixNanos::from(206),
3621 None,
3622 )
3623 }
3624
3625 fn make_trades_response() -> TradesResponse {
3626 TradesResponse::new(
3627 correlation_id(),
3628 client_id(),
3629 instrument_id(),
3630 Vec::new(),
3631 None,
3632 None,
3633 UnixNanos::from(207),
3634 None,
3635 )
3636 }
3637
3638 fn make_funding_rates_response() -> FundingRatesResponse {
3639 FundingRatesResponse::new(
3640 correlation_id(),
3641 client_id(),
3642 instrument_id(),
3643 Vec::new(),
3644 None,
3645 None,
3646 UnixNanos::from(208),
3647 None,
3648 )
3649 }
3650
3651 fn make_option_chain_reference_price_response() -> OptionChainReferencePriceResponse {
3652 OptionChainReferencePriceResponse::new(
3653 correlation_id(),
3654 client_id(),
3655 OptionSeriesId::new_derived(
3656 venue(),
3657 Ustr::from("BTC"),
3658 Ustr::from("BTC"),
3659 UnixNanos::from(100),
3660 ),
3661 Some(Price::from("50123.45")),
3662 UnixNanos::from(209),
3663 None,
3664 )
3665 }
3666
3667 fn make_bars_response() -> BarsResponse {
3668 BarsResponse::new(
3669 correlation_id(),
3670 client_id(),
3671 bar_type(),
3672 Vec::<Bar>::new(),
3673 None,
3674 None,
3675 UnixNanos::from(210),
3676 None,
3677 )
3678 }
3679
3680 #[rstest]
3681 fn data_response_custom_data_envelope_stamps_inner_tag_with_no_indices() {
3682 let response = make_custom_data_response();
3686 let envelope = DataResponse::Data(response);
3687 let encoded = encode_data_response(&envelope).expect("encode");
3688
3689 assert_eq!(
3690 encoded.payload_type.expect("override").as_str(),
3691 PAYLOAD_TYPE_CUSTOM_DATA_RESPONSE,
3692 );
3693 assert!(encoded.index_keys.is_empty());
3694 assert!(!encoded.payload.is_empty());
3695 }
3696
3697 #[rstest]
3698 fn data_response_custom_data_payload_round_trips_metadata() {
3699 #[derive(serde::Deserialize)]
3703 struct CustomDataResponseOwned {
3704 correlation_id: UUID4,
3705 client_id: ClientId,
3706 venue: Option<Venue>,
3707 ts_init: UnixNanos,
3708 }
3709
3710 let response = make_custom_data_response();
3711 let envelope = DataResponse::Data(response.clone());
3712 let encoded = encode_data_response(&envelope).expect("encode");
3713
3714 let decoded: CustomDataResponseOwned =
3715 rmp_serde::from_slice(&encoded.payload).expect("decode");
3716 assert_eq!(decoded.correlation_id, response.correlation_id);
3717 assert_eq!(decoded.client_id, response.client_id);
3718 assert_eq!(decoded.venue, response.venue);
3719 assert_eq!(decoded.ts_init, response.ts_init);
3720 }
3721
3722 #[rstest]
3723 fn data_response_book_envelope_stamps_inner_tag_with_no_indices() {
3724 let response = make_book_response();
3725 let envelope = DataResponse::Book(response);
3726 let encoded = encode_data_response(&envelope).expect("encode");
3727
3728 assert_eq!(
3729 encoded.payload_type.expect("override").as_str(),
3730 PAYLOAD_TYPE_BOOK_RESPONSE,
3731 );
3732 assert!(encoded.index_keys.is_empty());
3733 assert!(!encoded.payload.is_empty());
3734 }
3735
3736 #[rstest]
3737 fn data_response_book_payload_round_trips_metadata() {
3738 #[derive(serde::Deserialize)]
3741 struct BookResponseOwned {
3742 correlation_id: UUID4,
3743 instrument_id: InstrumentId,
3744 }
3745
3746 let response = make_book_response();
3747 let envelope = DataResponse::Book(response.clone());
3748 let encoded = encode_data_response(&envelope).expect("encode");
3749
3750 let decoded: BookResponseOwned = rmp_serde::from_slice(&encoded.payload).expect("decode");
3751 assert_eq!(decoded.correlation_id, response.correlation_id);
3752 assert_eq!(decoded.instrument_id, response.instrument_id);
3753 }
3754
3755 #[rstest]
3756 fn data_response_book_depth_payload_round_trips() {
3757 let response = make_book_depth_response();
3758 let envelope = DataResponse::BookDepth(response.clone());
3759 let encoded = encode_data_response(&envelope).expect("encode");
3760
3761 assert_eq!(
3762 encoded.payload_type.expect("override").as_str(),
3763 PAYLOAD_TYPE_BOOK_DEPTH_RESPONSE,
3764 );
3765 assert!(encoded.index_keys.is_empty());
3766
3767 let decoded: BookDepthResponse = rmp_serde::from_slice(&encoded.payload).expect("decode");
3768 assert_eq!(decoded.correlation_id, response.correlation_id);
3769 assert_eq!(decoded.instrument_id, response.instrument_id);
3770 assert_eq!(decoded.data.as_ref(), response.data.as_ref());
3771 }
3772
3773 #[rstest]
3774 fn data_response_quotes_payload_round_trips() {
3775 let response = make_quotes_response();
3776 let envelope = DataResponse::Quotes(response.clone());
3777 let encoded = encode_data_response(&envelope).expect("encode");
3778
3779 assert_eq!(
3780 encoded.payload_type.expect("override").as_str(),
3781 PAYLOAD_TYPE_QUOTES_RESPONSE,
3782 );
3783 assert!(encoded.index_keys.is_empty());
3784
3785 let decoded: QuotesResponse = rmp_serde::from_slice(&encoded.payload).expect("decode");
3786 assert_eq!(decoded.correlation_id, response.correlation_id);
3787 assert_eq!(decoded.instrument_ids, response.instrument_ids);
3788 assert_eq!(decoded.data.as_ref(), response.data.as_ref());
3789 }
3790
3791 #[rstest]
3792 fn data_response_trades_payload_round_trips() {
3793 let response = make_trades_response();
3794 let envelope = DataResponse::Trades(response.clone());
3795 let encoded = encode_data_response(&envelope).expect("encode");
3796
3797 assert_eq!(
3798 encoded.payload_type.expect("override").as_str(),
3799 PAYLOAD_TYPE_TRADES_RESPONSE,
3800 );
3801
3802 let decoded: TradesResponse = rmp_serde::from_slice(&encoded.payload).expect("decode");
3803 assert_eq!(decoded.correlation_id, response.correlation_id);
3804 }
3805
3806 #[rstest]
3807 fn data_response_bars_payload_round_trips() {
3808 let response = make_bars_response();
3809 let envelope = DataResponse::Bars(response.clone());
3810 let encoded = encode_data_response(&envelope).expect("encode");
3811
3812 assert_eq!(
3813 encoded.payload_type.expect("override").as_str(),
3814 PAYLOAD_TYPE_BARS_RESPONSE,
3815 );
3816
3817 let decoded: BarsResponse = rmp_serde::from_slice(&encoded.payload).expect("decode");
3818 assert_eq!(decoded.correlation_id, response.correlation_id);
3819 assert_eq!(decoded.bar_type, response.bar_type);
3820 }
3821
3822 #[rstest]
3823 fn data_response_instrument_payload_round_trips() {
3824 let response = make_instrument_response();
3825 let envelope = DataResponse::Instrument(Box::new(response.clone()));
3826 let encoded = encode_data_response(&envelope).expect("encode");
3827
3828 assert_eq!(
3829 encoded.payload_type.expect("override").as_str(),
3830 PAYLOAD_TYPE_INSTRUMENT_RESPONSE,
3831 );
3832
3833 let decoded: InstrumentResponse = rmp_serde::from_slice(&encoded.payload).expect("decode");
3834 assert_eq!(decoded.correlation_id, response.correlation_id);
3835 assert_eq!(decoded.instrument_id, response.instrument_id);
3836 }
3837
3838 #[rstest]
3843 #[case::data(
3844 DataResponse::Data(make_custom_data_response()),
3845 PAYLOAD_TYPE_CUSTOM_DATA_RESPONSE
3846 )]
3847 #[case::instrument(
3848 DataResponse::Instrument(Box::new(make_instrument_response())),
3849 PAYLOAD_TYPE_INSTRUMENT_RESPONSE
3850 )]
3851 #[case::instruments(
3852 DataResponse::Instruments(make_instruments_response()),
3853 PAYLOAD_TYPE_INSTRUMENTS_RESPONSE
3854 )]
3855 #[case::book(DataResponse::Book(make_book_response()), PAYLOAD_TYPE_BOOK_RESPONSE)]
3856 #[case::book_deltas(
3857 DataResponse::BookDeltas(make_book_deltas_response()),
3858 PAYLOAD_TYPE_BOOK_DELTAS_RESPONSE
3859 )]
3860 #[case::book_depth(
3861 DataResponse::BookDepth(make_book_depth_response()),
3862 PAYLOAD_TYPE_BOOK_DEPTH_RESPONSE
3863 )]
3864 #[case::quotes(
3865 DataResponse::Quotes(make_quotes_response()),
3866 PAYLOAD_TYPE_QUOTES_RESPONSE
3867 )]
3868 #[case::trades(
3869 DataResponse::Trades(make_trades_response()),
3870 PAYLOAD_TYPE_TRADES_RESPONSE
3871 )]
3872 #[case::funding_rates(
3873 DataResponse::FundingRates(make_funding_rates_response()),
3874 PAYLOAD_TYPE_FUNDING_RATES_RESPONSE
3875 )]
3876 #[case::option_chain_reference_price(
3877 DataResponse::OptionChainReferencePrice(make_option_chain_reference_price_response()),
3878 PAYLOAD_TYPE_OPTION_CHAIN_REFERENCE_PRICE_RESPONSE
3879 )]
3880 #[case::bars(DataResponse::Bars(make_bars_response()), PAYLOAD_TYPE_BARS_RESPONSE)]
3881 fn data_response_envelope_stamps_inner_tag_for_every_variant(
3882 #[case] response: DataResponse,
3883 #[case] expected_tag: &str,
3884 ) {
3885 let encoded = encode_data_response(&response).expect("encode");
3886 let tag = encoded.payload_type.expect("override").as_str().to_string();
3887
3888 assert_eq!(tag, expected_tag);
3889 assert_ne!(
3890 tag, PAYLOAD_TYPE_DATA_RESPONSE,
3891 "wrapper fallback tag must never reach the writer",
3892 );
3893 assert!(
3894 encoded.index_keys.is_empty(),
3895 "DataResponse correlation_id has no matching IndexKind today",
3896 );
3897 }
3898
3899 #[rstest]
3900 fn data_response_registered_under_canonical_payload_type() {
3901 let registry = default_registry();
3905 let envelope = DataResponse::Quotes(make_quotes_response());
3906 let (tag, encoded) = registry
3907 .encode(&envelope)
3908 .expect("encode")
3909 .expect("registered");
3910
3911 assert_eq!(tag.as_str(), PAYLOAD_TYPE_QUOTES_RESPONSE);
3912 assert!(encoded.index_keys.is_empty());
3913 }
3914
3915 #[rstest]
3916 fn data_response_headers_extractor_surfaces_correlation_id() {
3917 let registry = default_registry();
3922 let response = make_quotes_response();
3923 let expected = response.correlation_id;
3924 let envelope = DataResponse::Quotes(response);
3925
3926 let headers = registry
3927 .headers_for_any(&envelope as &dyn std::any::Any)
3928 .expect("registered");
3929 assert_eq!(headers.correlation_id, Some(expected));
3930 assert_eq!(headers.causation_id, None);
3931 }
3932
3933 #[rstest]
3934 fn data_command_request_headers_use_request_id_as_correlation() {
3935 let registry = default_registry();
3940 let request = make_quotes_request();
3941 let expected = request.request_id;
3942 let envelope = DataCommand::Request(RequestCommand::Quotes(request));
3943
3944 let headers = registry
3945 .headers_for_any(&envelope as &dyn std::any::Any)
3946 .expect("registered");
3947 assert_eq!(headers.correlation_id, Some(expected));
3948 }
3949
3950 #[rstest]
3951 fn data_command_subscribe_headers_surface_correlation_id() {
3952 let registry = default_registry();
3956 let subscribe = make_subscribe_command();
3957 let expected = subscribe.correlation_id();
3958 let envelope = DataCommand::Subscribe(subscribe);
3959
3960 let headers = registry
3961 .headers_for_any(&envelope as &dyn std::any::Any)
3962 .expect("registered");
3963 assert_eq!(headers.correlation_id, expected);
3964 }
3965
3966 #[rstest]
3967 fn data_command_unsubscribe_headers_surface_correlation_id() {
3968 let registry = default_registry();
3969 let unsubscribe = make_unsubscribe_command();
3970 let expected = unsubscribe.correlation_id();
3971 let envelope = DataCommand::Unsubscribe(unsubscribe);
3972
3973 let headers = registry
3974 .headers_for_any(&envelope as &dyn std::any::Any)
3975 .expect("registered");
3976 assert_eq!(headers.correlation_id, expected);
3977 }
3978
3979 #[rstest]
3980 #[case::submit_order(trading_command_submit_order)]
3981 #[case::submit_order_list(trading_command_submit_order_list)]
3982 #[case::modify_order(trading_command_modify_order)]
3983 #[case::batch_modify_orders(trading_command_batch_modify_orders)]
3984 #[case::cancel_order(trading_command_cancel_order)]
3985 #[case::cancel_all_orders(trading_command_cancel_all_orders)]
3986 #[case::batch_cancel_orders(trading_command_batch_cancel_orders)]
3987 #[case::query_order(trading_command_query_order)]
3988 #[case::query_account(trading_command_query_account)]
3989 fn trading_command_extractor_surfaces_both_headers(
3990 #[case] builder: fn() -> (TradingCommand, UUID4, UUID4),
3991 ) {
3992 let (envelope, corr, caus) = builder();
3997 let registry = default_registry();
3998
3999 let headers = registry
4000 .headers_for_any(&envelope as &dyn std::any::Any)
4001 .expect("registered");
4002 assert_eq!(headers.correlation_id, Some(corr));
4003 assert_eq!(headers.causation_id, Some(caus));
4004 }
4005
4006 fn trading_command_submit_order() -> (TradingCommand, UUID4, UUID4) {
4007 let corr = UUID4::new();
4008 let caus = UUID4::new();
4009 let mut cmd = make_submit_order();
4010 cmd.correlation_id = Some(corr);
4011 cmd.causation_id = Some(caus);
4012 (TradingCommand::SubmitOrder(cmd), corr, caus)
4013 }
4014
4015 fn trading_command_submit_order_list() -> (TradingCommand, UUID4, UUID4) {
4016 let corr = UUID4::new();
4017 let caus = UUID4::new();
4018 let mut cmd = make_submit_order_list(vec![client_order_id()]);
4019 cmd.correlation_id = Some(corr);
4020 cmd.causation_id = Some(caus);
4021 (TradingCommand::SubmitOrderList(cmd), corr, caus)
4022 }
4023
4024 fn trading_command_modify_order() -> (TradingCommand, UUID4, UUID4) {
4025 let corr = UUID4::new();
4026 let caus = UUID4::new();
4027 let mut cmd = make_modify_order(Some(venue_order_id()));
4028 cmd.correlation_id = Some(corr);
4029 cmd.causation_id = Some(caus);
4030 (TradingCommand::ModifyOrder(cmd), corr, caus)
4031 }
4032
4033 fn trading_command_batch_modify_orders() -> (TradingCommand, UUID4, UUID4) {
4034 let corr = UUID4::new();
4035 let caus = UUID4::new();
4036 let mut cmd = make_batch_modify_orders(vec![make_modify_order(Some(venue_order_id()))]);
4037 cmd.correlation_id = Some(corr);
4038 cmd.causation_id = Some(caus);
4039 (TradingCommand::ModifyOrders(cmd), corr, caus)
4040 }
4041
4042 fn trading_command_cancel_order() -> (TradingCommand, UUID4, UUID4) {
4043 let corr = UUID4::new();
4044 let caus = UUID4::new();
4045 let mut cmd = make_cancel_order();
4046 cmd.correlation_id = Some(corr);
4047 cmd.causation_id = Some(caus);
4048 (TradingCommand::CancelOrder(cmd), corr, caus)
4049 }
4050
4051 fn trading_command_batch_cancel_orders() -> (TradingCommand, UUID4, UUID4) {
4052 let corr = UUID4::new();
4053 let caus = UUID4::new();
4054 let mut cmd = make_batch_cancel_orders(vec![make_cancel_order()]);
4055 cmd.correlation_id = Some(corr);
4056 cmd.causation_id = Some(caus);
4057 (TradingCommand::CancelOrders(cmd), corr, caus)
4058 }
4059
4060 fn trading_command_cancel_all_orders() -> (TradingCommand, UUID4, UUID4) {
4061 let corr = UUID4::new();
4062 let caus = UUID4::new();
4063 let mut cmd = make_cancel_all_orders();
4064 cmd.correlation_id = Some(corr);
4065 cmd.causation_id = Some(caus);
4066 (TradingCommand::CancelAllOrders(cmd), corr, caus)
4067 }
4068
4069 fn trading_command_query_order() -> (TradingCommand, UUID4, UUID4) {
4070 let corr = UUID4::new();
4071 let caus = UUID4::new();
4072 let mut cmd = make_query_order(Some(venue_order_id()));
4073 cmd.correlation_id = Some(corr);
4074 cmd.causation_id = Some(caus);
4075 (TradingCommand::QueryOrder(cmd), corr, caus)
4076 }
4077
4078 fn trading_command_query_account() -> (TradingCommand, UUID4, UUID4) {
4079 let corr = UUID4::new();
4080 let caus = UUID4::new();
4081 let mut cmd = make_query_account();
4082 cmd.correlation_id = Some(corr);
4083 cmd.causation_id = Some(caus);
4084 (TradingCommand::QueryAccount(cmd), corr, caus)
4085 }
4086
4087 #[rstest]
4088 #[case::data(data_response_data())]
4089 #[case::instrument(data_response_instrument())]
4090 #[case::instruments(data_response_instruments())]
4091 #[case::book(data_response_book())]
4092 #[case::book_deltas(data_response_book_deltas())]
4093 #[case::book_depth(data_response_book_depth())]
4094 #[case::quotes(data_response_quotes())]
4095 #[case::trades(data_response_trades())]
4096 #[case::funding_rates(data_response_funding_rates())]
4097 #[case::option_chain_reference_price(data_response_option_chain_reference_price())]
4098 #[case::bars(data_response_bars())]
4099 fn data_response_extractor_surfaces_correlation_id_for_every_variant(
4100 #[case] envelope_with_expected: (DataResponse, UUID4),
4101 ) {
4102 let (envelope, expected) = envelope_with_expected;
4106 let registry = default_registry();
4107
4108 let headers = registry
4109 .headers_for_any(&envelope as &dyn std::any::Any)
4110 .expect("registered");
4111 assert_eq!(headers.correlation_id, Some(expected));
4112 assert_eq!(headers.causation_id, None);
4113 }
4114
4115 fn data_response_data() -> (DataResponse, UUID4) {
4116 let resp = make_custom_data_response();
4117 let expected = resp.correlation_id;
4118 (DataResponse::Data(resp), expected)
4119 }
4120
4121 fn data_response_instrument() -> (DataResponse, UUID4) {
4122 let resp = make_instrument_response();
4123 let expected = resp.correlation_id;
4124 (DataResponse::Instrument(Box::new(resp)), expected)
4125 }
4126
4127 fn data_response_instruments() -> (DataResponse, UUID4) {
4128 let resp = make_instruments_response();
4129 let expected = resp.correlation_id;
4130 (DataResponse::Instruments(resp), expected)
4131 }
4132
4133 fn data_response_book() -> (DataResponse, UUID4) {
4134 let resp = make_book_response();
4135 let expected = resp.correlation_id;
4136 (DataResponse::Book(resp), expected)
4137 }
4138
4139 fn data_response_book_deltas() -> (DataResponse, UUID4) {
4140 let resp = make_book_deltas_response();
4141 let expected = resp.correlation_id;
4142 (DataResponse::BookDeltas(resp), expected)
4143 }
4144
4145 fn data_response_book_depth() -> (DataResponse, UUID4) {
4146 let resp = make_book_depth_response();
4147 let expected = resp.correlation_id;
4148 (DataResponse::BookDepth(resp), expected)
4149 }
4150
4151 fn data_response_quotes() -> (DataResponse, UUID4) {
4152 let resp = make_quotes_response();
4153 let expected = resp.correlation_id;
4154 (DataResponse::Quotes(resp), expected)
4155 }
4156
4157 fn data_response_trades() -> (DataResponse, UUID4) {
4158 let resp = make_trades_response();
4159 let expected = resp.correlation_id;
4160 (DataResponse::Trades(resp), expected)
4161 }
4162
4163 fn data_response_funding_rates() -> (DataResponse, UUID4) {
4164 let resp = make_funding_rates_response();
4165 let expected = resp.correlation_id;
4166 (DataResponse::FundingRates(resp), expected)
4167 }
4168
4169 fn data_response_option_chain_reference_price() -> (DataResponse, UUID4) {
4170 let resp = make_option_chain_reference_price_response();
4171 let expected = resp.correlation_id;
4172 (DataResponse::OptionChainReferencePrice(resp), expected)
4173 }
4174
4175 fn data_response_bars() -> (DataResponse, UUID4) {
4176 let resp = make_bars_response();
4177 let expected = resp.correlation_id;
4178 (DataResponse::Bars(resp), expected)
4179 }
4180
4181 fn make_quotes_request() -> RequestQuotes {
4182 RequestQuotes {
4183 instrument_ids: vec![InstrumentId::from("EUR/USD.SIM")],
4184 start: None,
4185 end: None,
4186 limit: None,
4187 client_id: None,
4188 request_id: UUID4::new(),
4189 ts_init: UnixNanos::default(),
4190 params: None,
4191 }
4192 }
4193}