nautilus_interactive_brokers/

config.rs

// -------------------------------------------------------------------------------------------------
//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
//  https://nautechsystems.io
//
//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
//  You may not use this file except in compliance with the License.
//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
// -------------------------------------------------------------------------------------------------

//! Configuration types for the Interactive Brokers adapter.

use std::{
    collections::{HashMap, HashSet},
    fmt::Debug,
};

use nautilus_common::config::{ConfigResult, check_unique_values};
use nautilus_core::string::secret::SecretString;
use nautilus_model::{identifiers::InstrumentId, types::Currency};
use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error};

use crate::common::{
    consts::{DEFAULT_CLIENT_ID, DEFAULT_HOST, DEFAULT_PORT},
    contracts::{ConfiguredContract, parse_configured_contract_from_json},
    enums::IbSecurityType,
};

/// Market data type for switching between real-time and frozen/delayed.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
#[derive(Default)]
pub enum MarketDataType {
    /// Live market data
    #[default]
    Realtime = 1,
    /// Frozen market data (for when market is closed)
    Frozen = 2,
    /// Delayed market data (usually 15-20 minutes)
    Delayed = 3,
    /// Delayed frozen market data
    DelayedFrozen = 4,
}

impl From<MarketDataType> for ibapi::market_data::MarketDataType {
    fn from(data_type: MarketDataType) -> Self {
        match data_type {
            MarketDataType::Realtime => Self::Realtime,
            MarketDataType::Frozen => Self::Frozen,
            MarketDataType::Delayed => Self::Delayed,
            MarketDataType::DelayedFrozen => Self::DelayedFrozen,
        }
    }
}

/// Configuration for Interactive Brokers data client.
#[derive(Debug, Clone, Serialize, Deserialize, bon::Builder)]
#[serde(default)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        subclass,
        from_py_object
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub struct InteractiveBrokersDataClientConfig {
    /// Host for IB Gateway/TWS.
    #[builder(default = DEFAULT_HOST.to_string())]
    pub host: String,
    /// Port for IB Gateway/TWS.
    #[builder(default = DEFAULT_PORT)]
    pub port: u16,
    /// Client ID.
    #[builder(default = DEFAULT_CLIENT_ID)]
    pub client_id: i32,
    /// Whether to use regular trading hours only (RTH filtering).
    #[builder(default = true)]
    pub use_regular_trading_hours: bool,
    /// Market data type (realtime, delayed, frozen).
    #[builder(default)]
    pub market_data_type: MarketDataType,
    /// Whether to ignore quote tick size updates (filters size-only updates).
    #[builder(default)]
    pub ignore_quote_tick_size_updates: bool,
    /// Connection timeout in seconds.
    #[builder(default = 300)]
    pub connection_timeout: u64,
    /// Request timeout in seconds. Applied to IB API requests (open orders, executions, positions,
    /// account summary, order update stream, next order id). See execution/core.rs and
    /// execution/account.rs for call sites.
    #[builder(default = 60)]
    pub request_timeout: u64,
    /// Whether to publish every revision of an open bar.
    ///
    /// When `false`, a bar that IB keeps up to date is published once it completes: on IB's
    /// update after the bar closes, 2 seconds after the close, or on the next bar's first update,
    /// whichever comes first.
    #[builder(default)]
    pub handle_revised_bars: bool,
    /// Whether to use batch quotes (reqMktData) by default instead of tick-by-tick.
    #[builder(default = true)]
    pub batch_quotes: bool,
    /// Whether to include special-condition trades in tick-by-tick subscriptions.
    #[builder(default = true)]
    pub all_last_trades: bool,
    /// Optional interval without incoming market data before emitting a subscription idle event.
    pub subscription_idle_timeout_secs: Option<u64>,
    /// Bound on ibapi's automatic reconnect attempts for the shared client connection
    /// (`ClientBuilder::max_reconnect_attempts`). `None` keeps ibapi's default. `Some(0)`
    /// disables reconnection; `Some(u32::MAX)` retries for practical purposes forever.
    pub max_reconnect_attempts: Option<u32>,
    /// Instrument provider configuration.
    #[builder(default)]
    pub instrument_provider: InteractiveBrokersInstrumentProviderConfig,
}

