Fix Interactive Brokers v2 crypto market data (support PAXOS and ZeroHash)

IBKR routes retail crypto to both PAXOS and ZeroHash (which venue applies
depends on the account/region). The v2 IB adapter hardcoded PAXOS, so
ZeroHash-routed instruments like BTC/USD.ZEROHASH were unusable, and several
stacked defects broke crypto market data:

- Crypto venue was hardcoded to PAXOS, so BTC/USD.ZEROHASH failed contract
  resolution ([200] No security definition). Derive the venue from the
  contract's exchange (ZEROHASH or PAXOS), fall back to PAXOS when unspecified,
  and accept both in VENUES_CRYPTO. PAXOS continues to work unchanged.
- The data client registered for a single venue, so venue-routed subscriptions
  (e.g. BTC/USD.ZEROHASH) were silently dropped by the data engine. Return None
  from venue() for default multi-venue routing, matching Tardis/Databento.
- Real-time (5s) bars hardcoded whatToShow=TRADES, ignoring the bar's price
  type. Honor the requested price type.
- TWS rejects whatToShow=TRADES for crypto with error 10299 on both
  reqHistoricalData and reqRealTimeBars (for PAXOS and ZeroHash alike); the
  venue serves trade-price data only under AGGTRADES. Map crypto trade-price
  bars to AGGTRADES on the realtime path, the live-client historical path, and
  the standalone HistoricalInteractiveBrokersClient path.

AGGTRADES requires a WhatToShow::AggTrades variant that stock ibapi 3.0.1 lacks;
this is added via a temporary [patch.crates-io] ibapi (submitted upstream to
wboayue/rust-ibapi), to be replaced by a version bump once released.

Adds Rust unit tests for both PAXOS and ZeroHash venue derivation (explicit and
fallback), the crypto AGGTRADES mapping on all bar paths, and default routing.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: bebop23

Cargo.lock

@@ -390,6 +390,11 @@ walkdir = "2.5.0"
 [patch.crates-io]
 # Keep the pinned pyo3-stub-gen buildable with PyO3 0.29 API and exception alias changes.
 pyo3-stub-gen = { path = "patches/pyo3-stub-gen" }
+# IB requires whatToShow=AGGTRADES for crypto (TWS rejects TRADES with error 10299),
+# but stock ibapi 3.0.1's WhatToShow enums have no AggTrades variant. This patch adds it,
+# pending upstream merge/release (see https://github.com/wboayue/rust-ibapi/pull/693).
+# When that lands in a released ibapi, delete this patch and bump the `ibapi` version.
+ibapi = { git = "https://github.com/bebop23/rust-ibapi", branch = "feat/aggtrades-whattoshow" }
 
 # -----------------------------------------------------------------------------
 # Tools (for cargo install, used by Makefile and CI)

Cargo.toml

@@ -73,7 +73,17 @@ pub fn ib_contract_to_instrument_id_simplified(
                 }
             }
             SecurityType::ForexPair => Venue::from("IDEALPRO"),
