1use std::sync::Arc;
19
20use ahash::AHashMap;
21use indexmap::IndexMap;
22use jiff::Timestamp;
23use nautilus_core::{Params, UnixNanos};
24use nautilus_model::{
25 enums::{AssetClass, CurrencyType},
26 identifiers::{InstrumentId, Symbol},
27 instruments::{BinaryOption, InstrumentAny},
28 types::{Currency, Price, Quantity},
29};
30use rust_decimal::Decimal;
31use rust_decimal_macros::dec;
32use serde::{Deserialize, Serialize};
33use serde_json::{Value, from_str};
34use ustr::Ustr;
35
36use super::models::{CryptoMarketConfig, FeeSchedule, GammaEvent, GammaMarket, GammaTag};
37use crate::common::{
38 consts::{
39 MARKET_VERSION_KEY, MARKET_VERSION_V2, POLYMARKET_PRICE_PRECISION, POLYMARKET_VENUE, PUSD,
40 },
41 enums::PolymarketOutcome,
42 parse::{
43 parse_decimal_exact, validate_data_market_version, validate_outcome_ids, validate_outcomes,
44 },
45};
46
47const DEFAULT_TICK_SIZE: Decimal = dec!(0.001);
48
49const REBATE_CRYPTO: Decimal = dec!(0.20);
52const REBATE_SPORTS: Decimal = dec!(0.15);
53const REBATE_STANDARD: Decimal = dec!(0.25);
54
55#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
59pub struct PolymarketInstrumentDef {
60 pub symbol: Ustr,
62 pub token_id: Ustr,
64 pub condition_id: Ustr,
66 pub market_id: String,
68 pub event_id: Option<Ustr>,
70 #[serde(default)]
72 pub gamma_market: String,
73 pub gamma_event: Option<Arc<Value>>,
75 pub question_id: Option<String>,
77 pub outcome: PolymarketOutcome,
79 pub question: String,
81 pub description: Option<String>,
83 pub price_precision: u8,
85 pub tick_size: Decimal,
87 pub min_size: Option<Decimal>,
89 pub start_date: Option<String>,
91 pub event_start_time: Option<String>,
93 pub end_date: Option<String>,
95 pub active: bool,
97 #[serde(default)]
99 pub closed: bool,
100 pub market_slug: Option<String>,
102 pub neg_risk: Option<bool>,
104 pub resolution_source: Option<String>,
106 pub crypto_market_config: Option<CryptoMarketConfig>,
108 pub fee_schedule: Option<FeeSchedule>,
110 pub game_id: Option<String>,
113 pub market_version: String,
115}
116
117pub fn parse_gamma_market(market: &GammaMarket) -> anyhow::Result<Vec<PolymarketInstrumentDef>> {
122 parse_gamma_market_with_event_cache(market, &mut AHashMap::new())
123}
124
125pub(super) fn parse_gamma_market_with_event_cache(
126 market: &GammaMarket,
127 event_metadata: &mut AHashMap<*const GammaEvent, Arc<Value>>,
128) -> anyhow::Result<Vec<PolymarketInstrumentDef>> {
129 let version = validate_data_market_version(market.version.as_deref())?;
130 let event_id = market_event_id(market);
131
132 let game_id = market.game_id.clone().or_else(|| {
133 market
134 .events
135 .as_ref()?
136 .iter()
137 .find_map(|event| event.game_id.clone())
138 });
139
140 let (token_ids, outcomes) = parse_market_outcomes(market)?;
141
142 let tick_size = market
143 .order_price_min_tick_size
144 .unwrap_or(DEFAULT_TICK_SIZE);
145 let price_precision = POLYMARKET_PRICE_PRECISION;
146
147 let min_size = market.order_min_size;
148
149 let closed = is_market_closed(market);
150 let active =
151 market.active.unwrap_or(false) && !closed && market.accepting_orders.unwrap_or(false);
152
153 let neg_risk = market.neg_risk;
154
155 let gamma_event = market.parent_event.as_ref().map(|event| {
156 Arc::clone(
157 event_metadata
158 .entry(Arc::as_ptr(event))
159 .or_insert_with(|| Arc::new(Value::String(event.raw.clone()))),
160 )
161 });
162
163 let mut defs = Vec::with_capacity(2);
164
165 for (token_id, outcome_label) in token_ids.iter().zip(outcomes.iter()) {
166 let outcome = PolymarketOutcome::from(outcome_label.as_str());
167
168 let symbol_str = format!("{}-{token_id}", market.condition_id);
169
170 defs.push(PolymarketInstrumentDef {
171 symbol: Ustr::from(&symbol_str),
172 token_id: Ustr::from(token_id.as_str()),
173 condition_id: Ustr::from(market.condition_id.as_str()),
174 market_id: market.id.clone(),
175 event_id,
176 gamma_market: market.raw.clone(),
177 gamma_event: gamma_event.clone(),
178 question_id: market.question_id.clone(),
179 outcome,
180 question: market.question.clone(),
181 description: market.description.clone(),
182 price_precision,
183 tick_size,
184 min_size,
185 start_date: market.start_date.clone(),
186 event_start_time: market.event_start_time.clone(),
187 end_date: market.end_date.clone(),
188 active,
189 closed,
190 market_slug: market.market_slug.clone(),
191 neg_risk,
192 resolution_source: market.resolution_source.clone(),
193 crypto_market_config: market.crypto_market_config.clone(),
194 fee_schedule: market.fee_schedule.clone(),
195 game_id: game_id.clone(),
196 market_version: version.to_string(),
197 });
198 }
199
200 Ok(defs)
201}
202
203pub(crate) fn parse_market_outcomes(
204 market: &GammaMarket,
205) -> anyhow::Result<(Vec<String>, Vec<String>)> {
206 let version = validate_data_market_version(market.version.as_deref())?;
207 let ids = if version == MARKET_VERSION_V2 {
208 market
209 .position_ids
210 .clone()
211 .ok_or_else(|| anyhow::anyhow!("Missing V2 positionIds"))?
212 } else {
213 from_str::<Vec<String>>(&market.clob_token_ids)?
214 };
215
216 validate_outcome_ids(&ids)?;
217 let outcomes: Vec<String> = from_str(&market.outcomes)?;
218 validate_outcomes(&outcomes)?;
219 Ok((ids, outcomes))
220}
221
222pub(crate) fn is_market_closed(market: &GammaMarket) -> bool {
223 market.closed == Some(true)
224 || (market.version.as_deref() == Some(MARKET_VERSION_V2)
225 && market.resolution_status.as_deref() == Some("resolved"))
226}
227
228fn market_event_id(market: &GammaMarket) -> Option<Ustr> {
229 if let Some(event) = &market.parent_event {
230 return (!event.id.is_empty()).then(|| Ustr::from(event.id.as_str()));
231 }
232
233 let events = market.events.as_ref()?;
234 let first = events.first()?;
235 if first.id.is_empty() || events.iter().any(|event| event.id != first.id) {
236 log::warn!("Ambiguous Gamma parent event for market {}", market.id);
237 return None;
238 }
239
240 Some(Ustr::from(first.id.as_str()))
241}
242
243#[derive(Clone, Copy, Debug, PartialEq, Eq)]
244enum FeeCategory {
245 Crypto,
246 Sports,
247 Standard,
248 FeeFree,
249}
250
251pub(crate) fn resolve_maker_rebate_rate(market: &GammaMarket) -> Decimal {
255 match classify_market(market) {
256 Some(FeeCategory::Crypto) => REBATE_CRYPTO,
257 Some(FeeCategory::Sports) => REBATE_SPORTS,
258 Some(FeeCategory::Standard) => REBATE_STANDARD,
259 Some(FeeCategory::FeeFree) | None => Decimal::ZERO,
260 }
261}
262
263pub(crate) fn enrich_market_fee_schedule(market: &mut GammaMarket) {
266 let rebate = resolve_maker_rebate_rate(market);
267 if (market.fees_enabled == Some(true) || !rebate.is_zero())
268 && market
269 .fee_type
270 .as_deref()
271 .is_none_or(|fee_type| !fee_type.trim().eq_ignore_ascii_case("zero_fees"))
272 && market
273 .fee_schedule
274 .as_ref()
275 .is_none_or(|schedule| schedule.rate.is_zero())
276 {
277 log::warn!(
278 "Missing or zero Gamma taker fee rate for fee-enabled market {}, using zero",
279 market.id
280 );
281 }
282
283 match market.fee_schedule.as_mut() {
284 Some(schedule) => {
285 schedule.rebate_rate = rebate;
286 }
287 None => {
288 if rebate.is_zero() {
289 return;
290 }
291
292 market.fee_schedule = Some(FeeSchedule {
293 exponent: Decimal::ONE,
294 rate: Decimal::ZERO,
295 taker_only: true,
296 rebate_rate: rebate,
297 });
298 }
299 }
300}
301
302fn classify_market(market: &GammaMarket) -> Option<FeeCategory> {
303 if market.fees_enabled == Some(false) {
304 return Some(FeeCategory::FeeFree);
305 }
306
307 if let Some(fee_type) = market.fee_type.as_deref()
308 && let Some(category) = classify_fee_type(fee_type)
309 {
310 return Some(category);
311 }
312
313 if market.crypto_market_config.is_some() {
314 return Some(FeeCategory::Crypto);
315 }
316
317 if market.sports_market_type.is_some() || market.game_id.is_some() {
318 return Some(FeeCategory::Sports);
319 }
320
321 let mut candidates = Vec::new();
322
323 if let Some(category) = market.category.as_deref()
324 && let Some(matched) = classify_label(category)
325 {
326 candidates.push(matched);
327 }
328
329 candidates.extend(classify_tags(market.tags.as_deref()));
330
331 if let Some(parent) = market.parent_event.as_ref() {
332 if let Some(category) = parent.category.as_deref()
333 && let Some(matched) = classify_label(category)
334 {
335 candidates.push(matched);
336 }
337
338 candidates.extend(classify_tags(parent.tags.as_deref()));
339 if parent.game_id.is_some() {
340 candidates.push(FeeCategory::Sports);
341 }
342 }
343
344 if let Some(events) = market.events.as_ref() {
345 for event in events {
346 if let Some(category) = event.category.as_deref()
347 && let Some(matched) = classify_label(category)
348 {
349 candidates.push(matched);
350 }
351
352 candidates.extend(classify_tags(event.tags.as_deref()));
353 if event.game_id.is_some() {
354 candidates.push(FeeCategory::Sports);
355 }
356 }
357 }
358
359 let first = candidates.first()?;
360 if candidates.iter().all(|category| category == first) {
361 return Some(*first);
362 }
363
364 None
365}
366
367fn classify_fee_type(fee_type: &str) -> Option<FeeCategory> {
368 let normalized = fee_type.trim().to_lowercase();
369
370 if normalized.contains("crypto") {
371 return Some(FeeCategory::Crypto);
372 }
373
374 if normalized.contains("sport") {
375 return Some(FeeCategory::Sports);
376 }
377
378 if normalized.contains("geopolit") {
379 return Some(FeeCategory::FeeFree);
380 }
381
382 for token in [
383 "finance", "politic", "economic", "culture", "weather", "mention", "tech", "general",
384 "other", "prices",
385 ] {
386 if normalized.contains(token) {
387 return Some(FeeCategory::Standard);
388 }
389 }
390
391 None
392}
393
394fn classify_tags(tags: Option<&[GammaTag]>) -> Vec<FeeCategory> {
395 let mut categories = Vec::new();
396
397 for tag in tags.unwrap_or(&[]) {
398 for value in [tag.label.as_deref(), tag.slug.as_deref()]
399 .into_iter()
400 .flatten()
401 {
402 if let Some(category) = classify_label(value) {
403 categories.push(category);
404 }
405 }
406 }
407
408 categories
409}
410
411fn classify_label(value: &str) -> Option<FeeCategory> {
412 let normalized = value.trim().to_lowercase();
413
414 if normalized.contains("crypto") {
415 return Some(FeeCategory::Crypto);
416 }
417
418 if normalized.contains("sport") || normalized.contains("esport") {
419 return Some(FeeCategory::Sports);
420 }
421
422 if normalized.contains("geopolit") || normalized.contains("world event") {
423 return Some(FeeCategory::FeeFree);
424 }
425
426 for token in [
427 "finance", "politic", "economic", "culture", "weather", "mention", "tech", "general",
428 "other",
429 ] {
430 if normalized.contains(token) {
431 return Some(FeeCategory::Standard);
432 }
433 }
434
435 None
436}
437
438pub fn create_instrument_from_def(
440 def: &PolymarketInstrumentDef,
441 ts_init: UnixNanos,
442) -> anyhow::Result<InstrumentAny> {
443 validate_data_market_version(Some(&def.market_version))?;
444 let symbol = Symbol::new(def.symbol);
445 let venue = *POLYMARKET_VENUE;
446 let instrument_id = InstrumentId::new(symbol, venue);
447 let raw_symbol = Symbol::new(def.token_id);
448 let currency = get_currency(PUSD);
449
450 let size_increment = Quantity::from("0.000001");
451
452 let activation_ns = def
453 .start_date
454 .as_deref()
455 .and_then(parse_datetime_to_nanos)
456 .unwrap_or_default();
457 let expiration_ns = def
458 .end_date
459 .as_deref()
460 .and_then(parse_datetime_to_nanos)
461 .unwrap_or_default();
462
463 let (min_price, max_price) = tick_relative_price_bounds(def.tick_size)?;
467 let price_increment = min_price;
468
469 let min_quantity: Option<Quantity> = None;
473
474 let info = build_info(def);
475
476 let binary_option = BinaryOption::builder()
477 .instrument_id(instrument_id)
478 .raw_symbol(raw_symbol)
479 .asset_class(AssetClass::Alternative)
480 .currency(currency)
481 .activation_ns(activation_ns)
482 .expiration_ns(expiration_ns)
483 .price_precision(POLYMARKET_PRICE_PRECISION)
484 .size_precision(6)
486 .price_increment(price_increment)
487 .size_increment(size_increment)
488 .maybe_event_id(def.event_id)
489 .outcome(def.outcome.inner())
490 .description(Ustr::from(def.question.as_str()))
491 .maybe_min_quantity(min_quantity)
492 .max_price(max_price)
493 .min_price(min_price)
494 .info(info)
495 .ts_event(ts_init)
496 .ts_init(ts_init)
497 .build()?;
498
499 Ok(InstrumentAny::BinaryOption(binary_option))
500}
501
502#[must_use]
504pub fn instruments_from_defs(
505 defs: &[PolymarketInstrumentDef],
506 ts_init: UnixNanos,
507) -> Vec<InstrumentAny> {
508 defs.iter()
509 .filter_map(|def| {
510 create_instrument_from_def(def, ts_init)
511 .map_err(|e| log::warn!("Failed to create instrument {}: {e}", def.symbol))
512 .ok()
513 })
514 .collect()
515}
516
517pub fn rebuild_instrument_with_tick_size(
521 existing: &InstrumentAny,
522 new_tick_size: &str,
523 ts_event: UnixNanos,
524 ts_init: UnixNanos,
525) -> anyhow::Result<InstrumentAny> {
526 let bo = match existing {
527 InstrumentAny::BinaryOption(b) => b,
528 other => anyhow::bail!("Expected BinaryOption, was {other:?}"),
529 };
530
531 let tick_size = parse_decimal_exact(new_tick_size)
532 .map_err(|e| anyhow::anyhow!("Failed to parse tick size '{new_tick_size}': {e}"))?;
533 let (min_price, max_price) = tick_relative_price_bounds(tick_size)?;
534 let price_increment = min_price;
535
536 let rebuilt = BinaryOption::builder()
537 .instrument_id(bo.id)
538 .raw_symbol(bo.raw_symbol)
539 .asset_class(bo.asset_class)
540 .currency(bo.currency)
541 .activation_ns(bo.activation_ns)
542 .expiration_ns(bo.expiration_ns)
543 .price_precision(POLYMARKET_PRICE_PRECISION)
544 .size_precision(bo.size_precision)
545 .price_increment(price_increment)
546 .size_increment(bo.size_increment)
547 .maybe_event_id(bo.event_id)
548 .maybe_outcome(bo.outcome)
549 .maybe_description(bo.description)
550 .maybe_max_quantity(bo.max_quantity)
551 .maybe_max_notional(bo.max_notional)
553 .maybe_min_notional(bo.min_notional)
554 .max_price(max_price)
555 .min_price(min_price)
556 .margin_init(bo.margin_init)
557 .margin_maint(bo.margin_maint)
558 .maybe_info(bo.info.clone())
559 .ts_event(ts_event)
560 .ts_init(ts_init)
561 .build()?;
562
563 Ok(InstrumentAny::BinaryOption(rebuilt))
564}
565
566pub(crate) fn tick_relative_price_bounds(tick_size: Decimal) -> anyhow::Result<(Price, Price)> {
569 anyhow::ensure!(
570 tick_size > Decimal::ZERO,
571 "Tick size {tick_size} must be positive"
572 );
573
574 let min_price = Price::from_decimal_dp(tick_size, POLYMARKET_PRICE_PRECISION)?;
575 let max_price = Price::from_decimal_dp(Decimal::ONE - tick_size, POLYMARKET_PRICE_PRECISION)?;
576
577 anyhow::ensure!(
578 min_price.as_decimal() == tick_size,
579 "Tick size {tick_size} is not exactly representable at Polymarket price precision {POLYMARKET_PRICE_PRECISION}"
580 );
581 Ok((min_price, max_price))
582}
583
584fn build_info(def: &PolymarketInstrumentDef) -> Params {
585 let mut map = serde_json::Map::new();
586 map.insert(
587 MARKET_VERSION_KEY.to_string(),
588 def.market_version.clone().into(),
589 );
590 map.insert("gamma_market".to_string(), def.gamma_market.clone().into());
591 if def.gamma_event.is_some() {
592 map.insert("gamma_event".to_string(), Value::Null);
594 }
595
596 if let Some(event_id) = def.event_id {
597 map.insert("event_id".to_string(), event_id.to_string().into());
598 }
599
600 map.insert(
601 "token_id".to_string(),
602 serde_json::Value::String(def.token_id.to_string()),
603 );
604 map.insert(
605 "condition_id".to_string(),
606 serde_json::Value::String(def.condition_id.to_string()),
607 );
608 map.insert(
609 "market_id".to_string(),
610 serde_json::Value::String(def.market_id.clone()),
611 );
612
613 if let Some(qid) = &def.question_id {
614 map.insert(
615 "question_id".to_string(),
616 serde_json::Value::String(qid.clone()),
617 );
618 }
619
620 if let Some(slug) = &def.market_slug {
621 map.insert(
622 "market_slug".to_string(),
623 serde_json::Value::String(slug.clone()),
624 );
625 }
626
627 if let Some(description) = &def.description {
628 map.insert(
629 "description".to_string(),
630 serde_json::Value::String(description.clone()),
631 );
632 }
633
634 if let Some(event_start_time) = &def.event_start_time {
635 map.insert(
636 "event_start_time".to_string(),
637 serde_json::Value::String(event_start_time.clone()),
638 );
639 }
640
641 if let Some(end_date) = &def.end_date {
642 map.insert(
643 "end_date".to_string(),
644 serde_json::Value::String(end_date.clone()),
645 );
646 }
647
648 if let Some(neg_risk) = def.neg_risk {
649 map.insert("neg_risk".to_string(), serde_json::Value::Bool(neg_risk));
650 }
651
652 if let Some(resolution_source) = &def.resolution_source {
653 map.insert(
654 "resolution_source".to_string(),
655 serde_json::Value::String(resolution_source.clone()),
656 );
657 }
658
659 if let Some(crypto_market_config) = &def.crypto_market_config
660 && let Ok(value) = serde_json::to_value(crypto_market_config)
661 {
662 map.insert("crypto_market_config".to_string(), value);
663 }
664
665 if let Some(min_size) = def.min_size {
666 map.insert(
667 "min_order_size".to_string(),
668 serde_json::Value::String(min_size.to_string()),
669 );
670 }
671
672 if let Some(fee_schedule) = &def.fee_schedule {
673 map.insert("fee_schedule".to_string(), fee_schedule.to_info());
674 }
675
676 if let Some(game_id) = &def.game_id {
677 map.insert(
678 "game_id".to_string(),
679 serde_json::Value::String(game_id.clone()),
680 );
681 }
682
683 let mut map: IndexMap<_, _> = map
684 .into_iter()
685 .map(|(key, value)| (key, Arc::new(value)))
686 .collect();
687
688 if let Some(event) = &def.gamma_event {
689 map.insert("gamma_event".to_string(), Arc::clone(event));
690 }
691
692 Params::from_shared(map)
693}
694
695fn get_currency(code: &str) -> Currency {
696 Currency::try_from_str(code).unwrap_or_else(|| {
697 let currency = Currency::new(code, 6, 0, code, CurrencyType::Crypto);
698 if let Err(e) = Currency::register(currency, false) {
699 log::error!("Failed to register currency '{code}': {e}");
700 }
701 currency
702 })
703}
704
705fn parse_datetime_to_nanos(s: &str) -> Option<UnixNanos> {
706 s.parse::<Timestamp>()
707 .ok()
708 .and_then(|dt| u64::try_from(dt.as_nanosecond()).ok())
709 .map(UnixNanos::from)
710}
711
712#[cfg(test)]
713mod tests {
714 use nautilus_core::UUID4;
715 use nautilus_model::{
716 enums::{OrderSide, TimeInForce},
717 identifiers::{ClientOrderId, StrategyId, TraderId},
718 instruments::Instrument,
719 orders::{LimitOrder, OrderAny},
720 };
721 use rstest::rstest;
722 use rust_decimal_macros::dec;
723 use serde_json::to_string;
724
725 use super::*;
726 use crate::execution::order_builder::PolymarketOrderBuilder;
727
728 const UNSUPPORTED_TICK_SIZE: &str = "0.0000000000000000001";
729
730 fn load_gamma_market(filename: &str) -> GammaMarket {
731 let path = format!("test_data/{filename}");
732 let content = std::fs::read_to_string(path).expect("Failed to read test data");
733 serde_json::from_str(&content).expect("Failed to parse test data")
734 }
735
736 fn limit_order_at(price: Price) -> OrderAny {
737 OrderAny::Limit(LimitOrder::new(
738 TraderId::from("TESTER-001"),
739 StrategyId::from("S-001"),
740 InstrumentId::from("TEST.POLYMARKET"),
741 ClientOrderId::from("O-001"),
742 OrderSide::Buy,
743 Quantity::from("10"),
744 price,
745 TimeInForce::Gtc,
746 None,
747 false,
748 false,
749 false,
750 None,
751 None,
752 None,
753 None,
754 None,
755 None,
756 None,
757 None,
758 None,
759 None,
760 None,
761 UUID4::new(),
762 UnixNanos::default(),
763 ))
764 }
765
766 #[rstest]
767 #[case("v1")]
768 #[case("v2")]
769 fn test_market_protocol_selects_outcome_ids(
770 #[case] version: &str,
771 #[values(false, true)] equal: bool,
772 ) {
773 let mut market = load_gamma_market("gamma_market_protocol_v2.json");
774 market.version = Some(version.to_string());
775 market.clob_token_ids = to_string(&["101", "202"]).unwrap();
776 market.position_ids = Some(if equal {
777 vec!["101".into(), "202".into()]
778 } else {
779 vec!["303".into(), "404".into()]
780 });
781
782 let expected = if version == "v1" || equal {
783 ["101", "202"]
784 } else {
785 ["303", "404"]
786 };
787
788 let defs = parse_gamma_market(&market).unwrap();
789 for (index, def) in defs.iter().enumerate() {
790 let instrument = create_instrument_from_def(def, 1.into()).unwrap();
791 assert_eq!(def.token_id.as_str(), expected[index]);
792 assert_eq!(def.market_version, version);
793 assert_eq!(instrument.raw_symbol().as_str(), expected[index]);
794 assert_eq!(
795 instrument.id().to_string(),
796 format!("{}-{}.POLYMARKET", market.condition_id, expected[index])
797 );
798 assert_eq!(
799 instrument.info().unwrap().get_str(MARKET_VERSION_KEY),
800 Some(version)
801 );
802 }
803 }
804
805 #[rstest]
806 #[case::missing(None)]
807 #[case::empty(Some(vec![]))]
808 #[case::one(Some(vec!["1"]))]
809 #[case::three(Some(vec!["1", "2", "3"]))]
810 #[case::blank(Some(vec!["1", ""]))]
811 #[case::negative(Some(vec!["1", "-2"]))]
812 #[case::hex(Some(vec!["1", "0x02"]))]
813 #[case::float(Some(vec!["1", "2.0"]))]
814 #[case::duplicate(Some(vec!["1", "1"]))]
815 #[case::numeric_duplicate(Some(vec!["1", "01"]))]
816 #[case::overflow(Some(vec!["1", "115792089237316195423570985008687907853269984665640564039457584007913129639936"]))]
817 fn test_market_protocol_rejects_invalid_selected_ids(
818 #[case] ids: Option<Vec<&str>>,
819 #[values("v1", "v2")] version: &str,
820 ) {
821 let mut market = load_gamma_market("gamma_market_protocol_v2.json");
822 market.version = Some(version.into());
823 if version == "v1" {
824 market.clob_token_ids = ids.as_ref().map_or_default(|ids| to_string(ids).unwrap());
825 } else {
826 market.position_ids = ids.map(|ids| ids.into_iter().map(str::to_string).collect());
827 }
828
829 assert!(parse_gamma_market(&market).is_err());
830 }
831
832 #[rstest]
833 #[case(vec![])]
834 #[case(vec!["Yes"])]
835 #[case(vec!["Yes", "Yes"])]
836 #[case(vec!["Yes", " "])]
837 #[case(vec!["Yes", "No", "Other"])]
838 fn test_market_protocol_rejects_invalid_outcomes(
839 #[case] outcomes: Vec<&str>,
840 #[values("v1", "v2")] version: &str,
841 ) {
842 let mut market = load_gamma_market("gamma_market_protocol_v2.json");
843 market.version = Some(version.into());
844 market.outcomes = to_string(&outcomes).unwrap();
845 assert!(parse_gamma_market(&market).is_err());
846 }
847
848 #[rstest]
849 fn test_gamma_metadata_survives_parsing_and_tick_updates() {
850 let raw = include_str!("../../test_data/gamma_market_metadata.json");
851 let expected = raw.trim();
852 let mut market: GammaMarket = serde_json::from_str(raw).unwrap();
853 market.order_min_size = Some(dec!(10));
854 let defs = parse_gamma_market(&market).unwrap();
855 assert_eq!(defs.len(), 2);
856
857 for (def, outcome) in defs.iter().zip(["Yes", "No"]) {
858 let instrument = create_instrument_from_def(def, UnixNanos::default()).unwrap();
859 let rebuilt =
860 rebuild_instrument_with_tick_size(&instrument, "0.001", 1.into(), 2.into())
861 .unwrap();
862
863 for instrument in [instrument, rebuilt] {
864 let InstrumentAny::BinaryOption(binary) = instrument else {
865 unreachable!()
866 };
867
868 let info = binary.info.unwrap();
869 assert_eq!(binary.event_id, Some(Ustr::from("event-456")));
870 assert_eq!(binary.outcome, Some(Ustr::from(outcome)));
871 assert_eq!(info.get_str("event_id"), Some("event-456"));
872 assert_eq!(info.get_str("min_order_size"), Some("10"));
873 assert_eq!(info.get_str("gamma_market"), Some(expected));
874 }
875 }
876 }
877
878 #[rstest]
879 fn test_enclosing_event_takes_precedence_over_linked_events() {
880 let mut market = load_gamma_market("gamma_market_metadata.json");
881 let parent = market.events.as_ref().unwrap()[0].clone();
882 market.events.as_mut().unwrap()[0].id = "related-event".to_string();
883 market.parent_event = Some(std::sync::Arc::new(parent));
884 assert_eq!(
885 market_event_id(&market).map(|id| id.as_str()),
886 Some("event-456")
887 );
888 }
889
890 #[rstest]
891 #[case::missing(None, None)]
892 #[case::empty(Some(vec![]), None)]
893 #[case::unique(Some(vec!["event-1"]), Some("event-1"))]
894 #[case::duplicate(Some(vec!["event-1", "event-1"]), Some("event-1"))]
895 #[case::ambiguous(Some(vec!["event-1", "event-2"]), None)]
896 #[case::blank(Some(vec![""]), None)]
897 fn test_market_event_id(#[case] ids: Option<Vec<&str>>, #[case] expected: Option<&str>) {
898 let mut market = load_gamma_market("gamma_market_metadata.json");
899 let template = market.events.as_ref().unwrap()[0].clone();
900 market.events = ids.map(|ids| {
901 ids.into_iter()
902 .map(|id| {
903 let mut event = template.clone();
904 event.id = id.to_string();
905 event
906 })
907 .collect()
908 });
909
910 assert_eq!(market_event_id(&market).map(|id| id.as_str()), expected);
911 }
912
913 #[rstest]
914 fn test_parse_gamma_market_produces_two_defs() {
915 let market = load_gamma_market("gamma_market.json");
916 let defs = parse_gamma_market(&market).unwrap();
917
918 assert_eq!(defs.len(), 2);
919 assert_eq!(defs[0].outcome, PolymarketOutcome::from("Up"));
920 assert_eq!(defs[1].outcome, PolymarketOutcome::from("Down"));
921 }
922
923 #[rstest]
924 fn test_parse_gamma_market_fields() {
925 let market = load_gamma_market("gamma_market.json");
926 let defs = parse_gamma_market(&market).unwrap();
927 let yes_def = &defs[0];
928
929 assert_eq!(
930 yes_def.condition_id.as_str(),
931 "0x78443f961b9a65869dcb39359de9960165c7e5cbad0904eac7f29cd77872a63b"
932 );
933 assert_eq!(yes_def.market_id, "1557558");
934 assert_eq!(
935 yes_def.question_id.as_deref(),
936 Some("0x15813764bba41cfb5f99e2e649cfbae7a121a9f8f91ed47ca261aab95e9729de")
937 );
938 assert_eq!(
939 yes_def.question,
940 "Bitcoin Up or Down - March 12, 5:20AM-5:25AM ET"
941 );
942 assert_eq!(yes_def.tick_size, dec!(0.01));
943 assert_eq!(yes_def.price_precision, POLYMARKET_PRICE_PRECISION);
944 assert_eq!(yes_def.min_size, Some(dec!(5.0)));
945 assert_eq!(yes_def.fee_schedule, None);
946 assert!(yes_def.active);
947 assert_eq!(
948 yes_def.market_slug.as_deref(),
949 Some("btc-updown-5m-1773307200")
950 );
951 assert_eq!(yes_def.game_id, None);
952 }
953
954 #[rstest]
955 fn test_parse_gamma_market_sports_game_id_and_fee_schedule() {
956 let money_line = load_gamma_market("gamma_market_sports_market_money_line.json");
957 let map_handicap = load_gamma_market("gamma_market_sports_market_map_handicap.json");
958
959 let money_line_defs = parse_gamma_market(&money_line).unwrap();
960 let map_handicap_defs = parse_gamma_market(&map_handicap).unwrap();
961
962 assert_eq!(money_line_defs[0].game_id.as_deref(), Some("1427074"));
963 assert_eq!(map_handicap_defs[0].game_id.as_deref(), Some("1427074"));
964 assert_eq!(money_line_defs[0].fee_schedule, money_line.fee_schedule);
965 assert_eq!(map_handicap_defs[0].fee_schedule, map_handicap.fee_schedule);
966 }
967
968 #[rstest]
969 fn test_parse_gamma_market_symbol_format() {
970 let market = load_gamma_market("gamma_market.json");
971 let defs = parse_gamma_market(&market).unwrap();
972
973 assert_eq!(
974 defs[0].symbol.as_str(),
975 "0x78443f961b9a65869dcb39359de9960165c7e5cbad0904eac7f29cd77872a63b-104239898038807136052399800151408521467737075933964991162589336683346093173875"
976 );
977 assert_eq!(
978 defs[1].symbol.as_str(),
979 "0x78443f961b9a65869dcb39359de9960165c7e5cbad0904eac7f29cd77872a63b-71183960810705820955071415844881728181970340514894896943812046065452395013351"
980 );
981 }
982
983 #[rstest]
984 fn test_parse_gamma_market_token_ids() {
985 let market = load_gamma_market("gamma_market.json");
986 let defs = parse_gamma_market(&market).unwrap();
987
988 assert_eq!(
989 defs[0].token_id.as_str(),
990 "104239898038807136052399800151408521467737075933964991162589336683346093173875"
991 );
992 assert_eq!(
993 defs[1].token_id.as_str(),
994 "71183960810705820955071415844881728181970340514894896943812046065452395013351"
995 );
996 }
997
998 #[rstest]
999 fn test_parse_gamma_market_derives_outcome_from_label() {
1000 let mut market = load_gamma_market("gamma_market.json");
1001
1002 market.outcomes = r#"["No", "Yes"]"#.to_string();
1004
1005 let defs = parse_gamma_market(&market).unwrap();
1006
1007 assert_eq!(defs[0].outcome, PolymarketOutcome::no());
1008 assert_eq!(defs[1].outcome, PolymarketOutcome::yes());
1009 }
1010
1011 #[rstest]
1012 fn test_parse_gamma_market_accepts_arbitrary_outcome_label() {
1013 let mut market = load_gamma_market("gamma_market.json");
1014 market.outcomes = r#"["Maybe", "No"]"#.to_string();
1015
1016 let defs = parse_gamma_market(&market).unwrap();
1017
1018 assert_eq!(defs[0].outcome, PolymarketOutcome::from("Maybe"));
1019 assert_eq!(defs[1].outcome, PolymarketOutcome::no());
1020 }
1021
1022 #[rstest]
1023 fn test_parse_gamma_market_null_tick_size_uses_default() {
1024 let mut market = load_gamma_market("gamma_market.json");
1025 market.order_price_min_tick_size = None;
1026
1027 let defs = parse_gamma_market(&market).unwrap();
1028
1029 assert_eq!(defs[0].tick_size, dec!(0.001));
1030 assert_eq!(defs[0].price_precision, POLYMARKET_PRICE_PRECISION);
1031 }
1032
1033 #[rstest]
1034 fn test_parse_gamma_market_closed_is_inactive() {
1035 let mut market = load_gamma_market("gamma_market.json");
1036 market.closed = Some(true);
1037
1038 let defs = parse_gamma_market(&market).unwrap();
1039
1040 assert!(!defs[0].active);
1041 assert!(!defs[1].active);
1042 }
1043
1044 #[rstest]
1045 fn test_create_instrument_from_def() {
1046 let market = load_gamma_market("gamma_market.json");
1047 let defs = parse_gamma_market(&market).unwrap();
1048 let ts_init = UnixNanos::from(1_000_000_000u64);
1049
1050 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1051
1052 let binary = match &instrument {
1053 InstrumentAny::BinaryOption(b) => b,
1054 other => panic!("Expected BinaryOption, was {other:?}"),
1055 };
1056
1057 assert_eq!(
1058 binary.id.to_string(),
1059 "0x78443f961b9a65869dcb39359de9960165c7e5cbad0904eac7f29cd77872a63b-104239898038807136052399800151408521467737075933964991162589336683346093173875.POLYMARKET"
1060 );
1061 assert_eq!(binary.outcome, Some(Ustr::from("Up")));
1062 assert_eq!(binary.asset_class, AssetClass::Alternative);
1063 assert_eq!(binary.currency.code, "pUSD");
1064 assert_eq!(binary.price_precision, POLYMARKET_PRICE_PRECISION);
1065 assert_eq!(binary.size_precision, 6);
1066 assert_eq!(binary.price_increment(), Price::from("0.01"));
1067 assert_eq!(binary.size_increment(), Quantity::from("0.000001"));
1068 }
1069
1070 #[rstest]
1071 fn test_create_instrument_info_params() {
1072 let market = load_gamma_market("gamma_market.json");
1073 let defs = parse_gamma_market(&market).unwrap();
1074 let ts_init = UnixNanos::from(1_000_000_000u64);
1075
1076 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1077
1078 let binary = match &instrument {
1079 InstrumentAny::BinaryOption(b) => b,
1080 other => panic!("Expected BinaryOption, was {other:?}"),
1081 };
1082
1083 let info = binary.info.as_ref().expect("info should be Some");
1084 assert_eq!(
1085 info.get_str("token_id"),
1086 Some("104239898038807136052399800151408521467737075933964991162589336683346093173875")
1087 );
1088 assert_eq!(
1089 info.get_str("condition_id"),
1090 Some("0x78443f961b9a65869dcb39359de9960165c7e5cbad0904eac7f29cd77872a63b")
1091 );
1092 assert_eq!(info.get_str("market_id"), Some("1557558"));
1093 assert_eq!(
1094 info.get_str("question_id"),
1095 Some("0x15813764bba41cfb5f99e2e649cfbae7a121a9f8f91ed47ca261aab95e9729de")
1096 );
1097 assert_eq!(
1098 info.get_str("market_slug"),
1099 Some("btc-updown-5m-1773307200")
1100 );
1101 assert_eq!(
1102 info.get_str("event_start_time"),
1103 Some("2026-03-12T09:20:00Z")
1104 );
1105 assert_eq!(info.get_str("game_id"), None);
1106 assert_eq!(info.get_str("min_order_size"), Some("5"));
1107 assert_eq!(info.get_bool("neg_risk"), Some(false));
1108 assert_eq!(info.get("fee_schedule"), None);
1109 }
1110
1111 #[rstest]
1112 #[case(
1113 Some("Detailed resolution rules with https://example.com/source"),
1114 Some("Detailed resolution rules with https://example.com/source")
1115 )]
1116 #[case(None, None)]
1117 fn test_create_instrument_info_description(
1118 #[case] description: Option<&str>,
1119 #[case] expected: Option<&str>,
1120 ) {
1121 let mut market = load_gamma_market("gamma_market.json");
1122 market.description = description.map(str::to_string);
1123 market.resolution_source = None;
1124 let defs = parse_gamma_market(&market).unwrap();
1125
1126 let instrument =
1127 create_instrument_from_def(&defs[0], UnixNanos::from(1_000_000_000u64)).unwrap();
1128 let InstrumentAny::BinaryOption(binary) = instrument else {
1129 panic!("Expected BinaryOption");
1130 };
1131 let info = binary.info.as_ref().expect("info should be Some");
1132
1133 assert_eq!(info.get_str("description"), expected);
1134 assert_eq!(info.contains_key("description"), expected.is_some());
1135 assert_eq!(info.get_str("resolution_source"), None);
1136 }
1137
1138 #[rstest]
1139 fn test_instrument_info_preserves_json_map_order() {
1140 let market = load_gamma_market("gamma_market_crypto_twap.json");
1141 let mut def = parse_gamma_market(&market).unwrap().remove(0);
1142 let event = Arc::new(Value::String(market.raw));
1143 def.gamma_event = Some(Arc::clone(&event));
1144 def.event_id = Some(Ustr::from("event-123"));
1145 let info = build_info(&def);
1146 let mut expected = serde_json::Map::new();
1147
1148 for key in [
1149 "market_version",
1150 "gamma_market",
1151 "gamma_event",
1152 "event_id",
1153 "token_id",
1154 "condition_id",
1155 "market_id",
1156 "question_id",
1157 "market_slug",
1158 "description",
1159 "event_start_time",
1160 "end_date",
1161 "neg_risk",
1162 "resolution_source",
1163 "crypto_market_config",
1164 "min_order_size",
1165 "fee_schedule",
1166 "game_id",
1167 ] {
1168 if let Some(value) = info.get(key) {
1169 expected.insert(key.to_string(), value.clone());
1170 }
1171 }
1172
1173 assert_eq!(
1174 info.borrowed_entries()
1175 .map(|(key, _)| key)
1176 .collect::<Vec<_>>(),
1177 expected.keys().collect::<Vec<_>>()
1178 );
1179 assert_eq!(
1180 serde_json::to_string(&info).unwrap(),
1181 serde_json::to_string(&expected).unwrap()
1182 );
1183 assert!(std::ptr::eq(
1184 info.get("gamma_event").unwrap(),
1185 event.as_ref()
1186 ));
1187 }
1188
1189 #[rstest]
1190 fn test_create_instrument_info_includes_resolution_and_crypto_market_config() {
1191 let market = load_gamma_market("gamma_market_crypto_twap.json");
1192
1193 let defs = parse_gamma_market(&market).unwrap();
1194 assert_eq!(defs[0].end_date.as_deref(), Some("2026-08-22T16:05:00Z"));
1195 let instrument =
1196 create_instrument_from_def(&defs[0], UnixNanos::from(1_000_000_000u64)).unwrap();
1197 let InstrumentAny::BinaryOption(binary) = instrument else {
1198 panic!("Expected BinaryOption");
1199 };
1200 let info = binary.info.as_ref().expect("info should be Some");
1201
1202 assert_eq!(info.get_str("end_date"), Some("2026-08-22T16:05:00Z"));
1203 assert_eq!(
1204 info.get_str("resolution_source"),
1205 Some("https://data.chain.link/streams/btc-usd-twap-60s-streams")
1206 );
1207 assert_eq!(
1208 info.get("crypto_market_config"),
1209 Some(&serde_json::json!({
1210 "id": "btc-5m-twap-60",
1211 "asset": "btc",
1212 "duration": "5m",
1213 "twapEnabled": true,
1214 "twapLookbackSeconds": 60,
1215 }))
1216 );
1217 }
1218
1219 #[rstest]
1220 fn test_create_instrument_info_omits_missing_neg_risk() {
1221 let mut market = load_gamma_market("gamma_market.json");
1222 market.neg_risk = None;
1223 let defs = parse_gamma_market(&market).unwrap();
1224
1225 let instrument =
1226 create_instrument_from_def(&defs[0], UnixNanos::from(1_000_000_000u64)).unwrap();
1227 let InstrumentAny::BinaryOption(binary) = instrument else {
1228 panic!("Expected BinaryOption");
1229 };
1230 let info = binary.info.as_ref().expect("info should be Some");
1231
1232 assert_eq!(info.get_bool("neg_risk"), None);
1233 }
1234
1235 #[rstest]
1236 fn test_past_end_market_carries_closure_state_on_the_definition_only() {
1237 let mut market = load_gamma_market("gamma_market_past_end_date_open.json");
1238 let defs = parse_gamma_market(&market).unwrap();
1239
1240 assert!(!defs[0].closed);
1241
1242 market.closed = Some(true);
1243 let closed_defs = parse_gamma_market(&market).unwrap();
1244
1245 assert!(closed_defs[0].closed);
1246
1247 for def in [&defs[0], &closed_defs[0]] {
1250 let instrument =
1251 create_instrument_from_def(def, UnixNanos::from(1_000_000_000u64)).unwrap();
1252 let binary = match &instrument {
1253 InstrumentAny::BinaryOption(binary) => binary,
1254 other => panic!("Expected BinaryOption, was {other:?}"),
1255 };
1256 let info = binary.info.as_ref().expect("info should be present");
1257
1258 assert_eq!(info.get_bool("closed"), None);
1259 }
1260 }
1261
1262 #[rstest]
1263 fn test_create_instrument_info_params_includes_game_id_and_fee_schedule() {
1264 let market = load_gamma_market("gamma_market_sports_market_money_line.json");
1265 let defs = parse_gamma_market(&market).unwrap();
1266 let ts_init = UnixNanos::from(1_000_000_000u64);
1267
1268 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1269
1270 let binary = match &instrument {
1271 InstrumentAny::BinaryOption(b) => b,
1272 other => panic!("Expected BinaryOption, was {other:?}"),
1273 };
1274
1275 let info = binary.info.as_ref().expect("info should be Some");
1276 assert_eq!(info.get_str("game_id"), Some("1427074"));
1277 let schedule = info.get("fee_schedule").unwrap();
1278 let fields = schedule.as_object().unwrap();
1279 assert_eq!(fields.len(), 4);
1280 assert_eq!(schedule["rate"], "0.03");
1281 assert_eq!(schedule["exponent"], "1");
1282 assert_eq!(schedule["takerOnly"], true);
1283 assert_eq!(schedule["rebateRate"], "0.25");
1284 }
1285
1286 #[rstest]
1287 fn test_instruments_from_defs_batch() {
1288 let market = load_gamma_market("gamma_market.json");
1289 let defs = parse_gamma_market(&market).unwrap();
1290 let ts_init = UnixNanos::from(1_000_000_000u64);
1291
1292 let instruments = instruments_from_defs(&defs, ts_init);
1293
1294 assert_eq!(instruments.len(), 2);
1295 }
1296
1297 #[rstest]
1298 fn test_instruments_from_defs_skips_unsupported_tick_precision() {
1299 let mut market = load_gamma_market("gamma_market.json");
1300 let valid_defs = parse_gamma_market(&market).unwrap();
1301 market.order_price_min_tick_size = Some(UNSUPPORTED_TICK_SIZE.parse().unwrap());
1302 let invalid_defs = parse_gamma_market(&market).unwrap();
1303 let ts_init = UnixNanos::from(1_000_000_000u64);
1304 let expected = create_instrument_from_def(&valid_defs[1], ts_init).unwrap();
1305 let defs = [invalid_defs[0].clone(), valid_defs[1].clone()];
1306
1307 let instruments = instruments_from_defs(&defs, ts_init);
1308
1309 assert_eq!(instruments.len(), 1);
1310 assert_eq!(instruments[0].id(), expected.id());
1311 assert_eq!(instruments[0].price_increment(), expected.price_increment());
1312 assert_eq!(instruments[0].min_price(), expected.min_price());
1313 assert_eq!(instruments[0].max_price(), expected.max_price());
1314 }
1315
1316 #[rstest]
1317 #[case::zero("0")]
1318 #[case::negative("-0.005")]
1319 fn test_tick_relative_price_bounds_rejects_non_positive(#[case] tick_size: &str) {
1320 let tick_size: Decimal = tick_size.parse().unwrap();
1321
1322 let error = tick_relative_price_bounds(tick_size).unwrap_err();
1323
1324 assert_eq!(
1325 error.to_string(),
1326 format!("Tick size {tick_size} must be positive")
1327 );
1328 }
1329
1330 #[rstest]
1331 #[case("0.1", "0.1", "0.9", 1)]
1332 #[case("0.01", "0.01", "0.99", 2)]
1333 #[case("0.005", "0.005", "0.995", 3)]
1334 #[case("0.0025", "0.0025", "0.9975", 4)]
1335 #[case("0.001", "0.001", "0.999", 3)]
1336 #[case("0.0001", "0.0001", "0.9999", 4)]
1337 fn test_create_instrument_tick_relative_price_bounds(
1338 #[case] tick_size: &str,
1339 #[case] expected_min: &str,
1340 #[case] expected_max: &str,
1341 #[case] expected_tick_decimals: u8,
1342 ) {
1343 let mut market = load_gamma_market("gamma_market.json");
1344 market.order_price_min_tick_size = Some(tick_size.parse().unwrap());
1345 let defs = parse_gamma_market(&market).unwrap();
1346 let ts_init = UnixNanos::from(1_000_000_000u64);
1347
1348 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1349
1350 let binary = match &instrument {
1351 InstrumentAny::BinaryOption(b) => b,
1352 other => panic!("Expected BinaryOption, was {other:?}"),
1353 };
1354
1355 assert_eq!(binary.price_precision, POLYMARKET_PRICE_PRECISION);
1356 assert_eq!(binary.price_increment.precision, POLYMARKET_PRICE_PRECISION);
1357 assert_eq!(
1358 binary.min_price.unwrap().precision,
1359 POLYMARKET_PRICE_PRECISION
1360 );
1361 assert_eq!(
1362 binary.max_price.unwrap().precision,
1363 POLYMARKET_PRICE_PRECISION
1364 );
1365 assert_eq!(
1366 binary.min_price_increment_precision(),
1367 expected_tick_decimals
1368 );
1369 assert_eq!(binary.min_price, Some(Price::from(expected_min)));
1370 assert_eq!(binary.max_price, Some(Price::from(expected_max)));
1371 assert_eq!(binary.min_price, Some(binary.price_increment));
1373 }
1374
1375 #[rstest]
1376 fn test_instrument_bounds_agree_with_execution_validation() {
1377 let mut market = load_gamma_market("gamma_market.json");
1381 market.order_price_min_tick_size = Some(dec!(0.01));
1382 let defs = parse_gamma_market(&market).unwrap();
1383 let ts_init = UnixNanos::from(1_000_000_000u64);
1384
1385 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1386 let tick = instrument.price_increment();
1387 let min_price = instrument.min_price().expect("min_price");
1388 let max_price = instrument.max_price().expect("max_price");
1389
1390 assert_eq!(min_price, Price::from("0.01"));
1391 assert_eq!(max_price, Price::from("0.99"));
1392
1393 let at_min = limit_order_at(min_price);
1394 let at_max = limit_order_at(max_price);
1395 assert!(PolymarketOrderBuilder::validate_limit_price(&at_min, tick).is_ok());
1396 assert!(PolymarketOrderBuilder::validate_limit_price(&at_max, tick).is_ok());
1397
1398 let at_old_min = limit_order_at(Price::from("0.001"));
1399 let at_old_max = limit_order_at(Price::from("0.999"));
1400 assert!(PolymarketOrderBuilder::validate_limit_price(&at_old_min, tick).is_err());
1401 assert!(PolymarketOrderBuilder::validate_limit_price(&at_old_max, tick).is_err());
1402 }
1403
1404 #[rstest]
1405 fn test_rebuild_instrument_with_tick_size() {
1406 let market = load_gamma_market("gamma_market.json");
1407 let defs = parse_gamma_market(&market).unwrap();
1408 let ts_init = UnixNanos::from(1_000_000_000u64);
1409
1410 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1412 assert_eq!(instrument.price_precision(), POLYMARKET_PRICE_PRECISION);
1413
1414 let ts_event = UnixNanos::from(2_000_000_000u64);
1415 let rebuilt =
1416 rebuild_instrument_with_tick_size(&instrument, "0.001", ts_event, ts_event).unwrap();
1417
1418 assert_eq!(rebuilt.price_precision(), POLYMARKET_PRICE_PRECISION);
1419 assert_eq!(
1420 rebuilt.price_increment().precision,
1421 POLYMARKET_PRICE_PRECISION
1422 );
1423 assert_eq!(rebuilt.min_price_increment_precision(), 3);
1424 assert_eq!(rebuilt.price_increment(), Price::from("0.001"));
1425 assert_eq!(rebuilt.min_price(), Some(Price::from("0.001")));
1427 assert_eq!(rebuilt.max_price(), Some(Price::from("0.999")));
1428 }
1429
1430 #[rstest]
1431 #[case("0.005", "0.0025", 4, "0.9975")]
1432 #[case("0.0025", "0.005", 3, "0.995")]
1433 fn test_rebuild_instrument_between_non_power_ticks(
1434 #[case] old_tick: &str,
1435 #[case] new_tick: &str,
1436 #[case] expected_tick_decimals: u8,
1437 #[case] expected_max: &str,
1438 ) {
1439 let market = load_gamma_market("gamma_market.json");
1440 let defs = parse_gamma_market(&market).unwrap();
1441 let ts_init = UnixNanos::from(1_000_000_000u64);
1442 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1443 let instrument =
1444 rebuild_instrument_with_tick_size(&instrument, old_tick, ts_init, ts_init).unwrap();
1445
1446 let rebuilt =
1447 rebuild_instrument_with_tick_size(&instrument, new_tick, ts_init, ts_init).unwrap();
1448
1449 assert_eq!(instrument.price_increment(), Price::from(old_tick));
1450 assert_eq!(rebuilt.price_precision(), POLYMARKET_PRICE_PRECISION);
1451 assert_eq!(
1452 rebuilt.price_increment().precision,
1453 POLYMARKET_PRICE_PRECISION
1454 );
1455 assert_eq!(
1456 rebuilt.min_price_increment_precision(),
1457 expected_tick_decimals
1458 );
1459 assert_eq!(rebuilt.price_increment(), Price::from(new_tick));
1460 assert_eq!(rebuilt.min_price(), Some(Price::from(new_tick)));
1461 assert_eq!(rebuilt.max_price(), Some(Price::from(expected_max)));
1462 }
1463
1464 #[rstest]
1465 fn test_rebuild_instrument_with_tick_size_rejects_unsupported_tick_precision() {
1466 let market = load_gamma_market("gamma_market.json");
1467 let defs = parse_gamma_market(&market).unwrap();
1468 let ts_init = UnixNanos::from(1_000_000_000u64);
1469 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1470 let error =
1471 rebuild_instrument_with_tick_size(&instrument, UNSUPPORTED_TICK_SIZE, ts_init, ts_init)
1472 .unwrap_err();
1473
1474 assert_eq!(
1475 error.to_string(),
1476 format!(
1477 "Tick size {UNSUPPORTED_TICK_SIZE} is not exactly representable at Polymarket price precision {POLYMARKET_PRICE_PRECISION}"
1478 )
1479 );
1480 }
1481
1482 #[rstest]
1483 fn test_rebuild_instrument_preserves_fields() {
1484 let market = load_gamma_market("gamma_market.json");
1485 let defs = parse_gamma_market(&market).unwrap();
1486 let ts_init = UnixNanos::from(1_000_000_000u64);
1487
1488 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1489 let ts_event = UnixNanos::from(2_000_000_000u64);
1490 let rebuilt =
1491 rebuild_instrument_with_tick_size(&instrument, "0.01", ts_event, ts_event).unwrap();
1492
1493 assert_eq!(rebuilt.id(), instrument.id());
1494 assert_eq!(rebuilt.raw_symbol(), instrument.raw_symbol());
1495 assert_eq!(rebuilt.size_precision(), instrument.size_precision());
1496
1497 let orig_bo = match &instrument {
1498 InstrumentAny::BinaryOption(b) => b,
1499 _ => panic!(),
1500 };
1501 let new_bo = match &rebuilt {
1502 InstrumentAny::BinaryOption(b) => b,
1503 _ => panic!(),
1504 };
1505 assert_eq!(new_bo.outcome, orig_bo.outcome);
1506 assert_eq!(new_bo.currency, orig_bo.currency);
1507 }
1508
1509 #[rstest]
1510 #[case("gamma_market_fee_crypto.json", dec!(0.20))]
1511 #[case("gamma_market_fee_sports.json", dec!(0.15))]
1512 #[case("gamma_market_fee_politics.json", dec!(0.25))]
1513 #[case("gamma_market_fee_free.json", Decimal::ZERO)]
1514 #[case("gamma_market_fee_unclassifiable.json", Decimal::ZERO)]
1515 #[case("gamma_market_fee_zero_rate.json", dec!(0.20))]
1516 #[case("gamma_market_fee_conflict.json", Decimal::ZERO)]
1517 #[case("gamma_market_fee_priority.json", dec!(0.25))]
1518 fn test_resolve_maker_rebate_rate(#[case] filename: &str, #[case] expected: Decimal) {
1519 let market = load_gamma_market(filename);
1520
1521 assert_eq!(resolve_maker_rebate_rate(&market), expected);
1522 }
1523
1524 #[rstest]
1525 fn test_enrich_market_fee_schedule_overwrites_rebate_and_keeps_rate() {
1526 let mut market = load_gamma_market("gamma_market_fee_crypto.json");
1527 let original_rate = market.fee_schedule.as_ref().unwrap().rate;
1528
1529 enrich_market_fee_schedule(&mut market);
1530
1531 let schedule = market.fee_schedule.as_ref().unwrap();
1532 assert_eq!(schedule.rate, original_rate);
1533 assert_eq!(schedule.rebate_rate, dec!(0.20));
1534 assert_eq!(schedule.exponent, Decimal::ONE);
1535 assert!(schedule.taker_only);
1536 }
1537
1538 #[rstest]
1539 #[case(Decimal::ZERO)]
1540 #[case(dec!(0.0123))]
1541 fn test_enrich_market_fee_schedule_preserves_zero_fee_values(#[case] rate: Decimal) {
1542 let mut market = load_gamma_market("gamma_market_fee_zero_rate.json");
1543 market.fee_type = Some("zero_fees".to_string());
1544 let schedule = market.fee_schedule.as_mut().unwrap();
1545 schedule.exponent = dec!(2);
1546 schedule.rate = rate;
1547 schedule.taker_only = false;
1548 let original_schedule = market.fee_schedule.clone().unwrap();
1549
1550 enrich_market_fee_schedule(&mut market);
1551
1552 assert_eq!(market.fee_schedule, Some(original_schedule));
1553 }
1554
1555 #[rstest]
1556 fn test_enrich_market_fee_schedule_creates_schedule_for_fee_enabled() {
1557 let mut market = load_gamma_market("gamma_market_fee_crypto.json");
1558 market.fee_schedule = None;
1559
1560 enrich_market_fee_schedule(&mut market);
1561
1562 let schedule = market.fee_schedule.as_ref().unwrap();
1563 assert_eq!(schedule.rate, Decimal::ZERO);
1564 assert_eq!(schedule.rebate_rate, dec!(0.20));
1565 assert_eq!(schedule.exponent, Decimal::ONE);
1566 assert!(schedule.taker_only);
1567 }
1568
1569 #[rstest]
1570 #[case("gamma_market_fee_free.json")]
1571 #[case("gamma_market_fee_unclassifiable.json")]
1572 fn test_enrich_market_fee_schedule_keeps_zero_without_inventing(#[case] filename: &str) {
1573 let mut market = load_gamma_market(filename);
1574 market.fee_schedule = None;
1575
1576 enrich_market_fee_schedule(&mut market);
1577
1578 assert!(market.fee_schedule.is_none());
1579 }
1580}