Qubx 0.6.89__tar.gz → 0.6.90__tar.gz

{qubx-0.6.89 → qubx-0.6.90}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 0.6.89
+Version: 0.6.90
 Summary: Qubx - Quantitative Trading Framework
 License-File: LICENSE
 Author: Dmitry Marienko

{qubx-0.6.89 → qubx-0.6.90}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.6.89"
+version = "0.6.90"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"

{qubx-0.6.89 → qubx-0.6.90}/src/qubx/backtester/broker.py

@@ -6,7 +6,7 @@ from qubx.core.basics import (
     Instrument,
     Order,
 )
-from qubx.core.exceptions import OrderNotFound
+from qubx.core.exceptions import BadRequest, OrderNotFound
 from qubx.core.interfaces import IBroker
 
 from .account import SimulatedAccountProcessor
@@ -64,20 +64,66 @@ class SimulatedBroker(IBroker):
     ) -> 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:
+    def cancel_order(self, order_id: str) -> bool:
+        """Cancel an order synchronously and return success status."""
         try:
             self._send_execution_report(order_update := self._exchange.cancel_order(order_id))
-            return order_update.order if order_update is not None else None
+            return order_update is not None
         except OrderNotFound:
             # Order was already cancelled or doesn't exist
             logger.debug(f"Order {order_id} not found")
-            return None
+            return False
+
+    def cancel_order_async(self, order_id: str) -> None:
+        """Cancel an order asynchronously (fire-and-forget)."""
+        # For simulation, async is same as sync since it's fast
+        self.cancel_order(order_id)
 
     def cancel_orders(self, instrument: Instrument) -> None:
         raise NotImplementedError("Not implemented yet")
 
-    def update_order(self, order_id: str, price: float | None = None, amount: float | None = None) -> Order:
-        raise NotImplementedError("Not implemented yet")
+    def update_order(self, order_id: str, price: float, amount: float) -> Order:
+        """Update an existing limit order using cancel+recreate strategy.
+
+        Args:
+            order_id: The ID of the order to update
+            price: New price for the order
+            amount: New amount for the order
+
+        Returns:
+            Order: The updated (newly created) order object
+
+        Raises:
+            OrderNotFound: If the order is not found
+            BadRequest: If the order is not a limit order
+        """
+        # Get the existing order from account
+        active_orders = self._account.get_orders()
+        existing_order = active_orders.get(order_id)
+        if not existing_order:
+            raise OrderNotFound(f"Order {order_id} not found")
+
+        # Validate that it's a limit order
+        if existing_order.type.lower() != "limit":
+            raise BadRequest(
+                f"Order {order_id} is not a limit order (type: {existing_order.type}). Only limit orders can be updated."
+            )
+
+        # Cancel the existing order first
+        self.cancel_order(order_id)
+
+        # Create a new order with updated parameters, preserving original properties
+        updated_order = self.send_order(
+            instrument=existing_order.instrument,
+            order_side=existing_order.side,
+            order_type="limit",
+            amount=abs(amount),
+            price=price,
+            client_id=existing_order.client_id,  # Preserve original client_id for tracking
+            time_in_force=existing_order.time_in_force or "gtc",
+        )
+
+        return updated_order
 
     def _send_execution_report(self, report: SimulatedExecutionReport | None):
         if report is None:

{qubx-0.6.89 → qubx-0.6.90}/src/qubx/connectors/ccxt/broker.py

@@ -5,7 +5,6 @@ from typing import Any
 import pandas as pd
 
 import ccxt
