Skip to main content

nautilus_event_store/capture/
builtins.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Representative encoders for the SPEC's allow-listed message surface.
17//!
18//! Phase 6 shipped a sample triple (`SubmitOrder` command, `OrderFilled` generated event,
19//! `OrderStatusReport` raw venue report) so the bus capture adapter had a working
20//! allow-list end-to-end. Phase 7 adds envelope-aware dispatchers for the
21//! wrapper enums production code actually pushes through `send_trading_command`,
22//! `publish_order_event`, `send_execution_report`, and `publish_position_event`
23//! ([`TradingCommand`], [`OrderEventAny`], [`ExecutionReport`], [`PositionEvent`]).
24//! The same pattern covers `send_data_command` and `send_data_response` ([`DataCommand`],
25//! [`DataResponse`]). These reach the bus tap as their wrapper [`std::any::TypeId`] and
26//! the bare-type registrations would miss them. Each dispatcher unwraps its variant,
27//! runs the inner-typed encode, and stamps the inner-variant's canonical `payload_type`
28//! tag so forensics scans see entries identical to the bare-type capture path.
29//!
30//! The payload serialization format is MessagePack via `rmp-serde`. The on-disk envelope
31//! uses the positional codec; MessagePack inside the payload handles the upstream Nautilus
32//! types that carry `#[serde(tag = "type")]` internal tagging, which a non-self-describing
33//! format cannot round-trip.
34
35use 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
80/// The canonical `payload_type` tag for [`SubmitOrder`].
81pub const PAYLOAD_TYPE_SUBMIT_ORDER: &str = "SubmitOrder";
82/// The canonical `payload_type` tag for [`SubmitOrderList`].
83pub const PAYLOAD_TYPE_SUBMIT_ORDER_LIST: &str = "SubmitOrderList";
84/// The canonical `payload_type` tag for [`ModifyOrder`].
85pub const PAYLOAD_TYPE_MODIFY_ORDER: &str = "ModifyOrder";
86/// The canonical `payload_type` tag for [`BatchModifyOrders`].
87pub const PAYLOAD_TYPE_BATCH_MODIFY_ORDERS: &str = "BatchModifyOrders";
88/// The canonical `payload_type` tag for [`CancelOrder`].
89pub const PAYLOAD_TYPE_CANCEL_ORDER: &str = "CancelOrder";
90/// The canonical `payload_type` tag for [`CancelAllOrders`].
91pub const PAYLOAD_TYPE_CANCEL_ALL_ORDERS: &str = "CancelAllOrders";
92/// The canonical `payload_type` tag for [`BatchCancelOrders`].
93pub const PAYLOAD_TYPE_BATCH_CANCEL_ORDERS: &str = "BatchCancelOrders";
94/// The canonical `payload_type` tag for [`QueryOrder`].
95pub const PAYLOAD_TYPE_QUERY_ORDER: &str = "QueryOrder";
96/// The canonical `payload_type` tag for [`QueryAccount`].
97pub const PAYLOAD_TYPE_QUERY_ACCOUNT: &str = "QueryAccount";
98
99/// The canonical `payload_type` tag for [`OrderInitialized`].
100pub const PAYLOAD_TYPE_ORDER_INITIALIZED: &str = "OrderInitialized";
101/// The canonical `payload_type` tag for [`OrderDenied`].
102pub const PAYLOAD_TYPE_ORDER_DENIED: &str = "OrderDenied";
103/// The canonical `payload_type` tag for [`OrderEmulated`].
104pub const PAYLOAD_TYPE_ORDER_EMULATED: &str = "OrderEmulated";
105/// The canonical `payload_type` tag for [`OrderReleased`].
106pub const PAYLOAD_TYPE_ORDER_RELEASED: &str = "OrderReleased";
107/// The canonical `payload_type` tag for [`OrderSubmitted`].
108pub const PAYLOAD_TYPE_ORDER_SUBMITTED: &str = "OrderSubmitted";
109/// The canonical `payload_type` tag for [`OrderAccepted`].
110pub const PAYLOAD_TYPE_ORDER_ACCEPTED: &str = "OrderAccepted";
111/// The canonical `payload_type` tag for [`OrderRejected`].
112pub const PAYLOAD_TYPE_ORDER_REJECTED: &str = "OrderRejected";
113/// The canonical `payload_type` tag for [`OrderCanceled`].
114pub const PAYLOAD_TYPE_ORDER_CANCELED: &str = "OrderCanceled";
115/// The canonical `payload_type` tag for [`OrderExpired`].
116pub const PAYLOAD_TYPE_ORDER_EXPIRED: &str = "OrderExpired";
117/// The canonical `payload_type` tag for [`OrderTriggered`].
118pub const PAYLOAD_TYPE_ORDER_TRIGGERED: &str = "OrderTriggered";
119/// The canonical `payload_type` tag for [`OrderPendingUpdate`].
120pub const PAYLOAD_TYPE_ORDER_PENDING_UPDATE: &str = "OrderPendingUpdate";
121/// The canonical `payload_type` tag for [`OrderPendingCancel`].
122pub const PAYLOAD_TYPE_ORDER_PENDING_CANCEL: &str = "OrderPendingCancel";
123/// The canonical `payload_type` tag for [`OrderModifyDenied`].
124pub const PAYLOAD_TYPE_ORDER_MODIFY_DENIED: &str = "OrderModifyDenied";
125/// The canonical `payload_type` tag for [`OrderModifyRejected`].
126pub const PAYLOAD_TYPE_ORDER_MODIFY_REJECTED: &str = "OrderModifyRejected";
127
128/// The canonical `payload_type` tag for [`OrderCancelDenied`].
129pub const PAYLOAD_TYPE_ORDER_CANCEL_DENIED: &str = "OrderCancelDenied";
130/// The canonical `payload_type` tag for [`OrderCancelRejected`].
131pub const PAYLOAD_TYPE_ORDER_CANCEL_REJECTED: &str = "OrderCancelRejected";
132
133/// The canonical `payload_type` tag for [`OrderUpdated`].
134pub const PAYLOAD_TYPE_ORDER_UPDATED: &str = "OrderUpdated";
135/// The canonical `payload_type` tag for [`OrderFilled`].
136pub const PAYLOAD_TYPE_ORDER_FILLED: &str = "OrderFilled";
137/// The canonical `payload_type` tag for [`OrderFillVoided`].
138pub const PAYLOAD_TYPE_ORDER_FILL_VOIDED: &str = "OrderFillVoided";
139/// The canonical `payload_type` tag for [`OrderStatusReport`].
140pub const PAYLOAD_TYPE_ORDER_STATUS_REPORT: &str = "OrderStatusReport";
141/// The canonical `payload_type` tag for [`FillReport`].
142pub const PAYLOAD_TYPE_FILL_REPORT: &str = "FillReport";
143/// The canonical `payload_type` tag for the [`ExecutionReport::OrderWithFills`] bundle.
144pub const PAYLOAD_TYPE_ORDER_WITH_FILLS: &str = "OrderWithFills";
145/// The canonical `payload_type` tag for [`PositionStatusReport`].
146pub const PAYLOAD_TYPE_POSITION_STATUS_REPORT: &str = "PositionStatusReport";
147/// The canonical `payload_type` tag for [`ExecutionMassStatus`].
148pub const PAYLOAD_TYPE_EXECUTION_MASS_STATUS: &str = "ExecutionMassStatus";
149/// The canonical `payload_type` tag for [`PositionOpened`].
150pub const PAYLOAD_TYPE_POSITION_OPENED: &str = "PositionOpened";
151/// The canonical `payload_type` tag for [`PositionChanged`].
152pub const PAYLOAD_TYPE_POSITION_CHANGED: &str = "PositionChanged";
153/// The canonical `payload_type` tag for [`PositionClosed`].
154pub const PAYLOAD_TYPE_POSITION_CLOSED: &str = "PositionClosed";
155/// The canonical `payload_type` tag for [`PositionAdjusted`].
156pub const PAYLOAD_TYPE_POSITION_ADJUSTED: &str = "PositionAdjusted";
157/// The canonical `payload_type` tag for [`AccountState`].
158pub const PAYLOAD_TYPE_ACCOUNT_STATE: &str = "AccountState";
159/// The canonical `payload_type` tag for [`InstrumentClose`].
160pub const PAYLOAD_TYPE_INSTRUMENT_CLOSE: &str = "InstrumentClose";
161/// The canonical `payload_type` tag for [`TimeEvent`].
162pub const PAYLOAD_TYPE_TIME_EVENT: &str = "TimeEvent";
163
164/// The canonical `payload_type` tag for `RequestCommand`.
165pub const PAYLOAD_TYPE_REQUEST_COMMAND: &str = "RequestCommand";
166/// The canonical `payload_type` tag for `SubscribeCommand`.
167pub const PAYLOAD_TYPE_SUBSCRIBE_COMMAND: &str = "SubscribeCommand";
168/// The canonical `payload_type` tag for `UnsubscribeCommand`.
169pub const PAYLOAD_TYPE_UNSUBSCRIBE_COMMAND: &str = "UnsubscribeCommand";
170#[cfg(feature = "defi")]
171/// The canonical `payload_type` tag for `DefiRequestCommand`.
172pub const PAYLOAD_TYPE_DEFI_REQUEST_COMMAND: &str = "DefiRequestCommand";
173#[cfg(feature = "defi")]
174/// The canonical `payload_type` tag for `DefiSubscribeCommand`.
175pub const PAYLOAD_TYPE_DEFI_SUBSCRIBE_COMMAND: &str = "DefiSubscribeCommand";
176#[cfg(feature = "defi")]
177/// The canonical `payload_type` tag for `DefiUnsubscribeCommand`.
178pub const PAYLOAD_TYPE_DEFI_UNSUBSCRIBE_COMMAND: &str = "DefiUnsubscribeCommand";
179
180/// The canonical `payload_type` tag for [`CustomDataResponse`].
181pub const PAYLOAD_TYPE_CUSTOM_DATA_RESPONSE: &str = "CustomDataResponse";
182/// The canonical `payload_type` tag for [`InstrumentResponse`].
183pub const PAYLOAD_TYPE_INSTRUMENT_RESPONSE: &str = "InstrumentResponse";
184/// The canonical `payload_type` tag for [`InstrumentsResponse`].
185pub const PAYLOAD_TYPE_INSTRUMENTS_RESPONSE: &str = "InstrumentsResponse";
186/// The canonical `payload_type` tag for [`BookResponse`].
187pub const PAYLOAD_TYPE_BOOK_RESPONSE: &str = "BookResponse";
188/// The canonical `payload_type` tag for [`BookDeltasResponse`].
189pub const PAYLOAD_TYPE_BOOK_DELTAS_RESPONSE: &str = "BookDeltasResponse";
190/// The canonical `payload_type` tag for [`BookDepthResponse`].
191pub const PAYLOAD_TYPE_BOOK_DEPTH_RESPONSE: &str = "BookDepthResponse";
192/// The canonical `payload_type` tag for [`QuotesResponse`].
193pub const PAYLOAD_TYPE_QUOTES_RESPONSE: &str = "QuotesResponse";
194/// The canonical `payload_type` tag for [`TradesResponse`].
195pub const PAYLOAD_TYPE_TRADES_RESPONSE: &str = "TradesResponse";
196/// The canonical `payload_type` tag for [`FundingRatesResponse`].
197pub const PAYLOAD_TYPE_FUNDING_RATES_RESPONSE: &str = "FundingRatesResponse";
198/// The canonical `payload_type` tag for [`OptionChainReferencePriceResponse`].
199pub const PAYLOAD_TYPE_OPTION_CHAIN_REFERENCE_PRICE_RESPONSE: &str =
200    "OptionChainReferencePriceResponse";
201/// The canonical `payload_type` tag for [`BarsResponse`].
202pub const PAYLOAD_TYPE_BARS_RESPONSE: &str = "BarsResponse";
203/// The canonical `payload_type` tag for [`DataResponseEnvelope`].
204pub const PAYLOAD_TYPE_DATA_RESPONSE_ENVELOPE: &str = "DataResponseEnvelope";
205
206// Wrapper-level fallback tag reached only when a dispatcher returns an
207// `EncodedPayload` without an override. Every current variant stamps its own
208// inner tag, so this is a sentinel for a future variant that forgets the
209// override rather than a tag the writer is expected to commit.
210const 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/// Returns an [`EncoderRegistry`] preloaded with the default encoders.
288///
289/// Callers can extend the returned registry with additional encoders before constructing
290/// the [`crate::capture::BusCaptureAdapter`].
291#[must_use]
292pub fn default_registry() -> EncoderRegistry {
293    let mut registry = EncoderRegistry::new();
294    register_default(&mut registry);
295    registry
296}
297
298/// Adds the default encoders to `registry`.
299///
300/// The bare-type registrations remain for capture sites that already submit the inner
301/// type directly (the kernel's `RunStarted` path and a few internal tests). The envelope
302/// registrations are what production bus traffic actually hits: `send_trading_command`
303/// reaches the tap as [`TradingCommand`], `publish_order_event` reaches it as
304/// [`OrderEventAny`], `send_execution_report` reaches it as [`ExecutionReport`],
305/// `publish_position_event` reaches it as [`PositionEvent`], and `send_data_response`
306/// reaches it as [`DataResponse`]. Without these wrapper-aware dispatchers the tap looks
307/// up the wrapper's [`std::any::TypeId`], finds no encoder, and silently drops the
308/// capture.
309///
310/// [`AccountState`] is registered as a bare type: `publish_account_state` and
311/// `send_account_state` both reach the tap as the same `AccountState` `TypeId`, so a
312/// single registration covers both dispatch paths.
313///
314/// [`OrderStatusReport`], [`FillReport`], and [`PositionStatusReport`] are registered
315/// as bare types because the execution engine publishes raw venue reports through
316/// `publish_any` on `reconciliation.raw.*` topics before any state mutation. The
317/// bare-type registration is what captures those raw inputs for forensic replay.
318pub 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
390/// Attaches identity extractors for the types production dispatch pushes through more
391/// than one tap-visible boundary (portfolio endpoint send plus strategy topic publish,
392/// command hops through risk to execution, account states on both dispatch paths, data
393/// commands through the queue endpoint and the drained execute endpoint), so the
394/// adapter captures each logical message exactly once. The venue report types
395/// deliberately carry no extractor: the raw `reconciliation.raw.*` publish and the
396/// engine-bound dispatch are distinct capture boundaries.
397fn 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        // `DataCommand` is `#[non_exhaustive]`; future variants capture per dispatch
418        _ => 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
503// `send_trading_command` reaches the bus tap with the wrapper's `TypeId`, so the
504// extractor must mirror the encoder's variant dispatch to surface the inner command's
505// correlation metadata on the captured entry.
506fn 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
520// `send_data_command` reaches the bus tap with the wrapper's `TypeId`. The data engine
521// keys RPC request/response pairs by the request's `request_id`: the response's
522// `correlation_id` echoes that uuid back. Surfacing `request_id` as the captured entry's
523// `correlation_id` therefore lines a request entry up with its eventual response entry
524// under the same chain key. Subscribe / Unsubscribe variants carry an explicit
525// `correlation_id` field, which we forward as-is. DeFi variants are not yet wired through
526// header propagation.
527fn 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        // `DataCommand` is `#[non_exhaustive]` and the defi variants do not yet carry
533        // header propagation; future variants drop through this arm with empty headers
534        // until their correlation field shape lands.
535        _ => Headers::empty(),
536    }
537}
538
539// Every `DataResponse` variant carries a required `correlation_id` that pairs the
540// response with its originating request; the captured entry mirrors that value.
541fn 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
555/// Encodes a [`SubmitOrder`] command into canonical bytes plus its `client_order_id` index.
556///
557/// # Errors
558///
559/// Returns an error if MessagePack rejects the payload (a malformed value the type system should
560/// make unrepresentable; surfaced rather than swallowed because the audit contract refuses to drop
561/// captured commands).
562pub 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
571/// Encodes an [`OrderFilled`] event into canonical bytes plus its `client_order_id` and
572/// `venue_order_id` indices.
573///
574/// # Errors
575///
576/// Returns an error if MessagePack rejects the payload.
577pub 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
589/// Encodes a [`TradingCommand`] envelope by dispatching on the variant.
590///
591/// The captured entry's `payload_type` matches the inner-variant tag (e.g. `SubmitOrder`
592/// rather than `TradingCommand`) so forensics scans pair with the same decoder as the
593/// bare-type capture path. The serialized payload is the inner variant; the wrapper enum
594/// is never written to disk.
595///
596/// # Errors
597///
598/// Returns an error if the inner encoder rejects the [`TradingCommand::SubmitOrder`] variant, or if
599/// MessagePack rejects the inner payload for another variant.
600pub 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
616/// Encodes an [`OrderEventAny`] envelope by dispatching on the inner variant.
617///
618/// The captured entry's `payload_type` matches the inner-variant tag (e.g. `OrderFilled`
619/// rather than `OrderEventAny`); the serialized payload is the inner variant.
620///
621/// # Errors
622///
623/// Returns an error if the inner encoder rejects the [`OrderEventAny::Filled`] variant, or if
624/// MessagePack rejects the inner payload for another variant.
625pub 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
649/// Encodes an [`ExecutionReport`] envelope by dispatching on the variant.
650///
651/// `send_execution_report` hands the bus tap an [`ExecutionReport`] wrapper, so the tap
652/// dispatches by the wrapper's [`std::any::TypeId`] and the inner variants never reach
653/// their bare-type encoders. The dispatcher unwraps each variant, encodes the inner type
654/// with its own index keys, and stamps the inner-variant tag so forensics scans see
655/// entries identical to a bare capture path.
656///
657/// The [`ExecutionReport::Order`] arm reuses [`encode_order_status_report`] because the
658/// bare-type encoder already exists; the remaining variants delegate to private inner
659/// encoders that index the report's identifiers individually.
660///
661/// # Errors
662///
663/// Returns an error if MessagePack rejects the inner payload.
664pub 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
677/// Encodes a [`FillReport`] into canonical bytes plus its `venue_order_id` index and,
678/// when present, its `client_order_id` index.
679///
680/// # Errors
681///
682/// Returns an error if MessagePack rejects the payload.
683pub 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
705/// Encodes a [`PositionStatusReport`] into canonical bytes with no sidecar indices.
706///
707/// `PositionStatusReport` carries only `AccountId`, `InstrumentId`, and `PositionId`;
708/// none of those have a matching [`IndexKind`] variant today. Capture with no sidecar
709/// indices so the entry is forensics-discoverable by sequential scan rather than
710/// synthesizing an index against an identifier the reader cannot query.
711///
712/// # Errors
713///
714/// Returns an error if MessagePack rejects the payload.
715pub 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    // PositionStatusReport identifiers are not indexable today, see
832    // `encode_position_status_report`.
833    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
851/// Encodes a [`PositionEvent`] envelope by dispatching on the variant.
852///
853/// `publish_position_event` hands the bus tap a [`PositionEvent`] wrapper, so the tap
854/// dispatches by the wrapper's [`std::any::TypeId`] and the inner variants never reach
855/// their bare-type encoders. The dispatcher unwraps each variant, encodes the inner
856/// struct, and stamps the inner-variant tag so forensics scans see entries identical
857/// to the bare-type capture path.
858///
859/// # Errors
860///
861/// Returns an error if MessagePack rejects the inner payload.
862pub 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    // Opening and closing client_order_ids are distinct in normal operation; dedup
910    // guards the rare case where a single order both opens and closes the position.
911    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    // PositionAdjusted carries no client_order_id; identifiers are PositionId,
929    // AccountId, and InstrumentId, none of which have a matching IndexKind today.
930    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
1224/// Encodes an [`OrderStatusReport`] into canonical bytes plus its `venue_order_id` index
1225/// and, when present, its `client_order_id` index.
1226///
1227/// External orders observed only at the venue may not carry a `client_order_id`; the
1228/// index is omitted in that case so the secondary index never records an empty key.
1229///
1230/// # Errors
1231///
1232/// Returns an error if MessagePack rejects the payload.
1233pub 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
1252/// Encodes an [`AccountState`] into canonical bytes with no sidecar indices.
1253///
1254/// `AccountState` carries `AccountId` and `event_id` (UUID4); neither matches an
1255/// [`IndexKind`] variant today, so the encoder emits no sidecar keys and forensics
1256/// scans rely on sequential range over `seq`. This mirrors the [`PositionStatusReport`]
1257/// precedent.
1258///
1259/// # Errors
1260///
1261/// Returns an error if MessagePack rejects the payload.
1262pub fn encode_account_state(message: &AccountState) -> Result<EncodedPayload, EncodeError> {
1263    let payload = encode_serde(message)?;
1264    Ok(EncodedPayload::new(payload, Vec::new()))
1265}
1266
1267/// Encodes an [`InstrumentClose`] into canonical bytes with no sidecar indices.
1268///
1269/// Cache replay applies a captured contract expiration through the same settlement as the live
1270/// execution engine, so a restore keeps settled binary-option positions closed.
1271///
1272/// # Errors
1273///
1274/// Returns an error if MessagePack rejects the payload.
1275pub 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
1288/// Encodes a fired [`TimeEvent`] into canonical bytes with no sidecar indices.
1289///
1290/// Time events carry a callback boundary rather than a cache-state key. The event store
1291/// captures them for forensic ordering and deterministic replay inputs, while cache
1292/// replay leaves clock re-arming to the later clock lifecycle event workstream.
1293///
1294/// # Errors
1295///
1296/// Returns an error if MessagePack rejects the payload.
1297pub 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/// Encodes a [`DataCommand`] envelope by dispatching on its command category.
1308///
1309/// `send_data_command` hands the bus tap a [`DataCommand`] wrapper, so the tap
1310/// dispatches by the wrapper's [`std::any::TypeId`] and the inner command category
1311/// never reaches a bare-type encoder. The dispatcher unwraps the category, encodes the
1312/// serializable inner enum (`RequestCommand`, `SubscribeCommand`, or
1313/// `UnsubscribeCommand`), and stamps that category's canonical `payload_type` tag.
1314///
1315/// Request IDs, command IDs, and correlation IDs do not have a matching [`IndexKind`]
1316/// today, so data commands emit no sidecar indices. Correlation is recovered from the
1317/// captured payload and, once header propagation lands, propagated headers.
1318///
1319/// # Errors
1320///
1321/// Returns an error if MessagePack rejects the inner payload, or when a future non-exhaustive
1322/// [`DataCommand`] variant has no encoder yet.
1323#[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
1353/// Encodes a [`DataResponse`] envelope by dispatching on the variant.
1354///
1355/// `send_data_response` hands the bus tap a [`DataResponse`] wrapper, so the tap
1356/// dispatches by the wrapper's [`std::any::TypeId`] and the inner variants never reach
1357/// their bare-type encoders. The dispatcher unwraps each variant, encodes the inner
1358/// struct, and stamps the inner-variant tag so forensics scans see entries identical
1359/// to a bare-type capture path.
1360///
1361/// Each variant carries a `correlation_id` (UUID4) pairing the response with the
1362/// originating `RequestCommand::request_id`. [`IndexKind`] has no matching variant
1363/// today, so every variant emits zero sidecar indices, mirroring the
1364/// [`PositionStatusReport`] and [`AccountState`] precedents.
1365///
1366/// The [`DataResponse::Data`] and [`DataResponse::Book`] variants carry payloads that
1367/// are not directly serializable: [`CustomDataResponse`] holds an `Arc<dyn Any>` and
1368/// [`BookResponse`] holds a [`nautilus_model::orderbook::OrderBook`] without serde
1369/// derives. The dispatcher serializes the audit-relevant metadata for those two
1370/// variants via local borrowed wrapper structs (the `encode_order_with_fills`
1371/// precedent) and omits the opaque payload. `BookResponse` is state-affecting on
1372/// the data engine path (`handle_book_response` clones the book into the cache); a
1373/// follow-up that adds serde to `OrderBook`/`BookLadder` can replace the metadata
1374/// wrapper with full payload capture without changing the dispatcher contract.
1375///
1376/// # Errors
1377///
1378/// Returns an error if MessagePack rejects the inner payload.
1379pub 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    // `data: Arc<dyn Any + Send + Sync>` is type-erased at the dispatcher; the
1428    // payload is captured via a metadata-only wrapper so the audit entry pairs
1429    // with the originating request without depending on per-registration
1430    // serializers for the inner Any payload.
1431    #[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    // `data: OrderBook` is not serde-derived today (BookLadder/BookLevel chain), and
1484    // the full book state is rarely the audit value at this level. Capture
1485    // response-level metadata via a borrowed wrapper so the entry pairs with the
1486    // originating request.
1487    #[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, // correlation_id
1667        )
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        // Production pushes every queued data command through two tapped sends
1842        // (queue, then drained execute); the identity must key both hops to the
1843        // same command.
1844        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, // correlation_id
1920        )
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, // correlation_id
1932        )
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, // correlation_id
1960        )
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, // correlation_id
1974        )
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, // correlation_id
1988        )
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, // correlation_id
2003        )
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, // correlation_id
2017        )
2018    }
2019
2020    fn make_submit_order_list(client_order_ids: Vec<ClientOrderId>) -> SubmitOrderList {
2021        // OrderList::new asserts that order_inits' client_order_ids match the list's,
2022        // so we mint one OrderInitialized per id with the matching client_order_id.
2023        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, // correlation_id
2047        )
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        // TradingCommand reaches the bus tap as the wrapper TypeId; the dispatcher must
2197        // unwrap to SubmitOrder, produce the same bytes and indices as the bare-type
2198        // encoder, and stamp the inner payload_type so forensics scans pair the entry
2199        // with the SubmitOrder decoder.
2200        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        // QueryAccount carries no client_order_id or venue_order_id; the dispatcher
2243        // must not invent empty index keys.
2244        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    // Walks every TradingCommand variant and asserts the dispatcher stamps the inner-variant
2292    // payload_type tag and emits the expected number of index keys. Catches a swapped match
2293    // arm or a forgotten `with_payload_type` override that would otherwise fall back to the
2294    // wrapper sentinel tag.
2295    #[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    // Walks every OrderEventAny variant. Builds each variant from `Default::default()`
2363    // (gated by the `test-support` feature on `nautilus-model`) with the test client_order_id
2364    // patched in, so the assertion can verify the index value alongside the tag.
2365    #[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    // Optional venue_order_id branch coverage for variants that carry one. None must skip
2445    // the VenueOrderId index entirely; Some must push it second.
2446    #[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        // Two cancels: one with a venue_order_id (contributes 2 indices), one without
2502        // (contributes 1). The dispatcher must preserve both children's identifiers in
2503        // the same order they appear in the batch.
2504        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        // SubmitOrderList carries N orders; the dispatcher must emit a ClientOrderId
2568        // index per child so forensics can resolve any of the list's intents to the
2569        // captured seq.
2570        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        // ExecutionReport::Order maps onto the existing OrderStatusReport bare-type
2640        // encoder; the dispatcher must produce identical bytes and indices and stamp
2641        // the OrderStatusReport tag so forensics scans pair the entry with the same
2642        // decoder as the bare-type capture path.
2643        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        // PositionStatusReport identifiers (AccountId, InstrumentId, PositionId) have
2694        // no matching IndexKind today; the dispatcher must not invent sidecar indices
2695        // pointing at an identifier the reader cannot query.
2696        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        // The order and its fills semantically carry the same venue_order_id and
2714        // client_order_id, so the dispatcher must dedupe rather than emit a duplicate
2715        // (kind, key) pair the backend would silently drop.
2716        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        // A bundled OrderWithFills can carry a fill whose client_order_id differs
2738        // from the order's (rare, but real: external orders observed via a fill
2739        // before the venue confirms the canonical id). The dispatcher must index
2740        // both client_order_ids so forensics can resolve either to the same seq.
2741        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        // One order with venue+client ids, one fill sharing both ids, one position
2784        // (unindexable). The dispatcher must dedupe the shared ids.
2785        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        // Two distinct orders + a fill for a third venue_order_id with its own
2798        // client_order_id. The dispatcher must record an index for each unique id
2799        // so forensics can resolve any child of the status report.
2800        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        // Three venue_order_ids + three client_order_ids = 6 distinct keys
2825        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    // Walks every ExecutionReport variant and asserts the dispatcher stamps the
2847    // inner-variant tag. Catches a swapped match arm or a forgotten override that
2848    // would otherwise fall back to the wrapper sentinel tag.
2849    #[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        // Rare but real: a single order both opens and closes the position (e.g.,
3081        // reduce-only fills against a stale position). The dispatcher must dedupe
3082        // rather than insert the same (kind, key) twice.
3083        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        // PositionAdjusted has no ClientOrderId field; PositionId/AccountId/
3095        // InstrumentId have no matching IndexKind today, so the dispatcher must
3096        // not invent sidecar indices pointing at an identifier the reader cannot
3097        // query.
3098        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        // AccountState carries AccountId and event_id (UUID4); neither matches an
3164        // IndexKind variant today. The encoder must capture the payload without
3165        // synthesizing sidecar indices pointing at identifiers the reader cannot
3166        // query, mirroring the PositionStatusReport precedent.
3167        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        // The default registry must dispatch AccountState through encode_account_state
3190        // and stamp PAYLOAD_TYPE_ACCOUNT_STATE so both `publish_account_state` and
3191        // `send_account_state` capture under the same canonical tag.
3192        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        // DataCommand reaches the bus tap as the wrapper TypeId. The dispatcher must
3279        // unwrap one level, encode RequestCommand, and stamp the category tag so the
3280        // reader pairs the bytes with the RequestCommand decoder.
3281        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        // The default registry must dispatch DataCommand through encode_data_command and
3348        // stamp the inner category tag, not the wrapper sentinel tag.
3349        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        // CustomDataResponse holds `data: Arc<dyn Any>`; the dispatcher captures
3683        // metadata via a borrowed wrapper. Correlation_id has no matching IndexKind
3684        // today, so the encoder emits no sidecar keys.
3685        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        // The CustomDataResponseRef wrapper omits `data` (Arc<dyn Any>); the audit
3700        // entry captures correlation_id, client_id, venue, data_type, timing, and
3701        // params so forensics can pair the response with its request.
3702        #[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        // BookResponseRef omits `data: OrderBook` (not serde-derived). The audit
3739        // entry captures the correlation and addressing metadata.
3740        #[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    // Walks every DataResponse variant and asserts the dispatcher stamps the
3839    // inner-variant tag and emits zero sidecar indices. Catches a swapped match
3840    // arm or a forgotten `with_payload_type` override that would otherwise fall
3841    // back to the wrapper sentinel tag.
3842    #[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        // The default registry must dispatch DataResponse through encode_data_response
3902        // and stamp the inner-variant tag, so `send_data_response` captures under the
3903        // same canonical tag as a bare-type capture path.
3904        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        // The data engine pairs RPC requests and responses by correlation_id (see
3918        // `crates/data/src/engine/mod.rs` `send_response`). Captured DataResponse entries
3919        // must carry that uuid in `Headers::correlation_id` so forensics can join a
3920        // captured response to its request.
3921        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        // The request_id of an outbound RequestCommand IS the chain root: the eventual
3936        // DataResponse echoes the same uuid back as its correlation_id. Surfacing
3937        // request_id in `Headers::correlation_id` lines the request entry up with its
3938        // response entry under one chain key.
3939        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        // Subscribe variants carry an optional correlation_id field; the extractor
3953        // must forward whatever the inner command reports so captured subscribe
3954        // traffic joins its acknowledgements under one chain key.
3955        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        // The TradingCommand envelope dispatch must route every variant to the matching
3993        // per-type extractor and forward both correlation_id and causation_id intact.
3994        // A swap of args inside any extract_*_headers function or a misrouted wrapper arm
3995        // is caught by exercising each variant with distinct populated values.
3996        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        // Every DataResponse variant carries a required correlation_id paired with its
4103        // originating request; the extractor must forward that uuid intact regardless
4104        // of which variant is captured.
4105        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}