walrasquant-lib 0.4.20__py3-none-any.whl

walrasquant/base/exchange.py

@@ -0,0 +1,213 @@
+import warnings
+import ccxt
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List
+import nexuslog as logging
+
+from walrasquant.schema import BaseMarket, InstrumentId
+from walrasquant.constants import ExchangeType, AccountType, ConfigType
+
+
+class ExchangeManager(ABC):
+    def __init__(self, config: ConfigType | None = None):
+        if config is None:
+            raise ValueError("config is required")
+
+        self.config: ConfigType = config
+        self.api_key = config.get("apiKey")
+        self.secret = config.get("secret")
+        self.exchange_id = ExchangeType(config["exchange_id"])
+        self.api = self._init_exchange()
+        self._log = logging.getLogger(name=type(self).__name__)
+        self.is_testnet = config.get("sandbox", False)
+        self.market: Dict[str, BaseMarket] = {}
+        self.market_id: Dict[str, str] = {}
+
+        if not self.api_key or not self.secret:
+            warnings.warn(
+                "API Key and Secret not provided, So some features related to trading will not work"
+            )
+        self.load_markets()
+
+    def _init_exchange(self) -> ccxt.Exchange:
+        """
+        Initialize the exchange
+        """
+        try:
+            exchange_class = getattr(ccxt, self.config["exchange_id"])
+        except AttributeError:
+            raise AttributeError(
+                f"Exchange {self.config['exchange_id']} is not supported"
+            ) from None
+
+        api = exchange_class(self.config)
+        api.set_sandbox_mode(
+            self.config.get("sandbox", False)
+        )  # Set sandbox mode if demo trade is enabled
+        return api
+
+    def _parse_symbol(self, mkt: BaseMarket, exchange_suffix: str) -> str:
+        """
+        Parse the symbol for the exchange
+        """
+        if mkt.spot:
+            return f"{mkt.base}{mkt.quote}.{exchange_suffix}"
+        elif mkt.option:
+            symbol = mkt.symbol
+            parts = symbol.split("-")
+            expiry = parts[1]
+            strike = parts[2]
+            option_type = parts[3]
+            return f"{mkt.base}{mkt.quote}-{expiry}-{strike}-{option_type}.{exchange_suffix}"
+        elif mkt.future:
+            symbol = mkt.symbol
+            expiry_suffix = symbol.split("-")[-1]
+            return f"{mkt.base}{mkt.quote}-{expiry_suffix}.{exchange_suffix}"
+        elif mkt.linear:
+            return f"{mkt.base}{mkt.quote}-PERP.{exchange_suffix}"
+        elif mkt.inverse:
+            return f"{mkt.base}{mkt.quote}-PERP.{exchange_suffix}"
+        raise ValueError(f"Unsupported market type for symbol {mkt.symbol}")
+
+    @abstractmethod
+    def load_markets(self, reload: bool = False) -> None:
+        pass
+
+    def linear(
+        self,
+        base: str | None = None,
+        quote: str | None = None,
+        exclude: List[str] | None = None,
+    ) -> List[str]:
+        symbols = []
+        for symbol, market in self.market.items():
+            if not (
+                market.linear
+                and market.active
+                and not market.future
+                and not market.option
+            ):
+                continue
+
+            base_match = base is None or market.base == base
+            quote_match = quote is None or market.quote == quote
+
+            if (
+                base_match
+                and quote_match
+                and (exclude is None or symbol not in exclude)
+            ):
+                symbols.append(symbol)
+        return symbols
+
+    def inverse(
+        self,
+        base: str | None = None,
+        quote: str | None = None,
+        exclude: List[str] | None = None,
+    ) -> List[str]:
+        symbols = []
+        for symbol, market in self.market.items():
+            if not (
+                market.inverse
+                and market.active
+                and not market.future
+                and not market.option
+            ):
+                continue
+
+            base_match = base is None or market.base == base
+            quote_match = quote is None or market.quote == quote
+
+            if (
+                base_match
+                and quote_match
+                and (exclude is None or symbol not in exclude)
+            ):
+                symbols.append(symbol)
+        return symbols
+
+    def spot(
+        self,
+        base: str | None = None,
+        quote: str | None = None,
+        exclude: List[str] | None = None,
+    ) -> List[str]:
+        symbols = []
+        for symbol, market in self.market.items():
+            if not (market.spot and market.active and not market.option):
+                continue
+
+            base_match = base is None or market.base == base
+            quote_match = quote is None or market.quote == quote
+
+            if (
+                base_match
+                and quote_match
+                and (exclude is None or symbol not in exclude)
+            ):
+                symbols.append(symbol)
+        return symbols
+
+    def future(
+        self,
+        base: str | None = None,
+        quote: str | None = None,
+        exclude: List[str] | None = None,
+    ) -> List[str]:
+        symbols = []
+        for symbol, market in self.market.items():
+            if not (market.future and market.active and not market.option):
+                continue
+
+            base_match = base is None or market.base == base
+            quote_match = quote is None or market.quote == quote
+
+            if (
+                base_match
+                and quote_match
+                and (exclude is None or symbol not in exclude)
+            ):
+                symbols.append(symbol)
+        return symbols
+
+    def option(
+        self,
+        base: str | None = None,
+        quote: str | None = None,
+        exclude: List[str] | None = None,
+    ) -> List[str]:
+        symbols = []
+        for symbol, market in self.market.items():
+            if not market.active:
+                continue
+
+            base_match = base is None or market.base == base
+            quote_match = quote is None or market.quote == quote
+
+            if (
+                base_match
+                and quote_match
+                and (exclude is None or symbol not in exclude)
+            ):
+                symbols.append(symbol)
+        return symbols
+
+    @abstractmethod
+    def validate_public_connector_config(
+        self, account_type: AccountType, basic_config: Any
+    ) -> None:
+        """Validate public connector configuration for this exchange"""
+        pass
+
+    @abstractmethod
+    def validate_public_connector_limits(
+        self, existing_connectors: Dict[AccountType, Any]
+    ) -> None:
+        """Validate public connector limits for this exchange"""
+        pass
+
+    @abstractmethod
+    def instrument_id_to_account_type(self, instrument_id: InstrumentId) -> AccountType:
+        """Convert an instrument ID to the appropriate account type for this exchange"""
+        pass