-
 from ccxt.base.errors import ExchangeError
 from qubx import logger
 from qubx.core.basics import (
@@ -15,7 +14,7 @@ from qubx.core.basics import (
     OrderSide,
 )
 from qubx.core.errors import ErrorLevel, OrderCancellationError, OrderCreationError, create_error_event
-from qubx.core.exceptions import BadRequest, InvalidOrderParameters
+from qubx.core.exceptions import BadRequest, InvalidOrderParameters, OrderNotFound
 from qubx.core.interfaces import (
     IAccountProcessor,
     IBroker,
@@ -61,7 +60,6 @@ class CcxtBroker(IBroker):
         """Get current AsyncThreadLoop for the exchange."""
         return AsyncThreadLoop(self._exchange_manager.exchange.asyncio_loop)
 
-
     @property
     def is_simulated_trading(self) -> bool:
         return False
@@ -178,7 +176,7 @@ class CcxtBroker(IBroker):
         client_id: str | None = None,
         time_in_force: str = "gtc",
         **options,
-    ) -> Order | None:
+    ) -> Order:
         """
         Submit an order and wait for the result. Exceptions will be raised on errors.
 
@@ -221,22 +219,38 @@ class CcxtBroker(IBroker):
             self._post_order_error_to_databus(
                 err, instrument, order_side, order_type, amount, price, client_id, time_in_force, **options
             )
-            return None
+            raise err
 
-    def cancel_order(self, order_id: str) -> Order | None:
+    def cancel_order(self, order_id: str) -> bool:
+        """Cancel an order synchronously and return success status."""
         orders = self.account.get_orders()
         if order_id not in orders:
             logger.warning(f"Order {order_id} not found in active orders")
-            return None
+            return False
 
         order = orders[order_id]
-        logger.info(f"Canceling order {order_id} ...")
+        logger.info(f"Canceling order {order_id} synchronously...")
 
-        # 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))
+        try:
+            # Submit the task and wait for result
+            future = self._loop.submit(self._cancel_order_with_retry(order_id, order.instrument))
+            return future.result()  # This will block until completion or timeout
+        except Exception as e:
+            logger.error(f"Error during synchronous order cancellation: {e}")
+            return False  # Return False on any error for simplicity
+
+    def cancel_order_async(self, order_id: str) -> None:
+        """Cancel an order asynchronously (non blocking)."""
+        orders = self.account.get_orders()
+        if order_id not in orders:
+            logger.warning(f"Order {order_id} not found in active orders")
+            return
 
-        # Always return None as requested
-        return None
+        order = orders[order_id]
+        logger.info(f"Canceling order {order_id} asynchronously...")
+
+        # Submit the task without waiting for result
+        self._loop.submit(self._cancel_order_with_retry(order_id, order.instrument))
 
     async def _create_order(
         self,
@@ -298,8 +312,22 @@ class CcxtBroker(IBroker):
             logger.warning(f"[<y>{instrument.symbol}</y>] :: Quote is not available for order creation.")
             raise BadRequest(f"Quote is not available for order creation for {instrument.symbol}")
 
-        # TODO: think about automatically setting reduce only when needed
-        if not (reduce_only := options.get("reduceOnly", False)):
+        # Auto-detect if order reduces existing position
+        reduce_only = options.get("reduceOnly", False)
+        if not reduce_only:
+            positions = self.account.get_positions()
+            if instrument in positions:
+                position_qty = positions[instrument].quantity
+                # Check if order closes position AND doesn't exceed position size (which would flip to opposite side)
+                if (position_qty > 0 and order_side == "SELL" and abs(amount) <= abs(position_qty)) or (
+                    position_qty < 0 and order_side == "BUY" and abs(amount) <= abs(position_qty)
+                ):
+                    reduce_only = True
+                    logger.debug(
+                        f"[{instrument.symbol}] Auto-setting reduceOnly=True ({order_side}, position: {position_qty})"
+                    )
+
+        if not reduce_only:
             min_notional = instrument.min_notional
             if min_notional > 0 and abs(amount) * quote.mid_price() < min_notional:
                 raise InvalidOrderParameters(
@@ -364,9 +392,13 @@ class CcxtBroker(IBroker):
         while True:
             try:
                 if self.enable_cancel_order_ws:
-                    await self._exchange_manager.exchange.cancel_order_ws(order_id, symbol=instrument_to_ccxt_symbol(instrument))
+                    await self._exchange_manager.exchange.cancel_order_ws(
+                        order_id, symbol=instrument_to_ccxt_symbol(instrument)
+                    )
                 else:
-                    await self._exchange_manager.exchange.cancel_order(order_id, symbol=instrument_to_ccxt_symbol(instrument))
+                    await self._exchange_manager.exchange.cancel_order(
+                        order_id, symbol=instrument_to_ccxt_symbol(instrument)
+                    )
                 return True
             except ccxt.OperationRejected as err:
                 err_msg = str(err).lower()
@@ -375,8 +407,12 @@ class CcxtBroker(IBroker):
                     # 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
+                # Order cannot be cancelled (e.g., already filled)
+                elif "filled" in err_msg or "partially filled" in err_msg:
+                    logger.debug(f"[{order_id}] Order cannot be cancelled - already executed: {err}")
+                    return False  # FAILURE: Order cannot be cancelled
+                # Other operation rejected errors - don't retry
                 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:
@@ -424,8 +460,112 @@ class CcxtBroker(IBroker):
         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")
+    def update_order(self, order_id: str, price: float, amount: float) -> Order:
+        """Update an existing limit order with new price and amount.
+
+        Args:
+            order_id: The ID of the order to update
+            price: New price for the order (already adjusted by TradingManager)
+            amount: New amount for the order (already adjusted by TradingManager)
+
+        Returns:
+            Order: The updated Order object if successful
+
+        Raises:
+            OrderNotFound: If the order is not found
+            BadRequest: If the order is not a limit order
+            ExchangeError: If the exchange operation fails
+        """
+        logger.debug(f"Updating order {order_id} with price={price}, amount={amount}")
+
+        active_orders = self.account.get_orders()
+        if order_id not in active_orders:
+            raise OrderNotFound(f"Order {order_id} not found in active orders")
+
+        existing_order = active_orders[order_id]
+
+        # Validate that the order can still be updated (not fully filled/closed)
+        updatable_statuses = ["OPEN", "NEW", "PENDING"]
+        if existing_order.status not in updatable_statuses:
+            raise BadRequest(
+                f"Order {order_id} with status '{existing_order.status}' cannot be updated. "
+                f"Only orders with status {updatable_statuses} can be updated."
+            )
+
+        instrument = existing_order.instrument
+
+        logger.debug(
+            f"[<g>{instrument.symbol}</g>] :: Updating order {order_id}: "
+            f"{amount} @ {price} (was: {existing_order.quantity} @ {existing_order.price})"
+        )
+
+        try:
+            # Check if exchange supports order editing
+            if self._exchange_manager.exchange.has.get("editOrder", False):
+                return self._update_order_direct(order_id, existing_order, price, amount)
+            else:
+                return self._update_order_fallback(order_id, existing_order, price, amount)
+        except Exception as err:
+            logger.error(f"Failed to update order {order_id}: {err}")
+            raise
+
+    def _update_order_direct(self, order_id: str, existing_order: Order, price: float, amount: float) -> Order:
+        """Update order using exchange's native edit functionality."""
+        logger.debug(f"Using direct order update for {order_id}")
+
+        future_result = self._loop.submit(self._edit_order_async(order_id, existing_order, price, amount))
+        updated_order, error = future_result.result()
+
+        if error is not None:
+            raise error
+
+        if updated_order is not None:
+            self.account.process_order(updated_order)
+            logger.debug(f"Direct update successful for order {order_id}")
+            return updated_order
+        else:
+            raise Exception("Order update returned None without error")
+
+    def _update_order_fallback(self, order_id: str, existing_order: Order, price: float, amount: float) -> Order:
+        """Update order using cancel+recreate strategy for exchanges without editOrder support."""
+        logger.debug(f"Using fallback (cancel+recreate) strategy for order {order_id}")
+
+        success = self.cancel_order(order_id)
+        if not success:
+            raise Exception(f"Failed to cancel order {order_id} during update")
+
+        updated_order = self.send_order(
+            instrument=existing_order.instrument,
+            order_side=existing_order.side,
+            order_type=existing_order.type,
+            amount=amount,
+            price=price,
+            client_id=existing_order.client_id,  # Preserve original client_id for tracking
+            time_in_force=existing_order.time_in_force or "gtc",
+        )
+
+        logger.debug(f"Fallback update successful for order {order_id} -> new order {updated_order.id}")
+        return updated_order
+
+    async def _edit_order_async(
+        self, order_id: str, existing_order: Order, price: float, amount: float
+    ) -> tuple[Order | None, Exception | None]:
+        """Async helper for direct order editing."""
+        try:
+            ccxt_symbol = instrument_to_ccxt_symbol(existing_order.instrument)
+            ccxt_side = "buy" if existing_order.side == "BUY" else "sell"
+
+            result = await self._exchange_manager.exchange.edit_order(
+                id=order_id, symbol=ccxt_symbol, type="limit", side=ccxt_side, amount=amount, price=price, params={}
+            )
+
+            # Convert the result back to our Order format
+            updated_order = ccxt_convert_order_info(existing_order.instrument, result)
+            return updated_order, None
+
+        except Exception as err:
+            logger.error(f"Async edit order failed for {order_id}: {err}")
+            return None, err
 
     def exchange(self) -> str:
         """

{qubx-0.6.89 → qubx-0.6.90}/src/qubx/connectors/ccxt/exchange_manager.py

@@ -18,8 +18,6 @@ from qubx.core.interfaces import IDataArrivalListener
 
 # Constants for better maintainability
 DEFAULT_CHECK_INTERVAL_SECONDS = 60.0
-DEFAULT_MAX_RECREATIONS = 5
-DEFAULT_RESET_INTERVAL_HOURS = 6.0
 SECONDS_PER_HOUR = 3600
 
 # Custom stall detection thresholds (in seconds)
@@ -30,7 +28,7 @@ STALL_THRESHOLDS = {
     "trade": 60 * 60,  # 60 minutes = 3,600s
     "liquidation": 7 * 24 * SECONDS_PER_HOUR,  # 7 days = 604,800s
     "ohlc": 5 * 60,  # 5 minutes = 300s
-    "quote": 5 * 60,  # 5 minutes = 300s
+    "quote": 2 * 60,  # 2 minutes = 120s
 }
 DEFAULT_STALL_THRESHOLD_SECONDS = 2 * SECONDS_PER_HOUR  # 2 hours = 7,200s
 
@@ -45,7 +43,7 @@ class ExchangeManager(IDataArrivalListener):
     Key Features:
     - Explicit .exchange property for CCXT access
     - Self-contained stall detection and recreation triggering
-    - Circuit breaker protection with recreation limits
+    - Automatic recreation without limits when data stalls
     - Atomic exchange transitions during recreation
     - Background monitoring thread for stall detection
     """
