1use anyhow::Context;
17use nautilus_core::UnixNanos;
18use nautilus_model::{
19 data::{QuoteTick, TradeTick},
20 enums::AggressorSide,
21 identifiers::TradeId,
22 instruments::BinaryOption,
23 types::{Price, Quantity},
24};
25use rust_decimal::Decimal;
26use serde::Deserialize;
27use serde_json::Value;
28
29use crate::http::models::{BookSide, FixedPoint, OutcomeSide};
30
31pub fn trade(
42 value: Value,
43 instrument: &BinaryOption,
44 ts_init: UnixNanos,
45) -> anyhow::Result<Option<TradeTick>> {
46 let trade: Trade = serde_json::from_value(value)?;
47 if trade.is_block_trade {
48 return Ok(None);
49 }
50
51 if let Some(no_price) = trade.no_price_dollars {
52 anyhow::ensure!(
53 trade.yes_price_dollars.0.checked_add(no_price.0) == Some(Decimal::ONE),
54 "inconsistent trade prices"
55 );
56 }
57
58 let aggressor_side = match (trade.taker_book_side, trade.taker_outcome_side) {
59 (Some(BookSide::Bid), Some(OutcomeSide::Yes) | None) | (None, Some(OutcomeSide::Yes)) => {
60 AggressorSide::Buy
61 }
62 (Some(BookSide::Ask), Some(OutcomeSide::No) | None) | (None, Some(OutcomeSide::No)) => {
63 AggressorSide::Sell
64 }
65 _ => anyhow::bail!("missing or inconsistent canonical taker direction"),
66 };
67
68 let price = price(trade.yes_price_dollars, instrument.price_precision)?;
69 let size = size(trade.count_fp, instrument.size_precision)?;
70 let trade_id = TradeId::new_checked(trade.trade_id)?;
71 let ts_event = timestamp(trade.ts_ms, trade.ts)?;
72 let tick = TradeTick::new_checked(
73 instrument.id,
74 price,
75 size,
76 aggressor_side,
77 trade_id,
78 ts_event,
79 ts_init,
80 )?;
81 Ok(Some(tick))
82}
83
84pub fn quote(
94 value: Value,
95 instrument: &BinaryOption,
96 ts_init: UnixNanos,
97) -> anyhow::Result<Option<QuoteTick>> {
98 let quote: Ticker = serde_json::from_value(value)?;
99
100 let (Some(bid), Some(ask), Some(bid_size), Some(ask_size)) = (
101 quote.yes_bid_dollars,
102 quote.yes_ask_dollars,
103 quote.yes_bid_size_fp,
104 quote.yes_ask_size_fp,
105 ) else {
106 return Ok(None);
107 };
108
109 if bid_size.0.is_zero() || ask_size.0.is_zero() {
110 return Ok(None);
111 }
112
113 anyhow::ensure!(bid.0 <= ask.0, "crossed ticker quote");
114 let bid_price = price(bid, instrument.price_precision)?;
115 let ask_price = price(ask, instrument.price_precision)?;
116 let bid_size = size(bid_size, instrument.size_precision)?;
117 let ask_size = size(ask_size, instrument.size_precision)?;
118 let ts_event = timestamp(quote.ts_ms, quote.ts)?;
119 let tick = QuoteTick::new_checked(
120 instrument.id,
121 bid_price,
122 ask_price,
123 bid_size,
124 ask_size,
125 ts_event,
126 ts_init,
127 )?;
128 Ok(Some(tick))
129}
130
131pub(crate) fn price(value: FixedPoint, precision: u8) -> anyhow::Result<Price> {
132 anyhow::ensure!(
133 value.0 >= Decimal::ZERO && value.0 <= Decimal::ONE,
134 "price outside binary payout interval"
135 );
136 let price = Price::from_decimal_dp(value.0, precision)?;
137 anyhow::ensure!(
138 price.as_decimal() == value.0,
139 "price exceeds instrument precision"
140 );
141 Ok(price)
142}
143
144pub(crate) fn size(value: FixedPoint, precision: u8) -> anyhow::Result<Quantity> {
145 anyhow::ensure!(value.0 > Decimal::ZERO, "size must be positive");
146 let size = Quantity::from_decimal_dp(value.0, precision)?;
147 anyhow::ensure!(
148 size.as_decimal() == value.0,
149 "size exceeds instrument precision"
150 );
151 Ok(size)
152}
153
154fn timestamp(millis: Option<u64>, seconds: Option<u64>) -> anyhow::Result<UnixNanos> {
155 let nanos = match millis {
156 Some(value) => value.checked_mul(1_000_000),
157 None => seconds.and_then(|value| value.checked_mul(1_000_000_000)),
158 }
159 .context("missing or invalid venue timestamp")?;
160
161 Ok(UnixNanos::from(nanos))
162}
163
164#[derive(Deserialize)]
165struct Trade {
166 trade_id: String,
167 yes_price_dollars: FixedPoint,
168 no_price_dollars: Option<FixedPoint>,
169 count_fp: FixedPoint,
170 taker_book_side: Option<BookSide>,
171 taker_outcome_side: Option<OutcomeSide>,
172 #[serde(default)]
173 is_block_trade: bool,
174 ts_ms: Option<u64>,
175 ts: Option<u64>,
176}
177
178#[derive(Deserialize)]
179struct Ticker {
180 yes_bid_dollars: Option<FixedPoint>,
181 yes_ask_dollars: Option<FixedPoint>,
182 yes_bid_size_fp: Option<FixedPoint>,
183 yes_ask_size_fp: Option<FixedPoint>,
184 ts_ms: Option<u64>,
185 ts: Option<u64>,
186}
187
188#[cfg(test)]
189mod tests {
190 use rstest::rstest;
191
192 use super::*;
193 use crate::http::{
194 models::{Event, Market},
195 parse::parse_instrument,
196 };
197
198 #[rstest]
199 #[case(Some("bid"), Some("yes"), AggressorSide::Buy)]
200 #[case(Some("ask"), Some("no"), AggressorSide::Sell)]
201 #[case(None, Some("yes"), AggressorSide::Buy)]
202 #[case(Some("ask"), None, AggressorSide::Sell)]
203 fn trade_preserves_exact_fields(
204 #[case] book: Option<&str>,
205 #[case] outcome: Option<&str>,
206 #[case] side: AggressorSide,
207 ) {
208 let instrument = instrument();
209 let mut value = frame("trade");
210 value["taker_book_side"] = book.into();
211 value["taker_outcome_side"] = outcome.into();
212 let tick = trade(value, &instrument, UnixNanos::from(987))
213 .unwrap()
214 .unwrap();
215 assert_eq!(
216 tick,
217 TradeTick::new_checked(
218 instrument.id,
219 Price::from_decimal_dp("0.123456".parse().unwrap(), 6).unwrap(),
220 Quantity::from_decimal_dp("7.25".parse().unwrap(), 2).unwrap(),
221 side,
222 TradeId::new("e8cb18d4-8b99-40d3-9fce-cc0e33422e67"),
223 UnixNanos::from(1_700_000_123_456_000_000),
224 UnixNanos::from(987)
225 )
226 .unwrap()
227 );
228 }
229
230 #[rstest]
231 fn quote_preserves_every_field_without_last_price_or_complement() {
232 let instrument = instrument();
233 let tick = quote(frame("ticker"), &instrument, UnixNanos::from(654))
234 .unwrap()
235 .unwrap();
236 assert_eq!(
237 tick,
238 QuoteTick::new_checked(
239 instrument.id,
240 Price::from_decimal_dp("0.123456".parse().unwrap(), 6).unwrap(),
241 Price::from_decimal_dp("0.789123".parse().unwrap(), 6).unwrap(),
242 Quantity::from_decimal_dp("3.25".parse().unwrap(), 2).unwrap(),
243 Quantity::from_decimal_dp("6.75".parse().unwrap(), 2).unwrap(),
244 UnixNanos::from(1_700_000_123_789_000_000),
245 UnixNanos::from(654)
246 )
247 .unwrap()
248 );
249 }
250
251 #[rstest]
252 #[case("yes_bid_dollars")]
253 #[case("yes_ask_dollars")]
254 #[case("yes_bid_size_fp")]
255 #[case("yes_ask_size_fp")]
256 fn incomplete_ticker_never_invents_a_side(#[case] field: &str) {
257 let mut value = frame("ticker");
258 value.as_object_mut().unwrap().remove(field);
259 assert_eq!(
260 quote(value, &instrument(), UnixNanos::from(1)).unwrap(),
261 None
262 );
263 }
264
265 #[rstest]
266 #[case("yes_bid_size_fp")]
267 #[case("yes_ask_size_fp")]
268 fn empty_side_is_not_a_complete_quote(#[case] field: &str) {
269 let mut value = frame("ticker");
270 value[field] = "0.00".into();
271 assert_eq!(
272 quote(value, &instrument(), UnixNanos::from(1)).unwrap(),
273 None
274 );
275 }
276
277 #[rstest]
278 #[case("yes_price_dollars", "0.1234567")]
279 #[case("yes_price_dollars", "1.010000")]
280 #[case("count_fp", "7.251")]
281 #[case("count_fp", "-1.00")]
282 #[case("count_fp", "0.00")]
283 #[case("taker_book_side", "bid")]
284 #[case("taker_outcome_side", "yes")]
285 #[case("no_price_dollars", "0.100000")]
286 #[case("trade_id", "")]
287 fn invalid_trade_is_rejected(#[case] field: &str, #[case] invalid: &str) {
288 let mut value = frame("trade");
289 value[field] = invalid.into();
290 if field == "yes_price_dollars" {
291 value.as_object_mut().unwrap().remove("no_price_dollars");
292 }
293
294 assert!(trade(value, &instrument(), UnixNanos::from(1)).is_err());
295 }
296
297 #[rstest]
298 #[case(Decimal::MAX)]
299 #[case(Decimal::MIN)]
300 fn overflowing_trade_prices_are_rejected_without_panicking(#[case] price: Decimal) {
301 let mut value = frame("trade");
302 value["yes_price_dollars"] = price.to_string().into();
303 value["no_price_dollars"] = price.to_string().into();
304
305 assert_eq!(
306 trade(value, &instrument(), UnixNanos::from(1))
307 .unwrap_err()
308 .to_string(),
309 "inconsistent trade prices"
310 );
311 }
312
313 #[rstest]
314 #[case("yes_bid_dollars", "0.1234567")]
315 #[case("yes_ask_dollars", "0.100000")]
316 #[case("yes_bid_size_fp", "3.251")]
317 #[case("yes_ask_size_fp", "-1.00")]
318 fn invalid_quote_is_rejected(#[case] field: &str, #[case] invalid: &str) {
319 let mut value = frame("ticker");
320 value[field] = invalid.into();
321 assert!(quote(value, &instrument(), UnixNanos::from(1)).is_err());
322 }
323
324 #[rstest]
325 fn legacy_direction_is_not_a_fallback_and_block_trades_are_excluded() {
326 let mut value = frame("trade");
327 value.as_object_mut().unwrap().remove("taker_book_side");
328 value.as_object_mut().unwrap().remove("taker_outcome_side");
329 value["taker_side"] = "yes".into();
330 assert!(trade(value, &instrument(), UnixNanos::from(1)).is_err());
331 let mut value = frame("trade");
332 value["is_block_trade"] = true.into();
333 assert_eq!(
334 trade(value, &instrument(), UnixNanos::from(1)).unwrap(),
335 None
336 );
337 }
338
339 #[rstest]
340 fn timestamps_require_venue_evidence_and_reject_overflow() {
341 assert_eq!(
342 timestamp(None, Some(7)).unwrap(),
343 UnixNanos::from(7_000_000_000)
344 );
345 assert!(timestamp(None, None).is_err());
346 assert!(timestamp(Some(u64::MAX), Some(7)).is_err());
347 }
348
349 fn frame(name: &str) -> Value {
350 let fixtures: Value =
351 serde_json::from_str(include_str!("../../test_data/market_data.json")).unwrap();
352 fixtures[name].clone()
353 }
354
355 fn instrument() -> BinaryOption {
356 let fixtures: Value =
357 serde_json::from_str(include_str!("../../test_data/instruments.json")).unwrap();
358 let market: Market =
359 serde_json::from_value(fixtures["definitions"]["live"]["market"].clone()).unwrap();
360 let event: Event =
361 serde_json::from_value(fixtures["definitions"]["live"]["event"].clone()).unwrap();
362 parse_instrument(&market, &event, UnixNanos::from(1)).unwrap()
363 }
364}