walrasquant-lib 0.4.20__py3-none-any.whl

walrasquant/exchange/binance/ems.py

@@ -0,0 +1,140 @@
+from decimal import Decimal
+from typing import Dict, cast
+from walrasquant.constants import AccountType
+from walrasquant.schema import InstrumentId, BaseMarket
+from walrasquant.core.cache import AsyncCache
+from walrasquant.core.nautilius_core import MessageBus, LiveClock
+from walrasquant.core.entity import TaskManager
+from walrasquant.core.registry import OrderRegistry
+from walrasquant.exchange.binance import BinanceAccountType
+from walrasquant.exchange.binance.schema import BinanceMarket
+from walrasquant.base import ExecutionManagementSystem
+from walrasquant.base.ems import PriorityOrderQueue
+
+
+class BinanceExecutionManagementSystem(ExecutionManagementSystem):
+    _market: Dict[str, BinanceMarket]
+    _BATCH_CHUNK_SIZE = 5
+
+    BINANCE_SPOT_PRIORITY = [
+        BinanceAccountType.ISOLATED_MARGIN,
+        BinanceAccountType.MARGIN,
+        BinanceAccountType.SPOT_TESTNET,
+        BinanceAccountType.SPOT,
+    ]
+
+    def __init__(
+        self,
+        market: Dict[str, BinanceMarket],
+        cache: AsyncCache,
+        msgbus: MessageBus,
+        clock: LiveClock,
+        task_manager: TaskManager,
+        registry: OrderRegistry,
+        queue_maxsize: int = 100_000,
+    ):
+        super().__init__(
+            market=market,
+            cache=cache,
+            msgbus=msgbus,
+            clock=clock,
+            task_manager=task_manager,
+            registry=registry,
+            queue_maxsize=queue_maxsize,
+        )
+        self._binance_spot_account_type: BinanceAccountType | None = None
+        self._binance_linear_account_type: BinanceAccountType | None = None
+        self._binance_inverse_account_type: BinanceAccountType | None = None
+        self._binance_pm_account_type: BinanceAccountType | None = None
+
+    def _set_account_type(self):
+        account_types = self._private_connectors.keys()
+
+        if BinanceAccountType.PORTFOLIO_MARGIN in account_types:
+            self._binance_pm_account_type = BinanceAccountType.PORTFOLIO_MARGIN
+            return
+
+        for account_type in self.BINANCE_SPOT_PRIORITY:
+            if account_type in account_types:
+                self._binance_spot_account_type = account_type
+                break
+
+        self._binance_linear_account_type = (
+            BinanceAccountType.USD_M_FUTURE_TESTNET
+            if BinanceAccountType.USD_M_FUTURE_TESTNET in account_types
+            else BinanceAccountType.USD_M_FUTURE
+        )
+
+        self._binance_inverse_account_type = (
+            BinanceAccountType.COIN_M_FUTURE_TESTNET
+            if BinanceAccountType.COIN_M_FUTURE_TESTNET in account_types
+            else BinanceAccountType.COIN_M_FUTURE
+        )
+
+    def _instrument_id_to_account_type(
+        self, instrument_id: InstrumentId
+    ) -> AccountType:
+        if self._binance_pm_account_type:
+            return self._binance_pm_account_type
+
+        if instrument_id.is_spot:
+            account_type = self._binance_spot_account_type
+        elif instrument_id.is_linear:
+            account_type = self._binance_linear_account_type
+        elif instrument_id.is_inverse:
+            account_type = self._binance_inverse_account_type
+        else:
+            raise ValueError(f"Unsupported instrument type: {instrument_id.type}")
+
+        if account_type is None:
+            raise ValueError(f"No Binance account type configured for {instrument_id}")
+        return account_type
+
+    def _build_order_submit_queues(self):
+        for account_type in self._private_connectors.keys():
+            if isinstance(account_type, BinanceAccountType):
+                self._order_submit_queues[account_type] = PriorityOrderQueue(
+                    maxsize=self._queue_maxsize
+                )
+
+    def _get_min_order_amount(
+        self, symbol: str, market: BaseMarket, px: float
+    ) -> Decimal:
+        binance_market = cast(BinanceMarket, market)
+        # book = self._cache.bookl1(symbol)
+        cost_limits = binance_market.limits.cost
+        amount_limits = binance_market.limits.amount
+        cost_min = cost_limits.min if cost_limits is not None else 0.0
+        amount_min = amount_limits.min if amount_limits is not None else 0.0
+        cost_min = cost_min or 0.0
+        amount_min = amount_min or 0.0
+
+        min_order_amount = max(cost_min * 1.01 / px, amount_min)
+        min_order_amount = self._amount_to_precision(
+            symbol, min_order_amount, mode="ceil"
+        )
+        return min_order_amount
+
+    def _get_max_order_amount(
+        self, symbol: str, market: BaseMarket, is_market: bool, px: float
+    ) -> Decimal:
+        binance_market = cast(BinanceMarket, market)
+        cost = binance_market.limits.cost.max
+        _cost = (
+            self._amount_to_precision(symbol, cost / px, mode="floor")
+            if cost
+            else Decimal("Infinity")
+        )
+        amount = (
+            Decimal(str(binance_market.limits.amount.max))
+            if binance_market.limits.amount.max
+            else Decimal("Infinity")
+        )
+        if is_market:
+            mkt_max = (
+                Decimal(str(binance_market.limits.market.max))
+                if binance_market.limits.market and binance_market.limits.market.max
+                else Decimal("Infinity")
+            )
+            return min(_cost, amount, mkt_max)
+        return min(_cost, amount)