@@ -57,8 +55,6 @@ class ExchangeManager(IDataArrivalListener):
         exchange_name: str,
         factory_params: dict[str, Any],
         initial_exchange: Optional[cxp.Exchange] = None,
-        max_recreations: int = DEFAULT_MAX_RECREATIONS,
-        reset_interval_hours: float = DEFAULT_RESET_INTERVAL_HOURS,
         check_interval_seconds: float = DEFAULT_CHECK_INTERVAL_SECONDS,
     ):
         """Initialize ExchangeManager with underlying CCXT exchange.
@@ -67,19 +63,14 @@ class ExchangeManager(IDataArrivalListener):
             exchange_name: Exchange name for factory (e.g., "binance.um")
             factory_params: Parameters for get_ccxt_exchange()
             initial_exchange: Pre-created exchange instance (from factory)
-            max_recreations: Maximum recreation attempts before giving up
-            reset_interval_hours: Hours between recreation count resets
             check_interval_seconds: How often to check for stalls (default: 60.0)
         """
         self._exchange_name = exchange_name
         self._factory_params = factory_params.copy()
-        self._max_recreations = max_recreations
-        self._reset_interval_hours = reset_interval_hours
 
         # Recreation state
-        self._recreation_count = 0
         self._recreation_lock = threading.RLock()