impl InteractiveBrokersDataClientConfig {
    pub(crate) fn validate(&self) -> anyhow::Result<()> {
        self.instrument_provider.validate()?;

        anyhow::ensure!(
            self.subscription_idle_timeout_secs != Some(0),
            "subscription_idle_timeout_secs must be positive when set",
        );

        if let Some(timeout) = self.subscription_idle_timeout_secs {
            anyhow::ensure!(
                std::time::Instant::now()
                    .checked_add(std::time::Duration::from_secs(timeout))
                    .is_some(),
                "subscription_idle_timeout_secs exceeds the supported clock range",
            );
        }

        Ok(())
    }
}

impl Default for InteractiveBrokersDataClientConfig {
    fn default() -> Self {
        Self::builder().build()
    }
}

/// Configuration for Interactive Brokers execution client.
#[derive(Debug, Clone, Serialize, Deserialize, bon::Builder)]
#[serde(default)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        subclass,
        from_py_object
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub struct InteractiveBrokersExecutionClientConfig {
    /// Host for IB Gateway/TWS.
    #[builder(default = DEFAULT_HOST.to_string())]
    pub host: String,
    /// Port for IB Gateway/TWS.
    #[builder(default = DEFAULT_PORT)]
    pub port: u16,
    /// Client ID.
    #[builder(default = DEFAULT_CLIENT_ID)]
    pub client_id: i32,
    /// Raw IB account code, such as `DU123456`. The Nautilus account ID becomes
    /// `{client name}-{code}`.
    pub account_id: Option<String>,
    /// Base currency for the account, normally the currency IB reports the account summary in.
    /// `None` keeps a multi-currency account with one balance per currency.
    pub base_currency: Option<Currency>,
    /// Connection timeout in seconds.
    #[builder(default = 300)]
    pub connection_timeout: u64,
    /// Request timeout in seconds for IB API requests (open orders, executions, positions, etc.).
    #[builder(default = 60)]
    pub request_timeout: u64,
    /// Whether to fetch all open orders (reqAllOpenOrders vs reqOpenOrders).
    #[builder(default)]
    pub fetch_all_open_orders: bool,
    /// Whether to track option exercise from position updates.
    #[builder(default)]
    pub track_option_exercise_from_position_update: bool,
    /// Bound on ibapi's automatic reconnect attempts, see the field of the same name on
    /// [`InteractiveBrokersDataClientConfig`]. The shared-client registry connects once
    /// per `(host, port, client_id)`, so when data and exec share a connection the first
    /// creator's value wins.
    pub max_reconnect_attempts: Option<u32>,
    /// Instrument provider configuration.
    #[builder(default)]
    pub instrument_provider: InteractiveBrokersInstrumentProviderConfig,
}

impl Default for InteractiveBrokersExecutionClientConfig {
    fn default() -> Self {
        Self::builder().build()
    }
}

/// Symbology method for converting between IB contracts and Nautilus instrument IDs.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
#[derive(Default)]
pub enum SymbologyMethod {
    /// Simplified symbology: clean, readable symbols (e.g., "EUR/USD", "ESM23")
    #[serde(rename = "simplified")]
    #[default]
    Simplified,
    /// Raw symbology: preserves IB raw format with security type suffix (e.g., "EUR.USD=CASH", "AAPL=STK")
    #[serde(rename = "raw")]
    Raw,
}