walrasquant/base/oms.py

@@ -0,0 +1,428 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+import asyncio
+from typing import Dict, List, Literal, Optional, TYPE_CHECKING
+from decimal import Decimal
+import nexuslog as logging
+
+from decimal import ROUND_HALF_UP, ROUND_CEILING, ROUND_FLOOR
+from walrasquant.constants import AccountType, ExchangeType
+from walrasquant.core.cache import AsyncCache
+from walrasquant.core.nautilius_core import LiveClock, MessageBus
+from walrasquant.core.registry import OrderRegistry
+from walrasquant.core.entity import TaskManager
+from walrasquant.base.api_client import ApiClient
+from walrasquant.base.ws_client import WSClient
+from walrasquant.schema import (
+    Order,
+    BaseMarket,
+    BatchOrderSubmit,
+    CancelOrderSubmit,
+)
+from walrasquant.constants import (
+    OrderSide,
+    OrderType,
+    TimeInForce,
+    TriggerType,
+    OrderStatus,
+)
+
+if TYPE_CHECKING:
+    from walrasquant.config import OrderQueryConfig
+
+
+class OrderManagementSystem(ABC):
+    def __init__(
+        self,
+        account_type: AccountType,
+        market: Dict[str, BaseMarket],
+        market_id: Dict[str, str],
+        registry: OrderRegistry,
+        cache: AsyncCache,
+        api_client: ApiClient,
+        ws_client: WSClient,
+        exchange_id: ExchangeType,
+        clock: LiveClock,
+        msgbus: MessageBus,
+        task_manager: TaskManager,
+        order_query_config: OrderQueryConfig,
+    ):
+        self._log = logging.getLogger(name=type(self).__name__)
+        self._market = market
+        self._market_id = market_id
+        self._registry = registry
+        self._account_type = account_type
+        self._cache = cache
+        self._api_client = api_client
+        self._ws_client = ws_client
+        self._exchange_id = exchange_id
+        self._clock = clock
+        self._msgbus = msgbus
+        self._task_manager = task_manager
+        self._order_query_config = order_query_config
+        self._querying_oids: set[str] = set()
+        self._last_query_ms_by_oid: dict[str, int] = {}
+        self._order_query_started = False
+
+    async def _async_init(self):
+        """Two-phase initialization: call after __init__ in async context."""
+        await self._init_account_balance()
+        await self._init_position()
+        await self._position_mode_check()
+
+    def order_status_update(self, order: Order):
+        if order.oid is None:
+            return
+
+        if not self._registry.is_registered(order.oid):
+            return
+
+        valid = self._cache._order_status_update(order)  # INITIALIZED -> PENDING
+        match order.status:
+            case OrderStatus.PENDING:
+                self._log.debug(f"ORDER STATUS PENDING: {str(order)}")
+                self._msgbus.send(endpoint="pending", msg=order)
+            case OrderStatus.FAILED:
+                self._log.debug(f"ORDER STATUS FAILED: {str(order)}")
+                self._msgbus.send(endpoint="failed", msg=order)
+            case OrderStatus.ACCEPTED:
+                self._log.debug(f"ORDER STATUS ACCEPTED: {str(order)}")
+                self._msgbus.send(endpoint="accepted", msg=order)
+            case OrderStatus.PARTIALLY_FILLED:
+                self._log.debug(f"ORDER STATUS PARTIALLY FILLED: {str(order)}")
+                self._msgbus.send(endpoint="partially_filled", msg=order)
+            case OrderStatus.CANCELED:
+                self._log.debug(f"ORDER STATUS CANCELED: {str(order)}")
+                self._msgbus.send(endpoint="canceled", msg=order)
+            case OrderStatus.CANCELING:
+                self._log.debug(f"ORDER STATUS CANCELING: {str(order)}")
+                self._msgbus.send(endpoint="canceling", msg=order)
+            case OrderStatus.CANCEL_FAILED:
+                self._log.debug(f"ORDER STATUS CANCEL FAILED: {str(order)}")
+                self._msgbus.send(endpoint="cancel_failed", msg=order)
+            case OrderStatus.FILLED:
+                self._log.debug(f"ORDER STATUS FILLED: {str(order)}")
+                self._msgbus.send(endpoint="filled", msg=order)
+            case OrderStatus.EXPIRED:
+                self._log.debug(f"ORDER STATUS EXPIRED: {str(order)}")
+                self._msgbus.send(endpoint="expired", msg=order)
+
+        if valid and order.status == OrderStatus.CANCEL_FAILED:
+            self._schedule_query_order(order, reason="cancel_failed")
+
+        if valid and order.is_closed:
+            self._last_query_ms_by_oid.pop(order.oid, None)
+            self._registry.unregister_order(order.oid)
+            self._registry.unregister_tmp_order(order.oid)
+
+    def start_order_query(self) -> None:
+        if not self._order_query_enabled or self._order_query_started:
+            return
+        if self._order_query_config.check_interval_seconds == -1:
+            return
+        self._order_query_started = True
+        self._task_manager.create_task(
+            self._order_query_scan_loop(),
+            name=f"order_query:{self._exchange_id.value}:{self._account_type.value}",
+        )
+
+    @property
+    def _order_query_enabled(self) -> bool:
+        return self._order_query_config.enabled
+
+    async def _order_query_scan_loop(self) -> None:
+        try:
+            while True:
+                await asyncio.sleep(self._order_query_config.check_interval_seconds)
+                self._scan_timed_out_orders()
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            self._log.error(f"Order query scan loop stopped unexpectedly: {exc}")
+            raise
+
+    def _scan_timed_out_orders(self) -> None:
+        now_ms = self._clock.timestamp_ms()
+        oids = self._cache.get_open_orders(
+            exchange=self._exchange_id,
+            include_canceling=True,
+        )
+        for oid in oids:
+            order = self._cache.get_order(oid).value_or(None)
+            if order is None:
+                continue
+            if order.oid is None or order.timestamp is None:
+                continue
+            if not self._should_query_order(order):
+                continue
+
+            timeout_seconds = self._order_query_config.timeout_seconds.get(order.status)
+            if timeout_seconds is None:
+                continue
+
+            baseline_ms = max(
+                int(order.timestamp),
+                self._last_query_ms_by_oid.get(order.oid, 0),
+            )
+            age_seconds = (now_ms - baseline_ms) / 1000
+            if age_seconds >= timeout_seconds:
+                self._schedule_query_order(order, reason="timeout")
+
+    def _should_query_order(self, order: Order) -> bool:
+        if not self._order_query_enabled:
+            return False
+        if order.exchange != self._exchange_id:
+            return False
+        market = self._market.get(order.symbol)
+        if market is None:
+            return False
+        return self._supports_query_market(market)
+
+    def _supports_query_market(self, market: BaseMarket) -> bool:
+        return True
+
+    def _schedule_query_order(self, order: Order, *, reason: str) -> None:
+        if not self._should_query_order(order):
+            return
+
+        oid = order.oid
+        if oid is None:
+            return
+        if oid in self._querying_oids:
+            return
+
+        self._querying_oids.add(oid)
+        self._last_query_ms_by_oid[oid] = self._clock.timestamp_ms()
+        self._task_manager.create_task(
+            self._query_order_safe(order=order, reason=reason),
+            name=(
+                f"query_order:{self._exchange_id.value}:"
+                f"{self._account_type.value}:{oid}"
+            ),
+        )
+
+    async def _query_order_safe(self, *, order: Order, reason: str) -> None:
+        oid = order.oid
+        if oid is None:
+            return
+
+        try:
+            self._log.debug(
+                f"Querying order status: reason={reason} symbol={order.symbol} oid={oid}"
+            )
+            queried_order = await self.query_order(oid=oid, symbol=order.symbol)
+            if queried_order is None:
+                self._log.warning(
+                    f"Order status query returned no order: reason={reason} "
+                    f"symbol={order.symbol} oid={oid}"
+                )
+                return
+            if queried_order.oid is None:
+                self._log.error(
+                    f"Order status query returned order without oid: "
+                    f"symbol={order.symbol} oid={oid}"
+                )
+                return
+            self.order_status_update(queried_order)
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            self._log.error(
+                f"Order status query failed: reason={reason} "
+                f"symbol={order.symbol} oid={oid}: {exc}"
+            )
+        finally:
+            self._querying_oids.discard(oid)
+
+    def _rate_limit_failed_order(
+        self,
+        *,
+        oid: str,
+        symbol: str,
+        side: OrderSide,
+        type: OrderType,
+        amount: Decimal,
+        price: Decimal | None,
+        time_in_force: TimeInForce | None,
+        reduce_only: bool,
+        exc: Exception,
+    ) -> Order:
+        return Order(
+            oid=oid,
+            exchange=self._exchange_id,
+            timestamp=self._clock.timestamp_ms(),
+            symbol=symbol,
+            type=type,
+            side=side,
+            amount=amount,
+            price=float(price) if price else None,
+            time_in_force=time_in_force,
+            status=OrderStatus.FAILED,
+            filled=Decimal(0),
+            remaining=amount,
+            reduce_only=reduce_only,
+            reason=f"rate_limit (retry_after={getattr(exc, 'retry_after', None)}): {exc}",
+        )
+
+    async def wait_ready(self):
+        """Wait for the WebSocket client(s) to be ready.
+
+        This method waits for the main WebSocket client and optionally
+        for the WebSocket API client if it exists.
+        """
+        await self._ws_client.wait_ready()
+        # Check if subclass has a WebSocket API client
+        ws_api_client = getattr(self, "_ws_api_client", None)
+        if ws_api_client is not None:
+            await ws_api_client.wait_ready()
+
+    def _price_to_precision(
+        self,
+        symbol: str,
+        price: float,
+        mode: Literal["round", "ceil", "floor"] = "round",
+    ) -> Decimal:
+        """
+        Convert the price to the precision of the market
+        """
+        market = self._market[symbol]
+        price_decimal: Decimal = Decimal(str(price))
+
+        decimal = market.precision.price
+
+        if decimal >= 1:
+            exp = Decimal(int(decimal))
+            precision_decimal = Decimal("1")
+        else:
+            exp = Decimal("1")
+            precision_decimal = Decimal(str(decimal))
+
+        if mode == "round":
+            format_price = (price_decimal / exp).quantize(
+                precision_decimal, rounding=ROUND_HALF_UP
+            ) * exp
+        elif mode == "ceil":
+            format_price = (price_decimal / exp).quantize(
+                precision_decimal, rounding=ROUND_CEILING
+            ) * exp
+        elif mode == "floor":
+            format_price = (price_decimal / exp).quantize(
+                precision_decimal, rounding=ROUND_FLOOR
+            ) * exp
+        return format_price
+
+    @abstractmethod
+    async def _init_account_balance(self):
+        """Initialize the account balance"""
+        pass
+
+    @abstractmethod
+    async def _init_position(self):
+        """Initialize the position"""
+        pass
+
+    @abstractmethod
+    async def _position_mode_check(self):
+        """Check the position mode"""
+        pass
+
+    @abstractmethod
+    async def create_tp_sl_order(
+        self,
+        oid: str,
+        symbol: str,
+        side: OrderSide,
+        type: OrderType,
+        amount: Decimal,
+        price: Decimal | None = None,
+        time_in_force: TimeInForce | None = TimeInForce.GTC,
+        tp_order_type: OrderType | None = None,
+        tp_trigger_price: Decimal | None = None,
+        tp_price: Decimal | None = None,
+        tp_trigger_type: TriggerType | None = TriggerType.LAST_PRICE,
+        sl_order_type: OrderType | None = None,
+        sl_trigger_price: Decimal | None = None,
+        sl_price: Decimal | None = None,
+        sl_trigger_type: TriggerType | None = TriggerType.LAST_PRICE,
+        **kwargs,
+    ) -> Order:
+        """Create a take profit and stop loss order"""
+        pass
+
+    @abstractmethod
+    async def create_order(
+        self,
+        oid: str,
+        symbol: str,
+        side: OrderSide,
+        type: OrderType,
+        amount: Decimal,
+        price: Optional[Decimal],
+        time_in_force: Optional[TimeInForce],
+        reduce_only: bool,
+        **kwargs,
+    ) -> Order:
+        """Create an order"""
+        pass
+
+    @abstractmethod
+    async def create_order_ws(
+        self,
+        oid: str,
+        symbol: str,
+        side: OrderSide,
+        type: OrderType,
+        amount: Decimal,
+        price: Optional[Decimal],
+        time_in_force: Optional[TimeInForce],
+        reduce_only: bool,
+        **kwargs,
+    ):
+        pass
+
+    @abstractmethod
+    async def create_batch_orders(
+        self,
+        orders: List[BatchOrderSubmit],
+    ) -> List[Order]:
+        """Create a batch of orders"""
+        pass
+
+    @abstractmethod
+    async def cancel_order(self, oid: str, symbol: str, **kwargs) -> Order:
+        """Cancel an order"""
+        pass
+
+    @abstractmethod
+    async def cancel_order_ws(self, oid: str, symbol: str, **kwargs):
+        """Cancel an order"""
+        pass
+
+    @abstractmethod
+    async def query_order(self, oid: str, symbol: str) -> Order | None:
+        """Query an order by the local/client order id."""
+        pass
+
+    @abstractmethod
+    async def modify_order(
+        self,
+        oid: str,
+        symbol: str,
+        side: OrderSide | None = None,
+        price: Decimal | None = None,
+        amount: Decimal | None = None,
+        **kwargs,
+    ) -> Order:
+        """Modify an order"""
+        pass
+
+    @abstractmethod
+    async def cancel_batch_orders(self, orders: List[CancelOrderSubmit]) -> None:
+        """Cancel multiple orders in a single batch request"""
+        pass
+
+    @abstractmethod
+    async def cancel_all_orders(self, symbol: str) -> bool:
+        """Cancel all orders"""
+        pass