-        self._last_successful_reset = time.time()
+        self._recreation_count = 0  # Track for logging purposes only
 
         # Stall detection state
         self._check_interval = check_interval_seconds
@@ -142,28 +133,19 @@ class ExchangeManager(IDataArrivalListener):
 
     def force_recreation(self) -> bool:
         """
-        Force recreation due to data stalls (called by BaseHealthMonitor).
+        Force recreation due to data stalls.
 
         Returns:
-            True if recreation successful, False if failed/limit exceeded
+            True if recreation successful, False if failed
         """
         with self._recreation_lock:
-            # Check recreation limit
-            if self._recreation_count >= self._max_recreations:
-                logger.error(
-                    f"Cannot recreate {self._exchange_name}: recreation limit ({self._max_recreations}) exceeded"
-                )
-                return False
-
             logger.info(f"Stall-triggered recreation for {self._exchange_name}")
             return self._recreate_exchange()
 
     def _recreate_exchange(self) -> bool:
         """Recreate the underlying exchange (must be called with _recreation_lock held)."""
         self._recreation_count += 1
-        logger.warning(
-            f"Recreating {self._exchange_name} exchange (attempt {self._recreation_count}/{self._max_recreations})"
-        )
+        logger.warning(f"Recreating {self._exchange_name} exchange (attempt {self._recreation_count})")
 
         # Create new exchange
         try:
@@ -190,18 +172,6 @@ class ExchangeManager(IDataArrivalListener):
 
         return True
 
