nautilus_serialization/capnp/
instruments.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//! Conversion implementations between Nautilus instruments and Cap'n Proto.
17
18use std::error::Error;
19
20use nautilus_core::{Params, UnixNanos};
21use nautilus_model::{
22    identifiers::{InstrumentId, Symbol},
23    instruments::{
24        BettingInstrument, BinaryOption, Cfd, Commodity, CryptoFuture, CryptoFuturesSpread,
25        CryptoOption, CryptoOptionSpread, CryptoPerpetual, CurrencyPair, Equity, FuturesContract,
26        FuturesSpread, IndexInstrument, InstrumentAny, OptionContract, OptionSpread,
27        PerpetualContract, SyntheticInstrument, TokenizedAsset,
28    },
29    types::{Currency, Price, Quantity},
30};
31use rust_decimal::Decimal;
32use ustr::Ustr;
33
34use super::{
35    FromCapnp, ToCapnp,
36    conversions::{
37        CapnpWriteExt, asset_class_from_capnp, asset_class_to_capnp, option_kind_from_capnp,
38        option_kind_to_capnp, read_optional_from_capnp,
39    },
40};
41use crate::{base_capnp, instruments_capnp};
42
43fn write_unix_nanos(value: UnixNanos, mut builder: base_capnp::unix_nanos::Builder<'_>) {
44    builder.set_value(*value);
45}
46
47fn read_unix_nanos<'a>(
48    get: impl FnOnce() -> capnp::Result<base_capnp::unix_nanos::Reader<'a>>,
49) -> Result<UnixNanos, Box<dyn Error>> {
50    Ok(get()?.get_value().into())
51}
52
53fn write_optional_ustr(value: Option<Ustr>, mut set: impl FnMut(&str)) {
54    if let Some(value) = value {
55        set(value.as_str());
56    }
57}
58
59fn read_optional_ustr<'a>(
60    has: bool,
61    get: impl FnOnce() -> capnp::Result<capnp::text::Reader<'a>>,
62) -> Result<Option<Ustr>, Box<dyn Error>> {
63    if has {
64        Ok(Some(Ustr::from(get()?.to_str()?)))
65    } else {
66        Ok(None)
67    }
68}
69
70fn read_ustr<'a>(
71    get: impl FnOnce() -> capnp::Result<capnp::text::Reader<'a>>,
72) -> Result<Ustr, Box<dyn Error>> {
73    Ok(Ustr::from(get()?.to_str()?))
74}
75
76fn write_optional_info(info: Option<&Params>, mut set: impl FnMut(&[u8])) {
77    if let Some(info) = info {
78        let bytes = serde_json::to_vec(info).expect("Params serializes to JSON");
79        set(&bytes);
80    }
81}
82
83fn read_optional_info<'a>(
84    has: bool,
85    get: impl FnOnce() -> capnp::Result<&'a [u8]>,
86) -> Result<Option<Params>, Box<dyn Error>> {
87    if has {
88        Ok(Some(serde_json::from_slice(get()?)?))
89    } else {
90        Ok(None)
91    }
92}
93
94impl<'a> ToCapnp<'a> for BettingInstrument {
95    type Builder = instruments_capnp::betting_instrument::Builder<'a>;
96
97    fn to_capnp(&self, mut builder: Self::Builder) {
98        self.id.write_capnp(|| builder.reborrow().init_id());
99        self.raw_symbol
100            .write_capnp(|| builder.reborrow().init_raw_symbol());
101        builder.set_event_type_id(self.event_type_id);
102        builder.set_event_type_name(self.event_type_name.as_str());
103        builder.set_competition_id(self.competition_id);
104        builder.set_competition_name(self.competition_name.as_str());
105        builder.set_event_id(self.event_id);
106        builder.set_event_name(self.event_name.as_str());
107        builder.set_event_country_code(self.event_country_code.as_str());
108        write_unix_nanos(
109            self.event_open_date,
110            builder.reborrow().init_event_open_date(),
111        );
112        builder.set_betting_type(self.betting_type.as_str());
113        builder.set_market_id(self.market_id.as_str());
114        builder.set_market_name(self.market_name.as_str());
115        builder.set_market_type(self.market_type.as_str());
116        write_unix_nanos(
117            self.market_start_time,
118            builder.reborrow().init_market_start_time(),
119        );
120        builder.set_selection_id(self.selection_id);
121        builder.set_selection_name(self.selection_name.as_str());
122        builder.set_selection_handicap(self.selection_handicap);
123        self.currency
124            .write_capnp(|| builder.reborrow().init_currency());
125        builder.set_price_precision(self.price_precision);
126        builder.set_size_precision(self.size_precision);
127        self.price_increment
128            .write_capnp(|| builder.reborrow().init_price_increment());
129        self.size_increment
130            .write_capnp(|| builder.reborrow().init_size_increment());
131        self.margin_init
132            .write_capnp(|| builder.reborrow().init_margin_init());
133        self.margin_maint
134            .write_capnp(|| builder.reborrow().init_margin_maint());
135        self.maker_fee
136            .write_capnp(|| builder.reborrow().init_maker_fee());
137        self.taker_fee
138            .write_capnp(|| builder.reborrow().init_taker_fee());
139        self.max_quantity
140            .write_capnp(|| builder.reborrow().init_max_quantity());
141        self.min_quantity
142            .write_capnp(|| builder.reborrow().init_min_quantity());
143        self.max_notional
144            .write_capnp(|| builder.reborrow().init_max_notional());
145        self.min_notional
146            .write_capnp(|| builder.reborrow().init_min_notional());
147        self.max_price
148            .write_capnp(|| builder.reborrow().init_max_price());
149        self.min_price
150            .write_capnp(|| builder.reborrow().init_min_price());
151        write_optional_ustr(self.tick_scheme, |value| {
152            builder.reborrow().set_tick_scheme(value);
153        });
154
155        write_optional_info(self.info.as_ref(), |bytes| {
156            builder.reborrow().set_info(bytes);
157        });
158
159        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
160        write_unix_nanos(self.ts_init, builder.init_ts_init());
161    }
162}
163
164impl<'a> FromCapnp<'a> for BettingInstrument {
165    type Reader = instruments_capnp::betting_instrument::Reader<'a>;
166
167    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
168        Ok(Self {
169            id: InstrumentId::from_capnp(reader.get_id()?)?,
170            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
171            event_type_id: reader.get_event_type_id(),
172            event_type_name: read_ustr(|| reader.get_event_type_name())?,
173            competition_id: reader.get_competition_id(),
174            competition_name: read_ustr(|| reader.get_competition_name())?,
175            event_id: reader.get_event_id(),
176            event_name: read_ustr(|| reader.get_event_name())?,
177            event_country_code: read_ustr(|| reader.get_event_country_code())?,
178            event_open_date: read_unix_nanos(|| reader.get_event_open_date())?,
179            betting_type: read_ustr(|| reader.get_betting_type())?,
180            market_id: read_ustr(|| reader.get_market_id())?,
181            market_name: read_ustr(|| reader.get_market_name())?,
182            market_type: read_ustr(|| reader.get_market_type())?,
183            market_start_time: read_unix_nanos(|| reader.get_market_start_time())?,
184            selection_id: reader.get_selection_id(),
185            selection_name: read_ustr(|| reader.get_selection_name())?,
186            selection_handicap: reader.get_selection_handicap(),
187            currency: Currency::from_capnp(reader.get_currency()?)?,
188            price_precision: reader.get_price_precision(),
189            size_precision: reader.get_size_precision(),
190            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
191            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
192            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
193            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
194            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
195            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
196            max_quantity: read_optional_from_capnp(
197                || reader.has_max_quantity(),
198                || reader.get_max_quantity(),
199            )?,
200            min_quantity: read_optional_from_capnp(
201                || reader.has_min_quantity(),
202                || reader.get_min_quantity(),
203            )?,
204            max_notional: read_optional_from_capnp(
205                || reader.has_max_notional(),
206                || reader.get_max_notional(),
207            )?,
208            min_notional: read_optional_from_capnp(
209                || reader.has_min_notional(),
210                || reader.get_min_notional(),
211            )?,
212            max_price: read_optional_from_capnp(
213                || reader.has_max_price(),
214                || reader.get_max_price(),
215            )?,
216            min_price: read_optional_from_capnp(
217                || reader.has_min_price(),
218                || reader.get_min_price(),
219            )?,
220            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
221            info: read_optional_info(reader.has_info(), || reader.get_info())?,
222            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
223            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
224        })
225    }
226}
227
228impl<'a> ToCapnp<'a> for BinaryOption {
229    type Builder = instruments_capnp::binary_option::Builder<'a>;
230
231    fn to_capnp(&self, mut builder: Self::Builder) {
232        self.id.write_capnp(|| builder.reborrow().init_id());
233        self.raw_symbol
234            .write_capnp(|| builder.reborrow().init_raw_symbol());
235        builder.set_asset_class(asset_class_to_capnp(self.asset_class));
236        self.currency
237            .write_capnp(|| builder.reborrow().init_currency());
238        write_unix_nanos(self.activation_ns, builder.reborrow().init_activation_ns());
239        write_unix_nanos(self.expiration_ns, builder.reborrow().init_expiration_ns());
240        builder.set_price_precision(self.price_precision);
241        builder.set_size_precision(self.size_precision);
242        self.price_increment
243            .write_capnp(|| builder.reborrow().init_price_increment());
244        self.size_increment
245            .write_capnp(|| builder.reborrow().init_size_increment());
246        self.margin_init
247            .write_capnp(|| builder.reborrow().init_margin_init());
248        self.margin_maint
249            .write_capnp(|| builder.reborrow().init_margin_maint());
250        self.maker_fee
251            .write_capnp(|| builder.reborrow().init_maker_fee());
252        self.taker_fee
253            .write_capnp(|| builder.reborrow().init_taker_fee());
254        write_optional_ustr(self.event_id, |value| {
255            builder.reborrow().set_event_id(value);
256        });
257
258        write_optional_ustr(self.outcome, |value| {
259            builder.reborrow().set_outcome(value);
260        });
261
262        write_optional_ustr(self.description, |value| {
263            builder.reborrow().set_description(value);
264        });
265
266        self.max_quantity
267            .write_capnp(|| builder.reborrow().init_max_quantity());
268        self.min_quantity
269            .write_capnp(|| builder.reborrow().init_min_quantity());
270        self.max_notional
271            .write_capnp(|| builder.reborrow().init_max_notional());
272        self.min_notional
273            .write_capnp(|| builder.reborrow().init_min_notional());
274        self.max_price
275            .write_capnp(|| builder.reborrow().init_max_price());
276        self.min_price
277            .write_capnp(|| builder.reborrow().init_min_price());
278        write_optional_ustr(self.tick_scheme, |value| {
279            builder.reborrow().set_tick_scheme(value);
280        });
281
282        write_optional_info(self.info.as_ref(), |bytes| {
283            builder.reborrow().set_info(bytes);
284        });
285
286        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
287        write_unix_nanos(self.ts_init, builder.init_ts_init());
288    }
289}
290
291impl<'a> FromCapnp<'a> for BinaryOption {
292    type Reader = instruments_capnp::binary_option::Reader<'a>;
293
294    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
295        Ok(Self {
296            id: InstrumentId::from_capnp(reader.get_id()?)?,
297            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
298            asset_class: asset_class_from_capnp(reader.get_asset_class()?),
299            currency: Currency::from_capnp(reader.get_currency()?)?,
300            activation_ns: read_unix_nanos(|| reader.get_activation_ns())?,
301            expiration_ns: read_unix_nanos(|| reader.get_expiration_ns())?,
302            price_precision: reader.get_price_precision(),
303            size_precision: reader.get_size_precision(),
304            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
305            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
306            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
307            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
308            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
309            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
310            event_id: read_optional_ustr(reader.has_event_id(), || reader.get_event_id())?,
311            outcome: read_optional_ustr(reader.has_outcome(), || reader.get_outcome())?,
312            description: read_optional_ustr(reader.has_description(), || reader.get_description())?,
313            max_quantity: read_optional_from_capnp(
314                || reader.has_max_quantity(),
315                || reader.get_max_quantity(),
316            )?,
317            min_quantity: read_optional_from_capnp(
318                || reader.has_min_quantity(),
319                || reader.get_min_quantity(),
320            )?,
321            max_notional: read_optional_from_capnp(
322                || reader.has_max_notional(),
323                || reader.get_max_notional(),
324            )?,
325            min_notional: read_optional_from_capnp(
326                || reader.has_min_notional(),
327                || reader.get_min_notional(),
328            )?,
329            max_price: read_optional_from_capnp(
330                || reader.has_max_price(),
331                || reader.get_max_price(),
332            )?,
333            min_price: read_optional_from_capnp(
334                || reader.has_min_price(),
335                || reader.get_min_price(),
336            )?,
337            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
338            info: read_optional_info(reader.has_info(), || reader.get_info())?,
339            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
340            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
341        })
342    }
343}
344
345impl<'a> ToCapnp<'a> for Cfd {
346    type Builder = instruments_capnp::cfd::Builder<'a>;
347
348    fn to_capnp(&self, mut builder: Self::Builder) {
349        self.id.write_capnp(|| builder.reborrow().init_id());
350        self.raw_symbol
351            .write_capnp(|| builder.reborrow().init_raw_symbol());
352        builder.set_asset_class(asset_class_to_capnp(self.asset_class));
353        self.base_currency
354            .write_capnp(|| builder.reborrow().init_base_currency());
355        self.quote_currency
356            .write_capnp(|| builder.reborrow().init_quote_currency());
357        builder.set_price_precision(self.price_precision);
358        builder.set_size_precision(self.size_precision);
359        self.price_increment
360            .write_capnp(|| builder.reborrow().init_price_increment());
361        self.size_increment
362            .write_capnp(|| builder.reborrow().init_size_increment());
363        self.margin_init
364            .write_capnp(|| builder.reborrow().init_margin_init());
365        self.margin_maint
366            .write_capnp(|| builder.reborrow().init_margin_maint());
367        self.maker_fee
368            .write_capnp(|| builder.reborrow().init_maker_fee());
369        self.taker_fee
370            .write_capnp(|| builder.reborrow().init_taker_fee());
371        self.lot_size
372            .write_capnp(|| builder.reborrow().init_lot_size());
373        self.max_quantity
374            .write_capnp(|| builder.reborrow().init_max_quantity());
375        self.min_quantity
376            .write_capnp(|| builder.reborrow().init_min_quantity());
377        self.max_notional
378            .write_capnp(|| builder.reborrow().init_max_notional());
379        self.min_notional
380            .write_capnp(|| builder.reborrow().init_min_notional());
381        self.max_price
382            .write_capnp(|| builder.reborrow().init_max_price());
383        self.min_price
384            .write_capnp(|| builder.reborrow().init_min_price());
385        write_optional_ustr(self.tick_scheme, |value| {
386            builder.reborrow().set_tick_scheme(value);
387        });
388
389        write_optional_info(self.info.as_ref(), |bytes| {
390            builder.reborrow().set_info(bytes);
391        });
392
393        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
394        write_unix_nanos(self.ts_init, builder.init_ts_init());
395    }
396}
397
398impl<'a> FromCapnp<'a> for Cfd {
399    type Reader = instruments_capnp::cfd::Reader<'a>;
400
401    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
402        Ok(Self {
403            id: InstrumentId::from_capnp(reader.get_id()?)?,
404            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
405            asset_class: asset_class_from_capnp(reader.get_asset_class()?),
406            base_currency: read_optional_from_capnp(
407                || reader.has_base_currency(),
408                || reader.get_base_currency(),
409            )?,
410            quote_currency: Currency::from_capnp(reader.get_quote_currency()?)?,
411            price_precision: reader.get_price_precision(),
412            size_precision: reader.get_size_precision(),
413            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
414            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
415            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
416            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
417            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
418            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
419            lot_size: read_optional_from_capnp(|| reader.has_lot_size(), || reader.get_lot_size())?,
420            max_quantity: read_optional_from_capnp(
421                || reader.has_max_quantity(),
422                || reader.get_max_quantity(),
423            )?,
424            min_quantity: read_optional_from_capnp(
425                || reader.has_min_quantity(),
426                || reader.get_min_quantity(),
427            )?,
428            max_notional: read_optional_from_capnp(
429                || reader.has_max_notional(),
430                || reader.get_max_notional(),
431            )?,
432            min_notional: read_optional_from_capnp(
433                || reader.has_min_notional(),
434                || reader.get_min_notional(),
435            )?,
436            max_price: read_optional_from_capnp(
437                || reader.has_max_price(),
438                || reader.get_max_price(),
439            )?,
440            min_price: read_optional_from_capnp(
441                || reader.has_min_price(),
442                || reader.get_min_price(),
443            )?,
444            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
445            info: read_optional_info(reader.has_info(), || reader.get_info())?,
446            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
447            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
448        })
449    }
450}
451
452impl<'a> ToCapnp<'a> for Commodity {
453    type Builder = instruments_capnp::commodity::Builder<'a>;
454
455    fn to_capnp(&self, mut builder: Self::Builder) {
456        self.id.write_capnp(|| builder.reborrow().init_id());
457        self.raw_symbol
458            .write_capnp(|| builder.reborrow().init_raw_symbol());
459        builder.set_asset_class(asset_class_to_capnp(self.asset_class));
460        self.quote_currency
461            .write_capnp(|| builder.reborrow().init_quote_currency());
462        builder.set_price_precision(self.price_precision);
463        builder.set_size_precision(self.size_precision);
464        self.price_increment
465            .write_capnp(|| builder.reborrow().init_price_increment());
466        self.size_increment
467            .write_capnp(|| builder.reborrow().init_size_increment());
468        self.margin_init
469            .write_capnp(|| builder.reborrow().init_margin_init());
470        self.margin_maint
471            .write_capnp(|| builder.reborrow().init_margin_maint());
472        self.maker_fee
473            .write_capnp(|| builder.reborrow().init_maker_fee());
474        self.taker_fee
475            .write_capnp(|| builder.reborrow().init_taker_fee());
476        self.lot_size
477            .write_capnp(|| builder.reborrow().init_lot_size());
478        self.max_quantity
479            .write_capnp(|| builder.reborrow().init_max_quantity());
480        self.min_quantity
481            .write_capnp(|| builder.reborrow().init_min_quantity());
482        self.max_notional
483            .write_capnp(|| builder.reborrow().init_max_notional());
484        self.min_notional
485            .write_capnp(|| builder.reborrow().init_min_notional());
486        self.max_price
487            .write_capnp(|| builder.reborrow().init_max_price());
488        self.min_price
489            .write_capnp(|| builder.reborrow().init_min_price());
490        write_optional_ustr(self.tick_scheme, |value| {
491            builder.reborrow().set_tick_scheme(value);
492        });
493
494        write_optional_info(self.info.as_ref(), |bytes| {
495            builder.reborrow().set_info(bytes);
496        });
497
498        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
499        write_unix_nanos(self.ts_init, builder.init_ts_init());
500    }
501}
502
503impl<'a> FromCapnp<'a> for Commodity {
504    type Reader = instruments_capnp::commodity::Reader<'a>;
505
506    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
507        Ok(Self {
508            id: InstrumentId::from_capnp(reader.get_id()?)?,
509            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
510            asset_class: asset_class_from_capnp(reader.get_asset_class()?),
511            quote_currency: Currency::from_capnp(reader.get_quote_currency()?)?,
512            price_precision: reader.get_price_precision(),
513            size_precision: reader.get_size_precision(),
514            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
515            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
516            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
517            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
518            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
519            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
520            lot_size: read_optional_from_capnp(|| reader.has_lot_size(), || reader.get_lot_size())?,
521            max_quantity: read_optional_from_capnp(
522                || reader.has_max_quantity(),
523                || reader.get_max_quantity(),
524            )?,
525            min_quantity: read_optional_from_capnp(
526                || reader.has_min_quantity(),
527                || reader.get_min_quantity(),
528            )?,
529            max_notional: read_optional_from_capnp(
530                || reader.has_max_notional(),
531                || reader.get_max_notional(),
532            )?,
533            min_notional: read_optional_from_capnp(
534                || reader.has_min_notional(),
535                || reader.get_min_notional(),
536            )?,
537            max_price: read_optional_from_capnp(
538                || reader.has_max_price(),
539                || reader.get_max_price(),
540            )?,
541            min_price: read_optional_from_capnp(
542                || reader.has_min_price(),
543                || reader.get_min_price(),
544            )?,
545            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
546            info: read_optional_info(reader.has_info(), || reader.get_info())?,
547            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
548            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
549        })
550    }
551}
552
553impl<'a> ToCapnp<'a> for CryptoFuture {
554    type Builder = instruments_capnp::crypto_future::Builder<'a>;
555
556    fn to_capnp(&self, mut builder: Self::Builder) {
557        self.id.write_capnp(|| builder.reborrow().init_id());
558        self.raw_symbol
559            .write_capnp(|| builder.reborrow().init_raw_symbol());
560        self.underlying
561            .write_capnp(|| builder.reborrow().init_underlying());
562        self.quote_currency
563            .write_capnp(|| builder.reborrow().init_quote_currency());
564        self.settlement_currency
565            .write_capnp(|| builder.reborrow().init_settlement_currency());
566        builder.set_is_inverse(self.is_inverse);
567        write_unix_nanos(self.activation_ns, builder.reborrow().init_activation_ns());
568        write_unix_nanos(self.expiration_ns, builder.reborrow().init_expiration_ns());
569        builder.set_price_precision(self.price_precision);
570        builder.set_size_precision(self.size_precision);
571        self.price_increment
572            .write_capnp(|| builder.reborrow().init_price_increment());
573        self.size_increment
574            .write_capnp(|| builder.reborrow().init_size_increment());
575        self.multiplier
576            .write_capnp(|| builder.reborrow().init_multiplier());
577        self.lot_size
578            .write_capnp(|| builder.reborrow().init_lot_size());
579        self.margin_init
580            .write_capnp(|| builder.reborrow().init_margin_init());
581        self.margin_maint
582            .write_capnp(|| builder.reborrow().init_margin_maint());
583        self.maker_fee
584            .write_capnp(|| builder.reborrow().init_maker_fee());
585        self.taker_fee
586            .write_capnp(|| builder.reborrow().init_taker_fee());
587        self.max_quantity
588            .write_capnp(|| builder.reborrow().init_max_quantity());
589        self.min_quantity
590            .write_capnp(|| builder.reborrow().init_min_quantity());
591        self.max_notional
592            .write_capnp(|| builder.reborrow().init_max_notional());
593        self.min_notional
594            .write_capnp(|| builder.reborrow().init_min_notional());
595        self.max_price
596            .write_capnp(|| builder.reborrow().init_max_price());
597        self.min_price
598            .write_capnp(|| builder.reborrow().init_min_price());
599        write_optional_ustr(self.tick_scheme, |value| {
600            builder.reborrow().set_tick_scheme(value);
601        });
602
603        write_optional_info(self.info.as_ref(), |bytes| {
604            builder.reborrow().set_info(bytes);
605        });
606
607        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
608        write_unix_nanos(self.ts_init, builder.init_ts_init());
609    }
610}
611
612impl<'a> FromCapnp<'a> for CryptoFuture {
613    type Reader = instruments_capnp::crypto_future::Reader<'a>;
614
615    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
616        Ok(Self {
617            id: InstrumentId::from_capnp(reader.get_id()?)?,
618            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
619            underlying: Currency::from_capnp(reader.get_underlying()?)?,
620            quote_currency: Currency::from_capnp(reader.get_quote_currency()?)?,
621            settlement_currency: Currency::from_capnp(reader.get_settlement_currency()?)?,
622            is_inverse: reader.get_is_inverse(),
623            activation_ns: read_unix_nanos(|| reader.get_activation_ns())?,
624            expiration_ns: read_unix_nanos(|| reader.get_expiration_ns())?,
625            price_precision: reader.get_price_precision(),
626            size_precision: reader.get_size_precision(),
627            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
628            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
629            multiplier: Quantity::from_capnp(reader.get_multiplier()?)?,
630            lot_size: Quantity::from_capnp(reader.get_lot_size()?)?,
631            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
632            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
633            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
634            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
635            max_quantity: read_optional_from_capnp(
636                || reader.has_max_quantity(),
637                || reader.get_max_quantity(),
638            )?,
639            min_quantity: read_optional_from_capnp(
640                || reader.has_min_quantity(),
641                || reader.get_min_quantity(),
642            )?,
643            max_notional: read_optional_from_capnp(
644                || reader.has_max_notional(),
645                || reader.get_max_notional(),
646            )?,
647            min_notional: read_optional_from_capnp(
648                || reader.has_min_notional(),
649                || reader.get_min_notional(),
650            )?,
651            max_price: read_optional_from_capnp(
652                || reader.has_max_price(),
653                || reader.get_max_price(),
654            )?,
655            min_price: read_optional_from_capnp(
656                || reader.has_min_price(),
657                || reader.get_min_price(),
658            )?,
659            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
660            info: read_optional_info(reader.has_info(), || reader.get_info())?,
661            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
662            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
663        })
664    }
665}
666
667impl<'a> ToCapnp<'a> for CryptoFuturesSpread {
668    type Builder = instruments_capnp::crypto_futures_spread::Builder<'a>;
669
670    fn to_capnp(&self, mut builder: Self::Builder) {
671        self.id.write_capnp(|| builder.reborrow().init_id());
672        self.raw_symbol
673            .write_capnp(|| builder.reborrow().init_raw_symbol());
674        self.underlying
675            .write_capnp(|| builder.reborrow().init_underlying());
676        self.quote_currency
677            .write_capnp(|| builder.reborrow().init_quote_currency());
678        self.settlement_currency
679            .write_capnp(|| builder.reborrow().init_settlement_currency());
680        builder.set_is_inverse(self.is_inverse);
681        builder.set_strategy_type(self.strategy_type.as_str());
682        write_unix_nanos(self.activation_ns, builder.reborrow().init_activation_ns());
683        write_unix_nanos(self.expiration_ns, builder.reborrow().init_expiration_ns());
684        builder.set_price_precision(self.price_precision);
685        builder.set_size_precision(self.size_precision);
686        self.price_increment
687            .write_capnp(|| builder.reborrow().init_price_increment());
688        self.size_increment
689            .write_capnp(|| builder.reborrow().init_size_increment());
690        self.multiplier
691            .write_capnp(|| builder.reborrow().init_multiplier());
692        self.lot_size
693            .write_capnp(|| builder.reborrow().init_lot_size());
694        self.margin_init
695            .write_capnp(|| builder.reborrow().init_margin_init());
696        self.margin_maint
697            .write_capnp(|| builder.reborrow().init_margin_maint());
698        self.maker_fee
699            .write_capnp(|| builder.reborrow().init_maker_fee());
700        self.taker_fee
701            .write_capnp(|| builder.reborrow().init_taker_fee());
702        self.max_quantity
703            .write_capnp(|| builder.reborrow().init_max_quantity());
704        self.min_quantity
705            .write_capnp(|| builder.reborrow().init_min_quantity());
706        self.max_notional
707            .write_capnp(|| builder.reborrow().init_max_notional());
708        self.min_notional
709            .write_capnp(|| builder.reborrow().init_min_notional());
710        self.max_price
711            .write_capnp(|| builder.reborrow().init_max_price());
712        self.min_price
713            .write_capnp(|| builder.reborrow().init_min_price());
714        write_optional_ustr(self.tick_scheme, |value| {
715            builder.reborrow().set_tick_scheme(value);
716        });
717
718        write_optional_info(self.info.as_ref(), |bytes| {
719            builder.reborrow().set_info(bytes);
720        });
721
722        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
723        write_unix_nanos(self.ts_init, builder.init_ts_init());
724    }
725}
726
727impl<'a> FromCapnp<'a> for CryptoFuturesSpread {
728    type Reader = instruments_capnp::crypto_futures_spread::Reader<'a>;
729
730    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
731        Ok(Self {
732            id: InstrumentId::from_capnp(reader.get_id()?)?,
733            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
734            underlying: Currency::from_capnp(reader.get_underlying()?)?,
735            quote_currency: Currency::from_capnp(reader.get_quote_currency()?)?,
736            settlement_currency: Currency::from_capnp(reader.get_settlement_currency()?)?,
737            is_inverse: reader.get_is_inverse(),
738            strategy_type: read_ustr(|| reader.get_strategy_type())?,
739            activation_ns: read_unix_nanos(|| reader.get_activation_ns())?,
740            expiration_ns: read_unix_nanos(|| reader.get_expiration_ns())?,
741            price_precision: reader.get_price_precision(),
742            size_precision: reader.get_size_precision(),
743            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
744            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
745            multiplier: Quantity::from_capnp(reader.get_multiplier()?)?,
746            lot_size: Quantity::from_capnp(reader.get_lot_size()?)?,
747            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
748            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
749            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
750            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
751            max_quantity: read_optional_from_capnp(
752                || reader.has_max_quantity(),
753                || reader.get_max_quantity(),
754            )?,
755            min_quantity: read_optional_from_capnp(
756                || reader.has_min_quantity(),
757                || reader.get_min_quantity(),
758            )?,
759            max_notional: read_optional_from_capnp(
760                || reader.has_max_notional(),
761                || reader.get_max_notional(),
762            )?,
763            min_notional: read_optional_from_capnp(
764                || reader.has_min_notional(),
765                || reader.get_min_notional(),
766            )?,
767            max_price: read_optional_from_capnp(
768                || reader.has_max_price(),
769                || reader.get_max_price(),
770            )?,
771            min_price: read_optional_from_capnp(
772                || reader.has_min_price(),
773                || reader.get_min_price(),
774            )?,
775            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
776            info: read_optional_info(reader.has_info(), || reader.get_info())?,
777            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
778            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
779        })
780    }
781}
782
783impl<'a> ToCapnp<'a> for CryptoOption {
784    type Builder = instruments_capnp::crypto_option::Builder<'a>;
785
786    fn to_capnp(&self, mut builder: Self::Builder) {
787        self.id.write_capnp(|| builder.reborrow().init_id());
788        self.raw_symbol
789            .write_capnp(|| builder.reborrow().init_raw_symbol());
790        self.underlying
791            .write_capnp(|| builder.reborrow().init_underlying());
792        self.quote_currency
793            .write_capnp(|| builder.reborrow().init_quote_currency());
794        self.settlement_currency
795            .write_capnp(|| builder.reborrow().init_settlement_currency());
796        builder.set_is_inverse(self.is_inverse);
797        builder.set_option_kind(option_kind_to_capnp(self.option_kind));
798        self.strike_price
799            .write_capnp(|| builder.reborrow().init_strike_price());
800        write_unix_nanos(self.activation_ns, builder.reborrow().init_activation_ns());
801        write_unix_nanos(self.expiration_ns, builder.reborrow().init_expiration_ns());
802        builder.set_price_precision(self.price_precision);
803        builder.set_size_precision(self.size_precision);
804        self.price_increment
805            .write_capnp(|| builder.reborrow().init_price_increment());
806        self.size_increment
807            .write_capnp(|| builder.reborrow().init_size_increment());
808        self.multiplier
809            .write_capnp(|| builder.reborrow().init_multiplier());
810        self.lot_size
811            .write_capnp(|| builder.reborrow().init_lot_size());
812        self.margin_init
813            .write_capnp(|| builder.reborrow().init_margin_init());
814        self.margin_maint
815            .write_capnp(|| builder.reborrow().init_margin_maint());
816        self.maker_fee
817            .write_capnp(|| builder.reborrow().init_maker_fee());
818        self.taker_fee
819            .write_capnp(|| builder.reborrow().init_taker_fee());
820        self.max_quantity
821            .write_capnp(|| builder.reborrow().init_max_quantity());
822        self.min_quantity
823            .write_capnp(|| builder.reborrow().init_min_quantity());
824        self.max_notional
825            .write_capnp(|| builder.reborrow().init_max_notional());
826        self.min_notional
827            .write_capnp(|| builder.reborrow().init_min_notional());
828        self.max_price
829            .write_capnp(|| builder.reborrow().init_max_price());
830        self.min_price
831            .write_capnp(|| builder.reborrow().init_min_price());
832        write_optional_ustr(self.tick_scheme, |value| {
833            builder.reborrow().set_tick_scheme(value);
834        });
835
836        write_optional_info(self.info.as_ref(), |bytes| {
837            builder.reborrow().set_info(bytes);
838        });
839
840        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
841        write_unix_nanos(self.ts_init, builder.init_ts_init());
842    }
843}
844
845impl<'a> FromCapnp<'a> for CryptoOption {
846    type Reader = instruments_capnp::crypto_option::Reader<'a>;
847
848    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
849        Ok(Self {
850            id: InstrumentId::from_capnp(reader.get_id()?)?,
851            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
852            underlying: Currency::from_capnp(reader.get_underlying()?)?,
853            quote_currency: Currency::from_capnp(reader.get_quote_currency()?)?,
854            settlement_currency: Currency::from_capnp(reader.get_settlement_currency()?)?,
855            is_inverse: reader.get_is_inverse(),
856            option_kind: option_kind_from_capnp(reader.get_option_kind()?),
857            strike_price: Price::from_capnp(reader.get_strike_price()?)?,
858            activation_ns: read_unix_nanos(|| reader.get_activation_ns())?,
859            expiration_ns: read_unix_nanos(|| reader.get_expiration_ns())?,
860            price_precision: reader.get_price_precision(),
861            size_precision: reader.get_size_precision(),
862            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
863            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
864            multiplier: Quantity::from_capnp(reader.get_multiplier()?)?,
865            lot_size: Quantity::from_capnp(reader.get_lot_size()?)?,
866            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
867            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
868            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
869            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
870            max_quantity: read_optional_from_capnp(
871                || reader.has_max_quantity(),
872                || reader.get_max_quantity(),
873            )?,
874            min_quantity: read_optional_from_capnp(
875                || reader.has_min_quantity(),
876                || reader.get_min_quantity(),
877            )?,
878            max_notional: read_optional_from_capnp(
879                || reader.has_max_notional(),
880                || reader.get_max_notional(),
881            )?,
882            min_notional: read_optional_from_capnp(
883                || reader.has_min_notional(),
884                || reader.get_min_notional(),
885            )?,
886            max_price: read_optional_from_capnp(
887                || reader.has_max_price(),
888                || reader.get_max_price(),
889            )?,
890            min_price: read_optional_from_capnp(
891                || reader.has_min_price(),
892                || reader.get_min_price(),
893            )?,
894            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
895            info: read_optional_info(reader.has_info(), || reader.get_info())?,
896            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
897            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
898        })
899    }
900}
901
902impl<'a> ToCapnp<'a> for CryptoOptionSpread {
903    type Builder = instruments_capnp::crypto_option_spread::Builder<'a>;
904
905    fn to_capnp(&self, mut builder: Self::Builder) {
906        self.id.write_capnp(|| builder.reborrow().init_id());
907        self.raw_symbol
908            .write_capnp(|| builder.reborrow().init_raw_symbol());
909        self.underlying
910            .write_capnp(|| builder.reborrow().init_underlying());
911        self.quote_currency
912            .write_capnp(|| builder.reborrow().init_quote_currency());
913        self.settlement_currency
914            .write_capnp(|| builder.reborrow().init_settlement_currency());
915        builder.set_is_inverse(self.is_inverse);
916        builder.set_strategy_type(self.strategy_type.as_str());
917        write_unix_nanos(self.activation_ns, builder.reborrow().init_activation_ns());
918        write_unix_nanos(self.expiration_ns, builder.reborrow().init_expiration_ns());
919        builder.set_price_precision(self.price_precision);
920        builder.set_size_precision(self.size_precision);
921        self.price_increment
922            .write_capnp(|| builder.reborrow().init_price_increment());
923        self.size_increment
924            .write_capnp(|| builder.reborrow().init_size_increment());
925        self.multiplier
926            .write_capnp(|| builder.reborrow().init_multiplier());
927        self.lot_size
928            .write_capnp(|| builder.reborrow().init_lot_size());
929        self.margin_init
930            .write_capnp(|| builder.reborrow().init_margin_init());
931        self.margin_maint
932            .write_capnp(|| builder.reborrow().init_margin_maint());
933        self.maker_fee
934            .write_capnp(|| builder.reborrow().init_maker_fee());
935        self.taker_fee
936            .write_capnp(|| builder.reborrow().init_taker_fee());
937        self.max_quantity
938            .write_capnp(|| builder.reborrow().init_max_quantity());
939        self.min_quantity
940            .write_capnp(|| builder.reborrow().init_min_quantity());
941        self.max_notional
942            .write_capnp(|| builder.reborrow().init_max_notional());
943        self.min_notional
944            .write_capnp(|| builder.reborrow().init_min_notional());
945        self.max_price
946            .write_capnp(|| builder.reborrow().init_max_price());
947        self.min_price
948            .write_capnp(|| builder.reborrow().init_min_price());
949        write_optional_ustr(self.tick_scheme, |value| {
950            builder.reborrow().set_tick_scheme(value);
951        });
952
953        write_optional_info(self.info.as_ref(), |bytes| {
954            builder.reborrow().set_info(bytes);
955        });
956
957        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
958        write_unix_nanos(self.ts_init, builder.init_ts_init());
959    }
960}
961
962impl<'a> FromCapnp<'a> for CryptoOptionSpread {
963    type Reader = instruments_capnp::crypto_option_spread::Reader<'a>;
964
965    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
966        Ok(Self {
967            id: InstrumentId::from_capnp(reader.get_id()?)?,
968            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
969            underlying: Currency::from_capnp(reader.get_underlying()?)?,
970            quote_currency: Currency::from_capnp(reader.get_quote_currency()?)?,
971            settlement_currency: Currency::from_capnp(reader.get_settlement_currency()?)?,
972            is_inverse: reader.get_is_inverse(),
973            strategy_type: read_ustr(|| reader.get_strategy_type())?,
974            activation_ns: read_unix_nanos(|| reader.get_activation_ns())?,
975            expiration_ns: read_unix_nanos(|| reader.get_expiration_ns())?,
976            price_precision: reader.get_price_precision(),
977            size_precision: reader.get_size_precision(),
978            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
979            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
980            multiplier: Quantity::from_capnp(reader.get_multiplier()?)?,
981            lot_size: Quantity::from_capnp(reader.get_lot_size()?)?,
982            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
983            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
984            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
985            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
986            max_quantity: read_optional_from_capnp(
987                || reader.has_max_quantity(),
988                || reader.get_max_quantity(),
989            )?,
990            min_quantity: read_optional_from_capnp(
991                || reader.has_min_quantity(),
992                || reader.get_min_quantity(),
993            )?,
994            max_notional: read_optional_from_capnp(
995                || reader.has_max_notional(),
996                || reader.get_max_notional(),
997            )?,
998            min_notional: read_optional_from_capnp(
999                || reader.has_min_notional(),
1000                || reader.get_min_notional(),
1001            )?,
1002            max_price: read_optional_from_capnp(
1003                || reader.has_max_price(),
1004                || reader.get_max_price(),
1005            )?,
1006            min_price: read_optional_from_capnp(
1007                || reader.has_min_price(),
1008                || reader.get_min_price(),
1009            )?,
1010            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
1011            info: read_optional_info(reader.has_info(), || reader.get_info())?,
1012            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
1013            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
1014        })
1015    }
1016}
1017
1018impl<'a> ToCapnp<'a> for CryptoPerpetual {
1019    type Builder = instruments_capnp::crypto_perpetual::Builder<'a>;
1020
1021    fn to_capnp(&self, mut builder: Self::Builder) {
1022        self.id.write_capnp(|| builder.reborrow().init_id());
1023        self.raw_symbol
1024            .write_capnp(|| builder.reborrow().init_raw_symbol());
1025        self.base_currency
1026            .write_capnp(|| builder.reborrow().init_base_currency());
1027        self.quote_currency
1028            .write_capnp(|| builder.reborrow().init_quote_currency());
1029        self.settlement_currency
1030            .write_capnp(|| builder.reborrow().init_settlement_currency());
1031        builder.set_is_inverse(self.is_inverse);
1032        builder.set_price_precision(self.price_precision);
1033        builder.set_size_precision(self.size_precision);
1034        self.price_increment
1035            .write_capnp(|| builder.reborrow().init_price_increment());
1036        self.size_increment
1037            .write_capnp(|| builder.reborrow().init_size_increment());
1038        self.multiplier
1039            .write_capnp(|| builder.reborrow().init_multiplier());
1040        self.lot_size
1041            .write_capnp(|| builder.reborrow().init_lot_size());
1042        self.margin_init
1043            .write_capnp(|| builder.reborrow().init_margin_init());
1044        self.margin_maint
1045            .write_capnp(|| builder.reborrow().init_margin_maint());
1046        self.maker_fee
1047            .write_capnp(|| builder.reborrow().init_maker_fee());
1048        self.taker_fee
1049            .write_capnp(|| builder.reborrow().init_taker_fee());
1050        self.max_quantity
1051            .write_capnp(|| builder.reborrow().init_max_quantity());
1052        self.min_quantity
1053            .write_capnp(|| builder.reborrow().init_min_quantity());
1054        self.max_notional
1055            .write_capnp(|| builder.reborrow().init_max_notional());
1056        self.min_notional
1057            .write_capnp(|| builder.reborrow().init_min_notional());
1058        self.max_price
1059            .write_capnp(|| builder.reborrow().init_max_price());
1060        self.min_price
1061            .write_capnp(|| builder.reborrow().init_min_price());
1062        write_optional_ustr(self.tick_scheme, |value| {
1063            builder.reborrow().set_tick_scheme(value);
1064        });
1065
1066        write_optional_info(self.info.as_ref(), |bytes| {
1067            builder.reborrow().set_info(bytes);
1068        });
1069
1070        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
1071        write_unix_nanos(self.ts_init, builder.init_ts_init());
1072    }
1073}
1074
1075impl<'a> FromCapnp<'a> for CryptoPerpetual {
1076    type Reader = instruments_capnp::crypto_perpetual::Reader<'a>;
1077
1078    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
1079        Ok(Self {
1080            id: InstrumentId::from_capnp(reader.get_id()?)?,
1081            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
1082            base_currency: Currency::from_capnp(reader.get_base_currency()?)?,
1083            quote_currency: Currency::from_capnp(reader.get_quote_currency()?)?,
1084            settlement_currency: Currency::from_capnp(reader.get_settlement_currency()?)?,
1085            is_inverse: reader.get_is_inverse(),
1086            price_precision: reader.get_price_precision(),
1087            size_precision: reader.get_size_precision(),
1088            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
1089            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
1090            multiplier: Quantity::from_capnp(reader.get_multiplier()?)?,
1091            lot_size: Quantity::from_capnp(reader.get_lot_size()?)?,
1092            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
1093            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
1094            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
1095            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
1096            max_quantity: read_optional_from_capnp(
1097                || reader.has_max_quantity(),
1098                || reader.get_max_quantity(),
1099            )?,
1100            min_quantity: read_optional_from_capnp(
1101                || reader.has_min_quantity(),
1102                || reader.get_min_quantity(),
1103            )?,
1104            max_notional: read_optional_from_capnp(
1105                || reader.has_max_notional(),
1106                || reader.get_max_notional(),
1107            )?,
1108            min_notional: read_optional_from_capnp(
1109                || reader.has_min_notional(),
1110                || reader.get_min_notional(),
1111            )?,
1112            max_price: read_optional_from_capnp(
1113                || reader.has_max_price(),
1114                || reader.get_max_price(),
1115            )?,
1116            min_price: read_optional_from_capnp(
1117                || reader.has_min_price(),
1118                || reader.get_min_price(),
1119            )?,
1120            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
1121            info: read_optional_info(reader.has_info(), || reader.get_info())?,
1122            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
1123            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
1124        })
1125    }
1126}
1127
1128impl<'a> ToCapnp<'a> for CurrencyPair {
1129    type Builder = instruments_capnp::currency_pair::Builder<'a>;
1130
1131    fn to_capnp(&self, mut builder: Self::Builder) {
1132        self.id.write_capnp(|| builder.reborrow().init_id());
1133        self.raw_symbol
1134            .write_capnp(|| builder.reborrow().init_raw_symbol());
1135        self.base_currency
1136            .write_capnp(|| builder.reborrow().init_base_currency());
1137        self.quote_currency
1138            .write_capnp(|| builder.reborrow().init_quote_currency());
1139        builder.set_price_precision(self.price_precision);
1140        builder.set_size_precision(self.size_precision);
1141        self.price_increment
1142            .write_capnp(|| builder.reborrow().init_price_increment());
1143        self.size_increment
1144            .write_capnp(|| builder.reborrow().init_size_increment());
1145        self.multiplier
1146            .write_capnp(|| builder.reborrow().init_multiplier());
1147        self.lot_size
1148            .write_capnp(|| builder.reborrow().init_lot_size());
1149        self.margin_init
1150            .write_capnp(|| builder.reborrow().init_margin_init());
1151        self.margin_maint
1152            .write_capnp(|| builder.reborrow().init_margin_maint());
1153        self.maker_fee
1154            .write_capnp(|| builder.reborrow().init_maker_fee());
1155        self.taker_fee
1156            .write_capnp(|| builder.reborrow().init_taker_fee());
1157        self.max_quantity
1158            .write_capnp(|| builder.reborrow().init_max_quantity());
1159        self.min_quantity
1160            .write_capnp(|| builder.reborrow().init_min_quantity());
1161        self.max_notional
1162            .write_capnp(|| builder.reborrow().init_max_notional());
1163        self.min_notional
1164            .write_capnp(|| builder.reborrow().init_min_notional());
1165        self.max_price
1166            .write_capnp(|| builder.reborrow().init_max_price());
1167        self.min_price
1168            .write_capnp(|| builder.reborrow().init_min_price());
1169        write_optional_ustr(self.tick_scheme, |value| {
1170            builder.reborrow().set_tick_scheme(value);
1171        });
1172
1173        write_optional_info(self.info.as_ref(), |bytes| {
1174            builder.reborrow().set_info(bytes);
1175        });
1176
1177        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
1178        write_unix_nanos(self.ts_init, builder.init_ts_init());
1179    }
1180}
1181
1182impl<'a> FromCapnp<'a> for CurrencyPair {
1183    type Reader = instruments_capnp::currency_pair::Reader<'a>;
1184
1185    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
1186        Ok(Self {
1187            id: InstrumentId::from_capnp(reader.get_id()?)?,
1188            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
1189            base_currency: Currency::from_capnp(reader.get_base_currency()?)?,
1190            quote_currency: Currency::from_capnp(reader.get_quote_currency()?)?,
1191            price_precision: reader.get_price_precision(),
1192            size_precision: reader.get_size_precision(),
1193            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
1194            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
1195            multiplier: Quantity::from_capnp(reader.get_multiplier()?)?,
1196            lot_size: read_optional_from_capnp(|| reader.has_lot_size(), || reader.get_lot_size())?,
1197            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
1198            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
1199            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
1200            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
1201            max_quantity: read_optional_from_capnp(
1202                || reader.has_max_quantity(),
1203                || reader.get_max_quantity(),
1204            )?,
1205            min_quantity: read_optional_from_capnp(
1206                || reader.has_min_quantity(),
1207                || reader.get_min_quantity(),
1208            )?,
1209            max_notional: read_optional_from_capnp(
1210                || reader.has_max_notional(),
1211                || reader.get_max_notional(),
1212            )?,
1213            min_notional: read_optional_from_capnp(
1214                || reader.has_min_notional(),
1215                || reader.get_min_notional(),
1216            )?,
1217            max_price: read_optional_from_capnp(
1218                || reader.has_max_price(),
1219                || reader.get_max_price(),
1220            )?,
1221            min_price: read_optional_from_capnp(
1222                || reader.has_min_price(),
1223                || reader.get_min_price(),
1224            )?,
1225            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
1226            info: read_optional_info(reader.has_info(), || reader.get_info())?,
1227            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
1228            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
1229        })
1230    }
1231}
1232
1233impl<'a> ToCapnp<'a> for Equity {
1234    type Builder = instruments_capnp::equity::Builder<'a>;
1235
1236    fn to_capnp(&self, mut builder: Self::Builder) {
1237        self.id.write_capnp(|| builder.reborrow().init_id());
1238        self.raw_symbol
1239            .write_capnp(|| builder.reborrow().init_raw_symbol());
1240        write_optional_ustr(self.isin, |value| {
1241            builder.reborrow().set_isin(value);
1242        });
1243
1244        self.currency
1245            .write_capnp(|| builder.reborrow().init_currency());
1246        builder.set_price_precision(self.price_precision);
1247        self.price_increment
1248            .write_capnp(|| builder.reborrow().init_price_increment());
1249        self.margin_init
1250            .write_capnp(|| builder.reborrow().init_margin_init());
1251        self.margin_maint
1252            .write_capnp(|| builder.reborrow().init_margin_maint());
1253        self.maker_fee
1254            .write_capnp(|| builder.reborrow().init_maker_fee());
1255        self.taker_fee
1256            .write_capnp(|| builder.reborrow().init_taker_fee());
1257        self.lot_size
1258            .write_capnp(|| builder.reborrow().init_lot_size());
1259        self.max_quantity
1260            .write_capnp(|| builder.reborrow().init_max_quantity());
1261        self.min_quantity
1262            .write_capnp(|| builder.reborrow().init_min_quantity());
1263        self.max_price
1264            .write_capnp(|| builder.reborrow().init_max_price());
1265        self.min_price
1266            .write_capnp(|| builder.reborrow().init_min_price());
1267        write_optional_ustr(self.tick_scheme, |value| {
1268            builder.reborrow().set_tick_scheme(value);
1269        });
1270
1271        write_optional_info(self.info.as_ref(), |bytes| {
1272            builder.reborrow().set_info(bytes);
1273        });
1274
1275        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
1276        write_unix_nanos(self.ts_init, builder.init_ts_init());
1277    }
1278}
1279
1280impl<'a> FromCapnp<'a> for Equity {
1281    type Reader = instruments_capnp::equity::Reader<'a>;
1282
1283    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
1284        Ok(Self {
1285            id: InstrumentId::from_capnp(reader.get_id()?)?,
1286            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
1287            isin: read_optional_ustr(reader.has_isin(), || reader.get_isin())?,
1288            currency: Currency::from_capnp(reader.get_currency()?)?,
1289            price_precision: reader.get_price_precision(),
1290            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
1291            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
1292            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
1293            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
1294            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
1295            lot_size: read_optional_from_capnp(|| reader.has_lot_size(), || reader.get_lot_size())?,
1296            max_quantity: read_optional_from_capnp(
1297                || reader.has_max_quantity(),
1298                || reader.get_max_quantity(),
1299            )?,
1300            min_quantity: read_optional_from_capnp(
1301                || reader.has_min_quantity(),
1302                || reader.get_min_quantity(),
1303            )?,
1304            max_price: read_optional_from_capnp(
1305                || reader.has_max_price(),
1306                || reader.get_max_price(),
1307            )?,
1308            min_price: read_optional_from_capnp(
1309                || reader.has_min_price(),
1310                || reader.get_min_price(),
1311            )?,
1312            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
1313            info: read_optional_info(reader.has_info(), || reader.get_info())?,
1314            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
1315            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
1316        })
1317    }
1318}
1319
1320impl<'a> ToCapnp<'a> for FuturesContract {
1321    type Builder = instruments_capnp::futures_contract::Builder<'a>;
1322
1323    fn to_capnp(&self, mut builder: Self::Builder) {
1324        self.id.write_capnp(|| builder.reborrow().init_id());
1325        self.raw_symbol
1326            .write_capnp(|| builder.reborrow().init_raw_symbol());
1327        builder.set_asset_class(asset_class_to_capnp(self.asset_class));
1328        write_optional_ustr(self.exchange, |value| {
1329            builder.reborrow().set_exchange(value);
1330        });
1331
1332        builder.set_underlying(self.underlying.as_str());
1333        write_unix_nanos(self.activation_ns, builder.reborrow().init_activation_ns());
1334        write_unix_nanos(self.expiration_ns, builder.reborrow().init_expiration_ns());
1335        self.currency
1336            .write_capnp(|| builder.reborrow().init_currency());
1337        builder.set_price_precision(self.price_precision);
1338        self.price_increment
1339            .write_capnp(|| builder.reborrow().init_price_increment());
1340        self.size_increment
1341            .write_capnp(|| builder.reborrow().init_size_increment());
1342        builder.set_size_precision(self.size_precision);
1343        self.multiplier
1344            .write_capnp(|| builder.reborrow().init_multiplier());
1345        self.lot_size
1346            .write_capnp(|| builder.reborrow().init_lot_size());
1347        self.margin_init
1348            .write_capnp(|| builder.reborrow().init_margin_init());
1349        self.margin_maint
1350            .write_capnp(|| builder.reborrow().init_margin_maint());
1351        self.maker_fee
1352            .write_capnp(|| builder.reborrow().init_maker_fee());
1353        self.taker_fee
1354            .write_capnp(|| builder.reborrow().init_taker_fee());
1355        self.max_quantity
1356            .write_capnp(|| builder.reborrow().init_max_quantity());
1357        self.min_quantity
1358            .write_capnp(|| builder.reborrow().init_min_quantity());
1359        self.max_price
1360            .write_capnp(|| builder.reborrow().init_max_price());
1361        self.min_price
1362            .write_capnp(|| builder.reborrow().init_min_price());
1363        write_optional_ustr(self.tick_scheme, |value| {
1364            builder.reborrow().set_tick_scheme(value);
1365        });
1366
1367        write_optional_info(self.info.as_ref(), |bytes| {
1368            builder.reborrow().set_info(bytes);
1369        });
1370
1371        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
1372        write_unix_nanos(self.ts_init, builder.init_ts_init());
1373    }
1374}
1375
1376impl<'a> FromCapnp<'a> for FuturesContract {
1377    type Reader = instruments_capnp::futures_contract::Reader<'a>;
1378
1379    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
1380        Ok(Self {
1381            id: InstrumentId::from_capnp(reader.get_id()?)?,
1382            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
1383            asset_class: asset_class_from_capnp(reader.get_asset_class()?),
1384            exchange: read_optional_ustr(reader.has_exchange(), || reader.get_exchange())?,
1385            underlying: read_ustr(|| reader.get_underlying())?,
1386            activation_ns: read_unix_nanos(|| reader.get_activation_ns())?,
1387            expiration_ns: read_unix_nanos(|| reader.get_expiration_ns())?,
1388            currency: Currency::from_capnp(reader.get_currency()?)?,
1389            price_precision: reader.get_price_precision(),
1390            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
1391            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
1392            size_precision: reader.get_size_precision(),
1393            multiplier: Quantity::from_capnp(reader.get_multiplier()?)?,
1394            lot_size: Quantity::from_capnp(reader.get_lot_size()?)?,
1395            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
1396            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
1397            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
1398            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
1399            max_quantity: read_optional_from_capnp(
1400                || reader.has_max_quantity(),
1401                || reader.get_max_quantity(),
1402            )?,
1403            min_quantity: read_optional_from_capnp(
1404                || reader.has_min_quantity(),
1405                || reader.get_min_quantity(),
1406            )?,
1407            max_price: read_optional_from_capnp(
1408                || reader.has_max_price(),
1409                || reader.get_max_price(),
1410            )?,
1411            min_price: read_optional_from_capnp(
1412                || reader.has_min_price(),
1413                || reader.get_min_price(),
1414            )?,
1415            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
1416            info: read_optional_info(reader.has_info(), || reader.get_info())?,
1417            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
1418            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
1419        })
1420    }
1421}
1422
1423impl<'a> ToCapnp<'a> for FuturesSpread {
1424    type Builder = instruments_capnp::futures_spread::Builder<'a>;
1425
1426    fn to_capnp(&self, mut builder: Self::Builder) {
1427        self.id.write_capnp(|| builder.reborrow().init_id());
1428        self.raw_symbol
1429            .write_capnp(|| builder.reborrow().init_raw_symbol());
1430        builder.set_asset_class(asset_class_to_capnp(self.asset_class));
1431        write_optional_ustr(self.exchange, |value| {
1432            builder.reborrow().set_exchange(value);
1433        });
1434
1435        builder.set_underlying(self.underlying.as_str());
1436        builder.set_strategy_type(self.strategy_type.as_str());
1437        write_unix_nanos(self.activation_ns, builder.reborrow().init_activation_ns());
1438        write_unix_nanos(self.expiration_ns, builder.reborrow().init_expiration_ns());
1439        self.currency
1440            .write_capnp(|| builder.reborrow().init_currency());
1441        builder.set_price_precision(self.price_precision);
1442        self.price_increment
1443            .write_capnp(|| builder.reborrow().init_price_increment());
1444        self.size_increment
1445            .write_capnp(|| builder.reborrow().init_size_increment());
1446        builder.set_size_precision(self.size_precision);
1447        self.multiplier
1448            .write_capnp(|| builder.reborrow().init_multiplier());
1449        self.lot_size
1450            .write_capnp(|| builder.reborrow().init_lot_size());
1451        self.margin_init
1452            .write_capnp(|| builder.reborrow().init_margin_init());
1453        self.margin_maint
1454            .write_capnp(|| builder.reborrow().init_margin_maint());
1455        self.maker_fee
1456            .write_capnp(|| builder.reborrow().init_maker_fee());
1457        self.taker_fee
1458            .write_capnp(|| builder.reborrow().init_taker_fee());
1459        self.max_quantity
1460            .write_capnp(|| builder.reborrow().init_max_quantity());
1461        self.min_quantity
1462            .write_capnp(|| builder.reborrow().init_min_quantity());
1463        self.max_price
1464            .write_capnp(|| builder.reborrow().init_max_price());
1465        self.min_price
1466            .write_capnp(|| builder.reborrow().init_min_price());
1467        write_optional_ustr(self.tick_scheme, |value| {
1468            builder.reborrow().set_tick_scheme(value);
1469        });
1470
1471        write_optional_info(self.info.as_ref(), |bytes| {
1472            builder.reborrow().set_info(bytes);
1473        });
1474
1475        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
1476        write_unix_nanos(self.ts_init, builder.init_ts_init());
1477    }
1478}
1479
1480impl<'a> FromCapnp<'a> for FuturesSpread {
1481    type Reader = instruments_capnp::futures_spread::Reader<'a>;
1482
1483    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
1484        Ok(Self {
1485            id: InstrumentId::from_capnp(reader.get_id()?)?,
1486            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
1487            asset_class: asset_class_from_capnp(reader.get_asset_class()?),
1488            exchange: read_optional_ustr(reader.has_exchange(), || reader.get_exchange())?,
1489            underlying: read_ustr(|| reader.get_underlying())?,
1490            strategy_type: read_ustr(|| reader.get_strategy_type())?,
1491            activation_ns: read_unix_nanos(|| reader.get_activation_ns())?,
1492            expiration_ns: read_unix_nanos(|| reader.get_expiration_ns())?,
1493            currency: Currency::from_capnp(reader.get_currency()?)?,
1494            price_precision: reader.get_price_precision(),
1495            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
1496            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
1497            size_precision: reader.get_size_precision(),
1498            multiplier: Quantity::from_capnp(reader.get_multiplier()?)?,
1499            lot_size: Quantity::from_capnp(reader.get_lot_size()?)?,
1500            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
1501            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
1502            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
1503            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
1504            max_quantity: read_optional_from_capnp(
1505                || reader.has_max_quantity(),
1506                || reader.get_max_quantity(),
1507            )?,
1508            min_quantity: read_optional_from_capnp(
1509                || reader.has_min_quantity(),
1510                || reader.get_min_quantity(),
1511            )?,
1512            max_price: read_optional_from_capnp(
1513                || reader.has_max_price(),
1514                || reader.get_max_price(),
1515            )?,
1516            min_price: read_optional_from_capnp(
1517                || reader.has_min_price(),
1518                || reader.get_min_price(),
1519            )?,
1520            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
1521            info: read_optional_info(reader.has_info(), || reader.get_info())?,
1522            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
1523            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
1524        })
1525    }
1526}
1527
1528impl<'a> ToCapnp<'a> for IndexInstrument {
1529    type Builder = instruments_capnp::index_instrument::Builder<'a>;
1530
1531    fn to_capnp(&self, mut builder: Self::Builder) {
1532        self.id.write_capnp(|| builder.reborrow().init_id());
1533        self.raw_symbol
1534            .write_capnp(|| builder.reborrow().init_raw_symbol());
1535        self.currency
1536            .write_capnp(|| builder.reborrow().init_currency());
1537        builder.set_price_precision(self.price_precision);
1538        builder.set_size_precision(self.size_precision);
1539        self.price_increment
1540            .write_capnp(|| builder.reborrow().init_price_increment());
1541        self.size_increment
1542            .write_capnp(|| builder.reborrow().init_size_increment());
1543        write_optional_ustr(self.tick_scheme, |value| {
1544            builder.reborrow().set_tick_scheme(value);
1545        });
1546
1547        write_optional_info(self.info.as_ref(), |bytes| {
1548            builder.reborrow().set_info(bytes);
1549        });
1550
1551        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
1552        write_unix_nanos(self.ts_init, builder.init_ts_init());
1553    }
1554}
1555
1556impl<'a> FromCapnp<'a> for IndexInstrument {
1557    type Reader = instruments_capnp::index_instrument::Reader<'a>;
1558
1559    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
1560        Ok(Self {
1561            id: InstrumentId::from_capnp(reader.get_id()?)?,
1562            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
1563            currency: Currency::from_capnp(reader.get_currency()?)?,
1564            price_precision: reader.get_price_precision(),
1565            size_precision: reader.get_size_precision(),
1566            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
1567            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
1568            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
1569            info: read_optional_info(reader.has_info(), || reader.get_info())?,
1570            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
1571            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
1572        })
1573    }
1574}
1575
1576impl<'a> ToCapnp<'a> for OptionContract {
1577    type Builder = instruments_capnp::option_contract::Builder<'a>;
1578
1579    fn to_capnp(&self, mut builder: Self::Builder) {
1580        self.id.write_capnp(|| builder.reborrow().init_id());
1581        self.raw_symbol
1582            .write_capnp(|| builder.reborrow().init_raw_symbol());
1583        builder.set_asset_class(asset_class_to_capnp(self.asset_class));
1584        write_optional_ustr(self.exchange, |value| {
1585            builder.reborrow().set_exchange(value);
1586        });
1587
1588        builder.set_underlying(self.underlying.as_str());
1589        builder.set_option_kind(option_kind_to_capnp(self.option_kind));
1590        self.strike_price
1591            .write_capnp(|| builder.reborrow().init_strike_price());
1592        write_unix_nanos(self.activation_ns, builder.reborrow().init_activation_ns());
1593        write_unix_nanos(self.expiration_ns, builder.reborrow().init_expiration_ns());
1594        self.currency
1595            .write_capnp(|| builder.reborrow().init_currency());
1596        builder.set_price_precision(self.price_precision);
1597        self.price_increment
1598            .write_capnp(|| builder.reborrow().init_price_increment());
1599        self.size_increment
1600            .write_capnp(|| builder.reborrow().init_size_increment());
1601        builder.set_size_precision(self.size_precision);
1602        self.multiplier
1603            .write_capnp(|| builder.reborrow().init_multiplier());
1604        self.lot_size
1605            .write_capnp(|| builder.reborrow().init_lot_size());
1606        self.margin_init
1607            .write_capnp(|| builder.reborrow().init_margin_init());
1608        self.margin_maint
1609            .write_capnp(|| builder.reborrow().init_margin_maint());
1610        self.maker_fee
1611            .write_capnp(|| builder.reborrow().init_maker_fee());
1612        self.taker_fee
1613            .write_capnp(|| builder.reborrow().init_taker_fee());
1614        self.max_quantity
1615            .write_capnp(|| builder.reborrow().init_max_quantity());
1616        self.min_quantity
1617            .write_capnp(|| builder.reborrow().init_min_quantity());
1618        self.max_price
1619            .write_capnp(|| builder.reborrow().init_max_price());
1620        self.min_price
1621            .write_capnp(|| builder.reborrow().init_min_price());
1622        write_optional_ustr(self.tick_scheme, |value| {
1623            builder.reborrow().set_tick_scheme(value);
1624        });
1625
1626        write_optional_info(self.info.as_ref(), |bytes| {
1627            builder.reborrow().set_info(bytes);
1628        });
1629
1630        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
1631        write_unix_nanos(self.ts_init, builder.init_ts_init());
1632    }
1633}
1634
1635impl<'a> FromCapnp<'a> for OptionContract {
1636    type Reader = instruments_capnp::option_contract::Reader<'a>;
1637
1638    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
1639        Ok(Self {
1640            id: InstrumentId::from_capnp(reader.get_id()?)?,
1641            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
1642            asset_class: asset_class_from_capnp(reader.get_asset_class()?),
1643            exchange: read_optional_ustr(reader.has_exchange(), || reader.get_exchange())?,
1644            underlying: read_ustr(|| reader.get_underlying())?,
1645            option_kind: option_kind_from_capnp(reader.get_option_kind()?),
1646            strike_price: Price::from_capnp(reader.get_strike_price()?)?,
1647            activation_ns: read_unix_nanos(|| reader.get_activation_ns())?,
1648            expiration_ns: read_unix_nanos(|| reader.get_expiration_ns())?,
1649            currency: Currency::from_capnp(reader.get_currency()?)?,
1650            price_precision: reader.get_price_precision(),
1651            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
1652            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
1653            size_precision: reader.get_size_precision(),
1654            multiplier: Quantity::from_capnp(reader.get_multiplier()?)?,
1655            lot_size: Quantity::from_capnp(reader.get_lot_size()?)?,
1656            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
1657            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
1658            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
1659            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
1660            max_quantity: read_optional_from_capnp(
1661                || reader.has_max_quantity(),
1662                || reader.get_max_quantity(),
1663            )?,
1664            min_quantity: read_optional_from_capnp(
1665                || reader.has_min_quantity(),
1666                || reader.get_min_quantity(),
1667            )?,
1668            max_price: read_optional_from_capnp(
1669                || reader.has_max_price(),
1670                || reader.get_max_price(),
1671            )?,
1672            min_price: read_optional_from_capnp(
1673                || reader.has_min_price(),
1674                || reader.get_min_price(),
1675            )?,
1676            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
1677            info: read_optional_info(reader.has_info(), || reader.get_info())?,
1678            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
1679            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
1680        })
1681    }
1682}
1683
1684impl<'a> ToCapnp<'a> for OptionSpread {
1685    type Builder = instruments_capnp::option_spread::Builder<'a>;
1686
1687    fn to_capnp(&self, mut builder: Self::Builder) {
1688        self.id.write_capnp(|| builder.reborrow().init_id());
1689        self.raw_symbol
1690            .write_capnp(|| builder.reborrow().init_raw_symbol());
1691        builder.set_asset_class(asset_class_to_capnp(self.asset_class));
1692        write_optional_ustr(self.exchange, |value| {
1693            builder.reborrow().set_exchange(value);
1694        });
1695
1696        builder.set_underlying(self.underlying.as_str());
1697        builder.set_strategy_type(self.strategy_type.as_str());
1698        write_unix_nanos(self.activation_ns, builder.reborrow().init_activation_ns());
1699        write_unix_nanos(self.expiration_ns, builder.reborrow().init_expiration_ns());
1700        self.currency
1701            .write_capnp(|| builder.reborrow().init_currency());
1702        builder.set_price_precision(self.price_precision);
1703        self.price_increment
1704            .write_capnp(|| builder.reborrow().init_price_increment());
1705        self.size_increment
1706            .write_capnp(|| builder.reborrow().init_size_increment());
1707        builder.set_size_precision(self.size_precision);
1708        self.multiplier
1709            .write_capnp(|| builder.reborrow().init_multiplier());
1710        self.lot_size
1711            .write_capnp(|| builder.reborrow().init_lot_size());
1712        self.margin_init
1713            .write_capnp(|| builder.reborrow().init_margin_init());
1714        self.margin_maint
1715            .write_capnp(|| builder.reborrow().init_margin_maint());
1716        self.maker_fee
1717            .write_capnp(|| builder.reborrow().init_maker_fee());
1718        self.taker_fee
1719            .write_capnp(|| builder.reborrow().init_taker_fee());
1720        self.max_quantity
1721            .write_capnp(|| builder.reborrow().init_max_quantity());
1722        self.min_quantity
1723            .write_capnp(|| builder.reborrow().init_min_quantity());
1724        self.max_price
1725            .write_capnp(|| builder.reborrow().init_max_price());
1726        self.min_price
1727            .write_capnp(|| builder.reborrow().init_min_price());
1728        write_optional_ustr(self.tick_scheme, |value| {
1729            builder.reborrow().set_tick_scheme(value);
1730        });
1731
1732        write_optional_info(self.info.as_ref(), |bytes| {
1733            builder.reborrow().set_info(bytes);
1734        });
1735
1736        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
1737        write_unix_nanos(self.ts_init, builder.init_ts_init());
1738    }
1739}
1740
1741impl<'a> FromCapnp<'a> for OptionSpread {
1742    type Reader = instruments_capnp::option_spread::Reader<'a>;
1743
1744    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
1745        Ok(Self {
1746            id: InstrumentId::from_capnp(reader.get_id()?)?,
1747            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
1748            asset_class: asset_class_from_capnp(reader.get_asset_class()?),
1749            exchange: read_optional_ustr(reader.has_exchange(), || reader.get_exchange())?,
1750            underlying: read_ustr(|| reader.get_underlying())?,
1751            strategy_type: read_ustr(|| reader.get_strategy_type())?,
1752            activation_ns: read_unix_nanos(|| reader.get_activation_ns())?,
1753            expiration_ns: read_unix_nanos(|| reader.get_expiration_ns())?,
1754            currency: Currency::from_capnp(reader.get_currency()?)?,
1755            price_precision: reader.get_price_precision(),
1756            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
1757            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
1758            size_precision: reader.get_size_precision(),
1759            multiplier: Quantity::from_capnp(reader.get_multiplier()?)?,
1760            lot_size: Quantity::from_capnp(reader.get_lot_size()?)?,
1761            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
1762            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
1763            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
1764            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
1765            max_quantity: read_optional_from_capnp(
1766                || reader.has_max_quantity(),
1767                || reader.get_max_quantity(),
1768            )?,
1769            min_quantity: read_optional_from_capnp(
1770                || reader.has_min_quantity(),
1771                || reader.get_min_quantity(),
1772            )?,
1773            max_price: read_optional_from_capnp(
1774                || reader.has_max_price(),
1775                || reader.get_max_price(),
1776            )?,
1777            min_price: read_optional_from_capnp(
1778                || reader.has_min_price(),
1779                || reader.get_min_price(),
1780            )?,
1781            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
1782            info: read_optional_info(reader.has_info(), || reader.get_info())?,
1783            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
1784            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
1785        })
1786    }
1787}
1788
1789impl<'a> ToCapnp<'a> for PerpetualContract {
1790    type Builder = instruments_capnp::perpetual_contract::Builder<'a>;
1791
1792    fn to_capnp(&self, mut builder: Self::Builder) {
1793        self.id.write_capnp(|| builder.reborrow().init_id());
1794        self.raw_symbol
1795            .write_capnp(|| builder.reborrow().init_raw_symbol());
1796        builder.set_underlying(self.underlying.as_str());
1797        builder.set_asset_class(asset_class_to_capnp(self.asset_class));
1798        self.base_currency
1799            .write_capnp(|| builder.reborrow().init_base_currency());
1800        self.quote_currency
1801            .write_capnp(|| builder.reborrow().init_quote_currency());
1802        self.settlement_currency
1803            .write_capnp(|| builder.reborrow().init_settlement_currency());
1804        builder.set_is_inverse(self.is_inverse);
1805        builder.set_price_precision(self.price_precision);
1806        builder.set_size_precision(self.size_precision);
1807        self.price_increment
1808            .write_capnp(|| builder.reborrow().init_price_increment());
1809        self.size_increment
1810            .write_capnp(|| builder.reborrow().init_size_increment());
1811        self.multiplier
1812            .write_capnp(|| builder.reborrow().init_multiplier());
1813        self.lot_size
1814            .write_capnp(|| builder.reborrow().init_lot_size());
1815        self.margin_init
1816            .write_capnp(|| builder.reborrow().init_margin_init());
1817        self.margin_maint
1818            .write_capnp(|| builder.reborrow().init_margin_maint());
1819        self.maker_fee
1820            .write_capnp(|| builder.reborrow().init_maker_fee());
1821        self.taker_fee
1822            .write_capnp(|| builder.reborrow().init_taker_fee());
1823        self.max_quantity
1824            .write_capnp(|| builder.reborrow().init_max_quantity());
1825        self.min_quantity
1826            .write_capnp(|| builder.reborrow().init_min_quantity());
1827        self.max_notional
1828            .write_capnp(|| builder.reborrow().init_max_notional());
1829        self.min_notional
1830            .write_capnp(|| builder.reborrow().init_min_notional());
1831        self.max_price
1832            .write_capnp(|| builder.reborrow().init_max_price());
1833        self.min_price
1834            .write_capnp(|| builder.reborrow().init_min_price());
1835        write_optional_ustr(self.tick_scheme, |value| {
1836            builder.reborrow().set_tick_scheme(value);
1837        });
1838
1839        write_optional_info(self.info.as_ref(), |bytes| {
1840            builder.reborrow().set_info(bytes);
1841        });
1842
1843        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
1844        write_unix_nanos(self.ts_init, builder.init_ts_init());
1845    }
1846}
1847
1848impl<'a> FromCapnp<'a> for PerpetualContract {
1849    type Reader = instruments_capnp::perpetual_contract::Reader<'a>;
1850
1851    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
1852        Ok(Self {
1853            id: InstrumentId::from_capnp(reader.get_id()?)?,
1854            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
1855            underlying: read_ustr(|| reader.get_underlying())?,
1856            asset_class: asset_class_from_capnp(reader.get_asset_class()?),
1857            base_currency: read_optional_from_capnp(
1858                || reader.has_base_currency(),
1859                || reader.get_base_currency(),
1860            )?,
1861            quote_currency: Currency::from_capnp(reader.get_quote_currency()?)?,
1862            settlement_currency: Currency::from_capnp(reader.get_settlement_currency()?)?,
1863            is_inverse: reader.get_is_inverse(),
1864            price_precision: reader.get_price_precision(),
1865            size_precision: reader.get_size_precision(),
1866            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
1867            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
1868            multiplier: Quantity::from_capnp(reader.get_multiplier()?)?,
1869            lot_size: Quantity::from_capnp(reader.get_lot_size()?)?,
1870            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
1871            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
1872            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
1873            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
1874            max_quantity: read_optional_from_capnp(
1875                || reader.has_max_quantity(),
1876                || reader.get_max_quantity(),
1877            )?,
1878            min_quantity: read_optional_from_capnp(
1879                || reader.has_min_quantity(),
1880                || reader.get_min_quantity(),
1881            )?,
1882            max_notional: read_optional_from_capnp(
1883                || reader.has_max_notional(),
1884                || reader.get_max_notional(),
1885            )?,
1886            min_notional: read_optional_from_capnp(
1887                || reader.has_min_notional(),
1888                || reader.get_min_notional(),
1889            )?,
1890            max_price: read_optional_from_capnp(
1891                || reader.has_max_price(),
1892                || reader.get_max_price(),
1893            )?,
1894            min_price: read_optional_from_capnp(
1895                || reader.has_min_price(),
1896                || reader.get_min_price(),
1897            )?,
1898            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
1899            info: read_optional_info(reader.has_info(), || reader.get_info())?,
1900            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
1901            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
1902        })
1903    }
1904}
1905
1906impl<'a> ToCapnp<'a> for TokenizedAsset {
1907    type Builder = instruments_capnp::tokenized_asset::Builder<'a>;
1908
1909    fn to_capnp(&self, mut builder: Self::Builder) {
1910        self.id.write_capnp(|| builder.reborrow().init_id());
1911        self.raw_symbol
1912            .write_capnp(|| builder.reborrow().init_raw_symbol());
1913        builder.set_asset_class(asset_class_to_capnp(self.asset_class));
1914        self.base_currency
1915            .write_capnp(|| builder.reborrow().init_base_currency());
1916        self.quote_currency
1917            .write_capnp(|| builder.reborrow().init_quote_currency());
1918        write_optional_ustr(self.isin, |value| {
1919            builder.reborrow().set_isin(value);
1920        });
1921
1922        builder.set_price_precision(self.price_precision);
1923        builder.set_size_precision(self.size_precision);
1924        self.price_increment
1925            .write_capnp(|| builder.reborrow().init_price_increment());
1926        self.size_increment
1927            .write_capnp(|| builder.reborrow().init_size_increment());
1928        self.multiplier
1929            .write_capnp(|| builder.reborrow().init_multiplier());
1930        self.lot_size
1931            .write_capnp(|| builder.reborrow().init_lot_size());
1932        self.margin_init
1933            .write_capnp(|| builder.reborrow().init_margin_init());
1934        self.margin_maint
1935            .write_capnp(|| builder.reborrow().init_margin_maint());
1936        self.maker_fee
1937            .write_capnp(|| builder.reborrow().init_maker_fee());
1938        self.taker_fee
1939            .write_capnp(|| builder.reborrow().init_taker_fee());
1940        self.max_quantity
1941            .write_capnp(|| builder.reborrow().init_max_quantity());
1942        self.min_quantity
1943            .write_capnp(|| builder.reborrow().init_min_quantity());
1944        self.max_notional
1945            .write_capnp(|| builder.reborrow().init_max_notional());
1946        self.min_notional
1947            .write_capnp(|| builder.reborrow().init_min_notional());
1948        self.max_price
1949            .write_capnp(|| builder.reborrow().init_max_price());
1950        self.min_price
1951            .write_capnp(|| builder.reborrow().init_min_price());
1952        write_optional_ustr(self.tick_scheme, |value| {
1953            builder.reborrow().set_tick_scheme(value);
1954        });
1955
1956        write_optional_info(self.info.as_ref(), |bytes| {
1957            builder.reborrow().set_info(bytes);
1958        });
1959
1960        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
1961        write_unix_nanos(self.ts_init, builder.init_ts_init());
1962    }
1963}
1964
1965impl<'a> FromCapnp<'a> for TokenizedAsset {
1966    type Reader = instruments_capnp::tokenized_asset::Reader<'a>;
1967
1968    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
1969        Ok(Self {
1970            id: InstrumentId::from_capnp(reader.get_id()?)?,
1971            raw_symbol: Symbol::from_capnp(reader.get_raw_symbol()?)?,
1972            asset_class: asset_class_from_capnp(reader.get_asset_class()?),
1973            base_currency: Currency::from_capnp(reader.get_base_currency()?)?,
1974            quote_currency: Currency::from_capnp(reader.get_quote_currency()?)?,
1975            isin: read_optional_ustr(reader.has_isin(), || reader.get_isin())?,
1976            price_precision: reader.get_price_precision(),
1977            size_precision: reader.get_size_precision(),
1978            price_increment: Price::from_capnp(reader.get_price_increment()?)?,
1979            size_increment: Quantity::from_capnp(reader.get_size_increment()?)?,
1980            multiplier: Quantity::from_capnp(reader.get_multiplier()?)?,
1981            lot_size: read_optional_from_capnp(|| reader.has_lot_size(), || reader.get_lot_size())?,
1982            margin_init: Decimal::from_capnp(reader.get_margin_init()?)?,
1983            margin_maint: Decimal::from_capnp(reader.get_margin_maint()?)?,
1984            maker_fee: Decimal::from_capnp(reader.get_maker_fee()?)?,
1985            taker_fee: Decimal::from_capnp(reader.get_taker_fee()?)?,
1986            max_quantity: read_optional_from_capnp(
1987                || reader.has_max_quantity(),
1988                || reader.get_max_quantity(),
1989            )?,
1990            min_quantity: read_optional_from_capnp(
1991                || reader.has_min_quantity(),
1992                || reader.get_min_quantity(),
1993            )?,
1994            max_notional: read_optional_from_capnp(
1995                || reader.has_max_notional(),
1996                || reader.get_max_notional(),
1997            )?,
1998            min_notional: read_optional_from_capnp(
1999                || reader.has_min_notional(),
2000                || reader.get_min_notional(),
2001            )?,
2002            max_price: read_optional_from_capnp(
2003                || reader.has_max_price(),
2004                || reader.get_max_price(),
2005            )?,
2006            min_price: read_optional_from_capnp(
2007                || reader.has_min_price(),
2008                || reader.get_min_price(),
2009            )?,
2010            tick_scheme: read_optional_ustr(reader.has_tick_scheme(), || reader.get_tick_scheme())?,
2011            info: read_optional_info(reader.has_info(), || reader.get_info())?,
2012            ts_event: read_unix_nanos(|| reader.get_ts_event())?,
2013            ts_init: read_unix_nanos(|| reader.get_ts_init())?,
2014        })
2015    }
2016}
2017
2018impl<'a> ToCapnp<'a> for SyntheticInstrument {
2019    type Builder = instruments_capnp::synthetic_instrument::Builder<'a>;
2020
2021    fn to_capnp(&self, mut builder: Self::Builder) {
2022        self.id.write_capnp(|| builder.reborrow().init_id());
2023        builder.set_price_precision(self.price_precision);
2024        self.price_increment
2025            .write_capnp(|| builder.reborrow().init_price_increment());
2026        let mut components = builder
2027            .reborrow()
2028            .init_components(self.components.len() as u32);
2029        for (index, component) in self.components.iter().enumerate() {
2030            component.to_capnp(components.reborrow().get(index as u32));
2031        }
2032
2033        builder.set_formula(&self.formula);
2034        write_unix_nanos(self.ts_event, builder.reborrow().init_ts_event());
2035        write_unix_nanos(self.ts_init, builder.init_ts_init());
2036    }
2037}
2038
2039impl<'a> FromCapnp<'a> for SyntheticInstrument {
2040    type Reader = instruments_capnp::synthetic_instrument::Reader<'a>;
2041
2042    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
2043        let id = InstrumentId::from_capnp(reader.get_id()?)?;
2044        let price_increment = Price::from_capnp(reader.get_price_increment()?)?;
2045        let components_reader = reader.get_components()?;
2046        let mut components = Vec::with_capacity(components_reader.len() as usize);
2047        for component in components_reader {
2048            components.push(InstrumentId::from_capnp(component)?);
2049        }
2050
2051        let formula = reader.get_formula()?.to_str()?.to_owned();
2052
2053        // The builder compiles the formula and forces Venue::synthetic() plus a derived
2054        // increment. Restore the stored public fields so Cap'n Proto matches serde.
2055        let mut instrument = Self::builder()
2056            .symbol(id.symbol)
2057            .price_precision(reader.get_price_precision())
2058            .components(components)
2059            .formula(&formula)
2060            .ts_event(read_unix_nanos(|| reader.get_ts_event())?)
2061            .ts_init(read_unix_nanos(|| reader.get_ts_init())?)
2062            .build()?;
2063        instrument.id = id;
2064        instrument.price_increment = price_increment;
2065        Ok(instrument)
2066    }
2067}
2068
2069impl<'a> ToCapnp<'a> for InstrumentAny {
2070    type Builder = instruments_capnp::instrument_any::Builder<'a>;
2071
2072    fn to_capnp(&self, builder: Self::Builder) {
2073        match self {
2074            Self::Betting(value) => value.to_capnp(builder.init_betting()),
2075            Self::BinaryOption(value) => value.to_capnp(builder.init_binary_option()),
2076            Self::Cfd(value) => value.to_capnp(builder.init_cfd()),
2077            Self::Commodity(value) => value.to_capnp(builder.init_commodity()),
2078            Self::CryptoFuture(value) => value.to_capnp(builder.init_crypto_future()),
2079            Self::CryptoFuturesSpread(value) => {
2080                value.to_capnp(builder.init_crypto_futures_spread());
2081            }
2082            Self::CryptoOption(value) => value.to_capnp(builder.init_crypto_option()),
2083            Self::CryptoOptionSpread(value) => value.to_capnp(builder.init_crypto_option_spread()),
2084            Self::CryptoPerpetual(value) => value.to_capnp(builder.init_crypto_perpetual()),
2085            Self::CurrencyPair(value) => value.to_capnp(builder.init_currency_pair()),
2086            Self::Equity(value) => value.to_capnp(builder.init_equity()),
2087            Self::FuturesContract(value) => value.to_capnp(builder.init_futures_contract()),
2088            Self::FuturesSpread(value) => value.to_capnp(builder.init_futures_spread()),
2089            Self::IndexInstrument(value) => value.to_capnp(builder.init_index_instrument()),
2090            Self::OptionContract(value) => value.to_capnp(builder.init_option_contract()),
2091            Self::OptionSpread(value) => value.to_capnp(builder.init_option_spread()),
2092            Self::PerpetualContract(value) => value.to_capnp(builder.init_perpetual_contract()),
2093            Self::TokenizedAsset(value) => value.to_capnp(builder.init_tokenized_asset()),
2094        }
2095    }
2096}
2097
2098impl<'a> FromCapnp<'a> for InstrumentAny {
2099    type Reader = instruments_capnp::instrument_any::Reader<'a>;
2100
2101    #[rustfmt::skip]
2102    fn from_capnp(reader: Self::Reader) -> Result<Self, Box<dyn Error>> {
2103        match reader.which()? {
2104            instruments_capnp::instrument_any::Betting(reader) => Ok(Self::Betting(BettingInstrument::from_capnp(reader?)?)),
2105            instruments_capnp::instrument_any::BinaryOption(reader) => Ok(Self::BinaryOption(BinaryOption::from_capnp(reader?)?)),
2106            instruments_capnp::instrument_any::Cfd(reader) => Ok(Self::Cfd(Cfd::from_capnp(reader?)?)),
2107            instruments_capnp::instrument_any::Commodity(reader) => Ok(Self::Commodity(Commodity::from_capnp(reader?)?)),
2108            instruments_capnp::instrument_any::CryptoFuture(reader) => Ok(Self::CryptoFuture(CryptoFuture::from_capnp(reader?)?)),
2109            instruments_capnp::instrument_any::CryptoFuturesSpread(reader) => Ok(Self::CryptoFuturesSpread(CryptoFuturesSpread::from_capnp(reader?)?)),
2110            instruments_capnp::instrument_any::CryptoOption(reader) => Ok(Self::CryptoOption(CryptoOption::from_capnp(reader?)?)),
2111            instruments_capnp::instrument_any::CryptoOptionSpread(reader) => Ok(Self::CryptoOptionSpread(CryptoOptionSpread::from_capnp(reader?)?)),
2112            instruments_capnp::instrument_any::CryptoPerpetual(reader) => Ok(Self::CryptoPerpetual(CryptoPerpetual::from_capnp(reader?)?)),
2113            instruments_capnp::instrument_any::CurrencyPair(reader) => Ok(Self::CurrencyPair(CurrencyPair::from_capnp(reader?)?)),
2114            instruments_capnp::instrument_any::Equity(reader) => Ok(Self::Equity(Equity::from_capnp(reader?)?)),
2115            instruments_capnp::instrument_any::FuturesContract(reader) => Ok(Self::FuturesContract(FuturesContract::from_capnp(reader?)?)),
2116            instruments_capnp::instrument_any::FuturesSpread(reader) => Ok(Self::FuturesSpread(FuturesSpread::from_capnp(reader?)?)),
2117            instruments_capnp::instrument_any::IndexInstrument(reader) => Ok(Self::IndexInstrument(IndexInstrument::from_capnp(reader?)?)),
2118            instruments_capnp::instrument_any::OptionContract(reader) => Ok(Self::OptionContract(OptionContract::from_capnp(reader?)?)),
2119            instruments_capnp::instrument_any::OptionSpread(reader) => Ok(Self::OptionSpread(OptionSpread::from_capnp(reader?)?)),
2120            instruments_capnp::instrument_any::PerpetualContract(reader) => Ok(Self::PerpetualContract(PerpetualContract::from_capnp(reader?)?)),
2121            instruments_capnp::instrument_any::TokenizedAsset(reader) => Ok(Self::TokenizedAsset(TokenizedAsset::from_capnp(reader?)?)),
2122        }
2123    }
2124}
2125
2126/// Serializes an [`InstrumentAny`] to Cap'n Proto bytes.
2127///
2128/// # Errors
2129///
2130/// Returns an error if Cap'n Proto serialization fails.
2131pub fn serialize_instrument_any(instrument: &InstrumentAny) -> Result<Vec<u8>, Box<dyn Error>> {
2132    let mut message = capnp::message::Builder::new_default();
2133    let builder = message.init_root::<instruments_capnp::instrument_any::Builder>();
2134    instrument.to_capnp(builder);
2135
2136    let mut bytes = Vec::new();
2137    capnp::serialize::write_message(&mut bytes, &message)?;
2138    Ok(bytes)
2139}
2140
2141/// Deserializes an [`InstrumentAny`] from Cap'n Proto bytes.
2142///
2143/// # Errors
2144///
2145/// Returns an error if Cap'n Proto deserialization fails.
2146pub fn deserialize_instrument_any(bytes: &[u8]) -> Result<InstrumentAny, Box<dyn Error>> {
2147    let reader =
2148        capnp::serialize::read_message(&mut &bytes[..], capnp::message::ReaderOptions::new())?;
2149    let root = reader.get_root::<instruments_capnp::instrument_any::Reader>()?;
2150    InstrumentAny::from_capnp(root)
2151}
nautilus_serialization/capnp/instruments.rs

nautilus_serialization/capnp/
instruments.rs
