Skip to main content

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