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
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        // Reverse the outcomes order so No comes first
1006        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        // `create_instrument_from_def` is shared with the historical loader, which keeps terminal
1251        // state in `resolution_metadata`. Closure is stamped on the live Gamma path instead.
1252        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        // The lower bound is exactly the price increment (one tick)
1375        assert_eq!(binary.min_price, Some(binary.price_increment));
1376    }
1377
1378    #[rstest]
1379    fn test_instrument_bounds_agree_with_execution_validation() {
1380        // On a 0.01-tick market, clamping to the advertised bounds must land inside the
1381        // venue's [tick, 1 - tick] range that `validate_limit_price` enforces, and the old
1382        // static 0.001/0.999 bounds must be rejected by that same validation.
1383        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        // The active tick changes independently of canonical price precision
1414        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        // Bounds reflect the new tick, not the pre-change 0.01-tick range
1429        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}