Skip to main content

nautilus_polymarket/http/
parse.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Instrument parsing for Polymarket markets.
17
18use 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
49// Maker rebate shares per the published fee schedule.
50// Reference: https://docs.polymarket.com/trading/fees
51const REBATE_CRYPTO: Decimal = dec!(0.20);
52const REBATE_SPORTS: Decimal = dec!(0.15);
53const REBATE_STANDARD: Decimal = dec!(0.25);
54
55/// Normalized instrument definition for a single Polymarket outcome token.
56///
57/// Each Polymarket market produces two of these (Yes and No).
58#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
59pub struct PolymarketInstrumentDef {
60    /// Nautilus symbol: `{conditionId}-{tokenId}`.
61    pub symbol: Ustr,
62    /// Selected outcome asset ID for the market protocol.
63    pub token_id: Ustr,
64    /// On-chain condition ID.
65    pub condition_id: Ustr,
66    /// Gamma market ID.
67    pub market_id: String,
68    /// Gamma parent event ID, when unambiguous.
69    pub event_id: Option<Ustr>,
70    /// Original Gamma market response.
71    #[serde(default)]
72    pub gamma_market: String,
73    /// Shared `Value::String` containing the original enclosing event JSON from discovery.
74    pub gamma_event: Option<Arc<Value>>,
75    /// Question ID (resolution hash).
76    pub question_id: Option<String>,
77    /// Outcome label.
78    pub outcome: PolymarketOutcome,
79    /// Market question/title.
80    pub question: String,
81    /// Market description.
82    pub description: Option<String>,
83    /// Canonical price precision (four decimal places).
84    pub price_precision: u8,
85    /// Minimum tick size.
86    pub tick_size: Decimal,
87    /// Minimum order size.
88    pub min_size: Option<Decimal>,
89    /// Market start timestamp (ISO 8601).
90    pub start_date: Option<String>,
91    /// Event window start timestamp (ISO 8601).
92    pub event_start_time: Option<String>,
93    /// Market end timestamp (ISO 8601).
94    pub end_date: Option<String>,
95    /// Whether the market is active and accepting orders.
96    pub active: bool,
97    /// Whether Gamma reports the market closed.
98    #[serde(default)]
99    pub closed: bool,
100    /// URL slug for the market.
101    pub market_slug: Option<String>,
102    /// Whether the market uses the neg-risk CTF exchange contract.
103    pub neg_risk: Option<bool>,
104    /// Source used to resolve the market.
105    pub resolution_source: Option<String>,
106    /// Crypto market resolution configuration.
107    pub crypto_market_config: Option<CryptoMarketConfig>,
108    /// Fee schedule for this market.
109    pub fee_schedule: Option<FeeSchedule>,
110    /// Game ID for sport markets, kept verbatim because Gamma emits both
111    /// numeric and composite `<uuid>:<away>:<home>` forms.
112    pub game_id: Option<String>,
113    /// Market protocol version: `v1` or `v2`.
114    pub market_version: String,
115}
116
117/// Parses a Gamma market response into instrument definitions.
118///
119/// Each market produces two definitions: one for the Yes outcome
120/// and one for the No outcome.
121pub 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
251// Resolves the maker rebate share from market category metadata, returning
252// 0.20 for crypto, 0.15 for sports, 0.25 for other documented fee-enabled
253// categories, and zero for fee-free or unclassifiable markets.
254pub(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
263// Create missing schedules only for a resolved fee-enabled category.
264// Keep unknown taker rates at zero; the legacy CLOB base fee cannot supply them.
265pub(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
438/// Converts a Polymarket instrument definition into a Nautilus `InstrumentAny`.
439pub 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    // Advertise the tradeable range for the current tick so consumers and testers that clamp to
464    // these bounds land inside the venue's `[tick, 1 - tick]` range; execution-side validation in
465    // `PolymarketOrderBuilder::validate_limit_price` remains the source of truth.
466    let (min_price, max_price) = tick_relative_price_bounds(def.tick_size)?;
467    let price_increment = min_price;
468
469    // Polymarket exposes `orderMinSize` (limit-order minimum shares) and a separate
470    // $1 market-order minimum amount; the instrument model can only carry one
471    // `min_quantity`, so leave it unset and let the venue reject out-of-bounds orders.
472    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-decimal collateral increments
485        .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/// Converts a collection of definitions into Nautilus instruments.
503#[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
517/// Rebuilds an instrument with a new active tick size and canonical price precision.
518///
519/// All other fields are preserved from `existing`. Returns a new `InstrumentAny`.
520pub 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        // min_quantity: see `create_instrument_from_def`
552        .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
566// Returns the tradeable price bounds `[tick_size, 1 - tick_size]` for a Polymarket outcome,
567// mirroring the venue range enforced in `PolymarketOrderBuilder::validate_limit_price`.
568pub(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        // Reserve the event position under both serde_json map ordering configurations
593        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        // Reverse the outcomes order so No comes first
1003        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        // `create_instrument_from_def` is shared with the historical loader, which keeps terminal
1248        // state in `resolution_metadata`. Closure is stamped on the live Gamma path instead.
1249        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        // The lower bound is exactly the price increment (one tick)
1372        assert_eq!(binary.min_price, Some(binary.price_increment));
1373    }
1374
1375    #[rstest]
1376    fn test_instrument_bounds_agree_with_execution_validation() {
1377        // On a 0.01-tick market, clamping to the advertised bounds must land inside the
1378        // venue's [tick, 1 - tick] range that `validate_limit_price` enforces, and the old
1379        // static 0.001/0.999 bounds must be rejected by that same validation.
1380        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        // The active tick changes independently of canonical price precision
1411        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        // Bounds reflect the new tick, not the pre-change 0.01-tick range
1426        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}