/// Configuration for Interactive Brokers instrument provider.
#[derive(Debug, Clone, Serialize, Deserialize, bon::Builder)]
#[serde(default)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        subclass,
        from_py_object
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub struct InteractiveBrokersInstrumentProviderConfig {
    /// Symbology method to use for instrument ID conversion.
    #[builder(default)]
    pub symbology_method: SymbologyMethod,
    /// Instrument IDs to load on startup.
    #[builder(default)]
    pub load_ids: HashSet<InstrumentId>,
    /// IB contracts to load on startup.
    #[builder(default)]
    #[serde(
        deserialize_with = "deserialize_configured_contracts",
        serialize_with = "serialize_configured_contracts"
    )]
    pub load_contracts: Vec<ConfiguredContract>,
    /// Minimum expiry days for options and futures chains.
    pub min_expiry_days: Option<u32>,
    /// Maximum expiry days for options and futures chains.
    pub max_expiry_days: Option<u32>,
    /// Whether to build full options chain.
    pub build_options_chain: Option<bool>,
    /// Whether to build full futures chain.
    pub build_futures_chain: Option<bool>,
    /// Cache validity in days (None means no caching).
    pub cache_validity_days: Option<u32>,
    /// Whether to convert IB exchanges to MIC venues.
    #[builder(default)]
    pub convert_exchange_to_mic_venue: bool,
    /// Symbol to MIC venue mapping override.
    #[builder(default)]
    pub symbol_to_mic_venue: HashMap<String, String>,
    /// Security types to filter out.
    #[builder(default)]
    pub filter_sec_types: HashSet<IbSecurityType>,
    /// Fully-qualified Python callable path for custom instrument filtering.
    ///
    /// Configuring this without the Python feature enabled is an error.
    pub filter_callable: Option<String>,
    /// Path to cache file for persistent instrument caching (equivalent to pickle_path in Python).
    /// If provided, instruments will be cached to disk and loaded from cache if still valid.
    pub cache_path: Option<String>,
}

impl Default for InteractiveBrokersInstrumentProviderConfig {
    fn default() -> Self {
        Self::builder().build()
    }
}

fn deserialize_configured_contracts<'de, D>(
    deserializer: D,
) -> Result<Vec<ConfiguredContract>, D::Error>
where
    D: Deserializer<'de>,
{
    Vec::<serde_json::Value>::deserialize(deserializer)?
        .iter()
        .map(parse_configured_contract_from_json)
        .collect::<anyhow::Result<Vec<_>>>()
        .map_err(D::Error::custom)
}

fn serialize_configured_contracts<S>(
    contracts: &[ConfiguredContract],
    serializer: S,
) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    contracts
        .iter()
        .map(ConfiguredContract::to_json_value)
        .collect::<Vec<_>>()
        .serialize(serializer)
}

/// Trading mode for Dockerized IB Gateway.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
#[derive(Default)]
pub enum TradingMode {
    /// Paper trading mode.
    #[serde(rename = "paper")]
    #[default]
    Paper,
    /// Live trading mode.
    #[serde(rename = "live")]
    Live,
}

/// Configuration for Dockerized IB Gateway.
///
/// This configuration is for managing containerized IB Gateway instances.
/// It supports environment variable loading and sensitive data masking.
#[derive(Clone, Serialize, Deserialize, bon::Builder)]
#[serde(default)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        subclass,
        from_py_object
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub struct DockerizedIBGatewayConfig {
    /// Username for IB account (falls back to `TWS_USERNAME` env var via [`Default`]).
    pub username: Option<SecretString>,
    /// Password for IB account (falls back to `TWS_PASSWORD` env var via [`Default`]).
    #[serde(skip_serializing)]
    pub password: Option<SecretString>,
    /// Trading mode (paper or live).
    #[builder(default)]
    pub trading_mode: TradingMode,
    /// Whether to enable read-only API mode.
    #[builder(default = true)]
    pub read_only_api: bool,
    /// Timeout in seconds for container startup.
    #[builder(default = 300)]
    pub timeout: u64,
    /// Container image reference.
    #[builder(default = "ghcr.io/gnzsnz/ib-gateway:stable".to_string())]
    pub container_image: String,
    /// VNC port for remote desktop access (None to disable).
    pub vnc_port: Option<u16>,
}

