1use indexmap::IndexMap;
19use jiff::Timestamp;
20use nautilus_core::{Params, UnixNanos};
21use nautilus_model::{
22 enums::AssetClass,
23 identifiers::InstrumentId,
24 instruments::BinaryOption,
25 types::{Currency, Price, Quantity},
26};
27use rust_decimal::Decimal;
28use serde::Deserialize;
29use serde_json::{Value, json};
30use strum::{AsRefStr, EnumString};
31
32use super::{
33 error::Error,
34 models::{Market, MarketStatus, OutcomeType},
35};
36use crate::common::{consts::FINFEED, enums::Exchange, symbol::to_instrument_id};
37
38pub(crate) const TOKEN_ID_KEY: &str = "token_id";
39const PRICE_PRECISION: u8 = 4;
40const SIZE_PRECISION: u8 = 6;
41
42pub fn parse_instrument(market: &Market, ts_init: UnixNanos) -> Result<BinaryOption, Error> {
57 let exchange_id = market
58 .exchange_id
59 .as_deref()
60 .ok_or_else(|| definition_error(market, "exchange_id", "is missing"))?;
61 let market_id = market
62 .market_id
63 .as_deref()
64 .ok_or_else(|| definition_error(market, "market_id", "is missing"))?;
65 let instrument_id = to_instrument_id(exchange_id, market_id)?;
66
67 if market
68 .exchange
69 .as_ref()
70 .and_then(|exchange| exchange.exchange_id.as_deref())
71 .is_some_and(|nested| nested != exchange_id)
72 {
73 return Err(definition_error(
74 market,
75 "exchange_id",
76 "conflicts with nested exchange",
77 ));
78 }
79
80 if market.outcome_type != OutcomeType::Binary {
81 return Err(definition_error(market, "outcome_type", "is unsupported"));
82 }
83
84 if !matches!(exchange_id.parse::<Exchange>(), Ok(Exchange::Polymarket)) {
85 return Err(definition_error(
86 market,
87 "source_specific_data",
88 "has no verified complete definition rules for this venue",
89 ));
90 }
91
92 let instrument = parse_polymarket(market, instrument_id, ts_init)?;
93
94 if market.status == MarketStatus::Unknown {
95 log::warn!(
96 "Unknown FinFeed market status for {instrument_id}, retaining metadata without settlement inference"
97 );
98 }
99
100 Ok(instrument)
101}
102
103fn parse_polymarket(
104 market: &Market,
105 instrument_id: InstrumentId,
106 ts_init: UnixNanos,
107) -> Result<BinaryOption, Error> {
108 let title = market
109 .title
110 .as_deref()
111 .filter(|title| !title.trim().is_empty())
112 .ok_or_else(|| definition_error(market, "title", "is missing or empty"))?;
113 let outcome = market
114 .outcome_name
115 .as_deref()
116 .and_then(|outcome| outcome.parse::<BinaryOutcome>().ok())
117 .ok_or_else(|| definition_error(market, "outcome_name", "must be Yes or No"))?;
118
119 let suffix = match outcome {
120 BinaryOutcome::Yes => "_YES",
121 BinaryOutcome::No => "_NO",
122 };
123
124 if !instrument_id.symbol.as_str().ends_with(suffix) {
125 return Err(definition_error(
126 market,
127 "outcome_name",
128 "conflicts with the provider outcome ID suffix",
129 ));
130 }
131 let condition_id = source_string(market, "ConditionId")?;
132 if condition_id.len() != 66
133 || !condition_id.starts_with("0x")
134 || !condition_id[2..]
135 .bytes()
136 .all(|byte| byte.is_ascii_hexdigit())
137 {
138 return Err(definition_error(market, "ConditionId", "is invalid"));
139 }
140
141 let token_id = outcome_token(market, outcome)?;
142 let tick_string = source_string(market, "MinimumTickSize")?;
143 let tick = Decimal::from_str_exact(&tick_string)
144 .map_err(|_| definition_error(market, "MinimumTickSize", "is not an exact decimal"))?;
145 if tick <= Decimal::ZERO || tick >= Decimal::ONE {
146 return Err(definition_error(
147 market,
148 "MinimumTickSize",
149 "must be in (0, 1)",
150 ));
151 }
152 let price_increment = exact_price(market, tick, "MinimumTickSize")?;
153 if market.price < Decimal::ZERO || market.price > Decimal::ONE {
154 return Err(definition_error(market, "price", "must be in [0, 1]"));
155 }
156 exact_price(market, market.price, "price")?;
157
158 let end_date = source_string(market, "EndDateIso")?;
159 let expiration = end_date
160 .parse::<Timestamp>()
161 .map_err(|_| definition_error(market, "EndDateIso", "is not a timestamp with an offset"))?;
162 let expiration_ns = u64::try_from(expiration.as_nanosecond())
163 .ok()
164 .filter(|time| *time > 0)
165 .ok_or_else(|| {
166 definition_error(
167 market,
168 "EndDateIso",
169 "is outside the supported positive nanosecond range",
170 )
171 })?;
172
173 let currency = Currency::pUSD();
174 let size_decimal = Decimal::new(1, u32::from(SIZE_PRECISION));
175 let size_increment = Quantity::from_decimal_dp(size_decimal, SIZE_PRECISION)
176 .map_err(|_| definition_error(market, "size_increment", "could not be represented"))?;
177 let description = match &market.description {
178 Some(description) => description.clone(),
179 None if market
180 .source_specific_data
181 .as_ref()
182 .is_some_and(|source| source.contains_key("Description")) =>
183 {
184 source_string(market, "Description")?
185 }
186 None => title.to_owned(),
187 };
188
189 let mut info: IndexMap<String, Value> = serde_json::from_value(json!({
190 "provider": FINFEED,
191 "exchange_id": market.exchange_id,
192 "market_id": market.market_id,
193 "title": title,
194 "status": market.status,
195 "outcome_type": market.outcome_type,
196 "mechanism": market.mechanism,
197 "condition_id": condition_id,
198 TOKEN_ID_KEY: token_id,
199 "activation_source": "native_unknown_zero",
200 "expiration_source": "EndDateIso",
201 }))
202 .map_err(|_| definition_error(market, "info", "could not be constructed"))?;
203 if market
204 .source_specific_data
205 .as_ref()
206 .is_some_and(|source| source.contains_key("QuestionId"))
207 {
208 info.insert(
209 "question_id".into(),
210 source_string(market, "QuestionId")?.into(),
211 );
212 }
213
214 if market
215 .source_specific_data
216 .as_ref()
217 .is_some_and(|source| source.contains_key("Tags"))
218 {
219 let tags: Vec<String> = serde_json::from_str(&source_string(market, "Tags")?)
220 .map_err(|_| definition_error(market, "Tags", "must contain a string array"))?;
221 info.insert("tags".into(), json!(tags));
222 }
223
224 let info = Params::new(info);
225 BinaryOption::builder()
226 .instrument_id(instrument_id)
227 .raw_symbol(instrument_id.symbol)
228 .asset_class(AssetClass::Alternative)
229 .currency(currency)
230 .activation_ns(UnixNanos::default())
231 .expiration_ns(UnixNanos::from(expiration_ns))
232 .price_precision(PRICE_PRECISION)
233 .size_precision(SIZE_PRECISION)
234 .price_increment(price_increment)
235 .size_increment(size_increment)
236 .outcome(outcome.as_ref().into())
237 .description(description.as_str().into())
238 .info(info)
239 .ts_event(ts_init)
240 .ts_init(ts_init)
241 .build()
242 .map_err(|_| definition_error(market, "instrument", "failed checked construction"))
243}
244
245#[derive(Debug, Clone, Copy, PartialEq, Eq, AsRefStr, EnumString)]
246enum BinaryOutcome {
247 Yes,
248 No,
249}
250
251#[derive(Deserialize)]
252struct OutcomeToken {
253 token_id: String,
254 outcome: String,
255}
256
257fn outcome_token(market: &Market, outcome: BinaryOutcome) -> Result<String, Error> {
258 let value = source_string(market, "Tokens")?;
259 let mut tokens: Vec<OutcomeToken> = serde_json::from_str(&value)
260 .map_err(|_| definition_error(market, "Tokens", "is not a valid token array"))?;
261 if tokens.len() != 2 {
262 return Err(definition_error(
263 market,
264 "Tokens",
265 "must contain exactly two binary outcomes",
266 ));
267 }
268
269 let outcomes =
270 [&tokens[0].outcome, &tokens[1].outcome].map(|label| label.parse::<BinaryOutcome>().ok());
271
272 if tokens[0].token_id == tokens[1].token_id
273 || outcomes[0] == outcomes[1]
274 || outcomes.iter().any(Option::is_none)
275 || tokens.iter().any(|token| {
276 token.token_id.is_empty() || !token.token_id.bytes().all(|byte| byte.is_ascii_digit())
277 })
278 {
279 return Err(definition_error(
280 market,
281 "Tokens",
282 "contains ambiguous or invalid identities",
283 ));
284 }
285
286 let index = usize::from(outcomes[0] != Some(outcome));
287 Ok(tokens.swap_remove(index).token_id)
288}
289
290fn source_string(market: &Market, field: &'static str) -> Result<String, Error> {
291 let value = market
292 .source_specific_data
293 .as_ref()
294 .and_then(|source| source.get(field))
295 .ok_or_else(|| definition_error(market, field, "is missing"))?;
296 let value: String = serde_json::from_str(value.get())
297 .map_err(|_| definition_error(market, field, "must be a string"))?;
298 if value.trim().is_empty() {
299 return Err(definition_error(market, field, "is empty"));
300 }
301 Ok(value)
302}
303
304fn exact_price(market: &Market, value: Decimal, field: &'static str) -> Result<Price, Error> {
305 let price = Price::from_decimal_dp(value, PRICE_PRECISION)
306 .map_err(|_| definition_error(market, field, "cannot be represented at price precision"))?;
307 if price.as_decimal() != value {
308 return Err(definition_error(
309 market,
310 field,
311 "would require rounding at price precision",
312 ));
313 }
314 Ok(price)
315}
316
317fn definition_error(market: &Market, field: &'static str, reason: &'static str) -> Error {
318 Error::Definition {
319 exchange_id: market.exchange_id.unwrap_or_default(),
320 market_id: market.market_id.unwrap_or_default(),
321 field,
322 reason,
323 }
324}
325
326#[cfg(test)]
327mod tests {
328 use nautilus_model::enums::CurrencyType;
329 use rstest::rstest;
330
331 use super::*;
332 use crate::http::models::MarketsPage;
333
334 const MARKET: &str = include_str!("../../test_data/polymarket-market.json");
335 const LISTINGS: &str = include_str!("../../test_data/polymarket-listings.json");
336
337 #[rstest]
338 fn binary_pair_preserves_every_instrument_field() {
339 let page: MarketsPage = serde_json::from_str(LISTINGS).unwrap();
340 let markets = page.data.unwrap();
341 let instruments: Vec<_> = markets
342 .iter()
343 .map(|market| parse_instrument(market, UnixNanos::from(123)).unwrap())
344 .collect();
345 let ids: Vec<_> = instruments
346 .iter()
347 .map(|instrument| instrument.id.to_string())
348 .collect();
349 assert_eq!(
350 ids,
351 [
352 "TEST-PAIR_NO.FINFEED_POLYMARKET",
353 "TEST-PAIR_YES.FINFEED_POLYMARKET"
354 ]
355 );
356
357 for (index, instrument) in instruments.iter().enumerate() {
358 let token_id = [
359 "404044040440404404044040440404404044040440404404044040440404404044040440404",
360 "303033030330303303033030330303303033030330303303033030330303303033030330303",
361 ][index];
362 assert_definition_fields(instrument, 123, "0.0010", 1_780_358_400_000_000_000);
363 assert_eq!(instrument.outcome.unwrap().as_str(), ["No", "Yes"][index]);
364 assert_eq!(
365 instrument.description.unwrap().as_str(),
366 markets[index].description.as_deref().unwrap()
367 );
368 let expected_info = serde_json::from_value::<Params>(json!({
369 "provider": "FINFEED", "exchange_id": "POLYMARKET", "market_id": markets[index].market_id,
370 "title": "Authored binary outcome", "status": "Closed",
371 "outcome_type": "Binary", "mechanism": markets[index].mechanism,
372 "condition_id": "0x3333333333333333333333333333333333333333333333333333333333333333",
373 "token_id": token_id,
374 "activation_source": "native_unknown_zero", "expiration_source": "EndDateIso",
375 "question_id": "0x4444444444444444444444444444444444444444444444444444444444444444",
376 "tags": ["Test", "Binary"]
377 })).unwrap();
378 assert_eq!(instrument.info.as_ref().unwrap(), &expected_info);
379 }
380 }
381
382 #[rstest]
383 fn full_metadata_preserves_description_and_question_tags() {
384 let market: Market = serde_json::from_str(MARKET).unwrap();
385 let instrument = parse_instrument(&market, UnixNanos::from(456)).unwrap();
386 assert_definition_fields(&instrument, 456, "0.0100", 1_798_761_600_000_000_000);
387 assert_eq!(
388 instrument.description.unwrap().as_str(),
389 market.description.unwrap()
390 );
391 assert_eq!(instrument.outcome.unwrap().as_str(), "No");
392 let info = instrument.info.unwrap();
393 assert_eq!(
394 info["question_id"],
395 "0x2222222222222222222222222222222222222222222222222222222222222222"
396 );
397 assert_eq!(info["tags"], json!(["Test", "Binary"]));
398 let encoded = serde_json::to_string(&instrument.currency).unwrap();
399 let decoded: Currency = serde_json::from_str(&encoded).unwrap();
400 assert_eq!(decoded, instrument.currency);
401 assert_eq!(decoded.precision, instrument.currency.precision);
402 assert_eq!(decoded.iso4217, instrument.currency.iso4217);
403 assert_eq!(decoded.name, instrument.currency.name);
404 assert_eq!(decoded.currency_type, instrument.currency.currency_type);
405 }
406
407 #[rstest]
408 #[case(include_str!("../../test_data/kalshi-listings.json"), "KALSHI")]
409 #[case(include_str!("../../test_data/myriad-listings.json"), "MYRIAD")]
410 #[case(include_str!("../../test_data/manifold-listings.json"), "MANIFOLD")]
411 #[case(include_str!("../../test_data/hyperliquidoutcome-listings.json"), "HYPERLIQUIDOUTCOME")]
412 #[case(include_str!("../../test_data/pascal-listings.json"), "PASCAL")]
413 #[case(include_str!("../../test_data/geminipm-listings.json"), "GEMINIPM")]
414 #[case(include_str!("../../test_data/cryptocompm-listings.json"), "CRYPTOCOMPM")]
415 #[case(include_str!("../../test_data/forecastex-listings.json"), "FORECASTEX")]
416 fn incomplete_venue_definitions_fail_with_identity_context(
417 #[case] fixture: &str,
418 #[case] exchange: &str,
419 ) {
420 let page: MarketsPage = serde_json::from_str(fixture).unwrap();
421 for market in page.data.unwrap() {
422 match parse_instrument(&market, UnixNanos::default()).unwrap_err() {
423 Error::Definition {
424 exchange_id,
425 market_id,
426 field,
427 reason,
428 } => {
429 assert_eq!(exchange_id, exchange);
430 assert_eq!(Some(market_id), market.market_id);
431 assert_eq!(field, "source_specific_data");
432 assert_eq!(
433 reason,
434 "has no verified complete definition rules for this venue"
435 );
436 }
437 e => panic!("Unexpected error: {e}"),
438 }
439 }
440 }
441
442 #[rstest]
443 #[case("MinimumTickSize", json!("0"), "must be in (0, 1)")]
444 #[case("MinimumTickSize", json!("1"), "must be in (0, 1)")]
445 #[case("MinimumTickSize", json!("0.00001"), "would require rounding at price precision")]
446 #[case("MinimumTickSize", json!("0.1234567890123456789012345678901"), "is not an exact decimal")]
447 #[case("MinimumTickSize", json!(false), "must be a string")]
448 #[case("MinimumTickSize", json!(""), "is empty")]
449 #[case("EndDateIso", json!("2027-01-01"), "is not a timestamp with an offset")]
450 #[case("EndDateIso", json!("1960-01-01T00:00:00Z"), "is outside the supported positive nanosecond range")]
451 #[case("EndDateIso", json!("2600-01-01T00:00:00Z"), "is outside the supported positive nanosecond range")]
452 #[case("ConditionId", json!("not-a-condition"), "is invalid")]
453 #[case("Tokens", json!("[]"), "must contain exactly two binary outcomes")]
454 #[case("Tokens", json!("bad-array"), "is not a valid token array")]
455 #[case("Tags", json!("{}"), "must contain a string array")]
456 fn invalid_source_fields_fail_exactly(
457 #[case] field: &str,
458 #[case] value: Value,
459 #[case] reason: &str,
460 ) {
461 let mut value_market: Value = serde_json::from_str(MARKET).unwrap();
462 value_market["source_specific_data"][field] = value;
463 let market: Market = serde_json::from_value(value_market).unwrap();
464 match parse_instrument(&market, UnixNanos::default()).unwrap_err() {
465 Error::Definition {
466 exchange_id,
467 market_id,
468 field: actual_field,
469 reason: actual_reason,
470 } => {
471 assert_eq!(exchange_id, "POLYMARKET");
472 assert_eq!(Some(market_id), market.market_id);
473 assert_eq!(actual_field, field);
474 assert_eq!(actual_reason, reason);
475 }
476 e => panic!("Unexpected error: {e}"),
477 }
478 }
479
480 #[rstest]
481 #[case("ConditionId")]
482 #[case("Tokens")]
483 #[case("MinimumTickSize")]
484 #[case("EndDateIso")]
485 fn missing_source_fields_are_not_defaulted(#[case] field: &str) {
486 let mut market: Market = serde_json::from_str(MARKET).unwrap();
487 market.source_specific_data.as_mut().unwrap().remove(field);
488 assert!(
489 matches!(parse_instrument(&market, UnixNanos::default()), Err(Error::Definition { field: actual, reason: "is missing", .. }) if actual == field)
490 );
491 }
492
493 #[rstest]
494 #[case(OutcomeType::MultipleChoice)]
495 #[case(OutcomeType::Numeric)]
496 #[case(OutcomeType::Other)]
497 fn non_binary_outcomes_are_rejected(#[case] outcome_type: OutcomeType) {
498 let mut market: Market = serde_json::from_str(MARKET).unwrap();
499 market.outcome_type = outcome_type;
500 assert!(matches!(
501 parse_instrument(&market, UnixNanos::default()),
502 Err(Error::Definition {
503 exchange_id,
504 market_id,
505 field: "outcome_type",
506 reason: "is unsupported",
507 }) if exchange_id == "POLYMARKET" && Some(market_id.as_str()) == market.market_id.as_deref()
508 ));
509 }
510
511 #[rstest]
512 #[case("-0.0001")]
513 #[case("1.0001")]
514 #[case("0.12345")]
515 fn prices_outside_probability_or_exact_precision_are_rejected(#[case] price: &str) {
516 let mut market: Market = serde_json::from_str(MARKET).unwrap();
517 market.price = Decimal::from_str_exact(price).unwrap();
518 assert!(matches!(
519 parse_instrument(&market, UnixNanos::default()),
520 Err(Error::Definition { field: "price", .. })
521 ));
522 }
523
524 #[rstest]
525 #[case("0")]
526 #[case("1")]
527 #[case("0.1234")]
528 fn exact_probability_boundaries_are_supported(#[case] price: &str) {
529 let mut market: Market = serde_json::from_str(MARKET).unwrap();
530 market.price = Decimal::from_str_exact(price).unwrap();
531 let instrument = parse_instrument(&market, UnixNanos::from(1)).unwrap();
532 assert_eq!(instrument.price_precision, 4);
533 assert_eq!(
534 instrument.price_increment.as_decimal(),
535 Decimal::from_str_exact("0.01").unwrap()
536 );
537 }
538
539 #[rstest]
540 fn conflicting_exchange_or_outcome_cannot_change_identity() {
541 let mut market: Market = serde_json::from_str(MARKET).unwrap();
542 market.exchange.as_mut().unwrap().exchange_id = Some("KALSHI".into());
543 assert!(matches!(
544 parse_instrument(&market, UnixNanos::default()),
545 Err(Error::Definition {
546 field: "exchange_id",
547 ..
548 })
549 ));
550 market.exchange.as_mut().unwrap().exchange_id = Some("POLYMARKET".into());
551 market.outcome_name = Some("Yes".into());
552 assert!(matches!(
553 parse_instrument(&market, UnixNanos::default()),
554 Err(Error::Definition {
555 field: "outcome_name",
556 reason: "conflicts with the provider outcome ID suffix",
557 ..
558 })
559 ));
560 }
561
562 #[rstest]
563 #[case("duplicate-token")]
564 #[case("duplicate-outcome")]
565 #[case("unsupported-outcome")]
566 #[case("lowercase-outcome")]
567 #[case("empty-token")]
568 fn ambiguous_tokens_are_rejected(#[case] change: &str) {
569 let mut value: Value = serde_json::from_str(MARKET).unwrap();
570 let mut tokens: Value =
571 serde_json::from_str(value["source_specific_data"]["Tokens"].as_str().unwrap())
572 .unwrap();
573
574 match change {
575 "duplicate-token" => tokens[1]["token_id"] = tokens[0]["token_id"].clone(),
576 "duplicate-outcome" => tokens[1]["outcome"] = tokens[0]["outcome"].clone(),
577 "unsupported-outcome" => tokens[1]["outcome"] = "Maybe".into(),
578 "lowercase-outcome" => tokens[1]["outcome"] = "yes".into(),
579 "empty-token" => tokens[1]["token_id"] = "".into(),
580 _ => unreachable!(),
581 }
582
583 value["source_specific_data"]["Tokens"] = serde_json::to_string(&tokens).unwrap().into();
584 let market: Market = serde_json::from_value(value).unwrap();
585 assert!(matches!(
586 parse_instrument(&market, UnixNanos::default()),
587 Err(Error::Definition {
588 field: "Tokens",
589 reason: "contains ambiguous or invalid identities",
590 ..
591 })
592 ));
593 }
594
595 #[rstest]
596 #[case("yes")]
597 #[case("no")]
598 #[case("YES")]
599 #[case("NO")]
600 #[case("Maybe")]
601 #[case("")]
602 #[case(" Yes")]
603 fn native_outcomes_require_exact_binary_labels(#[case] label: &str) {
604 let mut market: Market = serde_json::from_str(MARKET).unwrap();
605 market.outcome_name = Some(label.to_owned());
606 let error = parse_instrument(&market, UnixNanos::default()).unwrap_err();
607
608 let Error::Definition {
609 exchange_id,
610 market_id,
611 field,
612 reason,
613 } = error
614 else {
615 panic!("expected invalid outcome definition");
616 };
617
618 assert_eq!(exchange_id, "POLYMARKET");
619 assert_eq!(Some(market_id), market.market_id);
620 assert_eq!(field, "outcome_name");
621 assert_eq!(reason, "must be Yes or No");
622 }
623
624 #[rstest]
625 #[case("exchange_id", "exchange_id")]
626 #[case("market_id", "market_id")]
627 #[case("title", "title")]
628 #[case("outcome_name", "outcome_name")]
629 #[case("source_specific_data", "ConditionId")]
630 fn missing_normalized_fields_fail_with_exact_context(
631 #[case] field: &str,
632 #[case] error_field: &str,
633 ) {
634 let mut value: Value = serde_json::from_str(MARKET).unwrap();
635 value[field] = Value::Null;
636 let market: Market = serde_json::from_value(value).unwrap();
637 match parse_instrument(&market, UnixNanos::default()).unwrap_err() {
638 Error::Definition {
639 exchange_id,
640 market_id,
641 field: actual_field,
642 ..
643 } => {
644 assert_eq!(actual_field, error_field);
645 assert_eq!(exchange_id, market.exchange_id.unwrap_or_default());
646 assert_eq!(market_id, market.market_id.unwrap_or_default());
647 }
648 e => panic!("Unexpected error: {e}"),
649 }
650 }
651
652 #[rstest]
653 fn absent_optional_description_and_event_fields_do_not_invent_metadata() {
654 let mut market: Market = serde_json::from_str(MARKET).unwrap();
655 market.description = None;
656 let source = market.source_specific_data.as_mut().unwrap();
657 source.remove("QuestionId");
658 source.remove("Tags");
659 source.remove("Description");
660 let instrument = parse_instrument(&market, UnixNanos::default()).unwrap();
661 assert_eq!(
662 instrument.description.unwrap().as_str(),
663 market.title.unwrap()
664 );
665 assert_eq!(instrument.event_id, None);
666 let info = instrument.info.unwrap();
667 assert_eq!(info.get("question_id"), None);
668 assert_eq!(info.get("tags"), None);
669 assert_eq!(info.get_str("outcome_type"), Some("Binary"));
670 assert_eq!(info.get("mechanism"), Some(&serde_json::Value::Null));
671 assert_eq!(info.len(), 11);
672 }
673
674 #[rstest]
675 fn source_description_fills_missing_normalized_description() {
676 let mut market: Market = serde_json::from_str(MARKET).unwrap();
677 let expected = market.description.take().unwrap();
678 let instrument = parse_instrument(&market, UnixNanos::default()).unwrap();
679 assert_eq!(instrument.description.unwrap().as_str(), expected);
680 }
681
682 fn assert_definition_fields(instrument: &BinaryOption, ts: u64, tick: &str, expiry: u64) {
683 assert_eq!(instrument.raw_symbol, instrument.id.symbol);
684 assert_eq!(instrument.asset_class, AssetClass::Alternative);
685 assert_eq!(instrument.currency.code.as_str(), "pUSD");
686 assert_eq!(instrument.currency.precision, 6);
687 assert_eq!(instrument.currency.iso4217, 0);
688 assert_eq!(instrument.currency.name.as_str(), "Polymarket USD");
689 assert_eq!(instrument.currency.currency_type, CurrencyType::Crypto);
690 assert_eq!(instrument.price_precision, 4);
691 assert_eq!(instrument.size_precision, 6);
692 assert_eq!(instrument.price_increment.precision, 4);
693 assert_eq!(
694 instrument.price_increment.as_decimal(),
695 Decimal::from_str_exact(tick).unwrap()
696 );
697 assert_eq!(instrument.size_increment.precision, 6);
698 assert_eq!(
699 instrument.size_increment.as_decimal(),
700 Decimal::from_str_exact("0.000001").unwrap()
701 );
702 assert_eq!(instrument.activation_ns, UnixNanos::default());
703 assert_eq!(instrument.expiration_ns, UnixNanos::from(expiry));
704 assert_eq!(instrument.margin_init, Decimal::ZERO);
705 assert_eq!(instrument.margin_maint, Decimal::ZERO);
706 assert_eq!(instrument.event_id, None);
707 assert_eq!(instrument.min_quantity, None);
708 assert_eq!(instrument.max_quantity, None);
709 assert_eq!(instrument.min_notional, None);
710 assert_eq!(instrument.max_notional, None);
711 assert_eq!(instrument.min_price, None);
712 assert_eq!(instrument.max_price, None);
713 assert_eq!(instrument.tick_scheme, None);
714 assert_eq!(instrument.ts_event, UnixNanos::from(ts));
715 assert_eq!(instrument.ts_init, UnixNanos::from(ts));
716 }
717}