-            SecurityType::Crypto => Venue::from("PAXOS"),
+            // IB routes crypto to multiple venues; both PAXOS and ZEROHASH are live
+            // (which one applies depends on the account/region). Derive the venue from
+            // the contract's actual exchange when set (e.g. ZEROHASH or PAXOS), falling
+            // back to PAXOS when it is unspecified.
+            SecurityType::Crypto => {
+                if !contract.exchange.as_str().is_empty() && contract.exchange.as_str() != "SMART" {
+                    Venue::from(contract.exchange.as_str())
+                } else {
+                    Venue::from("PAXOS")
+                }
+            }
             SecurityType::Stock => Venue::from("SMART"),
             SecurityType::Option | SecurityType::FuturesOption => {
                 if !contract.exchange.as_str().is_empty() && contract.exchange.as_str() != "SMART" {
@@ -234,7 +244,17 @@ pub fn ib_contract_to_instrument_id_raw(
 ) -> anyhow::Result<InstrumentId> {
     let venue = venue.unwrap_or_else(|| match contract.security_type {
         SecurityType::ForexPair => Venue::from("IDEALPRO"),
-        SecurityType::Crypto => Venue::from("PAXOS"),
+        // IB routes crypto to multiple venues; both PAXOS and ZEROHASH are live
+        // (which one applies depends on the account/region). Derive the venue from
+        // the contract's actual exchange when set (e.g. ZEROHASH or PAXOS), falling
+        // back to PAXOS when it is unspecified.
+        SecurityType::Crypto => {
+            if !contract.exchange.as_str().is_empty() && contract.exchange.as_str() != "SMART" {
+                Venue::from(contract.exchange.as_str())
+            } else {
+                Venue::from("PAXOS")
+            }
+        }
         SecurityType::Stock => Venue::from("SMART"),
         SecurityType::Option => Venue::from("SMART"),
         SecurityType::FuturesOption => Venue::from("SMART"),
@@ -371,7 +391,9 @@ pub fn possible_exchanges_for_venue(venue: &str) -> Vec<String> {
 
 /// Venue lists for different asset classes
 const VENUES_CASH: &[&str] = &["IDEALPRO"];
-const VENUES_CRYPTO: &[&str] = &["PAXOS"];
+// IB routes crypto to both PAXOS and ZEROHASH (which one applies depends on the
+// account/region); accept both.
+const VENUES_CRYPTO: &[&str] = &["PAXOS", "ZEROHASH"];
 const VENUES_OPT: &[&str] = &["SMART", "EUREX"];
 const VENUES_FUT: &[&str] = &[
     "BELFOX",
@@ -1365,6 +1387,86 @@ mod tests {
         assert_eq!(contract.local_symbol.as_str(), "DOGE.USD");
     }
 
+    #[rstest]
+    fn test_instrument_id_to_ib_contract_parses_zerohash_crypto_symbol() {
+        // ZEROHASH is one of IB's crypto venues (alongside PAXOS).
+        let instrument_id = InstrumentId::from("BTC/USD.ZEROHASH");
+
+        let contract = instrument_id_to_ib_contract(instrument_id, None).unwrap();
+
+        assert_eq!(contract.security_type, SecurityType::Crypto);
+        assert_eq!(contract.exchange.as_str(), "ZEROHASH");
+        assert_eq!(contract.symbol.as_str(), "BTC");
+        assert_eq!(contract.currency.as_str(), "USD");
+        assert_eq!(contract.local_symbol.as_str(), "BTC.USD");
+    }
+
+    #[rstest]
+    fn test_ib_contract_to_instrument_id_simplified_derives_zerohash_crypto_venue() {
+        // Contract -> InstrumentId derives the venue from the ZEROHASH exchange.
+        let contract = Contract {
+            symbol: Symbol::from("BTC"),
+            security_type: SecurityType::Crypto,
+            exchange: Exchange::from("ZEROHASH"),
+            currency: Currency::from("USD"),
+            local_symbol: "BTC.USD".to_string(),
+            ..Default::default()
+        };
+
+        let instrument_id = ib_contract_to_instrument_id_simplified(&contract, None).unwrap();
+
+        assert_eq!(instrument_id, InstrumentId::from("BTC/USD.ZEROHASH"));
+    }
+
+    #[rstest]
+    fn test_ib_contract_to_instrument_id_simplified_falls_back_to_paxos_crypto_venue() {
+        // Contract -> InstrumentId falls back to PAXOS when no exchange is set,
+        // preserving backwards compatibility.
+        let contract = Contract {
+            symbol: Symbol::from("DOGE"),
+            security_type: SecurityType::Crypto,
+            currency: Currency::from("USD"),
+            local_symbol: "DOGE.USD".to_string(),
+            ..Default::default()
+        };
+
+        let instrument_id = ib_contract_to_instrument_id_simplified(&contract, None).unwrap();
+
+        assert_eq!(instrument_id, InstrumentId::from("DOGE/USD.PAXOS"));
+    }
+
+    #[rstest]
+    fn test_instrument_id_to_ib_contract_parses_paxos_crypto_symbol() {
+        // PAXOS remains a live IB crypto venue alongside ZEROHASH.
+        let instrument_id = InstrumentId::from("BTC/USD.PAXOS");
+
+        let contract = instrument_id_to_ib_contract(instrument_id, None).unwrap();
+
+        assert_eq!(contract.security_type, SecurityType::Crypto);
+        assert_eq!(contract.exchange.as_str(), "PAXOS");
+        assert_eq!(contract.symbol.as_str(), "BTC");
+        assert_eq!(contract.currency.as_str(), "USD");
+        assert_eq!(contract.local_symbol.as_str(), "BTC.USD");
+    }
+
+    #[rstest]
+    fn test_ib_contract_to_instrument_id_simplified_derives_paxos_crypto_venue() {
+        // A PAXOS contract derives the PAXOS venue from its exchange (not via the
+        // fallback), proving both venues are honored when explicitly set.
+        let contract = Contract {
+            symbol: Symbol::from("BTC"),
+            security_type: SecurityType::Crypto,
+            exchange: Exchange::from("PAXOS"),
+            currency: Currency::from("USD"),
+            local_symbol: "BTC.USD".to_string(),
+            ..Default::default()
+        };
+
+        let instrument_id = ib_contract_to_instrument_id_simplified(&contract, None).unwrap();
+
+        assert_eq!(instrument_id, InstrumentId::from("BTC/USD.PAXOS"));
+    }
+
     #[rstest]
     fn test_instrument_id_to_ib_contract_uses_contfut_for_underlying() {
         let instrument_id = InstrumentId::from("ES.XCME");

crates/adapters/interactive_brokers/src/common/parse.rs

@@ -16,9 +16,12 @@
 //! Conversion utilities for Interactive Brokers data types.
 
 use chrono::{DateTime, Utc};
-use ibapi::market_data::historical::{
-    BarSize as HistoricalBarSize, BarTimestamp, Duration as IBDuration, ToDuration,
-    WhatToShow as HistoricalWhatToShow,
+use ibapi::market_data::{
+    historical::{
+        BarSize as HistoricalBarSize, BarTimestamp, Duration as IBDuration, ToDuration,
+        WhatToShow as HistoricalWhatToShow,
+    },
+    realtime::WhatToShow as RealtimeWhatToShow,
 };
 use nautilus_core::UnixNanos;
 use nautilus_model::{
@@ -85,6 +88,57 @@ pub fn price_type_to_ib_what_to_show(price_type: PriceType) -> HistoricalWhatToS
     }
 }
 
+/// Convert Nautilus PriceType to IB WhatToShow for historical bars, honoring the
+/// crypto trade-price special case.
+///
+/// IB rejects `TRADES` for crypto contracts (ZEROHASH/PAXOS) with error 10299 —
+/// the venue serves trade-price data only under `AGGTRADES`. So for a crypto
+/// contract requesting trade-price (`PriceType::Last`), map to
+/// [`HistoricalWhatToShow::AggTrades`] instead of [`HistoricalWhatToShow::Trades`].
+/// Non-crypto contracts and non-trade price types are unaffected. This mirrors the
+/// Java engine's `LiveOneMinBarIngestionService.whatToShowFor` rule exactly.
+#[must_use]
+pub fn price_type_to_ib_what_to_show_for_security(
+    price_type: PriceType,
+    is_crypto: bool,
+) -> HistoricalWhatToShow {
+    if is_crypto && price_type == PriceType::Last {
+        return HistoricalWhatToShow::AggTrades;
+    }
+    price_type_to_ib_what_to_show(price_type)
+}
+
+/// Convert Nautilus PriceType to IB WhatToShow for real-time (5-second) bars.
+#[must_use]
+pub fn price_type_to_ib_realtime_what_to_show(price_type: PriceType) -> RealtimeWhatToShow {
+    match price_type {
+        PriceType::Last => RealtimeWhatToShow::Trades,
+        PriceType::Bid => RealtimeWhatToShow::Bid,
+        PriceType::Ask => RealtimeWhatToShow::Ask,
+        PriceType::Mid => RealtimeWhatToShow::MidPoint,
+        _ => RealtimeWhatToShow::Trades, // Default to trades
+    }
+}
+
+/// Convert Nautilus PriceType to IB WhatToShow for real-time (5-second) bars,
+/// honoring the crypto trade-price special case.
+///
+/// TWS rejects `TRADES` for crypto contracts (ZEROHASH/PAXOS) with error 10299 on
+/// `reqRealTimeBars` too — not just historical. So for a crypto contract requesting
+/// trade-price (`PriceType::Last`), map to [`RealtimeWhatToShow::AggTrades`]. This
+/// mirrors the Java engine, which passes `whatToShowFor(CRYPTO) = "AGGTRADES"`
+/// straight into `subscribeRealTimeBars` (LiveOneMinBarIngestionService).
+#[must_use]
+pub fn price_type_to_ib_realtime_what_to_show_for_security(
+    price_type: PriceType,
+    is_crypto: bool,
+) -> RealtimeWhatToShow {
+    if is_crypto && price_type == PriceType::Last {
+        return RealtimeWhatToShow::AggTrades;
+    }
+    price_type_to_ib_realtime_what_to_show(price_type)
+}
+
 #[must_use]
 pub fn apply_price_magnifier(price: f64, price_magnifier: i32) -> f64 {
     if price_magnifier > 0 {
@@ -402,6 +456,102 @@ mod tests {
         );
     }
 
+    #[rstest]
+    fn test_price_type_to_ib_what_to_show_for_security_crypto() {
+        // Crypto trade-price (Last) must map to AGGTRADES, not TRADES — TWS rejects
+        // TRADES for crypto (error 10299). Mirrors the Java whatToShowFor rule.
+        assert_eq!(
+            price_type_to_ib_what_to_show_for_security(PriceType::Last, true),
+            HistoricalWhatToShow::AggTrades
+        );
+        // Non-trade price types are unaffected by the crypto special case.
+        assert_eq!(
+            price_type_to_ib_what_to_show_for_security(PriceType::Bid, true),
+            HistoricalWhatToShow::Bid
+        );
+        assert_eq!(
+            price_type_to_ib_what_to_show_for_security(PriceType::Ask, true),
+            HistoricalWhatToShow::Ask
+        );
+        assert_eq!(
+            price_type_to_ib_what_to_show_for_security(PriceType::Mid, true),
+            HistoricalWhatToShow::MidPoint
+        );
+    }
+
+    #[rstest]
+    fn test_price_type_to_ib_what_to_show_for_security_non_crypto() {
+        // Non-crypto: trade-price stays TRADES (equities/futures), everything else
+        // identical to the plain mapping.
+        assert_eq!(
+            price_type_to_ib_what_to_show_for_security(PriceType::Last, false),
+            HistoricalWhatToShow::Trades
+        );
+        assert_eq!(
+            price_type_to_ib_what_to_show_for_security(PriceType::Bid, false),
+            HistoricalWhatToShow::Bid
+        );
+        assert_eq!(
+            price_type_to_ib_what_to_show_for_security(PriceType::Mid, false),
+            HistoricalWhatToShow::MidPoint
+        );
+    }
+
+    #[rstest]
+    fn test_aggtrades_wire_string() {
+        // The vendored ibapi patch must serialize AggTrades as the exact IB wire
+        // token "AGGTRADES" on BOTH the historical and realtime enums.
+        assert_eq!(HistoricalWhatToShow::AggTrades.to_string(), "AGGTRADES");
+        assert_eq!(RealtimeWhatToShow::AggTrades.to_string(), "AGGTRADES");
+    }
+
+    #[rstest]
+    fn test_price_type_to_ib_realtime_what_to_show() {
+        // `RealtimeWhatToShow` does not derive `PartialEq`, so match on the variants.
+        assert!(matches!(
+            price_type_to_ib_realtime_what_to_show(PriceType::Last),
+            RealtimeWhatToShow::Trades
+        ));
+        assert!(matches!(
+            price_type_to_ib_realtime_what_to_show(PriceType::Bid),
+            RealtimeWhatToShow::Bid
+        ));
+        assert!(matches!(
+            price_type_to_ib_realtime_what_to_show(PriceType::Ask),
+            RealtimeWhatToShow::Ask
+        ));
+        assert!(matches!(
+            price_type_to_ib_realtime_what_to_show(PriceType::Mid),
+            RealtimeWhatToShow::MidPoint
+        ));
+    }
+
+    #[rstest]
+    fn test_price_type_to_ib_realtime_what_to_show_for_security_crypto() {
+        // Crypto trade-price (Last) 5-second bars must request AGGTRADES on the
+        // realtime path too — TWS rejects TRADES for crypto (error 10299) on
+        // reqRealTimeBars, exactly as on the historical path. Mirrors the Java
+        // engine passing whatToShowFor(CRYPTO)="AGGTRADES" to subscribeRealTimeBars.
+        assert!(matches!(
+            price_type_to_ib_realtime_what_to_show_for_security(PriceType::Last, true),
+            RealtimeWhatToShow::AggTrades
+        ));
+        // Non-trade price types unaffected by the crypto special case.
+        assert!(matches!(
+            price_type_to_ib_realtime_what_to_show_for_security(PriceType::Mid, true),
+            RealtimeWhatToShow::MidPoint
+        ));
+        assert!(matches!(
+            price_type_to_ib_realtime_what_to_show_for_security(PriceType::Bid, true),
+            RealtimeWhatToShow::Bid
+        ));
+        // Non-crypto trade-price stays TRADES.
+        assert!(matches!(
+            price_type_to_ib_realtime_what_to_show_for_security(PriceType::Last, false),
+            RealtimeWhatToShow::Trades
+        ));
+    }
+
     #[rstest]
     fn test_ib_bar_to_nautilus_bar() {
         let ib_bar = ibapi::market_data::historical::Bar {