impl DockerizedIBGatewayConfig {
    /// Validate configuration.
    ///
    /// # Errors
    ///
    /// Returns an error if validation fails.
    pub fn validate(&self) -> anyhow::Result<()> {
        if self.timeout == 0 {
            anyhow::bail!("Timeout must be greater than 0");
        }

        if self.timeout > 3600 {
            anyhow::bail!("Timeout must be less than 3600 seconds");
        }

        if let Some(port) = self.vnc_port
            && (!(5900..=5999).contains(&port))
        {
            anyhow::bail!("VNC port must be between 5900 and 5999");
        }

        Ok(())
    }
}

impl Debug for DockerizedIBGatewayConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct(stringify!(DockerizedIBGatewayConfig))
            .field("username", &self.username)
            .field("password", &self.password.as_ref().map(|_| "<redacted>"))
            .field("trading_mode", &self.trading_mode)
            .field("read_only_api", &self.read_only_api)
            .field("timeout", &self.timeout)
            .field("container_image", &self.container_image)
            .field("vnc_port", &self.vnc_port)
            .finish()
    }
}

impl Default for DockerizedIBGatewayConfig {
    fn default() -> Self {
        Self::builder()
            .maybe_username(std::env::var("TWS_USERNAME").ok().map(SecretString::from))
            .maybe_password(std::env::var("TWS_PASSWORD").ok().map(SecretString::from))
            .build()
    }
}

impl InteractiveBrokersInstrumentProviderConfig {
    /// Validates that configured selections contain no duplicates.
    ///
    /// # Errors
    ///
    /// Returns an error if a selection repeats a value.
    pub fn validate(&self) -> ConfigResult<()> {
        check_unique_values("load_contracts", &self.load_contracts)
    }
}

impl InteractiveBrokersExecutionClientConfig {
    /// Validates that configured selections contain no duplicates.
    ///
    /// # Errors
    ///
    /// Returns an error if a selection repeats a value.
    pub fn validate(&self) -> ConfigResult<()> {
        self.instrument_provider.validate()
    }
}

#[cfg(test)]
mod tests {
    use nautilus_common::config::ConfigError;
    use nautilus_model::types::Currency;
    use rstest::rstest;

    use super::{
        DockerizedIBGatewayConfig, InteractiveBrokersExecutionClientConfig,
        InteractiveBrokersInstrumentProviderConfig,
    };
    use crate::common::enums::IbSecurityType;

    #[rstest]
    fn test_gateway_password_is_redacted_from_debug_and_serialization() {
        let config = DockerizedIBGatewayConfig::builder()
            .username(String::from("user").into())
            .password(String::from("secret-password").into())
            .build();

        let debug = format!("{config:?}");
        let json = serde_json::to_string(&config).unwrap();

        assert!(!debug.contains("secret-password"));
        assert!(debug.contains("<redacted>"));
        assert!(!json.contains("secret-password"));
        assert!(!json.contains("password"));
    }

    #[rstest]
    fn test_execution_client_config_base_currency() {
        let config: InteractiveBrokersExecutionClientConfig =
            serde_json::from_value(serde_json::json!({"base_currency": "EUR"})).unwrap();

        assert_eq!(config.base_currency, Some(Currency::EUR()));
        assert_eq!(
            InteractiveBrokersExecutionClientConfig::default().base_currency,
            None
        );
    }

    #[rstest]
    fn test_instrument_provider_config_decodes_typed_contracts_and_filters() {
        let config: InteractiveBrokersInstrumentProviderConfig =
            serde_json::from_value(serde_json::json!({
                "load_contracts": [{
                    "secType": "STK",
                    "symbol": "AAPL",
                    "exchange": "SMART",
                    "conId": 265598
                }],
                "filter_sec_types": ["opt"]
            }))
            .unwrap();

        assert_eq!(config.load_contracts.len(), 1);
        assert_eq!(config.load_contracts[0].contract.contract_id, 265598);
        assert_eq!(
            config.load_contracts[0].contract.security_type,
            ibapi::contracts::SecurityType::Stock
        );
        assert!(config.filter_sec_types.contains(&IbSecurityType::Option));
    }

