Qubx 0.6.13__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.16__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/broker.py

@@ -57,6 +57,19 @@ class SimulatedBroker(IBroker):
         self._send_exec_report(instrument, report)
         return report.order
 
+    def send_order_async(
+        self,
+        instrument: Instrument,
+        order_side: str,
+        order_type: str,
+        amount: float,
+        price: float | None = None,
+        client_id: str | None = None,
+        time_in_force: str = "gtc",
+        **optional,
+    ) -> None:
+        self.send_order(instrument, order_side, order_type, amount, price, client_id, time_in_force, **optional)
+
     def cancel_order(self, order_id: str) -> Order | None:
         instrument = self._account.order_to_instrument.get(order_id)
         if instrument is None:

qubx/backtester/runner.py

@@ -248,6 +248,9 @@ class SimulationRunner:
             initializer=self.initializer,
         )
 
+        if self.emitter is not None:
+            self.emitter.set_time_provider(simulated_clock)
+
         # - setup base subscription from spec
         if ctx.get_base_subscription() == DataType.NONE:
             logger.debug(

qubx/backtester/simulator.py

@@ -8,6 +8,8 @@ from qubx.core.exceptions import SimulationError
 from qubx.core.metrics import TradingSessionResult
 from qubx.data.readers import DataReader
 from qubx.utils.misc import ProgressParallel, Stopwatch, get_current_user
+from qubx.utils.runner.configs import EmissionConfig
+from qubx.utils.runner.factory import create_metric_emitters
 from qubx.utils.time import handle_start_stop
 
 from .runner import SimulationRunner
@@ -45,6 +47,7 @@ def simulate(
     show_latency_report: bool = False,
     portfolio_log_freq: str = "5Min",
     parallel_backend: Literal["loky", "multiprocessing"] = "multiprocessing",
+    emission: EmissionConfig | None = None,
 ) -> list[TradingSessionResult]:
     """
     Backtest utility for trading strategies or signals using historical data.
@@ -67,6 +70,9 @@ def simulate(
         - open_close_time_indent_secs (int): Time indent in seconds for open/close times, default is 1.
         - debug (Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None): Logging level for debugging.
         - show_latency_report: If True, shows simulator's latency report.
+        - portfolio_log_freq (str): Frequency for portfolio logging, default is "5Min".
+        - parallel_backend (Literal["loky", "multiprocessing"]): Backend for parallel processing, default is "multiprocessing".
+        - emission (EmissionConfig | None): Configuration for metric emitters, default is None.
 
     Returns:
         - list[TradingSessionResult]: A list of TradingSessionResult objects containing the results of each simulation setup.
@@ -139,6 +145,7 @@ def simulate(
         show_latency_report=show_latency_report,
         portfolio_log_freq=portfolio_log_freq,
         parallel_backend=parallel_backend,
+        emission=emission,
     )
 
 
@@ -152,6 +159,7 @@ def _run_setups(
     show_latency_report: bool = False,
     portfolio_log_freq: str = "5Min",
     parallel_backend: Literal["loky", "multiprocessing"] = "multiprocessing",
+    emission: EmissionConfig | None = None,
 ) -> list[TradingSessionResult]:
     # loggers don't work well with joblib and multiprocessing in general because they contain
     # open file handlers that cannot be pickled. I found a solution which requires the usage of enqueue=True
@@ -165,7 +173,16 @@ def _run_setups(
         n_jobs=n_jobs, total=len(strategies_setups), silent=_main_loop_silent, backend=parallel_backend
     )(
         delayed(_run_setup)(
-            id, f"Simulated-{id}", setup, data_setup, start, stop, silent, show_latency_report, portfolio_log_freq
+            id,
+            f"Simulated-{id}",
+            setup,
+            data_setup,
+            start,
+            stop,
+            silent,
+            show_latency_report,
+            portfolio_log_freq,
+            emission,
         )
         for id, setup in enumerate(strategies_setups)
     )
@@ -182,7 +199,13 @@ def _run_setup(
     silent: bool,
     show_latency_report: bool,
     portfolio_log_freq: str,
+    emission: EmissionConfig | None = None,
 ) -> TradingSessionResult:
+    # Create metric emitter if configured
+    emitter = None
+    if emission is not None:
+        emitter = create_metric_emitters(emission, setup.name)
+
     runner = SimulationRunner(
         setup=setup,
         data_config=data_setup,
@@ -190,6 +213,7 @@ def _run_setup(
         stop=stop,
         account_id=account_id,
         portfolio_log_freq=portfolio_log_freq,
+        emitter=emitter,
     )
 
     # - we want to see simulate time in log messages

qubx/connectors/ccxt/account.py

@@ -77,6 +77,8 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         balance_interval: str = "30Sec",
         position_interval: str = "30Sec",
         subscription_interval: str = "10Sec",
+        open_order_interval: str = "1Min",
+        open_order_backoff: str = "1Min",
         max_position_restore_days: int = 30,
         max_retries: int = 10,
     ):
@@ -93,6 +95,8 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         self.balance_interval = balance_interval
         self.position_interval = position_interval
         self.subscription_interval = subscription_interval
+        self.open_order_interval = open_order_interval
+        self.open_order_backoff = open_order_backoff
         self.max_position_restore_days = max_position_restore_days
         self._loop = AsyncThreadLoop(exchange.asyncio_loop)
         self._is_running = False
@@ -140,11 +144,17 @@ class CcxtAccountProcessor(BasicAccountProcessor):
             logger.info("Account polling tasks have been initialized")
 
         # - start subscription polling task
-        self._polling_tasks["subscription"] = self._loop.submit(
-            self._poller("subscription", self._update_subscriptions, self.subscription_interval)
-        )
+        # self._polling_tasks["subscription"] = self._loop.submit(
+        #     self._poller("subscription", self._update_subscriptions, self.subscription_interval)
+        # )
         # - subscribe to order executions
         self._polling_tasks["executions"] = self._loop.submit(self._subscribe_executions("executions", channel))
+        # - sync open orders
+        self._polling_tasks["open_orders"] = self._loop.submit(
+            self._poller(
+                "open_orders", self._sync_open_orders, self.open_order_interval, backoff=self.open_order_backoff
+            )
+        )
 
     def stop(self):
         """Stop all polling tasks"""
@@ -188,10 +198,15 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         name: str,
         coroutine: Callable[[], Awaitable],
         interval: str,
+        backoff: str | None = None,
     ):
         sleep_time = pd.Timedelta(interval).total_seconds()
         retries = 0
 
+        if backoff is not None:
+            sleep_time = pd.Timedelta(backoff).total_seconds()
+            await asyncio.sleep(sleep_time)
+
         while self.channel.control.is_set():
             try:
                 await coroutine()
@@ -276,7 +291,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
     async def _update_positions(self) -> None:
         # fetch and update positions from exchange
         ccxt_positions = await self.exchange.fetch_positions()
-        positions = ccxt_convert_positions(ccxt_positions, self.exchange.name, self.exchange.markets)
+        positions = ccxt_convert_positions(ccxt_positions, self.exchange.name, self.exchange.markets)  # type: ignore
         # update required instruments that we need to subscribe to
         self._required_instruments.update([p.instrument for p in positions])
         # update positions
@@ -388,7 +403,10 @@ class CcxtAccountProcessor(BasicAccountProcessor):
     async def _init_open_orders(self) -> None:
         # wait for balances and positions to be initialized
         await self._wait(lambda: all([self._polling_to_init[task] for task in ["balance", "position"]]))
-        logger.debug("Fetching open orders ...")
+        await self._sync_open_orders(initial_call=True)
+
+    async def _sync_open_orders(self, initial_call: bool = False) -> None:
+        logger.debug("[SYNC] Fetching open orders ...")
 
         # in order to minimize order requests we only fetch open orders for instruments that we have positions in
         _nonzero_balances = {
@@ -405,20 +423,50 @@ class CcxtAccountProcessor(BasicAccountProcessor):
                 _orders = await self._fetch_orders(instrument, is_open=True)
                 _open_orders.update(_orders)
             except Exception as e:
-                logger.warning(f"Error fetching open orders for {instrument}: {e}")
+                logger.warning(f"[SYNC] Error fetching open orders for {instrument}: {e}")
 
         await asyncio.gather(*[_add_open_orders(i) for i in _instruments])
 
-        self.add_active_orders(_open_orders)
-
-        logger.debug(f"Found {len(_open_orders)} open orders ->")
-        _instr_to_open_orders: dict[Instrument, list[Order]] = defaultdict(list)
-        for od in _open_orders.values():
-            _instr_to_open_orders[od.instrument].append(od)
-        for instr, orders in _instr_to_open_orders.items():
-            logger.debug(f"  ::  {instr} ->")
-            for order in orders:
-                logger.debug(f"    :: {order.side} {order.quantity} @ {order.price} ({order.status})")
+        if initial_call:
+            # - when it's the initial call, we add the open orders to the account
+            self.add_active_orders(_open_orders)
+            logger.debug(f"[SYNC] Found {len(_open_orders)} open orders ->")
+            _instr_to_open_orders: dict[Instrument, list[Order]] = defaultdict(list)
+            for od in _open_orders.values():
+                _instr_to_open_orders[od.instrument].append(od)
+            for instr, orders in _instr_to_open_orders.items():
+                logger.debug(f"  :: [SYNC] {instr} ->")
+                for order in orders:
+                    logger.debug(f"    :: [SYNC] {order.side} {order.quantity} @ {order.price} ({order.status})")
+        else:
+            # TODO: think if this should actually be here
+            # - we need to cancel the unexpected orders
+            await self._cancel_unexpected_orders(_open_orders)
+
+    async def _cancel_unexpected_orders(self, open_orders: dict[str, Order]) -> None:
+        _expected_orders = set(self._active_orders.keys())
+        _unexpected_orders = set(open_orders.keys()) - _expected_orders
+        if _unexpected_orders:
+            logger.info(f"[SYNC] Canceling {len(_unexpected_orders)} unexpected open orders ...")
+            _instr_to_orders = defaultdict(list)
+            for _id in _unexpected_orders:
+                _order = open_orders[_id]
+                _instr_to_orders[_order.instrument].append(_order)
+
+            async def _cancel_order(order: Order) -> None:
+                try:
+                    await self.exchange.cancel_order(order.id, symbol=instrument_to_ccxt_symbol(order.instrument))
+                    logger.debug(
+                        f"  :: [SYNC] Canceled {order.id} {order.instrument.symbol} {order.side} {order.quantity} @ {order.price} ({order.status})"
+                    )
+                except Exception as e:
+                    logger.warning(f"[SYNC] Error canceling order {order.id}: {e}")
+
+            for instr, orders in _instr_to_orders.items():
+                logger.debug(
+                    f"[SYNC] Canceling {len(orders)} (out of {len(open_orders)}) unexpected open orders for {instr}"
+                )
+                await asyncio.gather(*[_cancel_order(order) for order in orders])
 
     async def _fetch_orders(
         self, instrument: Instrument, days_before: int = 30, limit: int | None = None, is_open: bool = False

qubx/connectors/ccxt/broker.py

@@ -1,6 +1,9 @@
+import asyncio
 import traceback
 from typing import Any
 
+import pandas as pd
+
 import ccxt
 import ccxt.pro as cxp
 from ccxt.base.errors import ExchangeError
@@ -9,12 +12,13 @@ from qubx.core.basics import (
     CtrlChannel,
     Instrument,
     Order,
-    Position,
 )
+from qubx.core.errors import OrderCancellationError, OrderCreationError, create_error_event
 from qubx.core.exceptions import InvalidOrderParameters
 from qubx.core.interfaces import (
     IAccountProcessor,
     IBroker,
+    IDataProvider,
     ITimeProvider,
 )
 from qubx.utils.misc import AsyncThreadLoop
@@ -24,8 +28,6 @@ from .utils import ccxt_convert_order_info, instrument_to_ccxt_symbol
 
 class CcxtBroker(IBroker):
     _exchange: cxp.Exchange
-
-    _positions: dict[Instrument, Position]
     _loop: AsyncThreadLoop
 
     def __init__(
@@ -34,18 +36,94 @@ class CcxtBroker(IBroker):
         channel: CtrlChannel,
         time_provider: ITimeProvider,
         account: IAccountProcessor,
+        data_provider: IDataProvider,
+        enable_price_match: bool = False,
+        price_match_ticks: int = 5,
+        cancel_timeout: int = 30,
+        cancel_retry_interval: int = 2,
+        max_cancel_retries: int = 10,
     ):
         self._exchange = exchange
         self.ccxt_exchange_id = str(exchange.name)
         self.channel = channel
         self.time_provider = time_provider
         self.account = account
+        self.data_provider = data_provider
+        self.enable_price_match = enable_price_match
+        self.price_match_ticks = price_match_ticks
         self._loop = AsyncThreadLoop(exchange.asyncio_loop)
+        self.cancel_timeout = cancel_timeout
+        self.cancel_retry_interval = cancel_retry_interval
+        self.max_cancel_retries = max_cancel_retries
 
     @property
     def is_simulated_trading(self) -> bool:
         return False
 
+    def send_order_async(
+        self,
+        instrument: Instrument,
+        order_side: str,
+        order_type: str,
+        amount: float,
+        price: float | None = None,
+        client_id: str | None = None,
+        time_in_force: str = "gtc",
+        **options,
+    ) -> Any:  # Return type as Any to avoid Future/Task typing issues
+        """
+        Submit an order asynchronously. Errors will be sent through the channel.
+
+        Returns:
+            Future-like object that will eventually contain the result
+        """
+
+        async def _execute_order_with_channel_errors():
+            try:
+                order, error = await self._create_order(
+                    instrument=instrument,
+                    order_side=order_side,
+                    order_type=order_type,
+                    amount=amount,
+                    price=price,
+                    client_id=client_id,
+                    time_in_force=time_in_force,
+                    **options,
+                )
+
+                if error:
+                    # Create and send an error event through the channel
+                    error_event = OrderCreationError(
+                        timestamp=self.time_provider.time(),
+                        message=str(error),
+                        instrument=instrument,
+                        amount=amount,
+                        price=price,
+                        order_type=order_type,
+                        side=order_side,
+                    )
+                    self.channel.send(create_error_event(error_event))
+                    return None
+                return order
+            except Exception as err:
+                # Catch any unexpected errors and send them through the channel as well
+                logger.error(f"Unexpected error in async order creation: {err}")
+                logger.error(traceback.format_exc())
+                error_event = OrderCreationError(
+                    timestamp=self.time_provider.time(),
+                    message=f"Unexpected error: {str(err)}",
+                    instrument=instrument,
+                    amount=amount,
+                    price=price,
+                    order_type=order_type,
+                    side=order_side,
+                )
+                self.channel.send(create_error_event(error_event))
+                return None
+
+        # Submit the task to the async loop
+        return self._loop.submit(_execute_order_with_channel_errors())
+
     def send_order(
         self,
         instrument: Instrument,
@@ -57,13 +135,97 @@ class CcxtBroker(IBroker):
         time_in_force: str = "gtc",
         **options,
     ) -> Order:
+        """
+        Submit an order and wait for the result. Exceptions will be raised on errors.
+
+        Returns:
+            Order: The created order object
+
+        Raises:
+            Various exceptions based on the error that occurred
+        """
+        try:
+            # Create a task that executes the order creation
+            future = self._loop.submit(
+                self._create_order(
+                    instrument=instrument,
+                    order_side=order_side,
+                    order_type=order_type,
+                    amount=amount,
+                    price=price,
+                    client_id=client_id,
+                    time_in_force=time_in_force,
+                    **options,
+                )
+            )
+
+            # Wait for the result
+            order, error = future.result()
+
+            # If there was an error, raise it
+            if error:
+                raise error
+
+            # If there was no error but also no order, something went wrong
+            if not order:
+                raise ExchangeError("Order creation failed with no specific error")
+
+            return order
+
+        except Exception as err:
+            # This will catch any errors from future.result() or if we explicitly raise an error
+            logger.error(f"Error in send_order: {err}")
+            raise
+
+    def cancel_order(self, order_id: str) -> Order | None:
+        orders = self.account.get_orders()
+        if order_id not in orders:
+            logger.warning(f"Order {order_id} not found in active orders")
+            return None
+
+        order = orders[order_id]
+        logger.info(f"Canceling order {order_id} ...")
+
+        # Submit the cancellation task to the async loop without waiting for the result
+        self._loop.submit(self._cancel_order_with_retry(order_id, order.instrument))
+
+        # Always return None as requested
+        return None
+
+    async def _create_order(
+        self,
+        instrument: Instrument,
+        order_side: str,
+        order_type: str,
+        amount: float,
+        price: float | None = None,
+        client_id: str | None = None,
+        time_in_force: str = "gtc",
+        **options,
+    ) -> tuple[Order | None, Exception | None]:
+        """
+        Asynchronously create an order with the exchange.
+
+        Returns:
+            tuple: (Order object if successful, Exception if failed)
+        """
         params = {}
         _is_trigger_order = order_type.startswith("stop_")
 
         if order_type == "limit" or _is_trigger_order:
             params["timeInForce"] = time_in_force.upper()
             if price is None:
-                raise InvalidOrderParameters(f"Price must be specified for '{order_type}' order")
+                return None, InvalidOrderParameters(f"Price must be specified for '{order_type}' order")
+
+        quote = self.data_provider.get_quote(instrument)
+
+        # TODO: think about automatically setting reduce only when needed
+        if not options.get("reduceOnly", False):
+            min_notional = instrument.min_notional
+            if min_notional > 0 and abs(amount) * quote.mid_price() < min_notional:
+                return None, InvalidOrderParameters(
+                    f"[{instrument.symbol}] Order amount {amount} is too small. Minimum notional is {min_notional}"
+                )
 
         # - handle trigger (stop) orders
         if _is_trigger_order:
@@ -73,62 +235,159 @@ class CcxtBroker(IBroker):
         if client_id:
             params["newClientOrderId"] = client_id
 
+        if "priceMatch" in options:
+            params["priceMatch"] = options["priceMatch"]
+
         if instrument.is_futures():
             params["type"] = "swap"
 
+            if time_in_force == "gtx" and price is not None and self.enable_price_match:
+                if (order_side == "buy" and quote.bid - price < self.price_match_ticks * instrument.tick_size) or (
+                    order_side == "sell" and price - quote.ask < self.price_match_ticks * instrument.tick_size
+                ):
+                    params["priceMatch"] = "QUEUE"
+                    logger.debug(f"[<y>{instrument.symbol}</y>] :: Price match is set to QUEUE. Price will be ignored.")
+
+        if "priceMatch" in params:
+            # - if price match is set, we don't need to specify the price
+            price = None
+
         ccxt_symbol = instrument_to_ccxt_symbol(instrument)
 
-        r: dict[str, Any] | None = None
         try:
-            r = self._loop.submit(
-                self._exchange.create_order(
-                    symbol=ccxt_symbol,
-                    type=order_type,  # type: ignore
-                    side=order_side,  # type: ignore
+            # Type annotation issue: We need to use type ignore for CCXT API compatibility
+            r = await self._exchange.create_order(
+                symbol=ccxt_symbol,
+                type=order_type,  # type: ignore
+                side=order_side,  # type: ignore
+                amount=amount,
+                price=price,
+                params=params,
+            )
+
+            if r is None:
+                msg = "(::_create_order) No response from exchange"
+                logger.error(msg)
+                return None, ExchangeError(msg)
+
+            order = ccxt_convert_order_info(instrument, r)
+            logger.info(f"New order {order}")
+            return order, None
+
+        except ccxt.OrderNotFillable as exc:
+            logger.error(
+                f"(::_create_order) [{instrument.symbol}] ORDER NOT FILLEABLE for {order_side} {amount} {order_type} : {exc}"
+            )
+            exc_msg = str(exc)
+            if (
+                self.enable_price_match
+                and "priceMatch" not in options
+                and ("-5022" in exc_msg or "Post Only order will be rejected" in exc_msg)
+            ):
+                logger.debug(f"(::_create_order) [{instrument.symbol}] Trying again with price match ...")
+                options_with_price_match = options.copy()
+                options_with_price_match["priceMatch"] = "QUEUE"
+                return await self._create_order(
+                    instrument=instrument,
+                    order_side=order_side,
+                    order_type=order_type,
                     amount=amount,
                     price=price,
-                    params=params,
+                    client_id=client_id,
+                    time_in_force=time_in_force,
+                    **options_with_price_match,
                 )
-            ).result()
+            return None, exc
+        except ccxt.InvalidOrder as exc:
+            logger.error(
+                f"(::_create_order) INVALID ORDER for {order_side} {amount} {order_type} for {instrument.symbol} : {exc}"
+            )
+            return None, exc
         except ccxt.BadRequest as exc:
             logger.error(
-                f"(::send_order) BAD REQUEST for {order_side} {amount} {order_type} for {instrument.symbol} : {exc}"
+                f"(::_create_order) BAD REQUEST for {order_side} {amount} {order_type} for {instrument.symbol} : {exc}"
             )
-            raise exc
+            return None, exc
         except Exception as err:
-            logger.error(f"(::send_order) {order_side} {amount} {order_type} for {instrument.symbol} exception : {err}")
+            logger.error(
+                f"(::_create_order) {order_side} {amount} {order_type} for {instrument.symbol} exception : {err}"
+            )
             logger.error(traceback.format_exc())
-            raise err
+            return None, err
 
-        if r is None:
-            msg = "(::send_order) No response from exchange"
-            logger.error(msg)
-            raise ExchangeError(msg)
+    async def _cancel_order_with_retry(self, order_id: str, instrument: Instrument) -> bool:
+        """
+        Attempts to cancel an order with retries.
 
-        order = ccxt_convert_order_info(instrument, r)
-        logger.info(f"New order {order}")
-        return order
+        Args:
+            order_id: The ID of the order to cancel
+            symbol: The symbol of the instrument
 
-    def cancel_order(self, order_id: str) -> Order | None:
-        order = None
-        orders = self.account.get_orders()
-        if order_id in orders:
-            order = orders[order_id]
+        Returns:
+            bool: True if cancellation was successful, False otherwise
+        """
+        start_time = self.time_provider.time()
+        timeout_delta = self.cancel_timeout
+        retries = 0
+
+        while True:
             try:
-                logger.info(f"Canceling order {order_id} ...")
-                result = self._loop.submit(
-                    self._exchange.cancel_order(order_id, symbol=instrument_to_ccxt_symbol(order.instrument))
-                ).result()
-                logger.debug(f"Cancel order result: {result}")
-                return order
+                await self._exchange.cancel_order_ws(order_id, symbol=instrument_to_ccxt_symbol(instrument))
+                return True
+            except ccxt.OperationRejected as err:
+                err_msg = str(err).lower()
+                # Check if the error is about an unknown order or non-existent order
+                if "unknown order" in err_msg or "order does not exist" in err_msg or "order not found" in err_msg:
+                    # These errors might be temporary if the order is still being processed, so retry
+                    logger.debug(f"[{order_id}] Order not found for cancellation, might retry: {err}")
+                    # Continue with the retry logic instead of returning immediately
+                else:
+                    # For other operation rejected errors, don't retry
+                    logger.debug(f"[{order_id}] Could not cancel order: {err}")
+                    return False
+            except (ccxt.NetworkError, ccxt.ExchangeError, ccxt.ExchangeNotAvailable) as e:
+                logger.debug(f"[{order_id}] Network or exchange error while cancelling: {e}")
+                # Continue with retry logic
             except Exception as err:
-                logger.error(f"Canceling [{order}] exception : {err}")
+                logger.error(f"Unexpected error canceling order {order_id}: {err}")
                 logger.error(traceback.format_exc())
-                raise err
-        return order
+                return False
+
+            # Common retry logic for all retryable errors
+            current_time = self.time_provider.time()
+            elapsed_seconds = pd.Timedelta(current_time - start_time).total_seconds()
+            retries += 1
+
+            if elapsed_seconds >= timeout_delta or retries >= self.max_cancel_retries:
+                logger.error(f"Timeout reached for canceling order {order_id}")
+                self.channel.send(
+                    create_error_event(
+                        OrderCancellationError(
+                            timestamp=self.time_provider.time(),
+                            order_id=order_id,
+                            message=f"Timeout reached for canceling order {order_id}",
+                            instrument=instrument,
+                        )
+                    )
+                )
+                return False
+
+            # Wait before retrying with exponential backoff
+            backoff_time = min(self.cancel_retry_interval * (2 ** (retries - 1)), 30)
+            logger.debug(f"Retrying order cancellation for {order_id} in {backoff_time} seconds (retry {retries})")
+            await asyncio.sleep(backoff_time)
+
+        # This should never be reached due to the return statements above,
+        # but it's here to satisfy the type checker
+        return False
 
     def cancel_orders(self, instrument: Instrument) -> None:
-        raise NotImplementedError("Not implemented yet")
+        orders = self.account.get_orders()
+        instrument_orders = [order_id for order_id, order in orders.items() if order.instrument == instrument]
+
+        # Submit all cancellations without waiting for results
+        for order_id in instrument_orders:
+            self.cancel_order(order_id)
 
     def update_order(self, order_id: str, price: float | None = None, amount: float | None = None) -> Order:
         raise NotImplementedError("Not implemented yet")