walrasquant-lib 0.4.20__py3-none-any.whl

walrasquant/strategy.py

@@ -0,0 +1,1805 @@
+import asyncio
+import inspect
+import os
+import signal
+import copy
+from datetime import datetime, timedelta
+from typing import Dict, List, Callable, Literal, Optional, Any
+from decimal import Decimal
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+import nexuslog as logging
+from walrasquant.base import ExchangeManager
+from walrasquant.indicator import IndicatorManager, Indicator, IndicatorProxy
+from walrasquant.core.clock import precise_sleep
+from walrasquant.core.entity import TaskManager
+from walrasquant.core.cache import AsyncCache
+from walrasquant.error import StrategyBuildError
+from walrasquant.base import (
+    ExecutionManagementSystem,
+    PrivateConnector,
+    PublicConnector,
+    SubscriptionManagementSystem,
+)
+from walrasquant.core.entity import OidGen
+from walrasquant.core.nautilius_core import MessageBus, LiveClock
+from walrasquant.schema import (
+    BookL1,
+    Trade,
+    Kline,
+    BookL2,
+    Order,
+    FundingRate,
+    Ticker,
+    IndexPrice,
+    MarkPrice,
+    InstrumentId,
+    BaseMarket,
+    AccountBalance,
+    CreateOrderSubmit,
+    TakeProfitAndStopLossOrderSubmit,
+    # TWAPOrderSubmit,
+    ModifyOrderSubmit,
+    CancelOrderSubmit,
+    CancelAllOrderSubmit,
+    # CancelTWAPOrderSubmit,
+    KlineList,
+    BatchOrder,
+    BatchOrderSubmit,
+    CancelBatchOrder,
+)
+from walrasquant.constants import (
+    DataType,
+    BookLevel,
+    OrderSide,
+    OrderType,
+    TimeInForce,
+    ParamBackend,
+    # PositionSide,
+    AccountType,
+    SubmitType,
+    ExchangeType,
+    KlineInterval,
+    TriggerType,
+    BACKEND_LITERAL,
+)
+from walrasquant.core.connection import ConnectionPolicyState
+from walrasquant.push import FlashDutyPushService, EventStatus
+from walrasquant.execution import (
+    ExecAlgorithm,
+    ExecAlgorithmCommand,
+    ExecAlgorithmCommandType,
+    ExecAlgorithmOrder,
+    ExecAlgorithmOrderParams,
+)
+
+
+class Strategy:
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        async_methods = [
+            name
+            for name, method in cls.__dict__.items()
+            if inspect.iscoroutinefunction(method)
+        ]
+        if async_methods:
+            raise TypeError(
+                f"{cls.__name__} defines async methods which are not allowed in Strategy: "
+                + ", ".join(async_methods)
+            )
+
+    def __init__(self):
+        # Track which symbols use aggregator: {(interval, symbol): use_aggregator}
+        self._kline_use_aggregator: list = []
+
+        self._initialized = False
+        self._started = False
+        self._scheduler = AsyncIOScheduler()
+        # On-loop fast timers (schedule(..., fast=True)), tracked for cancellation
+        # at dispose. Each entry is the per-timer state dict from _schedule_fast.
+        self._fast_timers: list[dict] = []
+        self.indicator = IndicatorProxy()
+        self._connection_status: ConnectionPolicyState | None = None
+
+    def register(
+        self,
+        exchanges: Dict[ExchangeType, ExchangeManager],
+        public_connectors: Dict[AccountType, PublicConnector],
+        private_connectors: Dict[AccountType, PrivateConnector],
+        cache: AsyncCache,
+        msgbus: MessageBus,
+        clock: LiveClock,
+        oidgen: OidGen,
+        task_manager: TaskManager,
+        sms: SubscriptionManagementSystem,
+        ems: Dict[ExchangeType, ExecutionManagementSystem],
+        push_service: FlashDutyPushService,
+        exec_algorithms: Dict[str, ExecAlgorithm] | None = None,
+        strategy_id: str | None = None,
+        user_id: str | None = None,
+    ) -> None:
+        if self._initialized:
+            return
+
+        self.log = logging.getLogger(name=type(self).__name__)
+        self._sys_log = logging.getLogger(name=Strategy.__name__)
+
+        self.cache = cache
+        self.clock = clock
+        self._oidgen = oidgen
+        self._ems = ems
+        self._sms = sms
+        self._task_manager = task_manager
+        self._msgbus = msgbus
+        self._private_connectors = private_connectors
+        self._public_connectors = public_connectors
+        self._exchanges = exchanges
+        self._indicator_manager = IndicatorManager(self._msgbus)
+        self._push_service = push_service
+        self._exec_algorithms = exec_algorithms if exec_algorithms is not None else {}
+
+        self._msgbus.register(endpoint="pending", handler=self.on_pending_order)
+        self._msgbus.register(endpoint="accepted", handler=self.on_accepted_order)
+        self._msgbus.register(
+            endpoint="partially_filled", handler=self.on_partially_filled_order
+        )
+        self._msgbus.register(endpoint="filled", handler=self.on_filled_order)
+        self._msgbus.register(endpoint="canceling", handler=self.on_canceling_order)
+        self._msgbus.register(endpoint="canceled", handler=self.on_canceled_order)
+        self._msgbus.register(endpoint="failed", handler=self.on_failed_order)
+        self._msgbus.register(
+            endpoint="cancel_failed", handler=self.on_cancel_failed_order
+        )
+        self._msgbus.register(endpoint="expired", handler=self.on_expired_order)
+
+        self._msgbus.register(endpoint="balance", handler=self.on_balance)
+        self._msgbus.register(
+            endpoint="connection_status", handler=self._handle_connection_status
+        )
+
+        self._initialized = True
+
+    @property
+    def ready(self):
+        return self._sms.ready
+
+    def send_alert(
+        self,
+        event_status: EventStatus,
+        title_rule: str,
+        alert_key: Optional[str] = None,
+        description: Optional[str] = None,
+        labels: Optional[dict[str, str]] = None,
+        images: Optional[list[dict[str, str]]] = None,
+    ) -> None:
+        self._push_service.send_alert(
+            event_status=event_status,
+            title_rule=title_rule,
+            alert_key=alert_key,
+            description=description,
+            labels=labels,
+            images=images,
+        )
+
+    def alert_ok(
+        self,
+        title_rule: str,
+        alert_key: Optional[str] = None,
+        description: Optional[str] = None,
+        labels: Optional[dict[str, str]] = None,
+        images: Optional[list[dict[str, str]]] = None,
+    ) -> None:
+        self.send_alert(
+            event_status="Ok",
+            title_rule=title_rule,
+            alert_key=alert_key,
+            description=description,
+            labels=labels,
+            images=images,
+        )
+
+    def alert_info(
+        self,
+        title_rule: str,
+        alert_key: Optional[str] = None,
+        description: Optional[str] = None,
+        labels: Optional[dict[str, str]] = None,
+        images: Optional[list[dict[str, str]]] = None,
+    ) -> None:
+        self.send_alert(
+            event_status="Info",
+            title_rule=title_rule,
+            alert_key=alert_key,
+            description=description,
+            labels=labels,
+            images=images,
+        )
+
+    def alert_warning(
+        self,
+        title_rule: str,
+        alert_key: Optional[str] = None,
+        description: Optional[str] = None,
+        labels: Optional[dict[str, str]] = None,
+        images: Optional[list[dict[str, str]]] = None,
+    ) -> None:
+        self.send_alert(
+            event_status="Warning",
+            title_rule=title_rule,
+            alert_key=alert_key,
+            description=description,
+            labels=labels,
+            images=images,
+        )
+
+    def alert_critical(
+        self,
+        title_rule: str,
+        alert_key: Optional[str] = None,
+        description: Optional[str] = None,
+        labels: Optional[dict[str, str]] = None,
+        images: Optional[list[dict[str, str]]] = None,
+    ) -> None:
+        self.send_alert(
+            event_status="Critical",
+            title_rule=title_rule,
+            alert_key=alert_key,
+            description=description,
+            labels=labels,
+            images=images,
+        )
+
+    @property
+    def connection_status(self) -> ConnectionPolicyState | None:
+        return self._connection_status
+
+    @property
+    def can_open(self) -> bool:
+        if self._connection_status is None:
+            return False
+        # allow_open == md_ok and td_ok
+        return self._connection_status.allow_open
+
+    @property
+    def can_trade(self) -> bool:
+        if self._connection_status is None:
+            return False
+        # allow_trade == td_ok
+        return self._connection_status.allow_trade
+
+    @property
+    def close_only(self) -> bool:
+        if self._connection_status is None:
+            return False
+        return self._connection_status.allow_close_only
+
+    def _handle_connection_status(self, status: ConnectionPolicyState) -> None:
+        """Internal handler for connection policy updates from the engine."""
+        self.on_connection_status(status)
+        self._connection_status = status
+
+    def on_connection_status(self, status: ConnectionPolicyState) -> None:
+        """Optional user hook for connection policy updates."""
+        pass
+
+    def tick_sz(self, symbol: str) -> float:
+        return self.market(symbol).precision.price
+
+    def lot_sz(self, symbol: str) -> float:
+        return self.market(symbol).precision.amount
+
+    def api(self, account_type: AccountType):
+        return self._private_connectors[account_type].api
+
+    def api_fire(self, account_type: AccountType):
+        """Fire-and-forget REST API call: non-blocking, no return value."""
+        return self._private_connectors[account_type].api_fire
+
+    def register_indicator(
+        self,
+        symbols: str | List[str],
+        indicator: Indicator,
+        data_type: DataType,
+        account_type: AccountType | None = None,
+    ):
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `register_indicator` in `on_start` method"
+            )
+
+        if isinstance(symbols, str):
+            symbols = [symbols]
+
+        # Create separate indicator instances for each symbol to avoid shared state
+        for symbol in symbols:
+            # Create a deep copy of the indicator for each symbol
+            symbol_indicator = copy.deepcopy(indicator)
+
+            # Register the symbol-specific indicator with the proxy
+            self.indicator.register_indicator(indicator.name, symbol, symbol_indicator)
+
+            match data_type:
+                case DataType.BOOKL1:
+                    self._indicator_manager.add_bookl1_indicator(
+                        symbol, symbol_indicator
+                    )
+                case DataType.BOOKL2:
+                    self._indicator_manager.add_bookl2_indicator(
+                        symbol, symbol_indicator
+                    )
+                case DataType.KLINE:
+                    self._indicator_manager.add_kline_indicator(
+                        symbol, symbol_indicator
+                    )
+                case DataType.TRADE:
+                    self._indicator_manager.add_trade_indicator(
+                        symbol, symbol_indicator
+                    )
+                case DataType.INDEX_PRICE:
+                    self._indicator_manager.add_index_price_indicator(
+                        symbol, symbol_indicator
+                    )
+                case DataType.FUNDING_RATE:
+                    self._indicator_manager.add_funding_rate_indicator(
+                        symbol, symbol_indicator
+                    )
+                case DataType.MARK_PRICE:
+                    self._indicator_manager.add_mark_price_indicator(
+                        symbol, symbol_indicator
+                    )
+                case _:
+                    raise ValueError(f"Invalid data type: {data_type}")
+
+            if symbol_indicator.requires_warmup:
+                warmup_account_type = account_type or self._infer_account_type(symbol)
+                self._perform_indicator_warmup(
+                    symbol, symbol_indicator, warmup_account_type
+                )
+
+    def _infer_account_type(self, symbol: str) -> AccountType:
+        """
+        Infer the account type based on the symbol's exchange and type.
+        This is useful for methods that require an account type but don't have it explicitly provided.
+        """
+        instrument_id = InstrumentId.from_str(symbol)
+        exchange = self._exchanges.get(instrument_id.exchange)
+        if not exchange:
+            raise ValueError(
+                f"Exchange {instrument_id.exchange} not found, please add it to the config"
+            )
+        return exchange.instrument_id_to_account_type(instrument_id)
+
+    def request_ticker(
+        self,
+        symbol: str,
+        account_type: AccountType | None = None,
+    ) -> Ticker:
+        account_type = account_type or self._infer_account_type(symbol)
+        connector = self._public_connectors.get(account_type)
+        if not connector:
+            raise ValueError(
+                f"Account type {account_type} not found in public connectors"
+            )
+        return self._task_manager.run_sync(connector.request_ticker(symbol))
+
+    def request_all_tickers(
+        self,
+        account_type: AccountType,
+    ) -> Dict[str, Ticker]:
+        connector = self._public_connectors.get(account_type)
+        if not connector:
+            raise ValueError(
+                f"Account type {account_type} not found in public connectors"
+            )
+        return self._task_manager.run_sync(connector.request_all_tickers())
+
+    def request_klines(
+        self,
+        symbol: str | List[str],
+        interval: KlineInterval,
+        limit: int | None = None,
+        start_time: int | datetime | None = None,
+        end_time: int | datetime | None = None,
+        account_type: AccountType | None = None,
+    ) -> KlineList:
+        if isinstance(start_time, datetime):
+            start_time = int(start_time.timestamp() * 1000)
+        if isinstance(end_time, datetime):
+            end_time = int(end_time.timestamp() * 1000)
+
+        if isinstance(symbol, str):
+            symbol = [symbol]
+        inferred_symbol = symbol[0]
+        account_type = account_type or self._infer_account_type(inferred_symbol)
+        connector = self._public_connectors.get(account_type)
+        if not connector:
+            raise ValueError(
+                f"Account type {account_type} not found in public connectors"
+            )
+
+        klines = KlineList([])
+        for sym in symbol:
+            res = self._task_manager.run_sync(
+                connector.request_klines(
+                    symbol=sym,
+                    interval=interval,
+                    limit=limit,
+                    start_time=start_time,
+                    end_time=end_time,
+                )
+            )
+            klines.extend(res)
+        return klines
+
+    def request_index_klines(
+        self,
+        symbol: str | List[str],
+        interval: KlineInterval,
+        limit: int | None = None,
+        start_time: int | datetime | None = None,
+        end_time: int | datetime | None = None,
+        account_type: AccountType | None = None,
+    ) -> KlineList:
+        if isinstance(start_time, datetime):
+            start_time = int(start_time.timestamp() * 1000)
+        if isinstance(end_time, datetime):
+            end_time = int(end_time.timestamp() * 1000)
+        if isinstance(symbol, str):
+            symbol = [symbol]
+        inferred_symbol = symbol[0]
+        account_type = account_type or self._infer_account_type(inferred_symbol)
+        connector = self._public_connectors.get(account_type)
+        if not connector:
+            raise ValueError(
+                f"Account type {account_type} not found in public connectors"
+            )
+
+        klines = KlineList([])
+        for sym in symbol:
+            res = self._task_manager.run_sync(
+                connector.request_index_klines(
+                    symbol=sym,
+                    interval=interval,
+                    limit=limit,
+                    start_time=start_time,
+                    end_time=end_time,
+                )
+            )
+            klines.extend(res)
+        return klines
+
+    def _perform_indicator_warmup(
+        self, symbol: str, indicator: Indicator, account_type: AccountType
+    ):
+        """Automatically fetch historical data to warm up an indicator."""
+        try:
+            # Calculate how much historical data we need
+            if indicator.warmup_period is None:
+                raise ValueError("indicator.warmup_period is required for warmup")
+            if indicator.kline_interval is None:
+                raise ValueError("indicator.kline_interval is required for warmup")
+            warmup_limit = indicator.warmup_period
+            if not indicator.warmup_include_unclosed:
+                warmup_limit += 1
+            warmup_milliseconds = warmup_limit * indicator.kline_interval.milliseconds
+            start_time_ms = self.clock.timestamp_ms() - warmup_milliseconds
+
+            # Fetch historical klines
+            historical_klines = self.request_klines(
+                symbol=symbol,
+                account_type=account_type,
+                interval=indicator.kline_interval,
+                limit=warmup_limit,
+                start_time=start_time_ms,
+            )
+
+            # Process historical data for warmup (oldest first)
+            for kline in historical_klines.values:
+                if kline.symbol == symbol and (
+                    kline.confirm or indicator.warmup_include_unclosed
+                ):
+                    indicator._process_warmup_kline(kline)
+
+            self._sys_log.debug(
+                f"Warmed up indicator {indicator.name} for {symbol} with {len(historical_klines)} klines"
+            )
+
+        except Exception as e:
+            self._sys_log.error(
+                f"Failed to warm up indicator {indicator.name} for {symbol}: {e}"
+            )
+
+    def get_warmup_status(self) -> dict[Any, list[dict[str, Any]]]:
+        """Get the warmup status of all indicators by symbol."""
+        status: dict[Any, list[dict[str, Any]]] = {}
+        requirements = self._indicator_manager.get_warmup_requirements()
+
+        for symbol, indicator_list in requirements.items():
+            status[symbol] = []
+            for indicator, period, interval in indicator_list:
+                status[symbol].append(
+                    {
+                        "name": indicator.name,
+                        "warmup_period": period,
+                        "warmup_interval": interval.value,
+                        "is_warmed_up": indicator.is_warmed_up,
+                        "data_count": indicator._warmup_data_count,
+                    }
+                )
+
+        return status
+
+    def wait_for_warmup(self, timeout_seconds: int = 60) -> bool:
+        """Wait for all indicators to complete warmup. Returns True if all warmed up."""
+        start_time = self.clock.timestamp()
+        while self.clock.timestamp() - start_time < timeout_seconds:
+            if not self._indicator_manager.has_warmup_pending():
+                return True
+
+        return False
+
+    # Interval-unit -> seconds, used by the fast=True fast-path.
+    _INTERVAL_UNITS_S = {
+        "weeks": 604800,
+        "days": 86400,
+        "hours": 3600,
+        "minutes": 60,
+        "seconds": 1,
+    }
+
+    def schedule(
+        self,
+        func: Callable[..., Any],
+        trigger: Literal["interval", "cron", "date"] = "interval",
+        fast: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        """
+        There are three modes:
+
+        - **cron**: run at a specific time second, minute, hour, day, month, year
+        - **interval**: run at a specific interval  seconds, minutes, hours, days, weeks, months, years
+        - **date**: run at a specific date and time, `run_date` must be provided
+
+        kwargs:
+            next_run_time: datetime, when to run the first time
+            seconds/minutes/hours/days/weeks: int, interval between runs
+            year/month/day/hour/minute/second: int, specific time to run
+            args: list, arguments to pass to the function
+            kwargs: dict, keyword arguments to pass to the function
+
+        fast:
+            Opt into the on-loop, low-overhead fast-path (interval trigger only),
+            backed by ``loop.call_at`` instead of APScheduler. Intended for
+            high-frequency (sub-second) jobs, e.g. ``seconds=0.1``. The job runs
+            directly ON the event loop, so it MUST be non-blocking: blocking
+            ``run_sync``-based facades (``request_klines``/``request_ticker``/...)
+            will raise instead of deadlocking — read cached data (``self.cache...``)
+            or submit orders (``create_order_ws``) instead. Cadence is fixed-rate
+            (drift-free); async jobs skip a tick if the previous run is still in
+            flight. See ``_schedule_fast``.
+        """
+        if not self._initialized:
+            raise RuntimeError(
+                "Strategy not initialized, please use `schedule` in `on_start` method"
+            )
+        if fast:
+            self._schedule_fast(func, trigger, kwargs)
+            return
+        if not inspect.iscoroutinefunction(func):
+            _args = kwargs.pop("args", ())
+            _kwargs = kwargs.pop("kwargs", {})
+
+            # Run the sync job in a thread pool (Path B). This keeps blocking
+            # facades like request_klines (built on run_sync ->
+            # run_coroutine_threadsafe().result()) working: they block the worker
+            # thread while the loop runs the coroutine. Running the job directly on
+            # the loop would deadlock such calls. Order/subscription submits from
+            # this thread are safe because EMS/SMS._safe_put marshals the queue put
+            # back onto the loop via call_soon_threadsafe.
+            async def _wrapper():
+                loop = asyncio.get_event_loop()
+                try:
+                    await loop.run_in_executor(None, lambda: func(*_args, **_kwargs))
+                except asyncio.CancelledError:
+                    pass
+
+            _wrapper.__name__ = getattr(func, "__name__", type(func).__name__)
+            self._scheduler.add_job(_wrapper, trigger=trigger, **kwargs)
+        else:
+            self._scheduler.add_job(func, trigger=trigger, **kwargs)
+
+    def _schedule_fast(
+        self, func: Callable[..., Any], trigger: str, kwargs: dict[str, Any]
+    ) -> None:
+        """On-loop fast-path for schedule(..., fast=True). See schedule() docstring."""
+        if trigger != "interval":
+            raise ValueError("fast=True only supports trigger='interval'")
+        args = kwargs.pop("args", ())
+        fkwargs = kwargs.pop("kwargs", {})
+        interval_s = 0.0
+        for unit, mult in self._INTERVAL_UNITS_S.items():
+            if unit in kwargs:
+                interval_s += float(kwargs.pop(unit)) * mult
+        if kwargs:
+            raise ValueError(f"fast=True does not support kwargs: {list(kwargs)}")
+        if interval_s <= 0:
+            raise ValueError("fast=True requires a positive interval, e.g. seconds=0.1")
+
+        is_coro = inspect.iscoroutinefunction(func)
+        name = getattr(func, "__name__", type(func).__name__)
+        loop = self._task_manager.loop
+        state = {"handle": None, "running": False, "cancelled": False, "next": 0.0}
+
+        async def _run_coro():
+            try:
+                await func(*args, **fkwargs)
+            except Exception as e:
+                self.log.error(f"[fast timer:{name}] error: {e!r}")
+            finally:
+                state["running"] = False
+
+        def _tick():
+            if state["cancelled"]:
+                return
+            # Fixed-rate: aim for absolute target times so cadence doesn't drift.
+            # If we've fallen behind, realign to now+interval (skip missed ticks)
+            # rather than firing a burst of catch-up ticks.
+            state["next"] += interval_s
+            now = loop.time()
+            if state["next"] <= now:
+                state["next"] = now + interval_s
+            state["handle"] = loop.call_at(state["next"], _tick)
+
+            if is_coro:
+                if state["running"]:
+                    self.log.warning(
+                        f"[fast timer:{name}] previous run still in flight, skipping tick"
+                    )
+                    return
+                state["running"] = True
+                self._task_manager.create_task(_run_coro())
+            else:
+                try:
+                    func(*args, **fkwargs)  # ON the loop; must be non-blocking
+                except Exception as e:
+                    self.log.error(f"[fast timer:{name}] error: {e!r}")
+
+        def _arm():
+            state["next"] = loop.time() + interval_s
+            state["handle"] = loop.call_at(state["next"], _tick)
+            self._fast_timers.append(state)
+
+        # schedule() runs in the on_start executor thread; loop.call_at is not
+        # thread-safe, so marshal the initial arm onto the loop. call_soon_threadsafe
+        # is also safe when already on the loop, so no thread check is needed.
+        loop.call_soon_threadsafe(_arm)
+
+    def _cancel_fast_timers(self) -> None:
+        """Stop and clear all fast timers. Runs on the loop thread (engine dispose)."""
+        for state in self._fast_timers:
+            state["cancelled"] = True
+            handle = state.get("handle")
+            if handle is not None:
+                handle.cancel()
+        self._fast_timers.clear()
+
+    def market(self, symbol: str) -> BaseMarket:
+        instrument_id = InstrumentId.from_str(symbol)
+        exchange = self._exchanges[instrument_id.exchange]
+        return exchange.market[instrument_id.symbol]
+
+    def min_order_amount(self, symbol: str, px: float | None = None) -> Decimal:
+        instrument_id = InstrumentId.from_str(symbol)
+        ems = self._ems[instrument_id.exchange]
+        book = self.cache.bookl1(symbol)
+        px = px or (book.mid if book is not None else None)
+        if px is None:
+            raise ValueError(
+                "px must be provided for if you call `min_order_amount` or just set `px`"
+            )
+        return ems._get_min_order_amount(instrument_id.symbol, self.market(symbol), px)
+
+    def max_order_amount(
+        self, symbol: str, is_market: bool = False, px: float | None = None
+    ) -> Decimal:
+        instrument_id = InstrumentId.from_str(symbol)
+        ems = self._ems[instrument_id.exchange]
+        book = self.cache.bookl1(symbol)
+        px = px or (book.mid if book is not None else None)
+        if px is None:
+            raise ValueError(
+                "px must be provided for if you call `max_order_amount` or just set `px`"
+            )
+        return ems._get_max_order_amount(
+            instrument_id.symbol, self.market(symbol), is_market, px
+        )
+
+    def amount_to_precision(
+        self,
+        symbol: str,
+        amount: float,
+        mode: Literal["round", "ceil", "floor"] = "round",
+    ) -> Decimal:
+        instrument_id = InstrumentId.from_str(symbol)
+        ems = self._ems[instrument_id.exchange]
+        return ems._amount_to_precision(instrument_id.symbol, amount, mode)
+
+    def price_to_precision(
+        self,
+        symbol: str,
+        price: float,
+        mode: Literal["round", "ceil", "floor"] = "round",
+    ) -> Decimal:
+        instrument_id = InstrumentId.from_str(symbol)
+        ems = self._ems[instrument_id.exchange]
+        return ems._price_to_precision(instrument_id.symbol, price, mode)
+
+    def create_batch_orders(
+        self,
+        orders: List[BatchOrder],
+        account_type: AccountType | None = None,
+    ):
+        """
+        Create a batch of orders.
+
+        Args:
+            orders (List[BatchOrder]): A list of BatchOrder objects to be submitted.
+            account_type (AccountType | None): The account type for the orders. If None, it will auto selected the account_type, but for performance issue, recommend to set.
+        """
+        batch_orders: list[BatchOrderSubmit] = []
+        for order in orders:
+            batch_order = BatchOrderSubmit(
+                symbol=order.symbol,
+                instrument_id=InstrumentId.from_str(order.symbol),
+                side=order.side,
+                type=order.type,
+                oid=self._oidgen.oid,
+                amount=order.amount,
+                price=order.price,
+                time_in_force=order.time_in_force or TimeInForce.GTC,
+                reduce_only=order.reduce_only,
+                kwargs=order.kwargs,
+            )
+            batch_orders.append(batch_order)
+            self._sys_log.info(
+                f"[new batch order] symbol={order.symbol}, oid={batch_order.oid}, side={order.side}, type={order.type}, amount={order.amount}, price={order.price}, time_in_force={order.time_in_force}, reduce_only={order.reduce_only}"
+            )
+        self._ems[batch_orders[0].instrument_id.exchange]._submit_order(
+            batch_orders, SubmitType.BATCH, account_type
+        )
+        return [order.oid for order in batch_orders]
+
+    def create_tp_sl_order(
+        self,
+        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 = TriggerType.LAST_PRICE,
+        sl_order_type: OrderType | None = None,
+        sl_trigger_price: Decimal | None = None,
+        sl_price: Decimal | None = None,
+        sl_trigger_type: TriggerType = TriggerType.LAST_PRICE,
+        account_type: AccountType | None = None,
+        **kwargs,
+    ) -> str:
+        if tp_order_type is None and tp_trigger_price is not None:
+            raise ValueError("tp_order_type is required when tp_trigger_price is set")
+        if sl_order_type is None and sl_trigger_price is not None:
+            raise ValueError("sl_order_type is required when sl_trigger_price is set")
+        order = TakeProfitAndStopLossOrderSubmit(
+            symbol=symbol,
+            instrument_id=InstrumentId.from_str(symbol),
+            side=side,
+            type=type,
+            oid=self._oidgen.oid,
+            amount=amount,
+            price=price,
+            time_in_force=time_in_force,
+            tp_order_type=tp_order_type or OrderType.TAKE_PROFIT_MARKET,
+            tp_trigger_price=tp_trigger_price,
+            tp_price=tp_price,
+            tp_trigger_type=tp_trigger_type,
+            sl_order_type=sl_order_type or OrderType.STOP_LOSS_MARKET,
+            sl_trigger_price=sl_trigger_price,
+            sl_price=sl_price,
+            sl_trigger_type=sl_trigger_type,
+            kwargs=kwargs,
+        )
+        self._ems[order.instrument_id.exchange]._submit_order(
+            order, SubmitType.TAKE_PROFIT_AND_STOP_LOSS, account_type
+        )
+        return order.oid
+
+    def create_order(
+        self,
+        symbol: str,
+        side: OrderSide,
+        type: OrderType,
+        amount: Decimal,
+        price: Decimal | None = None,
+        time_in_force: TimeInForce | None = TimeInForce.GTC,
+        reduce_only: bool = False,
+        account_type: AccountType | None = None,
+        **kwargs,
+    ) -> str:
+        order = CreateOrderSubmit(
+            symbol=symbol,
+            oid=self._oidgen.oid,
+            instrument_id=InstrumentId.from_str(symbol),
+            side=side,
+            type=type,
+            amount=amount,
+            price=price,
+            time_in_force=time_in_force,
+            reduce_only=reduce_only,
+            # position_side=position_side,
+            kwargs=kwargs,
+        )
+        self._ems[order.instrument_id.exchange]._submit_order(
+            order, SubmitType.CREATE, account_type
+        )
+        self._sys_log.info(
+            f"[new order] symbol={symbol}, oid={order.oid}, side={side}, type={type}, amount={amount}, price={price}, time_in_force={time_in_force}, reduce_only={reduce_only}"
+        )
+        return order.oid
+
+    def create_order_ws(
+        self,
+        symbol: str,
+        side: OrderSide,
+        type: OrderType,
+        amount: Decimal,
+        price: Decimal | None = None,
+        time_in_force: TimeInForce | None = TimeInForce.GTC,
+        reduce_only: bool = False,
+        account_type: AccountType | None = None,
+        **kwargs,
+    ) -> str:
+        order = CreateOrderSubmit(
+            symbol=symbol,
+            oid=self._oidgen.oid,
+            instrument_id=InstrumentId.from_str(symbol),
+            side=side,
+            type=type,
+            amount=amount,
+            price=price,
+            time_in_force=time_in_force,
+            reduce_only=reduce_only,
+            # position_side=position_side,
+            kwargs=kwargs,
+        )
+        self._ems[order.instrument_id.exchange]._submit_order(
+            order, SubmitType.CREATE_WS, account_type
+        )
+        self._sys_log.info(
+            f"[new order ws] symbol={symbol}, oid={order.oid}, side={side}, type={type}, amount={amount}, price={price}, time_in_force={time_in_force}, reduce_only={reduce_only}"
+        )
+        return order.oid
+
+    def cancel_order(
+        self, symbol: str, oid: str, account_type: AccountType | None = None, **kwargs
+    ) -> str:
+        self.cache.mark_cancel_intent(oid)
+        order = CancelOrderSubmit(
+            symbol=symbol,
+            instrument_id=InstrumentId.from_str(symbol),
+            oid=oid,
+            kwargs=kwargs,
+        )
+        self._ems[order.instrument_id.exchange]._submit_order(
+            order, SubmitType.CANCEL, account_type
+        )
+        self._sys_log.info(f"[cancel order] symbol={symbol}, oid={oid}")
+        return order.oid
+
+    def cancel_batch_orders(
+        self,
+        orders: List[CancelBatchOrder],
+        account_type: AccountType | None = None,
+    ) -> List[str]:
+        cancel_submits = [
+            CancelOrderSubmit(
+                symbol=order.symbol,
+                instrument_id=InstrumentId.from_str(order.symbol),
+                oid=order.oid,
+                kwargs=order.kwargs,
+            )
+            for order in orders
+        ]
+        if not cancel_submits:
+            return []
+        for submit in cancel_submits:
+            self.cache.mark_cancel_intent(submit.oid)
+            self._sys_log.info(
+                f"[cancel batch order] symbol={submit.symbol}, oid={submit.oid}"
+            )
+        self._ems[cancel_submits[0].instrument_id.exchange]._submit_order(
+            cancel_submits, SubmitType.CANCEL_BATCH, account_type
+        )
+        return [s.oid for s in cancel_submits]
+
+    def cancel_order_ws(
+        self, symbol: str, oid: str, account_type: AccountType | None = None, **kwargs
+    ) -> str:
+        self.cache.mark_cancel_intent(oid)
+        order = CancelOrderSubmit(
+            symbol=symbol,
+            instrument_id=InstrumentId.from_str(symbol),
+            oid=oid,
+            kwargs=kwargs,
+        )
+        self._ems[order.instrument_id.exchange]._submit_order(
+            order, SubmitType.CANCEL_WS, account_type
+        )
+        self._sys_log.info(f"[cancel order ws] symbol={symbol}, oid={oid}")
+        return order.oid
+
+    def cancel_all_orders(
+        self, symbol: str, account_type: AccountType | None = None
+    ) -> str:
+        self.cache.mark_all_cancel_intent(symbol)
+        order = CancelAllOrderSubmit(
+            symbol=symbol,
+            instrument_id=InstrumentId.from_str(symbol),
+        )
+        self._ems[order.instrument_id.exchange]._submit_order(
+            order, SubmitType.CANCEL_ALL, account_type
+        )
+        self._sys_log.info(f"[cancel all orders] symbol={symbol}")
+        return symbol
+
+    def modify_order(
+        self,
+        symbol: str,
+        oid: str,
+        side: OrderSide | None = None,
+        price: Decimal | None = None,
+        amount: Decimal | None = None,
+        account_type: AccountType | None = None,
+        **kwargs,
+    ) -> str:
+        if side is None or price is None or amount is None:
+            raise ValueError("side, price, and amount are required to modify an order")
+        order = ModifyOrderSubmit(
+            symbol=symbol,
+            instrument_id=InstrumentId.from_str(symbol),
+            oid=oid,
+            side=side,
+            price=price,
+            amount=amount,
+            kwargs=kwargs,
+        )
+        self._ems[order.instrument_id.exchange]._submit_order(
+            order, SubmitType.MODIFY, account_type
+        )
+        self._sys_log.info(
+            f"[modify order] symbol={symbol}, oid={oid}, side={side}, price={price}, amount={amount}"
+        )
+        return order.oid
+
+    def create_algo_order(
+        self,
+        symbol: str,
+        side: OrderSide,
+        amount: Decimal,
+        exec_algorithm_id: str,
+        exec_params: Dict[str, Any],
+        reduce_only: bool = False,
+        account_type: AccountType | None = None,
+    ) -> str:
+        """
+        Create an order to be executed by an execution algorithm.
+
+        Parameters
+        ----------
+        symbol : str
+            The trading symbol.
+        side : OrderSide
+            The order side (BUY/SELL).
+        amount : Decimal
+            The total order amount.
+        exec_algorithm_id : str
+            The execution algorithm ID (e.g., "TWAP").
+        exec_params : Dict[str, Any]
+            Parameters for the execution algorithm.
+        reduce_only : bool
+            If True, only reduce position.
+        account_type : AccountType | None
+            The account type.
+
+        Returns
+        -------
+        str
+            The primary order ID.
+
+        Example
+        -------
+        >>> oid = self.create_algo_order(
+        ...     symbol="BTCUSDT-PERP.BINANCE",
+        ...     side=OrderSide.BUY,
+        ...     amount=Decimal("1.0"),
+        ...     exec_algorithm_id="TWAP",
+        ...     exec_params={
+        ...         "horizon_secs": 300,  # 5 minutes
+        ...         "interval_secs": 30,  # every 30 seconds
+        ...     },
+        ... )
+        """
+        if exec_algorithm_id not in self._exec_algorithms:
+            raise ValueError(
+                f"Execution algorithm '{exec_algorithm_id}' not registered"
+            )
+
+        oid = self._oidgen.oid
+        instrument_id = InstrumentId.from_str(symbol)
+
+        if not account_type:
+            account_type = self._ems[
+                instrument_id.exchange
+            ]._instrument_id_to_account_type(instrument_id)
+
+        # Create command to send to ExecAlgorithm
+        command = ExecAlgorithmCommand(
+            command_type=ExecAlgorithmCommandType.EXECUTE,
+            exec_algorithm_id=exec_algorithm_id,
+            order_params=ExecAlgorithmOrderParams(
+                oid=oid,
+                symbol=symbol,
+                side=side,
+                amount=amount,
+                account_type=account_type,
+                reduce_only=reduce_only,
+            ),
+            exec_params=exec_params,
+        )
+
+        # Send to execution algorithm via MessageBus
+        self._msgbus.send(
+            endpoint=f"{exec_algorithm_id}.execute",
+            msg=command,
+        )
+
+        self._sys_log.info(
+            f"[algo order] symbol={symbol}, oid={oid}, side={side}, "
+            f"amount={amount}, algorithm={exec_algorithm_id}"
+        )
+
+        return oid
+
+    def cancel_algo_order(self, oid: str, exec_algorithm_id: str):
+        """
+        Cancel an execution algorithm order.
+
+        Parameters
+        ----------
+        oid : str
+            The primary order ID.
+        exec_algorithm_id : str
+            The execution algorithm ID.
+        """
+        if exec_algorithm_id not in self._exec_algorithms:
+            raise ValueError(
+                f"Execution algorithm '{exec_algorithm_id}' not registered"
+            )
+
+        command = ExecAlgorithmCommand(
+            command_type=ExecAlgorithmCommandType.CANCEL,
+            exec_algorithm_id=exec_algorithm_id,
+            primary_oid=oid,
+        )
+
+        self._msgbus.send(
+            endpoint=f"{exec_algorithm_id}.execute",
+            msg=command,
+        )
+
+        self._sys_log.info(
+            f"[cancel algo order] oid={oid}, algorithm={exec_algorithm_id}"
+        )
+
+    def get_algo_order(
+        self, oid: str, exec_algorithm_id: str
+    ) -> ExecAlgorithmOrder | None:
+        """
+        Get an execution algorithm order by its primary order ID.
+
+        Parameters
+        ----------
+        oid : str
+            The primary order ID.
+        exec_algorithm_id : str
+            The execution algorithm ID.
+
+        Returns
+        -------
+        ExecAlgorithmOrder | None
+            The execution algorithm order, or None if not found.
+        """
+        if exec_algorithm_id not in self._exec_algorithms:
+            raise ValueError(
+                f"Execution algorithm '{exec_algorithm_id}' not registered"
+            )
+
+        return self._exec_algorithms[exec_algorithm_id].get_algo_order(oid)
+
+    # def create_twap(
+    #     self,
+    #     symbol: str,
+    #     side: OrderSide,
+    #     amount: Decimal,
+    #     duration: int,
+    #     wait: int,
+    #     check_interval: float = 0.1,
+    #     position_side: PositionSide | None = None,
+    #     account_type: AccountType | None = None,
+    #     **kwargs,
+    # ) -> str:
+    #     order = TWAPOrderSubmit(
+    #         symbol=symbol,
+    #         instrument_id=InstrumentId.from_str(symbol),
+    #         side=side,
+    #         amount=amount,
+    #         duration=duration,
+    #         wait=wait,
+    #         check_interval=check_interval,
+    #         position_side=position_side,
+    #         kwargs=kwargs,
+    #     )
+    #     self._ems[order.instrument_id.exchange]._submit_order(
+    #         order, SubmitType.TWAP, account_type
+    #     )
+    #     return order.uuid
+
+    # def cancel_twap(
+    #     self, symbol: str, uuid: str, account_type: AccountType | None = None
+    # ) -> str:
+    #     order = CancelTWAPOrderSubmit(
+    #         symbol=symbol,
+    #         instrument_id=InstrumentId.from_str(symbol),
+    #         uuid=uuid,
+    #     )
+    #     self._ems[order.instrument_id.exchange]._submit_order(
+    #         order, SubmitType.CANCEL_TWAP, account_type
+    #     )
+    #     return order.uuid
+
+    def subscribe_bookl1(
+        self, symbols: str | List[str], ready_timeout: int = 60, ready: bool = True
+    ):
+        """
+        Subscribe to level 1 book data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to subscribe to.
+            ready_timeout (int): The timeout for the data to be ready.
+            ready (bool): default is True. Whether the data is ready. If True, the data will be ready immediately. When you use event driven strategy, you can set it to True. Otherwise, set it to False.
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `subscribe_bookl1` in `on_start` method"
+            )
+
+        self._msgbus.subscribe(topic="bookl1", handler=self._on_bookl1)
+
+        self._sms.subscribe(
+            symbols=symbols,
+            data_type=DataType.BOOKL1,
+            ready_timeout=ready_timeout,
+            ready=ready,
+        )
+
+    def subscribe_trade(
+        self, symbols: str | List[str], ready_timeout: int = 60, ready: bool = True
+    ):
+        """
+        Subscribe to trade data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to subscribe to.
+            ready_timeout (int): The timeout for the data to be ready.
+            ready (bool): default is True. Whether the data is ready. If True, the data will be ready immediately. When you use event driven strategy, you can set it to True. Otherwise, set it to False.
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `subscribe_trade` in `on_start` method"
+            )
+
+        self._msgbus.subscribe(topic="trade", handler=self._on_trade)
+
+        self._sms.subscribe(
+            symbols=symbols,
+            data_type=DataType.TRADE,
+            ready_timeout=ready_timeout,
+            ready=ready,
+        )
+
+    def subscribe_kline(
+        self,
+        symbols: str | List[str],
+        interval: KlineInterval,
+        ready_timeout: int = 60,
+        ready: bool = True,
+        use_aggregator: bool = False,
+        build_with_no_updates: bool = True,
+    ):
+        """
+        Subscribe to kline data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to subscribe to.
+            interval (str): The interval of the kline data
+            ready_timeout (int): The timeout for the data to be ready.
+            ready (bool): default is True. Whether the data is ready. If True, the data will be ready immediately. When you use event driven strategy, you can set it to True. Otherwise, set it to False.
+            use_aggregator (bool): If True, use TimeKlineAggregator instead of exchange native klines. Useful when exchange doesn't support certain intervals.
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `subscribe_kline` in `on_start` method"
+            )
+
+        self._msgbus.subscribe(topic="kline", handler=self._on_kline)
+
+        if isinstance(symbols, str):
+            symbols = [symbols]
+
+        self._sms.subscribe(
+            symbols=symbols,
+            data_type=DataType.KLINE,
+            params={
+                "interval": interval,
+                "use_aggregator": use_aggregator,
+                "build_with_no_updates": build_with_no_updates,
+            },
+            ready_timeout=ready_timeout,
+            ready=ready,
+        )
+
+    def subscribe_volume_kline(
+        self,
+        symbols: str | List[str],
+        volume_threshold: float,
+        volume_type: Literal["DEFAULT", "BUY", "SELL"] = "DEFAULT",
+        ready_timeout: int = 60,
+        ready: bool = True,
+    ):
+        """
+        Subscribe to volume-based kline data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to subscribe to.
+            volume_threshold (float): The volume threshold for creating new klines
+            ready_timeout (int): The timeout for the data to be ready.
+            ready (bool): default is True. Whether the data is ready. If True, the data will be ready immediately. When you use event driven strategy, you can set it to True. Otherwise, set it to False.
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `subscribe_volume_kline` in `on_start` method"
+            )
+
+        self._msgbus.subscribe(topic="kline", handler=self._on_kline)
+
+        self._sms.subscribe(
+            symbols=symbols,
+            data_type=DataType.VOLUME_KLINE,
+            params={
+                "volume_threshold": volume_threshold,
+                "volume_type": volume_type,
+            },
+            ready_timeout=ready_timeout,
+            ready=ready,
+        )
+
+    def subscribe_bookl2(
+        self,
+        symbols: str | List[str],
+        level: BookLevel,
+        ready_timeout: int = 60,
+        ready: bool = True,
+    ):
+        """
+        Subscribe to level 2 book data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to subscribe to.
+            level (BookLevel): The level of the book data
+            ready_timeout (int): The timeout for the data to be ready.
+            ready (bool): default is True. Whether the data is ready. If True, the data will be ready immediately. When you use event driven strategy, you can set it to True. Otherwise, set it to False.
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `subscribe_bookl2` in `on_start` method"
+            )
+
+        self._msgbus.subscribe(topic="bookl2", handler=self._on_bookl2)
+
+        self._sms.subscribe(
+            symbols=symbols,
+            data_type=DataType.BOOKL2,
+            params={"level": level},
+            ready_timeout=ready_timeout,
+            ready=ready,
+        )
+
+    def subscribe_funding_rate(
+        self, symbols: str | List[str], ready_timeout: int = 60, ready: bool = True
+    ):
+        """
+        Subscribe to funding rate data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to subscribe to.
+            ready_timeout (int): The timeout for the data to be ready.
+            ready (bool): default is True. Whether the data is ready. If True, the data will be ready immediately. When you use event driven strategy, you can set it to True. Otherwise, set it to False.
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `subscribe_funding_rate` in `on_start` method"
+            )
+
+        self._msgbus.subscribe(topic="funding_rate", handler=self._on_funding_rate)
+
+        self._sms.subscribe(
+            symbols=symbols,
+            data_type=DataType.FUNDING_RATE,
+            ready=ready,
+            ready_timeout=ready_timeout,
+        )
+
+    def subscribe_index_price(
+        self, symbols: str | List[str], ready_timeout: int = 60, ready: bool = True
+    ):
+        """
+        Subscribe to index price data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to subscribe to.
+            ready_timeout (int): The timeout for the data to be ready.
+            ready (bool): default is True. Whether the data is ready. If True, the data will be ready immediately. When you use event driven strategy, you can set it to True. Otherwise, set it to False.
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `subscribe_index_price` in `on_start` method"
+            )
+
+        self._msgbus.subscribe(topic="index_price", handler=self._on_index_price)
+
+        self._sms.subscribe(
+            symbols=symbols,
+            data_type=DataType.INDEX_PRICE,
+            ready=ready,
+            ready_timeout=ready_timeout,
+        )
+
+    def subscribe_mark_price(
+        self, symbols: str | List[str], ready_timeout: int = 60, ready: bool = True
+    ):
+        """
+        Subscribe to mark price data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to subscribe to.
+            ready_timeout (int): The timeout for the data to be ready.
+            ready (bool): default is True. Whether the data is ready. If True, the data will be ready immediately. When you use event driven strategy, you can set it to True. Otherwise, set it to False.
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `subscribe_mark_price` in `on_start` method"
+            )
+
+        self._msgbus.subscribe(topic="mark_price", handler=self._on_mark_price)
+
+        self._sms.subscribe(
+            symbols=symbols,
+            data_type=DataType.MARK_PRICE,
+            ready=ready,
+            ready_timeout=ready_timeout,
+        )
+
+    def unsubscribe_bookl1(self, symbols: str | List[str]):
+        """
+        Unsubscribe from level 1 book data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to unsubscribe from.
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `unsubscribe_bookl1` in a valid method"
+            )
+
+        self._sms.unsubscribe(symbols=symbols, data_type=DataType.BOOKL1)
+
+    def unsubscribe_trade(self, symbols: str | List[str]):
+        """
+        Unsubscribe from trade data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to unsubscribe from.
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `unsubscribe_trade` in a valid method"
+            )
+
+        self._sms.unsubscribe(symbols=symbols, data_type=DataType.TRADE)
+
+    def unsubscribe_kline(
+        self,
+        symbols: str | List[str],
+        interval: KlineInterval,
+        use_aggregator: bool = False,
+    ):
+        """
+        Unsubscribe from kline data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to unsubscribe from.
+            interval (KlineInterval): The interval of the kline data
+            use_aggregator (bool): If True, unsubscribe from TimeKlineAggregator instead of exchange native klines.
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `unsubscribe_kline` in a valid method"
+            )
+
+        self._sms.unsubscribe(
+            symbols=symbols,
+            data_type=DataType.KLINE,
+            params={"interval": interval, "use_aggregator": use_aggregator},
+        )
+
+    def unsubscribe_volume_kline(
+        self,
+        symbols: str | List[str],
+        volume_threshold: float,
+        volume_type: Literal["DEFAULT", "BUY", "SELL"] = "DEFAULT",
+    ):
+        """
+        Unsubscribe from volume-based kline data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to unsubscribe from.
+            volume_threshold (float): The volume threshold for the kline aggregator
+            volume_type (str): The type of volume to use
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `unsubscribe_volume_kline` in a valid method"
+            )
+
+        self._sms.unsubscribe(
+            symbols=symbols,
+            data_type=DataType.VOLUME_KLINE,
+            params={
+                "volume_threshold": volume_threshold,
+                "volume_type": volume_type,
+            },
+        )
+
+    def unsubscribe_bookl2(self, symbols: str | List[str], level: BookLevel):
+        """
+        Unsubscribe from level 2 book data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to unsubscribe from.
+            level (BookLevel): The level of the book data
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `unsubscribe_bookl2` in a valid method"
+            )
+
+        self._sms.unsubscribe(
+            symbols=symbols, data_type=DataType.BOOKL2, params={"level": level}
+        )
+
+    def unsubscribe_funding_rate(self, symbols: str | List[str]):
+        """
+        Unsubscribe from funding rate data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to unsubscribe from.
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `unsubscribe_funding_rate` in a valid method"
+            )
+
+        self._sms.unsubscribe(symbols=symbols, data_type=DataType.FUNDING_RATE)
+
+    def unsubscribe_index_price(self, symbols: str | List[str]):
+        """
+        Unsubscribe from index price data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to unsubscribe from.
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `unsubscribe_index_price` in a valid method"
+            )
+
+        self._sms.unsubscribe(symbols=symbols, data_type=DataType.INDEX_PRICE)
+
+    def unsubscribe_mark_price(self, symbols: str | List[str]):
+        """
+        Unsubscribe from mark price data for the given symbols.
+
+        Args:
+            symbols (List[str]): The symbols to unsubscribe from.
+        """
+        if not self._initialized:
+            raise StrategyBuildError(
+                "Strategy not initialized, please use `unsubscribe_mark_price` in a valid method"
+            )
+
+        self._sms.unsubscribe(symbols=symbols, data_type=DataType.MARK_PRICE)
+
+    def linear_info(
+        self,
+        exchange: ExchangeType,
+        base: str | None = None,
+        quote: str | None = None,
+        exclude: List[str] | None = None,
+    ) -> List[str]:
+        _exchange: ExchangeManager = self._exchanges[exchange]
+        return _exchange.linear(base, quote, exclude)
+
+    def spot_info(
+        self,
+        exchange: ExchangeType,
+        base: str | None = None,
+        quote: str | None = None,
+        exclude: List[str] | None = None,
+    ) -> List[str]:
+        _exchange: ExchangeManager = self._exchanges[exchange]
+        return _exchange.spot(base, quote, exclude)
+
+    def future_info(
+        self,
+        exchange: ExchangeType,
+        base: str | None = None,
+        quote: str | None = None,
+        exclude: List[str] | None = None,
+    ) -> List[str]:
+        _exchange: ExchangeManager = self._exchanges[exchange]
+        return _exchange.future(base, quote, exclude)
+
+    def inverse_info(
+        self,
+        exchange: ExchangeType,
+        base: str | None = None,
+        quote: str | None = None,
+        exclude: List[str] | None = None,
+    ) -> List[str]:
+        _exchange: ExchangeManager = self._exchanges[exchange]
+        return _exchange.inverse(base, quote, exclude)
+
+    def on_start(self):
+        pass
+
+    def on_stop(self):
+        pass
+
+    def _on_start(self):
+        self.on_start()
+        self._started = True
+
+    def _on_stop(self):
+        self.on_stop()
+
+    def on_trade(self, trade: Trade):
+        pass
+
+    def on_bookl1(self, bookl1: BookL1):
+        pass
+
+    def on_bookl2(self, bookl2: BookL2):
+        pass
+
+    def on_kline(self, kline: Kline):
+        pass
+
+    def on_funding_rate(self, funding_rate: FundingRate):
+        pass
+
+    def on_index_price(self, index_price: IndexPrice):
+        pass
+
+    def on_mark_price(self, mark_price: MarkPrice):
+        pass
+
+    def on_pending_order(self, order: Order):
+        pass
+
+    def on_accepted_order(self, order: Order):
+        pass
+
+    def on_partially_filled_order(self, order: Order):
+        pass
+
+    def on_filled_order(self, order: Order):
+        pass
+
+    def on_canceling_order(self, order: Order):
+        pass
+
+    def on_expired_order(self, order: Order):
+        pass
+
+    def on_canceled_order(self, order: Order):
+        pass
+
+    def on_failed_order(self, order: Order):
+        pass
+
+    def on_cancel_failed_order(self, order: Order):
+        pass
+
+    def on_balance(self, balance: AccountBalance):
+        pass
+
+    def stop(self):
+        precise_sleep(
+            milliseconds=200
+        )  # wait for 200ms to ensure all messages are processed
+        os.kill(os.getpid(), signal.SIGINT)
+
+    def wait(
+        self,
+        seconds: float = 0,
+        milliseconds: float = 0,
+        microseconds: float = 0,
+    ):
+        """High-precision wait using Linux ``clock_nanosleep`` (~50-100 µs accuracy).
+
+        Parameters are additive. At least one must be positive.
+
+        Parameters
+        ----------
+        seconds : float
+            Duration in seconds.
+        milliseconds : float
+            Duration in milliseconds.
+        microseconds : float
+            Duration in microseconds.
+        """
+        precise_sleep(
+            seconds=seconds,
+            milliseconds=milliseconds,
+            microseconds=microseconds,
+        )
+
+    def _on_trade(self, trade: Trade):
+        if not self._started:
+            return
+        self.on_trade(trade)
+        self._sms.input(DataType.TRADE, trade)
+
+    def _on_bookl2(self, bookl2: BookL2):
+        if not self._started:
+            return
+        self.on_bookl2(bookl2)
+        self._sms.input(DataType.BOOKL2, bookl2)
+
+    def _on_kline(self, kline: Kline):
+        if not self._started:
+            return
+        self.on_kline(kline)
+        if kline.interval == KlineInterval.VOLUME:
+            self._sms.input(kline.symbol, kline)
+        else:
+            self._sms.input(kline.interval.value, kline)
+
+    def _on_funding_rate(self, funding_rate: FundingRate):
+        if not self._started:
+            return
+        self.on_funding_rate(funding_rate)
+        self._sms.input(DataType.FUNDING_RATE, funding_rate)
+
+    def _on_bookl1(self, bookl1: BookL1):
+        if not self._started:
+            return
+        self.on_bookl1(bookl1)
+        self._sms.input(DataType.BOOKL1, bookl1)
+
+    def _on_index_price(self, index_price: IndexPrice):
+        if not self._started:
+            return
+        self.on_index_price(index_price)
+        self._sms.input(DataType.INDEX_PRICE, index_price)
+
+    def _on_mark_price(self, mark_price: MarkPrice):
+        if not self._started:
+            return
+        self.on_mark_price(mark_price)
+        self._sms.input(DataType.MARK_PRICE, mark_price)
+
+    def param(
+        self,
+        name: str,
+        value: Optional[Any] = None,
+        default: Optional[Any] = None,
+        backend: BACKEND_LITERAL = "memory",
+    ) -> Any:
+        """
+        Get or set a parameter in the cache.
+
+        Args:
+            name: The parameter name
+            value: The parameter value to set. If None, will get the parameter.
+
+        Returns:
+            The parameter value if getting, None if setting.
+
+        Examples:
+            # Set a parameter
+            self.param('rolling_n', 10)
+
+            # Get a parameter
+            rolling_n = self.param('rolling_n')
+        """
+        param_backend = ParamBackend(backend)
+        if value is not None:
+            # Set parameter
+            self.cache.set_param(name, value, param_backend)
+            return None
+        else:
+            # Get parameter
+            return self.cache.get_param(name, default, param_backend)
+
+    def clear_param(
+        self, name: Optional[str] = None, backend: BACKEND_LITERAL = "memory"
+    ) -> None:
+        """
+        Clear parameter(s) from the cache.
+
+        Args:
+            name: The parameter name to clear. If None, clears all parameters.
+
+        Examples:
+            # Clear a specific parameter
+            self.clear_param('rolling_n')
+
+            # Clear all parameters
+            self.clear_param()
+        """
+        self.cache.clear_param(name, ParamBackend(backend))
+
+    def set_timer(
+        self,
+        callback: Callable[..., Any],
+        interval: timedelta,
+        name: str | None = None,
+        start_time: datetime | None = None,
+        stop_time: datetime | None = None,
+    ) -> None:
+        """
+        Set a timer that calls a callback function at regular intervals.
+
+        Args:
+            callback: The function to call
+            interval: Time interval between calls
+            name: Optional timer name. If not provided, uses the callback function name.
+            start_time: When to start the timer (defaults to now + interval)
+            stop_time: When to stop the timer (optional)
+        """
+        if name is None:
+            name = getattr(callback, "__name__", type(callback).__name__)
+
+        if start_time is None:
+            start_time = self.clock.utc_now() + interval
+
+        self.clock.set_timer(
+            name=name,
+            interval=interval,
+            start_time=start_time,
+            stop_time=stop_time,
+            callback=callback,
+        )