    #[rstest]
    fn test_instrument_provider_config_keeps_per_contract_chain_settings() {
        let config: InteractiveBrokersInstrumentProviderConfig =
            serde_json::from_value(serde_json::json!({
                "build_futures_chain": true,
                "load_contracts": [
                    {
                        "secType": "STK",
                        "symbol": "SPY",
                        "exchange": "SMART",
                        "primaryExchange": "ARCA",
                        "build_options_chain": true,
                        "min_expiry_days": 7,
                        "max_expiry_days": 14
                    },
                    {
                        "secType": "FUT",
                        "exchange": "NYMEX",
                        "localSymbol": "CLZ6",
                        "build_futures_chain": false
                    }
                ]
            }))
            .unwrap();

        let spy = &config.load_contracts[0];
        assert_eq!(spy.build_options_chain, Some(true));
        assert_eq!(spy.build_futures_chain, None);
        assert_eq!(spy.min_expiry_days, Some(7));
        assert_eq!(spy.max_expiry_days, Some(14));
        assert_eq!(spy.options_chain_exchange, None);
        assert_eq!(
            spy.chain_spec_json().unwrap(),
            serde_json::json!({
                "build_options_chain": true,
                "min_expiry_days": 7,
                "max_expiry_days": 14
            })
        );

        let cl = &config.load_contracts[1];
        assert_eq!(cl.build_futures_chain, Some(false));
        assert_eq!(
            cl.chain_spec_json().unwrap(),
            serde_json::json!({"build_futures_chain": false})
        );

        let round_trip = serde_json::to_value(&config).unwrap();
        assert_eq!(
            round_trip["load_contracts"][0]["build_options_chain"],
            serde_json::json!(true)
        );
        assert_eq!(
            round_trip["load_contracts"][1]["build_futures_chain"],
            serde_json::json!(false)
        );
    }

    #[rstest]
    fn test_instrument_provider_config_accepts_con_id_only_contract() {
        let config: InteractiveBrokersInstrumentProviderConfig =
            serde_json::from_value(serde_json::json!({
                "load_contracts": [{"conId": 265598}]
            }))
            .unwrap();

        assert_eq!(config.load_contracts[0].contract.contract_id, 265598);
        assert_eq!(
            config.load_contracts[0].contract.security_type,
            ibapi::contracts::SecurityType::Stock
        );
    }