-    def reset_recreation_count_if_needed(self) -> None:
-        """Reset recreation count periodically (called by monitoring loop)."""
-        reset_interval_seconds = self._reset_interval_hours * SECONDS_PER_HOUR
-
-        current_time = time.time()
-        time_since_reset = current_time - self._last_successful_reset
-
-        if time_since_reset >= reset_interval_seconds and self._recreation_count > 0:
-            logger.info(f"Resetting recreation count for {self._exchange_name} (was {self._recreation_count})")
-            self._recreation_count = 0
-            self._last_successful_reset = current_time
-
     def on_data_arrival(self, event_type: str, event_time: dt_64) -> None:
         """Record data arrival for stall detection.
 
@@ -254,7 +224,6 @@ class ExchangeManager(IDataArrivalListener):
         while self._monitoring_enabled:
             try:
                 self._check_and_handle_stalls()
-                self.reset_recreation_count_if_needed()
                 time.sleep(self._check_interval)
             except Exception as e:
                 logger.error(f"Error in ExchangeManager stall detection: {e}")

{qubx-0.6.89 → qubx-0.6.90}/src/qubx/connectors/ccxt/factory.py

@@ -85,8 +85,6 @@ def get_ccxt_exchange_manager(
     secret: str | None = None,
     loop: asyncio.AbstractEventLoop | None = None,
     use_testnet: bool = False,
-    max_recreations: int = 3,
-    reset_interval_hours: float = 24.0,
     check_interval_seconds: float = 30.0,
     **kwargs,
 ) -> ExchangeManager:
@@ -102,8 +100,6 @@ def get_ccxt_exchange_manager(
         secret (str, optional): The API secret. Default is None.
         loop (asyncio.AbstractEventLoop, optional): Event loop. Default is None.
         use_testnet (bool): Use testnet/sandbox mode. Default is False.
-        max_recreations (int): Maximum recreation attempts before circuit breaker. Default is 3.
-        reset_interval_hours (float): Hours between recreation count resets. Default is 24.0.
         check_interval_seconds (float): How often to check for stalls. Default is 30.0.
         **kwargs: Additional parameters for exchange configuration.
         
@@ -117,9 +113,7 @@ def get_ccxt_exchange_manager(
         'secret': secret,
         'loop': loop,
         'use_testnet': use_testnet,
-        **{k: v for k, v in kwargs.items() if k not in {
-            'max_recreations', 'reset_interval_hours', 'check_interval_seconds'
-        }}
+        **{k: v for k, v in kwargs.items() if k != 'check_interval_seconds'}
     }
     
     # Create raw CCXT exchange using public factory method
@@ -137,8 +131,6 @@ def get_ccxt_exchange_manager(
         exchange_name=exchange,
         factory_params=factory_params,
         initial_exchange=ccxt_exchange,
-        max_recreations=max_recreations,
-        reset_interval_hours=reset_interval_hours,
         check_interval_seconds=check_interval_seconds,
     )
 

{qubx-0.6.89 → qubx-0.6.90}/src/qubx/core/context.py

@@ -468,12 +468,22 @@ class StrategyContext(IStrategyContext):
     def close_positions(self, market_type: MarketType | None = None, without_signals: bool = False) -> None:
         return self._trading_manager.close_positions(market_type, without_signals)
 
-    def cancel_order(self, order_id: str, exchange: str | None = None) -> None:
+    def cancel_order(self, order_id: str, exchange: str | None = None) -> bool:
+        """Cancel a specific order synchronously."""
         return self._trading_manager.cancel_order(order_id, exchange)
 
-    def cancel_orders(self, instrument: Instrument):
+    def cancel_order_async(self, order_id: str, exchange: str | None = None) -> None:
+        """Cancel a specific order asynchronously (non blocking)."""
+        return self._trading_manager.cancel_order_async(order_id, exchange)
+
+    def cancel_orders(self, instrument: Instrument) -> None:
+        """Cancel all orders for an instrument."""
         return self._trading_manager.cancel_orders(instrument)
 
+    def update_order(self, order_id: str, price: float, amount: float, exchange: str | None = None) -> Order:
+        """Update an existing limit order with new price and amount."""
+        return self._trading_manager.update_order(order_id, price, amount, exchange)
+
     # IUniverseManager delegation
     def set_universe(
         self, instruments: list[Instrument], skip_callback: bool = False, if_has_position_then: RemovalPolicy = "close"

{qubx-0.6.89 → qubx-0.6.90}/src/qubx/core/helpers.py

@@ -237,12 +237,20 @@ class CachedMarketDataHolder:
             bought_volume_quote = volume_quote if trade.side == 1 else 0.0
             for ser in series.values():
                 if len(ser) > 0:
-                    current_bar_start = floor_t64(np.datetime64(ser[0].time, 'ns'), np.timedelta64(ser.timeframe, 'ns'))
-                    trade_bar_start = floor_t64(np.datetime64(trade.time, 'ns'), np.timedelta64(ser.timeframe, 'ns'))
+                    current_bar_start = floor_t64(np.datetime64(ser[0].time, "ns"), np.timedelta64(ser.timeframe, "ns"))
+                    trade_bar_start = floor_t64(np.datetime64(trade.time, "ns"), np.timedelta64(ser.timeframe, "ns"))
                     if trade_bar_start < current_bar_start:
                         # Trade belongs to a previous bar - skip it
                         continue
-                ser.update(trade.time, trade.price, total_vol, bought_vol, volume_quote, bought_volume_quote, 1)
+                ser.update(
+                    trade.time,
+                    trade.price,
+                    volume=total_vol,
+                    bvolume=bought_vol,
+                    volume_quote=volume_quote,
+                    bought_volume_quote=bought_volume_quote,
+                    trade_count=1,
+                )
 
     def finalize_ohlc_for_instruments(self, time: dt_64, instruments: list[Instrument]):
         """

