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
825 .as_ref()
826 .map(|ids| to_string(ids).unwrap())
827 .unwrap_or_default();
828 } else {
829 market.position_ids = ids.map(|ids| ids.into_iter().map(str::to_string).collect());
830 }
831
832 assert!(parse_gamma_market(&market).is_err());
833 }
834
835 #[rstest]
836 #[case(vec![])]
837 #[case(vec!["Yes"])]
838 #[case(vec!["Yes", "Yes"])]
839 #[case(vec!["Yes", " "])]
840 #[case(vec!["Yes", "No", "Other"])]
841 fn test_market_protocol_rejects_invalid_outcomes(
842 #[case] outcomes: Vec<&str>,
843 #[values("v1", "v2")] version: &str,
844 ) {
845 let mut market = load_gamma_market("gamma_market_protocol_v2.json");
846 market.version = Some(version.into());
847 market.outcomes = to_string(&outcomes).unwrap();
848 assert!(parse_gamma_market(&market).is_err());
849 }
850
851 #[rstest]
852 fn test_gamma_metadata_survives_parsing_and_tick_updates() {
853 let raw = include_str!("../../test_data/gamma_market_metadata.json");
854 let expected = raw.trim();
855 let mut market: GammaMarket = serde_json::from_str(raw).unwrap();
856 market.order_min_size = Some(dec!(10));
857 let defs = parse_gamma_market(&market).unwrap();
858 assert_eq!(defs.len(), 2);
859
860 for (def, outcome) in defs.iter().zip(["Yes", "No"]) {
861 let instrument = create_instrument_from_def(def, UnixNanos::default()).unwrap();
862 let rebuilt =
863 rebuild_instrument_with_tick_size(&instrument, "0.001", 1.into(), 2.into())
864 .unwrap();
865
866 for instrument in [instrument, rebuilt] {
867 let InstrumentAny::BinaryOption(binary) = instrument else {
868 unreachable!()
869 };
870
871 let info = binary.info.unwrap();
872 assert_eq!(binary.event_id, Some(Ustr::from("event-456")));
873 assert_eq!(binary.outcome, Some(Ustr::from(outcome)));
874 assert_eq!(info.get_str("event_id"), Some("event-456"));
875 assert_eq!(info.get_str("min_order_size"), Some("10"));
876 assert_eq!(info.get_str("gamma_market"), Some(expected));
877 }
878 }
879 }
880
881 #[rstest]
882 fn test_enclosing_event_takes_precedence_over_linked_events() {
883 let mut market = load_gamma_market("gamma_market_metadata.json");
884 let parent = market.events.as_ref().unwrap()[0].clone();
885 market.events.as_mut().unwrap()[0].id = "related-event".to_string();
886 market.parent_event = Some(std::sync::Arc::new(parent));
887 assert_eq!(
888 market_event_id(&market).map(|id| id.as_str()),
889 Some("event-456")
890 );
891 }
892
893 #[rstest]
894 #[case::missing(None, None)]
895 #[case::empty(Some(vec![]), None)]
896 #[case::unique(Some(vec!["event-1"]), Some("event-1"))]
897 #[case::duplicate(Some(vec!["event-1", "event-1"]), Some("event-1"))]
898 #[case::ambiguous(Some(vec!["event-1", "event-2"]), None)]
899 #[case::blank(Some(vec![""]), None)]
900 fn test_market_event_id(#[case] ids: Option<Vec<&str>>, #[case] expected: Option<&str>) {
901 let mut market = load_gamma_market("gamma_market_metadata.json");
902 let template = market.events.as_ref().unwrap()[0].clone();
903 market.events = ids.map(|ids| {
904 ids.into_iter()
905 .map(|id| {
906 let mut event = template.clone();
907 event.id = id.to_string();
908 event
909 })
910 .collect()
911 });
912
913 assert_eq!(market_event_id(&market).map(|id| id.as_str()), expected);
914 }
915
916 #[rstest]
917 fn test_parse_gamma_market_produces_two_defs() {
918 let market = load_gamma_market("gamma_market.json");
919 let defs = parse_gamma_market(&market).unwrap();
920
921 assert_eq!(defs.len(), 2);
922 assert_eq!(defs[0].outcome, PolymarketOutcome::from("Up"));
923 assert_eq!(defs[1].outcome, PolymarketOutcome::from("Down"));
924 }
925
926 #[rstest]
927 fn test_parse_gamma_market_fields() {
928 let market = load_gamma_market("gamma_market.json");
929 let defs = parse_gamma_market(&market).unwrap();
930 let yes_def = &defs[0];
931
932 assert_eq!(
933 yes_def.condition_id.as_str(),
934 "0x78443f961b9a65869dcb39359de9960165c7e5cbad0904eac7f29cd77872a63b"
935 );
936 assert_eq!(yes_def.market_id, "1557558");
937 assert_eq!(
938 yes_def.question_id.as_deref(),
939 Some("0x15813764bba41cfb5f99e2e649cfbae7a121a9f8f91ed47ca261aab95e9729de")
940 );
941 assert_eq!(
942 yes_def.question,
943 "Bitcoin Up or Down - March 12, 5:20AM-5:25AM ET"
944 );
945 assert_eq!(yes_def.tick_size, dec!(0.01));
946 assert_eq!(yes_def.price_precision, POLYMARKET_PRICE_PRECISION);
947 assert_eq!(yes_def.min_size, Some(dec!(5.0)));
948 assert_eq!(yes_def.fee_schedule, None);
949 assert!(yes_def.active);
950 assert_eq!(
951 yes_def.market_slug.as_deref(),
952 Some("btc-updown-5m-1773307200")
953 );
954 assert_eq!(yes_def.game_id, None);
955 }
956
957 #[rstest]
958 fn test_parse_gamma_market_sports_game_id_and_fee_schedule() {
959 let money_line = load_gamma_market("gamma_market_sports_market_money_line.json");
960 let map_handicap = load_gamma_market("gamma_market_sports_market_map_handicap.json");
961
962 let money_line_defs = parse_gamma_market(&money_line).unwrap();
963 let map_handicap_defs = parse_gamma_market(&map_handicap).unwrap();
964
965 assert_eq!(money_line_defs[0].game_id.as_deref(), Some("1427074"));
966 assert_eq!(map_handicap_defs[0].game_id.as_deref(), Some("1427074"));
967 assert_eq!(money_line_defs[0].fee_schedule, money_line.fee_schedule);
968 assert_eq!(map_handicap_defs[0].fee_schedule, map_handicap.fee_schedule);
969 }
970
971 #[rstest]
972 fn test_parse_gamma_market_symbol_format() {
973 let market = load_gamma_market("gamma_market.json");
974 let defs = parse_gamma_market(&market).unwrap();
975
976 assert_eq!(
977 defs[0].symbol.as_str(),
978 "0x78443f961b9a65869dcb39359de9960165c7e5cbad0904eac7f29cd77872a63b-104239898038807136052399800151408521467737075933964991162589336683346093173875"
979 );
980 assert_eq!(
981 defs[1].symbol.as_str(),
982 "0x78443f961b9a65869dcb39359de9960165c7e5cbad0904eac7f29cd77872a63b-71183960810705820955071415844881728181970340514894896943812046065452395013351"
983 );
984 }
985
986 #[rstest]
987 fn test_parse_gamma_market_token_ids() {
988 let market = load_gamma_market("gamma_market.json");
989 let defs = parse_gamma_market(&market).unwrap();
990
991 assert_eq!(
992 defs[0].token_id.as_str(),
993 "104239898038807136052399800151408521467737075933964991162589336683346093173875"
994 );
995 assert_eq!(
996 defs[1].token_id.as_str(),
997 "71183960810705820955071415844881728181970340514894896943812046065452395013351"
998 );
999 }
1000
1001 #[rstest]
1002 fn test_parse_gamma_market_derives_outcome_from_label() {
1003 let mut market = load_gamma_market("gamma_market.json");
1004
1005 market.outcomes = r#"["No", "Yes"]"#.to_string();
1007
1008 let defs = parse_gamma_market(&market).unwrap();
1009
1010 assert_eq!(defs[0].outcome, PolymarketOutcome::no());
1011 assert_eq!(defs[1].outcome, PolymarketOutcome::yes());
1012 }
1013
1014 #[rstest]
1015 fn test_parse_gamma_market_accepts_arbitrary_outcome_label() {
1016 let mut market = load_gamma_market("gamma_market.json");
1017 market.outcomes = r#"["Maybe", "No"]"#.to_string();
1018
1019 let defs = parse_gamma_market(&market).unwrap();
1020
1021 assert_eq!(defs[0].outcome, PolymarketOutcome::from("Maybe"));
1022 assert_eq!(defs[1].outcome, PolymarketOutcome::no());
1023 }
1024
1025 #[rstest]
1026 fn test_parse_gamma_market_null_tick_size_uses_default() {
1027 let mut market = load_gamma_market("gamma_market.json");
1028 market.order_price_min_tick_size = None;
1029
1030 let defs = parse_gamma_market(&market).unwrap();
1031
1032 assert_eq!(defs[0].tick_size, dec!(0.001));
1033 assert_eq!(defs[0].price_precision, POLYMARKET_PRICE_PRECISION);
1034 }
1035
1036 #[rstest]
1037 fn test_parse_gamma_market_closed_is_inactive() {
1038 let mut market = load_gamma_market("gamma_market.json");
1039 market.closed = Some(true);
1040
1041 let defs = parse_gamma_market(&market).unwrap();
1042
1043 assert!(!defs[0].active);
1044 assert!(!defs[1].active);
1045 }
1046
1047 #[rstest]
1048 fn test_create_instrument_from_def() {
1049 let market = load_gamma_market("gamma_market.json");
1050 let defs = parse_gamma_market(&market).unwrap();
1051 let ts_init = UnixNanos::from(1_000_000_000u64);
1052
1053 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1054
1055 let binary = match &instrument {
1056 InstrumentAny::BinaryOption(b) => b,
1057 other => panic!("Expected BinaryOption, was {other:?}"),
1058 };
1059
1060 assert_eq!(
1061 binary.id.to_string(),
1062 "0x78443f961b9a65869dcb39359de9960165c7e5cbad0904eac7f29cd77872a63b-104239898038807136052399800151408521467737075933964991162589336683346093173875.POLYMARKET"
1063 );
1064 assert_eq!(binary.outcome, Some(Ustr::from("Up")));
1065 assert_eq!(binary.asset_class, AssetClass::Alternative);
1066 assert_eq!(binary.currency.code, "pUSD");
1067 assert_eq!(binary.price_precision, POLYMARKET_PRICE_PRECISION);
1068 assert_eq!(binary.size_precision, 6);
1069 assert_eq!(binary.price_increment(), Price::from("0.01"));
1070 assert_eq!(binary.size_increment(), Quantity::from("0.000001"));
1071 }
1072
1073 #[rstest]
1074 fn test_create_instrument_info_params() {
1075 let market = load_gamma_market("gamma_market.json");
1076 let defs = parse_gamma_market(&market).unwrap();
1077 let ts_init = UnixNanos::from(1_000_000_000u64);
1078
1079 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1080
1081 let binary = match &instrument {
1082 InstrumentAny::BinaryOption(b) => b,
1083 other => panic!("Expected BinaryOption, was {other:?}"),
1084 };
1085
1086 let info = binary.info.as_ref().expect("info should be Some");
1087 assert_eq!(
1088 info.get_str("token_id"),
1089 Some("104239898038807136052399800151408521467737075933964991162589336683346093173875")
1090 );
1091 assert_eq!(
1092 info.get_str("condition_id"),
1093 Some("0x78443f961b9a65869dcb39359de9960165c7e5cbad0904eac7f29cd77872a63b")
1094 );
1095 assert_eq!(info.get_str("market_id"), Some("1557558"));
1096 assert_eq!(
1097 info.get_str("question_id"),
1098 Some("0x15813764bba41cfb5f99e2e649cfbae7a121a9f8f91ed47ca261aab95e9729de")
1099 );
1100 assert_eq!(
1101 info.get_str("market_slug"),
1102 Some("btc-updown-5m-1773307200")
1103 );
1104 assert_eq!(
1105 info.get_str("event_start_time"),
1106 Some("2026-03-12T09:20:00Z")
1107 );
1108 assert_eq!(info.get_str("game_id"), None);
1109 assert_eq!(info.get_str("min_order_size"), Some("5"));
1110 assert_eq!(info.get_bool("neg_risk"), Some(false));
1111 assert_eq!(info.get("fee_schedule"), None);
1112 }
1113
1114 #[rstest]
1115 #[case(
1116 Some("Detailed resolution rules with https://example.com/source"),
1117 Some("Detailed resolution rules with https://example.com/source")
1118 )]
1119 #[case(None, None)]
1120 fn test_create_instrument_info_description(
1121 #[case] description: Option<&str>,
1122 #[case] expected: Option<&str>,
1123 ) {
1124 let mut market = load_gamma_market("gamma_market.json");
1125 market.description = description.map(str::to_string);
1126 market.resolution_source = None;
1127 let defs = parse_gamma_market(&market).unwrap();
1128
1129 let instrument =
1130 create_instrument_from_def(&defs[0], UnixNanos::from(1_000_000_000u64)).unwrap();
1131 let InstrumentAny::BinaryOption(binary) = instrument else {
1132 panic!("Expected BinaryOption");
1133 };
1134 let info = binary.info.as_ref().expect("info should be Some");
1135
1136 assert_eq!(info.get_str("description"), expected);
1137 assert_eq!(info.contains_key("description"), expected.is_some());
1138 assert_eq!(info.get_str("resolution_source"), None);
1139 }
1140
1141 #[rstest]
1142 fn test_instrument_info_preserves_json_map_order() {
1143 let market = load_gamma_market("gamma_market_crypto_twap.json");
1144 let mut def = parse_gamma_market(&market).unwrap().remove(0);
1145 let event = Arc::new(Value::String(market.raw));
1146 def.gamma_event = Some(Arc::clone(&event));
1147 def.event_id = Some(Ustr::from("event-123"));
1148 let info = build_info(&def);
1149 let mut expected = serde_json::Map::new();
1150
1151 for key in [
1152 "market_version",
1153 "gamma_market",
1154 "gamma_event",
1155 "event_id",
1156 "token_id",
1157 "condition_id",
1158 "market_id",
1159 "question_id",
1160 "market_slug",
1161 "description",
1162 "event_start_time",
1163 "end_date",
1164 "neg_risk",
1165 "resolution_source",
1166 "crypto_market_config",
1167 "min_order_size",
1168 "fee_schedule",
1169 "game_id",
1170 ] {
1171 if let Some(value) = info.get(key) {
1172 expected.insert(key.to_string(), value.clone());
1173 }
1174 }
1175
1176 assert_eq!(
1177 info.borrowed_entries()
1178 .map(|(key, _)| key)
1179 .collect::<Vec<_>>(),
1180 expected.keys().collect::<Vec<_>>()
1181 );
1182 assert_eq!(
1183 serde_json::to_string(&info).unwrap(),
1184 serde_json::to_string(&expected).unwrap()
1185 );
1186 assert!(std::ptr::eq(
1187 info.get("gamma_event").unwrap(),
1188 event.as_ref()
1189 ));
1190 }
1191
1192 #[rstest]
1193 fn test_create_instrument_info_includes_resolution_and_crypto_market_config() {
1194 let market = load_gamma_market("gamma_market_crypto_twap.json");
1195
1196 let defs = parse_gamma_market(&market).unwrap();
1197 assert_eq!(defs[0].end_date.as_deref(), Some("2026-08-22T16:05:00Z"));
1198 let instrument =
1199 create_instrument_from_def(&defs[0], UnixNanos::from(1_000_000_000u64)).unwrap();
1200 let InstrumentAny::BinaryOption(binary) = instrument else {
1201 panic!("Expected BinaryOption");
1202 };
1203 let info = binary.info.as_ref().expect("info should be Some");
1204
1205 assert_eq!(info.get_str("end_date"), Some("2026-08-22T16:05:00Z"));
1206 assert_eq!(
1207 info.get_str("resolution_source"),
1208 Some("https://data.chain.link/streams/btc-usd-twap-60s-streams")
1209 );
1210 assert_eq!(
1211 info.get("crypto_market_config"),
1212 Some(&serde_json::json!({
1213 "id": "btc-5m-twap-60",
1214 "asset": "btc",
1215 "duration": "5m",
1216 "twapEnabled": true,
1217 "twapLookbackSeconds": 60,
1218 }))
1219 );
1220 }
1221
1222 #[rstest]
1223 fn test_create_instrument_info_omits_missing_neg_risk() {
1224 let mut market = load_gamma_market("gamma_market.json");
1225 market.neg_risk = None;
1226 let defs = parse_gamma_market(&market).unwrap();
1227
1228 let instrument =
1229 create_instrument_from_def(&defs[0], UnixNanos::from(1_000_000_000u64)).unwrap();
1230 let InstrumentAny::BinaryOption(binary) = instrument else {
1231 panic!("Expected BinaryOption");
1232 };
1233 let info = binary.info.as_ref().expect("info should be Some");
1234
1235 assert_eq!(info.get_bool("neg_risk"), None);
1236 }
1237
1238 #[rstest]
1239 fn test_past_end_market_carries_closure_state_on_the_definition_only() {
1240 let mut market = load_gamma_market("gamma_market_past_end_date_open.json");
1241 let defs = parse_gamma_market(&market).unwrap();
1242
1243 assert!(!defs[0].closed);
1244
1245 market.closed = Some(true);
1246 let closed_defs = parse_gamma_market(&market).unwrap();
1247
1248 assert!(closed_defs[0].closed);
1249
1250 for def in [&defs[0], &closed_defs[0]] {
1253 let instrument =
1254 create_instrument_from_def(def, UnixNanos::from(1_000_000_000u64)).unwrap();
1255 let binary = match &instrument {
1256 InstrumentAny::BinaryOption(binary) => binary,
1257 other => panic!("Expected BinaryOption, was {other:?}"),
1258 };
1259 let info = binary.info.as_ref().expect("info should be present");
1260
1261 assert_eq!(info.get_bool("closed"), None);
1262 }
1263 }
1264
1265 #[rstest]
1266 fn test_create_instrument_info_params_includes_game_id_and_fee_schedule() {
1267 let market = load_gamma_market("gamma_market_sports_market_money_line.json");
1268 let defs = parse_gamma_market(&market).unwrap();
1269 let ts_init = UnixNanos::from(1_000_000_000u64);
1270
1271 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1272
1273 let binary = match &instrument {
1274 InstrumentAny::BinaryOption(b) => b,
1275 other => panic!("Expected BinaryOption, was {other:?}"),
1276 };
1277
1278 let info = binary.info.as_ref().expect("info should be Some");
1279 assert_eq!(info.get_str("game_id"), Some("1427074"));
1280 let schedule = info.get("fee_schedule").unwrap();
1281 let fields = schedule.as_object().unwrap();
1282 assert_eq!(fields.len(), 4);
1283 assert_eq!(schedule["rate"], "0.03");
1284 assert_eq!(schedule["exponent"], "1");
1285 assert_eq!(schedule["takerOnly"], true);
1286 assert_eq!(schedule["rebateRate"], "0.25");
1287 }
1288
1289 #[rstest]
1290 fn test_instruments_from_defs_batch() {
1291 let market = load_gamma_market("gamma_market.json");
1292 let defs = parse_gamma_market(&market).unwrap();
1293 let ts_init = UnixNanos::from(1_000_000_000u64);
1294
1295 let instruments = instruments_from_defs(&defs, ts_init);
1296
1297 assert_eq!(instruments.len(), 2);
1298 }
1299
1300 #[rstest]
1301 fn test_instruments_from_defs_skips_unsupported_tick_precision() {
1302 let mut market = load_gamma_market("gamma_market.json");
1303 let valid_defs = parse_gamma_market(&market).unwrap();
1304 market.order_price_min_tick_size = Some(UNSUPPORTED_TICK_SIZE.parse().unwrap());
1305 let invalid_defs = parse_gamma_market(&market).unwrap();
1306 let ts_init = UnixNanos::from(1_000_000_000u64);
1307 let expected = create_instrument_from_def(&valid_defs[1], ts_init).unwrap();
1308 let defs = [invalid_defs[0].clone(), valid_defs[1].clone()];
1309
1310 let instruments = instruments_from_defs(&defs, ts_init);
1311
1312 assert_eq!(instruments.len(), 1);
1313 assert_eq!(instruments[0].id(), expected.id());
1314 assert_eq!(instruments[0].price_increment(), expected.price_increment());
1315 assert_eq!(instruments[0].min_price(), expected.min_price());
1316 assert_eq!(instruments[0].max_price(), expected.max_price());
1317 }
1318
1319 #[rstest]
1320 #[case::zero("0")]
1321 #[case::negative("-0.005")]
1322 fn test_tick_relative_price_bounds_rejects_non_positive(#[case] tick_size: &str) {
1323 let tick_size: Decimal = tick_size.parse().unwrap();
1324
1325 let error = tick_relative_price_bounds(tick_size).unwrap_err();
1326
1327 assert_eq!(
1328 error.to_string(),
1329 format!("Tick size {tick_size} must be positive")
1330 );
1331 }
1332
1333 #[rstest]
1334 #[case("0.1", "0.1", "0.9", 1)]
1335 #[case("0.01", "0.01", "0.99", 2)]
1336 #[case("0.005", "0.005", "0.995", 3)]
1337 #[case("0.0025", "0.0025", "0.9975", 4)]
1338 #[case("0.001", "0.001", "0.999", 3)]
1339 #[case("0.0001", "0.0001", "0.9999", 4)]
1340 fn test_create_instrument_tick_relative_price_bounds(
1341 #[case] tick_size: &str,
1342 #[case] expected_min: &str,
1343 #[case] expected_max: &str,
1344 #[case] expected_tick_decimals: u8,
1345 ) {
1346 let mut market = load_gamma_market("gamma_market.json");
1347 market.order_price_min_tick_size = Some(tick_size.parse().unwrap());
1348 let defs = parse_gamma_market(&market).unwrap();
1349 let ts_init = UnixNanos::from(1_000_000_000u64);
1350
1351 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1352
1353 let binary = match &instrument {
1354 InstrumentAny::BinaryOption(b) => b,
1355 other => panic!("Expected BinaryOption, was {other:?}"),
1356 };
1357
1358 assert_eq!(binary.price_precision, POLYMARKET_PRICE_PRECISION);
1359 assert_eq!(binary.price_increment.precision, POLYMARKET_PRICE_PRECISION);
1360 assert_eq!(
1361 binary.min_price.unwrap().precision,
1362 POLYMARKET_PRICE_PRECISION
1363 );
1364 assert_eq!(
1365 binary.max_price.unwrap().precision,
1366 POLYMARKET_PRICE_PRECISION
1367 );
1368 assert_eq!(
1369 binary.min_price_increment_precision(),
1370 expected_tick_decimals
1371 );
1372 assert_eq!(binary.min_price, Some(Price::from(expected_min)));
1373 assert_eq!(binary.max_price, Some(Price::from(expected_max)));
1374 assert_eq!(binary.min_price, Some(binary.price_increment));
1376 }
1377
1378 #[rstest]
1379 fn test_instrument_bounds_agree_with_execution_validation() {
1380 let mut market = load_gamma_market("gamma_market.json");
1384 market.order_price_min_tick_size = Some(dec!(0.01));
1385 let defs = parse_gamma_market(&market).unwrap();
1386 let ts_init = UnixNanos::from(1_000_000_000u64);
1387
1388 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1389 let tick = instrument.price_increment();
1390 let min_price = instrument.min_price().expect("min_price");
1391 let max_price = instrument.max_price().expect("max_price");
1392
1393 assert_eq!(min_price, Price::from("0.01"));
1394 assert_eq!(max_price, Price::from("0.99"));
1395
1396 let at_min = limit_order_at(min_price);
1397 let at_max = limit_order_at(max_price);
1398 assert!(PolymarketOrderBuilder::validate_limit_price(&at_min, tick).is_ok());
1399 assert!(PolymarketOrderBuilder::validate_limit_price(&at_max, tick).is_ok());
1400
1401 let at_old_min = limit_order_at(Price::from("0.001"));
1402 let at_old_max = limit_order_at(Price::from("0.999"));
1403 assert!(PolymarketOrderBuilder::validate_limit_price(&at_old_min, tick).is_err());
1404 assert!(PolymarketOrderBuilder::validate_limit_price(&at_old_max, tick).is_err());
1405 }
1406
1407 #[rstest]
1408 fn test_rebuild_instrument_with_tick_size() {
1409 let market = load_gamma_market("gamma_market.json");
1410 let defs = parse_gamma_market(&market).unwrap();
1411 let ts_init = UnixNanos::from(1_000_000_000u64);
1412
1413 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1415 assert_eq!(instrument.price_precision(), POLYMARKET_PRICE_PRECISION);
1416
1417 let ts_event = UnixNanos::from(2_000_000_000u64);
1418 let rebuilt =
1419 rebuild_instrument_with_tick_size(&instrument, "0.001", ts_event, ts_event).unwrap();
1420
1421 assert_eq!(rebuilt.price_precision(), POLYMARKET_PRICE_PRECISION);
1422 assert_eq!(
1423 rebuilt.price_increment().precision,
1424 POLYMARKET_PRICE_PRECISION
1425 );
1426 assert_eq!(rebuilt.min_price_increment_precision(), 3);
1427 assert_eq!(rebuilt.price_increment(), Price::from("0.001"));
1428 assert_eq!(rebuilt.min_price(), Some(Price::from("0.001")));
1430 assert_eq!(rebuilt.max_price(), Some(Price::from("0.999")));
1431 }
1432
1433 #[rstest]
1434 #[case("0.005", "0.0025", 4, "0.9975")]
1435 #[case("0.0025", "0.005", 3, "0.995")]
1436 fn test_rebuild_instrument_between_non_power_ticks(
1437 #[case] old_tick: &str,
1438 #[case] new_tick: &str,
1439 #[case] expected_tick_decimals: u8,
1440 #[case] expected_max: &str,
1441 ) {
1442 let market = load_gamma_market("gamma_market.json");
1443 let defs = parse_gamma_market(&market).unwrap();
1444 let ts_init = UnixNanos::from(1_000_000_000u64);
1445 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1446 let instrument =
1447 rebuild_instrument_with_tick_size(&instrument, old_tick, ts_init, ts_init).unwrap();
1448
1449 let rebuilt =
1450 rebuild_instrument_with_tick_size(&instrument, new_tick, ts_init, ts_init).unwrap();
1451
1452 assert_eq!(instrument.price_increment(), Price::from(old_tick));
1453 assert_eq!(rebuilt.price_precision(), POLYMARKET_PRICE_PRECISION);
1454 assert_eq!(
1455 rebuilt.price_increment().precision,
1456 POLYMARKET_PRICE_PRECISION
1457 );
1458 assert_eq!(
1459 rebuilt.min_price_increment_precision(),
1460 expected_tick_decimals
1461 );
1462 assert_eq!(rebuilt.price_increment(), Price::from(new_tick));
1463 assert_eq!(rebuilt.min_price(), Some(Price::from(new_tick)));
1464 assert_eq!(rebuilt.max_price(), Some(Price::from(expected_max)));
1465 }
1466
1467 #[rstest]
1468 fn test_rebuild_instrument_with_tick_size_rejects_unsupported_tick_precision() {
1469 let market = load_gamma_market("gamma_market.json");
1470 let defs = parse_gamma_market(&market).unwrap();
1471 let ts_init = UnixNanos::from(1_000_000_000u64);
1472 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1473 let error =
1474 rebuild_instrument_with_tick_size(&instrument, UNSUPPORTED_TICK_SIZE, ts_init, ts_init)
1475 .unwrap_err();
1476
1477 assert_eq!(
1478 error.to_string(),
1479 format!(
1480 "Tick size {UNSUPPORTED_TICK_SIZE} is not exactly representable at Polymarket price precision {POLYMARKET_PRICE_PRECISION}"
1481 )
1482 );
1483 }
1484
1485 #[rstest]
1486 fn test_rebuild_instrument_preserves_fields() {
1487 let market = load_gamma_market("gamma_market.json");
1488 let defs = parse_gamma_market(&market).unwrap();
1489 let ts_init = UnixNanos::from(1_000_000_000u64);
1490
1491 let instrument = create_instrument_from_def(&defs[0], ts_init).unwrap();
1492 let ts_event = UnixNanos::from(2_000_000_000u64);
1493 let rebuilt =
1494 rebuild_instrument_with_tick_size(&instrument, "0.01", ts_event, ts_event).unwrap();
1495
1496 assert_eq!(rebuilt.id(), instrument.id());
1497 assert_eq!(rebuilt.raw_symbol(), instrument.raw_symbol());
1498 assert_eq!(rebuilt.size_precision(), instrument.size_precision());
1499
1500 let orig_bo = match &instrument {
1501 InstrumentAny::BinaryOption(b) => b,
1502 _ => panic!(),
1503 };
1504 let new_bo = match &rebuilt {
1505 InstrumentAny::BinaryOption(b) => b,
1506 _ => panic!(),
1507 };
1508 assert_eq!(new_bo.outcome, orig_bo.outcome);
1509 assert_eq!(new_bo.currency, orig_bo.currency);
1510 }
1511
1512 #[rstest]
1513 #[case("gamma_market_fee_crypto.json", dec!(0.20))]
1514 #[case("gamma_market_fee_sports.json", dec!(0.15))]
1515 #[case("gamma_market_fee_politics.json", dec!(0.25))]
1516 #[case("gamma_market_fee_free.json", Decimal::ZERO)]
1517 #[case("gamma_market_fee_unclassifiable.json", Decimal::ZERO)]
1518 #[case("gamma_market_fee_zero_rate.json", dec!(0.20))]
1519 #[case("gamma_market_fee_conflict.json", Decimal::ZERO)]
1520 #[case("gamma_market_fee_priority.json", dec!(0.25))]
1521 fn test_resolve_maker_rebate_rate(#[case] filename: &str, #[case] expected: Decimal) {
1522 let market = load_gamma_market(filename);
1523
1524 assert_eq!(resolve_maker_rebate_rate(&market), expected);
1525 }
1526
1527 #[rstest]
1528 fn test_enrich_market_fee_schedule_overwrites_rebate_and_keeps_rate() {
1529 let mut market = load_gamma_market("gamma_market_fee_crypto.json");
1530 let original_rate = market.fee_schedule.as_ref().unwrap().rate;
1531
1532 enrich_market_fee_schedule(&mut market);
1533
1534 let schedule = market.fee_schedule.as_ref().unwrap();
1535 assert_eq!(schedule.rate, original_rate);
1536 assert_eq!(schedule.rebate_rate, dec!(0.20));
1537 assert_eq!(schedule.exponent, Decimal::ONE);
1538 assert!(schedule.taker_only);
1539 }
1540
1541 #[rstest]
1542 #[case(Decimal::ZERO)]
1543 #[case(dec!(0.0123))]
1544 fn test_enrich_market_fee_schedule_preserves_zero_fee_values(#[case] rate: Decimal) {
1545 let mut market = load_gamma_market("gamma_market_fee_zero_rate.json");
1546 market.fee_type = Some("zero_fees".to_string());
1547 let schedule = market.fee_schedule.as_mut().unwrap();
1548 schedule.exponent = dec!(2);
1549 schedule.rate = rate;
1550 schedule.taker_only = false;
1551 let original_schedule = market.fee_schedule.clone().unwrap();
1552
1553 enrich_market_fee_schedule(&mut market);
1554
1555 assert_eq!(market.fee_schedule, Some(original_schedule));
1556 }
1557
1558 #[rstest]
1559 fn test_enrich_market_fee_schedule_creates_schedule_for_fee_enabled() {
1560 let mut market = load_gamma_market("gamma_market_fee_crypto.json");
1561 market.fee_schedule = None;
1562
1563 enrich_market_fee_schedule(&mut market);
1564
1565 let schedule = market.fee_schedule.as_ref().unwrap();
1566 assert_eq!(schedule.rate, Decimal::ZERO);
1567 assert_eq!(schedule.rebate_rate, dec!(0.20));
1568 assert_eq!(schedule.exponent, Decimal::ONE);
1569 assert!(schedule.taker_only);
1570 }
1571
1572 #[rstest]
1573 #[case("gamma_market_fee_free.json")]
1574 #[case("gamma_market_fee_unclassifiable.json")]
1575 fn test_enrich_market_fee_schedule_keeps_zero_without_inventing(#[case] filename: &str) {
1576 let mut market = load_gamma_market(filename);
1577 market.fee_schedule = None;
1578
1579 enrich_market_fee_schedule(&mut market);
1580
1581 assert!(market.fee_schedule.is_none());
1582 }
1583}