    #[rstest]
    #[case(
        serde_json::json!({"load_contracts": [{"secType": "UNKNOWN"}]}),
        "Unknown IB security type: UNKNOWN"
    )]
    #[case(
        serde_json::json!({"load_contracts": [{"secType": "STK", "conId": "265598"}]}),
        "Configured contract field 'conId' must be an integer"
    )]
    #[case(
        serde_json::json!({"load_contracts": [{"symbol": "SPY"}]}),
        "Configured contract requires 'secType' as a known IB security type string, or a positive 'conId'"
    )]
    #[case(
        serde_json::json!({"load_contracts": [{"secType": "STK", "build_options_chain": "yes"}]}),
        "Configured contract field 'build_options_chain' must be a boolean"
    )]
    #[case(
        serde_json::json!({"load_contracts": [{"secType": "STK", "min_expiry_days": -1}]}),
        "Configured contract field 'min_expiry_days' must be a non-negative integer"
    )]
    #[case(
        serde_json::json!({"filter_sec_types": ["UNKNOWN"]}),
        "Unknown IB security type: UNKNOWN"
    )]
    fn test_instrument_provider_config_rejects_invalid_typed_values(
        #[case] value: serde_json::Value,
        #[case] expected: &str,
    ) {
        let error = serde_json::from_value::<InteractiveBrokersInstrumentProviderConfig>(value)
            .unwrap_err();

        assert!(error.to_string().contains(expected), "{error}");
    }

    #[rstest]
    #[case("load_contracts", serde_json::json!([{"secType": "STK", "conId": 265598}, {"secType": "STK", "conId": 756733}]))]
    fn test_instrument_provider_selection_uniqueness(
        #[case] field: &str,
        #[case] mut values: serde_json::Value,
        #[values(false, true)] duplicate: bool,
    ) {
        if duplicate {
            let entries = values.as_array_mut().unwrap();
            entries.push(entries[0].clone());
        }

        let mut input =
            serde_json::to_value(InteractiveBrokersInstrumentProviderConfig::default()).unwrap();
        input[field] = values;
        let config: InteractiveBrokersInstrumentProviderConfig =
            serde_json::from_value(input).unwrap();
        let original = serde_json::to_value(&config).unwrap();

        let expected = if duplicate {
            Err(ConfigError::duplicate(field, None))
        } else {
            Ok(())
        };

        let result = config.validate();

        assert_eq!(result, expected);
        assert_eq!(serde_json::to_value(&config).unwrap(), original);
    }

    #[rstest]
    fn test_client_configs_reject_duplicate_provider_selections() {
        let provider: InteractiveBrokersInstrumentProviderConfig = serde_json::from_value(serde_json::json!({
            "load_contracts": [{"secType": "STK", "conId": 265598}, {"secType": "STK", "conId": 265598}]
        })).unwrap();

        let data = super::InteractiveBrokersDataClientConfig {
            instrument_provider: provider.clone(),
            ..Default::default()
        };

        let execution = InteractiveBrokersExecutionClientConfig {
            instrument_provider: provider,
            ..Default::default()
        };

        let data_result = data
            .validate()
            .map_err(|e| e.downcast::<ConfigError>().unwrap());
        let execution_result = execution.validate();
        let expected = Err(ConfigError::duplicate("load_contracts", None));

        assert_eq!(data_result, expected);
        assert_eq!(execution_result, expected);
    }

    #[rstest]
    #[case::data(false)]
    #[case::execution(true)]
    fn test_client_constructor_rejects_duplicate_config_before_setup(#[case] execution: bool) {
        use std::{cell::RefCell, rc::Rc, sync::Arc};

        use nautilus_common::cache::Cache;
        use nautilus_live::ExecutionClientCore;
        use nautilus_model::{
            enums::{AccountType, OmsType},
            identifiers::{AccountId, ClientId, TraderId, Venue},
        };

        use crate::{
            data::InteractiveBrokersDataClient, execution::InteractiveBrokersExecutionClient,
            providers::instruments::InteractiveBrokersInstrumentProvider,
        };

        let duplicate_config: InteractiveBrokersInstrumentProviderConfig =
            serde_json::from_value(serde_json::json!({
                "load_contracts": [{"conId": 265598}, {"conId": 265598}]
            }))
            .unwrap();
        let provider =
            Arc::new(InteractiveBrokersInstrumentProvider::new(Default::default()).unwrap());

        let error = if execution {
            let core = ExecutionClientCore::new(
                TraderId::from("TESTER-001"),
                ClientId::from("IB"),
                Venue::from("IB"),
                OmsType::Netting,
                AccountId::from("IB-001"),
                AccountType::Margin,
                None,
                Rc::new(RefCell::new(Cache::default())),
            );

            let config = InteractiveBrokersExecutionClientConfig {
                client_id: 1,
                instrument_provider: duplicate_config,
                ..Default::default()
            };

            InteractiveBrokersExecutionClient::new(core, config, provider).err()
        } else {
            InteractiveBrokersDataClient::new(
                ClientId::from("IB"),
                super::InteractiveBrokersDataClientConfig {
                    instrument_provider: duplicate_config,
                    ..Default::default()
                },
                provider,
            )
            .err()
        }
        .expect("duplicate config must fail before client setup or connection");

        assert_eq!(
            error.downcast_ref::<ConfigError>(),
            Some(&ConfigError::duplicate("load_contracts", None))
        );
    }

    #[rstest]
    fn test_provider_constructor_rejects_duplicate_config() {
        let config = serde_json::from_value(serde_json::json!({
            "load_contracts": [{"conId": 265598}, {"conId": 265598}]
        }))
        .unwrap();

        let error =
            crate::providers::instruments::InteractiveBrokersInstrumentProvider::new(config)
                .unwrap_err();

        assert_eq!(error, ConfigError::duplicate("load_contracts", None));
    }
}