{qubx-0.6.89 → qubx-0.6.90}/src/qubx/core/interfaces.py

@@ -348,14 +348,25 @@ class IBroker:
         """
         raise NotImplementedError("send_order_async is not implemented")
 
-    def cancel_order(self, order_id: str) -> None:
-        """Cancel an existing order (non blocking).
+    def cancel_order(self, order_id: str) -> bool:
+        """Cancel an existing order synchronously.
 
         Args:
             order_id: The ID of the order to cancel.
+
+        Returns:
+            bool: True if cancellation was successful, False otherwise.
         """
         raise NotImplementedError("cancel_order is not implemented")
 
+    def cancel_order_async(self, order_id: str) -> None:
+        """Cancel an existing order asynchronously (non blocking).
+
+        Args:
+            order_id: The ID of the order to cancel.
+        """
+        raise NotImplementedError("cancel_order_async is not implemented")
+
     def cancel_orders(self, instrument: Instrument) -> None:
         """Cancel all orders for an instrument.
 
@@ -364,8 +375,8 @@ class IBroker:
         """
         raise NotImplementedError("cancel_orders is not implemented")
 
-    def update_order(self, order_id: str, price: float | None = None, amount: float | None = None) -> Order:
-        """Update an existing order.
+    def update_order(self, order_id: str, price: float, amount: float) -> Order:
+        """Update an existing order with new price and amount.
 
         Args:
             order_id: The ID of the order to update.
@@ -378,7 +389,8 @@ class IBroker:
         Raises:
             NotImplementedError: If the method is not implemented
             OrderNotFound: If the order is not found
-            BadRequest: If the request is invalid
+            BadRequest: If the request is invalid (e.g., not a limit order)
+            InvalidOrderParameters: If the order cannot be updated
         """
         raise NotImplementedError("update_order is not implemented")
 
@@ -698,11 +710,24 @@ class ITradingManager:
         """Close all positions."""
         ...
 
-    def cancel_order(self, order_id: str, exchange: str | None = None) -> None:
-        """Cancel a specific order.
+    def cancel_order(self, order_id: str, exchange: str | None = None) -> bool:
+        """Cancel a specific order synchronously.
 
         Args:
             order_id: ID of the order to cancel
+            exchange: Exchange to cancel on (optional)
+
+        Returns:
+            bool: True if cancellation was successful, False otherwise.
+        """
+        ...
+
+    def cancel_order_async(self, order_id: str, exchange: str | None = None) -> None:
+        """Cancel a specific order asynchronously (non blocking).
+
+        Args:
+            order_id: ID of the order to cancel
+            exchange: Exchange to cancel on (optional)
         """
         ...
 
@@ -714,6 +739,25 @@ class ITradingManager:
         """
         ...
 
+    def update_order(self, order_id: str, price: float, amount: float, exchange: str | None = None) -> Order:
+        """Update an existing limit order with new price and amount.
+
+        Args:
+            order_id: ID of the order to update
+            price: New price for the order
+            amount: New amount for the order
+            exchange: Exchange to update on (optional, defaults to first exchange)
+
+        Returns:
+            Order: The updated order object
+
+        Raises:
+            OrderNotFound: If the order is not found
+            BadRequest: If the order is not a limit order or other validation errors
+            InvalidOrderParameters: If the update parameters are invalid
+        """
+        ...
+
     def exchanges(self) -> list[str]: ...