walrasquant/exchange/binance/error.py

@@ -0,0 +1,48 @@
+class BinanceClientError(Exception):
+    """
+    The base class for all Binance specific errors.
+    """
+
+    def __init__(self, code: int, message: str):
+        super().__init__(message)
+        self.code = code
+        self.message = message
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(code={self.code}, message='{self.message}')"
+
+    __str__ = __repr__
+
+
+class BinanceServerError(Exception):
+    """
+    The base class for all Binance specific errors.
+    """
+
+    def __init__(self, code: int, message: str):
+        super().__init__(message)
+        self.code = code
+        self.message = message
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(code={self.code}, message='{self.message}')"
+
+    __str__ = __repr__
+
+
+class BinanceRateLimitError(Exception):
+    """
+    Raised when Binance API rate limit is exceeded.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        retry_after: float = 0.0,
+        api_type: str | None = None,
+        rate_limit_type: str | None = None,
+    ):
+        super().__init__(message)
+        self.retry_after = retry_after
+        self.api_type = api_type
+        self.rate_limit_type = rate_limit_type

walrasquant/exchange/binance/exchange.py

@@ -0,0 +1,144 @@
+import ccxt
+import msgspec
+from typing import Any, Dict, List
+from walrasquant.base import ExchangeManager
+from walrasquant.exchange.binance.schema import BinanceMarket
+from walrasquant.exchange.binance.constants import BinanceAccountType
+from walrasquant.schema import InstrumentId
+from walrasquant.constants import AccountType, ConfigType
+from walrasquant.error import EngineBuildError
+
+
+class BinanceExchangeManager(ExchangeManager):
+    api: ccxt.binance
+    market: Dict[str, BinanceMarket]
+    market_id: Dict[str, str]
+
+    def __init__(self, config: ConfigType | None = None):
+        resolved_config: ConfigType = {
+            "apiKey": config.get("apiKey", "") if config else "",
+            "secret": config.get("secret", "") if config else "",
+            "exchange_id": config.get("exchange_id", "binance")
+            if config
+            else "binance",
+            "sandbox": config.get("sandbox", False) if config else False,
+        }
+        if config and "password" in config:
+            resolved_config["password"] = config["password"]
+        super().__init__(resolved_config)
+
+    def load_markets(self, reload: bool = False) -> None:
+        market = self.api.load_markets(reload=reload)
+        for symbol, mkt in market.items():
+            try:
+                mkt_json = msgspec.json.encode(mkt)
+                mkt = msgspec.json.decode(mkt_json, type=BinanceMarket)
+
+                if (
+                    mkt.spot or mkt.linear or mkt.inverse or mkt.future
+                ) and not mkt.option:
+                    symbol = self._parse_symbol(mkt, exchange_suffix="BINANCE")
+                    mkt.symbol = symbol
+                    self.market[symbol] = mkt
+                    if mkt.type.value == "spot":
+                        self.market_id[f"{mkt.id}_spot"] = symbol
+                    elif mkt.linear:
+                        self.market_id[f"{mkt.id}_linear"] = symbol
+                    elif mkt.inverse:
+                        self.market_id[f"{mkt.id}_inverse"] = symbol
+
+            except msgspec.ValidationError as ve:
+                self._log.warning(f"Symbol Format Error: {ve}, {symbol}, {mkt}")
+                continue
+
+    def option(
+        self,
+        base: str | None = None,
+        quote: str | None = None,
+        exclude: List[str] | None = None,
+    ) -> List[str]:
+        raise NotImplementedError("Option is not supported for Binance")
+
+    def validate_public_connector_config(
+        self, account_type: AccountType, basic_config: Any
+    ) -> None:
+        """Validate public connector configuration for Binance exchange"""
+        if not isinstance(account_type, BinanceAccountType):
+            raise EngineBuildError(
+                f"Expected BinanceAccountType, got {type(account_type)}"
+            )
+
+        if (
+            account_type.is_isolated_margin_or_margin
+            or account_type.is_portfolio_margin
+        ):
+            raise EngineBuildError(
+                f"{account_type} is not supported for public connector."
+            )
+
+        if basic_config.testnet != account_type.is_testnet:
+            raise EngineBuildError(
+                f"The `testnet` setting of Binance is not consistent with the public connector's account type `{account_type}`."
+            )
+
+    def validate_public_connector_limits(
+        self, existing_connectors: Dict[AccountType, Any]
+    ) -> None:
+        """Validate public connector limits for Binance exchange"""
+        # Binance has no specific connector limits
+        pass
+
+    def instrument_id_to_account_type(self, instrument_id: InstrumentId) -> AccountType:
+        """Convert an instrument ID to the appropriate account type for Binance exchange"""
+        if instrument_id.is_spot:
+            return (
+                BinanceAccountType.SPOT_TESTNET
+                if self.is_testnet
+                else BinanceAccountType.SPOT
+            )
+        elif instrument_id.is_linear:
+            return (
+                BinanceAccountType.USD_M_FUTURE_TESTNET
+                if self.is_testnet
+                else BinanceAccountType.USD_M_FUTURE
+            )
+        elif instrument_id.is_inverse:
+            return (
+                BinanceAccountType.COIN_M_FUTURE_TESTNET
+                if self.is_testnet
+                else BinanceAccountType.COIN_M_FUTURE
+            )
+        else:
+            raise ValueError(f"Unsupported instrument type: {instrument_id.type}")
+
+
+def check():
+    bnc = BinanceExchangeManager()
+    market = bnc.market
+    market_id = bnc.market_id  # noqa: F841
+
+    for symbol, mkt in market.items():
+        instrument_id = InstrumentId.from_str(symbol)
+        if mkt.subType:
+            assert instrument_id.type == mkt.subType
+        else:
+            assert instrument_id.type == mkt.type
+
+        if mkt.limits.market is None:
+            print(f"Market limits is None for {symbol} ({mkt.type})")
+
+        assert mkt.limits.amount is not None
+
+        if mkt.limits.cost.max is None:
+            print(f"Cost max limit is None for {symbol} ({mkt.type})")
+
+        if mkt.limits.amount.max is None:
+            print(f"Amount max limit is None for {symbol} ({mkt.type})")
+
+        assert mkt.limits.cost is not None
+
+    print("All checks passed")
+
+
+if __name__ == "__main__":
+    check()

walrasquant/exchange/binance/factory.py

@@ -0,0 +1,115 @@
+"""
+Binance exchange factory implementation.
+"""
+
+from typing import cast
+
+from walrasquant.constants import ExchangeType, AccountType, ConfigType
+from walrasquant.config import (
+    PublicConnectorConfig,
+    PrivateConnectorConfig,
+    BasicConfig,
+)
+from walrasquant.exchange.base_factory import ExchangeFactory, BuildContext
+from walrasquant.base import (
+    ExchangeManager,
+    PublicConnector,
+    PrivateConnector,
+    ExecutionManagementSystem,
+)
+
+from walrasquant.exchange.binance.exchange import BinanceExchangeManager
+from walrasquant.exchange.binance.constants import BinanceAccountType
+from walrasquant.exchange.binance.connector import (
+    BinancePublicConnector,
+    BinancePrivateConnector,
+)
+from walrasquant.exchange.binance.ems import BinanceExecutionManagementSystem
+from walrasquant.exchange.binance.schema import BinanceMarket
+
+
+class BinanceFactory(ExchangeFactory):
+    """Factory for creating Binance exchange components."""
+
+    @property
+    def exchange_type(self) -> ExchangeType:
+        return ExchangeType.BINANCE
+
+    def create_manager(self, basic_config: BasicConfig) -> ExchangeManager:
+        """Create BinanceExchangeManager."""
+        ccxt_config: ConfigType = {
+            "apiKey": basic_config.api_key or "",
+            "secret": basic_config.secret or "",
+            "exchange_id": "binance",
+            "sandbox": basic_config.testnet,
+        }
+        if basic_config.passphrase:
+            ccxt_config["password"] = basic_config.passphrase
+
+        return BinanceExchangeManager(ccxt_config)
+
+    def create_public_connector(
+        self,
+        config: PublicConnectorConfig,
+        exchange: ExchangeManager,
+        context: BuildContext,
+    ) -> PublicConnector:
+        """Create BinancePublicConnector."""
+        if not isinstance(config.account_type, BinanceAccountType):
+            raise TypeError("Binance public connector requires BinanceAccountType")
+        return BinancePublicConnector(
+            account_type=config.account_type,
+            exchange=cast(BinanceExchangeManager, exchange),
+            msgbus=context.msgbus,
+            clock=context.clock,
+            task_manager=context.task_manager,
+            enable_rate_limit=config.enable_rate_limit,
+            custom_url=config.custom_url,
+            max_subscriptions_per_client=config.max_subscriptions_per_client,
+            max_clients=config.max_clients,
+        )
+
+    def create_private_connector(
+        self,
+        config: PrivateConnectorConfig,
+        exchange: ExchangeManager,
+        context: BuildContext,
+        account_type: AccountType | None = None,
+    ) -> PrivateConnector:
+        """Create BinancePrivateConnector."""
+        # Use provided account_type or fall back to config
+        final_account_type = account_type or config.account_type
+        if not isinstance(final_account_type, BinanceAccountType):
+            raise TypeError("Binance private connector requires BinanceAccountType")
+
+        return BinancePrivateConnector(
+            exchange=cast(BinanceExchangeManager, exchange),
+            account_type=final_account_type,
+            cache=context.cache,
+            clock=context.clock,
+            msgbus=context.msgbus,
+            registry=context.registry,
+            enable_rate_limit=config.enable_rate_limit,
+            task_manager=context.task_manager,
+            max_retries=config.max_retries,
+            delay_initial_ms=config.delay_initial_ms,
+            delay_max_ms=config.delay_max_ms,
+            backoff_factor=config.backoff_factor,
+            max_subscriptions_per_client=config.max_subscriptions_per_client,
+            max_clients=config.max_clients,
+            order_query_config=context.order_query_config,
+        )
+
+    def create_ems(
+        self, exchange: ExchangeManager, context: BuildContext
+    ) -> ExecutionManagementSystem:
+        """Create BinanceExecutionManagementSystem."""
+        return BinanceExecutionManagementSystem(
+            market=cast(dict[str, BinanceMarket], exchange.market),
+            cache=context.cache,
+            msgbus=context.msgbus,
+            clock=context.clock,
+            task_manager=context.task_manager,
+            registry=context.registry,
+            queue_maxsize=context.queue_maxsize,
+        )