Qubx 0.6.90__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.91__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/account.py

@@ -42,7 +42,7 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
                 _pos = self.get_position(instrument)
                 _pos.reset_by_position(position)
 
-    def get_orders(self, instrument: Instrument | None = None) -> dict[str, Order]:
+    def get_orders(self, instrument: Instrument | None = None, exchange: str | None = None) -> dict[str, Order]:
         return self._exchange.get_open_orders(instrument)
 
     def get_position(self, instrument: Instrument) -> Position:

qubx/cli/commands.py

@@ -69,11 +69,14 @@ def main(debug: bool, debug_port: int, log_level: str):
 @click.option(
     "--jupyter", "-j", is_flag=True, default=False, help="Run strategy in jupyter console.", show_default=True
 )
+@click.option(
+    "--textual", "-t", is_flag=True, default=False, help="Run strategy in textual TUI.", show_default=True
+)
 @click.option(
     "--restore", "-r", is_flag=True, default=False, help="Restore strategy state from previous run.", show_default=True
 )
 @click.option("--no-color", is_flag=True, default=False, help="Disable colored logging output.", show_default=True)
-def run(config_file: Path, account_file: Path | None, paper: bool, jupyter: bool, restore: bool, no_color: bool):
+def run(config_file: Path, account_file: Path | None, paper: bool, jupyter: bool, textual: bool, restore: bool, no_color: bool):
     """
     Starts the strategy with the given configuration file. If paper mode is enabled, account is not required.
 
@@ -84,12 +87,21 @@ def run(config_file: Path, account_file: Path | None, paper: bool, jupyter: bool
     """
     from qubx.utils.misc import add_project_to_system_path, logo
     from qubx.utils.runner.runner import run_strategy_yaml, run_strategy_yaml_in_jupyter
+    from qubx.utils.runner.textual import run_strategy_yaml_in_textual
+
+    # Ensure jupyter and textual are mutually exclusive
+    if jupyter and textual:
+        click.echo("Error: --jupyter and --textual cannot be used together.", err=True)
+        raise click.Abort()
 
     add_project_to_system_path()
     add_project_to_system_path(str(config_file.parent.parent))
     add_project_to_system_path(str(config_file.parent))
+
     if jupyter:
         run_strategy_yaml_in_jupyter(config_file, account_file, paper, restore)
+    elif textual:
+        run_strategy_yaml_in_textual(config_file, account_file, paper, restore)
     else:
         logo()
         run_strategy_yaml(config_file, account_file, paper=paper, restore=restore, blocking=True, no_color=no_color)

qubx/connectors/ccxt/account.py

@@ -337,7 +337,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         current_pos.change_position_by(timestamp, quantity_diff, _current_price)
 
     def _get_start_time_in_ms(self, days_before: int) -> int:
-        return (self.time_provider.time() - days_before * pd.Timedelta("1d")).asm8.item() // 1000000
+        return (self.time_provider.time() - days_before * pd.Timedelta("1d")).asm8.item() // 1000000  # type: ignore
 
     def _is_our_order(self, order: Order) -> bool:
         if order.client_id is None:
@@ -365,7 +365,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         _fetch_instruments: list[Instrument] = []
         for instr in instruments:
             _dt, _ = self._instrument_to_last_price.get(instr, (None, None))
-            if _dt is None or pd.Timedelta(_current_time - _dt) > pd.Timedelta(self.balance_interval):
+            if _dt is None or pd.Timedelta(_current_time - _dt) > pd.Timedelta(self.balance_interval):  # type: ignore
                 _fetch_instruments.append(instr)
 
         _symbol_to_instrument = {instr.symbol: instr for instr in instruments}
@@ -506,6 +506,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         deals: list[Deal] = [ccxt_convert_deal_info(o) for o in deals_data]
         return sorted(deals, key=lambda x: x.time) if deals else []
 
+    # TODO: this should take the exchange manager instead of cxp.Exchange
     async def _listen_to_stream(
         self,
         subscriber: Callable[[], Awaitable[None]],

qubx/connectors/ccxt/broker.py

@@ -42,6 +42,7 @@ class CcxtBroker(IBroker):
         max_cancel_retries: int = 10,
         enable_create_order_ws: bool = False,
         enable_cancel_order_ws: bool = False,
+        enable_edit_order_ws: bool = False,
     ):
         self._exchange_manager = exchange_manager
         self.ccxt_exchange_id = str(self._exchange_manager.exchange.name)
@@ -54,6 +55,7 @@ class CcxtBroker(IBroker):
         self.max_cancel_retries = max_cancel_retries
         self.enable_create_order_ws = enable_create_order_ws
         self.enable_cancel_order_ws = enable_cancel_order_ws
+        self.enable_edit_order_ws = enable_edit_order_ws
 
     @property
     def _loop(self) -> AsyncThreadLoop:
@@ -476,8 +478,6 @@ class CcxtBroker(IBroker):
             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")
@@ -496,7 +496,7 @@ class CcxtBroker(IBroker):
 
         logger.debug(
             f"[<g>{instrument.symbol}</g>] :: Updating order {order_id}: "
-            f"{amount} @ {price} (was: {existing_order.quantity} @ {existing_order.price})"
+            f"{amount} @ {price} (was: {existing_order.quantity} @ {existing_order.price} ({existing_order.time_in_force}))"
         )
 
         try:
@@ -511,8 +511,6 @@ class CcxtBroker(IBroker):
 
     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()
 
@@ -521,15 +519,13 @@ class CcxtBroker(IBroker):
 
         if updated_order is not None:
             self.account.process_order(updated_order)
-            logger.debug(f"Direct update successful for order {order_id}")
+            logger.debug(f"[<g>{existing_order.instrument.symbol}</g>] :: Successfully updated 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")
@@ -544,7 +540,9 @@ class CcxtBroker(IBroker):
             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}")
+        logger.debug(
+            f"[<g>{existing_order.instrument.symbol}</g>] :: Successfully updated order {order_id} -> new order {updated_order.id}"
+        )
         return updated_order
 
     async def _edit_order_async(
@@ -555,9 +553,18 @@ class CcxtBroker(IBroker):
             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={}
-            )
+            # CCXT requires positive amount (side determines direction)
+            abs_amount = abs(amount)
+
+            # Use WebSocket if enabled, otherwise use REST API
+            if self.enable_edit_order_ws:
+                result = await self._exchange_manager.exchange.edit_order_ws(
+                    id=order_id, symbol=ccxt_symbol, type="limit", side=ccxt_side, amount=abs_amount, price=price, params={}
+                )
+            else:
+                result = await self._exchange_manager.exchange.edit_order(
+                    id=order_id, symbol=ccxt_symbol, type="limit", side=ccxt_side, amount=abs_amount, price=price, params={}
+                )
 
             # Convert the result back to our Order format
             updated_order = ccxt_convert_order_info(existing_order.instrument, result)

qubx/connectors/ccxt/connection_manager.py

@@ -13,6 +13,7 @@ from collections import defaultdict
 from typing import Awaitable, Callable
 
 from ccxt import ExchangeClosedByUser, ExchangeError, ExchangeNotAvailable, NetworkError
+from ccxt.async_support.base.ws.client import Client as _WsClient
 from ccxt.pro import Exchange
 from qubx import logger
 from qubx.core.basics import CtrlChannel
@@ -23,6 +24,19 @@ from .exchange_manager import ExchangeManager
 from .subscription_manager import SubscriptionManager
 
 
+def _safe_buffer(self):
+    conn = getattr(self.connection, "_conn", None)
+    if not conn or not getattr(conn, "protocol", None):
+        return b""
+    payload = getattr(conn.protocol, "_payload", None)
+    buf = getattr(payload, "_buffer", None)
+    return buf if buf is not None else b""
+
+
+# SAFETY PATCH: make ccxt WS buffer access resilient to closed connections
+_WsClient.buffer = property(_safe_buffer)  # type: ignore
+
+
 class ConnectionManager:
     """
     Manages WebSocket connections and stream lifecycle for CCXT data provider.

qubx/connectors/ccxt/exchanges/__init__.py

@@ -12,6 +12,7 @@ from .binance.broker import BinanceCcxtBroker
 from .binance.exchange import BINANCE_UM_MM, BinancePortfolioMargin, BinanceQV, BinanceQVUSDM
 from .bitfinex.bitfinex import BitfinexF
 from .bitfinex.bitfinex_account import BitfinexAccountProcessor
+from .hyperliquid.account import HyperliquidAccountProcessor
 from .hyperliquid.broker import HyperliquidCcxtBroker
 from .hyperliquid.hyperliquid import Hyperliquid, HyperliquidF
 from .kraken.kraken import CustomKrakenFutures
@@ -45,12 +46,14 @@ CUSTOM_BROKERS = {
     "binance.cm": partial(BinanceCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
     "binance.pm": partial(BinanceCcxtBroker, enable_create_order_ws=False, enable_cancel_order_ws=False),
     "bitfinex.f": partial(CcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=True),
-    "hyperliquid": partial(HyperliquidCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
-    "hyperliquid.f": partial(HyperliquidCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
+    "hyperliquid": partial(HyperliquidCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False, enable_edit_order_ws=True),
+    "hyperliquid.f": partial(HyperliquidCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False, enable_edit_order_ws=True),
 }
 
 CUSTOM_ACCOUNTS = {
     "bitfinex.f": BitfinexAccountProcessor,
+    "hyperliquid": HyperliquidAccountProcessor,
+    "hyperliquid.f": HyperliquidAccountProcessor,
 }
 
 READER_CAPABILITIES = {

qubx/connectors/ccxt/exchanges/hyperliquid/__init__.py

@@ -1,6 +1,7 @@
 # Hyperliquid exchange overrides
 
+from .account import HyperliquidAccountProcessor
 from .broker import HyperliquidCcxtBroker
-from .hyperliquid import HyperliquidF
+from .hyperliquid import Hyperliquid, HyperliquidF
 
-__all__ = ["HyperliquidF", "HyperliquidCcxtBroker"]
+__all__ = ["HyperliquidAccountProcessor", "HyperliquidCcxtBroker", "Hyperliquid", "HyperliquidF"]

qubx/connectors/ccxt/exchanges/hyperliquid/account.py

@@ -0,0 +1,75 @@
+import asyncio
+
+from qubx import logger
+from qubx.connectors.ccxt.account import CcxtAccountProcessor
+from qubx.connectors.ccxt.utils import (
+    ccxt_convert_order_info,
+    ccxt_extract_deals_from_exec,
+    ccxt_find_instrument,
+)
+from qubx.core.basics import CtrlChannel, Instrument
+from qubx.utils.time import now_utc, timestamp_to_ms
+
+
+class HyperliquidAccountProcessor(CcxtAccountProcessor):
+    """
+    Hyperliquid-specific account processor.
+
+    Hyperliquid uses separate WebSocket channels:
+    - orderUpdates: for order status (watch_orders)
+    - userFills: for trade/fill updates (watch_my_trades)
+
+    Unlike Binance, Hyperliquid's watch_orders does NOT include trades,
+    so we must subscribe to both channels separately.
+    """
+
+    async def _subscribe_instruments(self, instruments: list[Instrument]):
+        """Override to filter out instruments from other exchanges (e.g., spot vs futures)."""
+        # Filter instruments to only those belonging to this exchange
+        exchange_name = self.exchange_manager.exchange.name
+        matching_instruments = [instr for instr in instruments if instr.exchange == exchange_name]
+
+        if len(matching_instruments) < len(instruments):
+            skipped = [instr for instr in instruments if instr.exchange != exchange_name]
+            logger.debug(f"Skipping subscription for {len(skipped)} instruments from other exchanges: {skipped}")
+
+        # Call parent with filtered instruments
+        if matching_instruments:
+            await super()._subscribe_instruments(matching_instruments)
+
+    async def _subscribe_executions(self, name: str, channel: CtrlChannel):
+        logger.info("<yellow>[Hyperliquid]</yellow> Subscribing to executions")
+        _symbol_to_instrument = {}
+
+        async def _watch_orders():
+            orders = await self.exchange_manager.exchange.watch_orders()
+            for order in orders:
+                instrument = ccxt_find_instrument(
+                    order["symbol"], self.exchange_manager.exchange, _symbol_to_instrument
+                )
+                order = ccxt_convert_order_info(instrument, order)
+                channel.send((instrument, "order", order, False))
+
+        async def _watch_my_trades():
+            trades = await self.exchange_manager.exchange.watch_my_trades(since=timestamp_to_ms(now_utc()))
+            for trade in trades:  # type: ignore
+                instrument = ccxt_find_instrument(
+                    trade["symbol"], self.exchange_manager.exchange, _symbol_to_instrument
+                )
+                deals = ccxt_extract_deals_from_exec({"trades": [trade]})
+                channel.send((instrument, "deals", deals, False))
+
+        await asyncio.gather(
+            self._listen_to_stream(
+                subscriber=_watch_orders,
+                exchange=self.exchange_manager.exchange,
+                channel=channel,
+                name=f"{name}_orders",
+            ),
+            self._listen_to_stream(
+                subscriber=_watch_my_trades,
+                exchange=self.exchange_manager.exchange,
+                channel=channel,
+                name=f"{name}_trades",
+            ),
+        )

qubx/connectors/ccxt/exchanges/hyperliquid/broker.py

@@ -1,8 +1,15 @@
 from typing import Any
 
+import pandas as pd
+
 from qubx import logger
 from qubx.connectors.ccxt.broker import CcxtBroker
-from qubx.core.basics import Instrument, OrderSide
+from qubx.connectors.ccxt.utils import ccxt_convert_order_info, instrument_to_ccxt_symbol
+from qubx.core.basics import (
+    Instrument,
+    Order,
+    OrderSide,
+)
 from qubx.core.exceptions import BadRequest
 
 
@@ -17,12 +24,164 @@ class HyperliquidCcxtBroker(CcxtBroker):
     def __init__(
         self,
         *args,
-        market_order_slippage: float = 0.01,  # 5% default slippage
+        market_order_slippage: float = 0.05,  # 5% default slippage
         **kwargs,
     ):
         super().__init__(*args, **kwargs)
         self.market_order_slippage = market_order_slippage
 
+    def _enrich_order_response(
+        self,
+        response: dict[str, Any],
+        symbol: str,
+        order_type: str,
+        side: str,
+        amount: float,
+        price: float | None = None,
+        client_id: str | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Fill in missing fields in HyperLiquid order response.
+
+        HyperLiquid often returns minimal order information (sometimes only order ID),
+        so we need to reconstruct the full order from the request parameters.
+
+        Args:
+            response: The raw response from HyperLiquid
+            symbol: CCXT symbol (e.g., "BTC/USDC:USDC")
+            order_type: Order type ("limit" or "market")
+            side: Order side ("buy" or "sell")
+            amount: Order amount
+            price: Order price (optional for market orders)
+            client_id: Client order ID (optional)
+            params: Additional params (timeInForce, reduceOnly, etc.)
+
+        Returns:
+            Enriched response dictionary ready for ccxt_convert_order_info
+        """
+        if params is None:
+            params = {}
+
+        # Fill in missing fields from the request parameters
+        if not response.get("symbol"):
+            response["symbol"] = symbol
+        if not response.get("type"):
+            response["type"] = order_type
+        # Always set side from request params (CCXT can't parse from resting/filled structures)
+        if not response.get("side") or response.get("side") == "unknown":
+            response["side"] = side
+        if not response.get("amount") or response.get("amount") == 0:
+            response["amount"] = amount
+        if not response.get("price") or response.get("price") == 0:
+            if price is not None:
+                response["price"] = price
+        if not response.get("timestamp"):
+            response["timestamp"] = pd.Timestamp.now(tz="UTC").value // 1_000_000  # Convert to milliseconds
+        if not response.get("status"):
+            response["status"] = "open"
+        if not response.get("timeInForce"):
+            response["timeInForce"] = params.get("timeInForce")
+        if not response.get("clientOrderId") and client_id:
+            response["clientOrderId"] = client_id
+        if not response.get("cost"):
+            response["cost"] = 0.0
+
+        # Ensure reduceOnly is propagated
+        if params.get("reduceOnly"):
+            response["reduceOnly"] = True
+
+        return response
+
+    def _translate_time_in_force(self, tif: str | None) -> str | None:
+        """
+        Translate standard timeInForce values to HyperLiquid format.
+
+        HyperLiquid uses:
+        - "Alo" for Add Liquidity Only (post-only/maker)
+        - "Ioc" for Immediate or Cancel
+        - "Gtc" for Good til Cancelled
+
+        This method translates common aliases:
+        - GTX (Binance post-only) → Alo
+        - FOK (Fill or Kill) → Ioc
+        - GTC, IOC, ALO (any case) → proper HyperLiquid format
+        """
+        if tif is None:
+            return None
+
+        # If already in correct HyperLiquid format, return as-is
+        if tif in ["Alo", "Ioc", "Gtc"]:
+            return tif
+
+        # Translation map for timeInForce values
+        tif_map = {
+            "GTX": "Alo",  # Binance post-only → Hyperliquid post-only
+            "FOK": "Ioc",  # Fill or Kill → Immediate or Cancel
+            "GTC": "Gtc",  # Good til Cancelled (normalize case)
+            "IOC": "Ioc",  # Immediate or Cancel (normalize case)
+            "ALO": "Alo",  # Add Liquidity Only (normalize case)
+        }
+
+        # Normalize to uppercase for lookup
+        tif_upper = tif.upper()
+        return tif_map.get(tif_upper, tif)  # Return translated or original if not in map
+
+    async def _create_order(
+        self,
+        instrument: Instrument,
+        order_side: OrderSide,
+        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]:
+        """
+        Override _create_order to fill missing order details from request.
+
+        HyperLiquid returns minimal order information (only order ID),
+        so we need to reconstruct the full order from the request parameters.
+        """
+        try:
+            payload = self._prepare_order_payload(
+                instrument, order_side, order_type, amount, price, client_id, time_in_force, **options
+            )
+            if self.enable_create_order_ws:
+                r = await self._exchange_manager.exchange.create_order_ws(**payload)
+            else:
+                r = await self._exchange_manager.exchange.create_order(**payload)
+
+            if r is None:
+                msg = "(::_create_order) No response from exchange"
+                logger.error(msg)
+                from ccxt.base.errors import ExchangeError
+
+                return None, ExchangeError(msg)
+
+            if r["id"] is None:
+                return None, None
+
+            # Fill in missing fields from the request parameters
+            r = self._enrich_order_response(
+                response=r,
+                symbol=payload["symbol"],
+                order_type=payload["type"],
+                side=payload["side"],
+                amount=payload["amount"],
+                price=payload["price"],
+                client_id=client_id,
+                params=payload["params"],
+            )
+
+            order = ccxt_convert_order_info(instrument, r)
+            logger.info(f"New order {order}")
+            return order, None
+
+        except Exception as err:
+            return None, err
+
     def _prepare_order_payload(
         self,
         instrument: Instrument,
@@ -67,11 +226,81 @@ class HyperliquidCcxtBroker(CcxtBroker):
             instrument, order_side, order_type, amount, price, client_id, time_in_force, **options
         )
 
-        # Add slippage parameter to params if specified in options
+        # Translate timeInForce to HyperLiquid format (GTX → Alo, etc.)
         params = payload.get("params", {})
+        if "timeInForce" in params:
+            params["timeInForce"] = self._translate_time_in_force(params["timeInForce"])
+
+        # Add slippage parameter to params if specified in options
         if "slippage" in options:
             # HyperLiquid accepts slippage as a percentage (e.g., 0.05 for 5%)
             params["px"] = price  # Explicit price for slippage calculation
 
         payload["params"] = params
         return payload
+
+    async def _edit_order_async(
+        self, order_id: str, existing_order: Order, price: float, amount: float
+    ) -> tuple[Order | None, Exception | None]:
+        """
+        Override _edit_order_async with WebSocket support and response enrichment.
+
+        HyperLiquid requires params to match the original order and may return
+        minimal order information, so we fill missing fields from the request.
+        """
+        try:
+            ccxt_symbol = instrument_to_ccxt_symbol(existing_order.instrument)
+            ccxt_side = "buy" if existing_order.side == "BUY" else "sell"
+
+            params = {}
+            if existing_order.time_in_force:
+                # Translate TIF to HyperLiquid format (GTX → Alo, etc.)
+                params["timeInForce"] = self._translate_time_in_force(existing_order.time_in_force)
+            else:
+                # If no TIF is set on the existing order, default to Alo (post-only) for limit orders
+                # This is the safest default for market making
+                params["timeInForce"] = "Alo"
+            if existing_order.options.get("reduceOnly", False):
+                params["reduceOnly"] = True
+
+            # Use WebSocket if enabled, otherwise use REST API
+            if self.enable_edit_order_ws:
+                result = await self._exchange_manager.exchange.edit_order_ws(
+                    id=order_id,
+                    symbol=ccxt_symbol,
+                    type="limit",
+                    side=ccxt_side,
+                    amount=amount,
+                    price=price,
+                    params=params,
+                )
+            else:
+                result = await self._exchange_manager.exchange.edit_order(
+                    id=order_id,
+                    symbol=ccxt_symbol,
+                    type="limit",
+                    side=ccxt_side,
+                    amount=amount,
+                    price=price,
+                    params=params,
+                )
+
+            # Fill in missing fields from the request parameters
+            result = self._enrich_order_response(
+                response=result,
+                symbol=ccxt_symbol,
+                order_type="limit",
+                side=ccxt_side,
+                amount=amount,
+                price=price,
+                client_id=existing_order.client_id,
+                params=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

qubx/connectors/ccxt/exchanges/hyperliquid/hyperliquid.py

@@ -2,6 +2,8 @@ import math
 from typing import Any, Dict, List, Optional
 
 import ccxt.pro as cxp
+from ccxt.async_support.base.ws.client import Client
+from ccxt.base.errors import ExchangeError, InvalidOrder
 from qubx import logger
 
 from ...adapters.polling_adapter import PollingConfig, PollingToWebSocketAdapter
@@ -50,6 +52,67 @@ class HyperliquidEnhanced(CcxtFuturePatchMixin, cxp.hyperliquid):
             0.0,  # bought_volume_quote (not provided by Hyperliquid)
         ]
 
+    def handle_error_message(self, client: Client, message) -> bool:
+        """
+        Override CCXT's handle_error_message to fix the bug where error strings
+        are passed to client.reject() instead of Exception objects.
+
+        This method also adds detailed logging for debugging order failures.
+
+        CCXT Bug: Lines 908, 919, 924 in ccxt/pro/hyperliquid.py pass error strings
+        to client.reject(), but Future.set_exception() requires Exception objects.
+        """
+        # Log the raw message for debugging
+        # logger.debug(f"[Hyperliquid WS Error] Raw message: {self.json(message)}")
+
+        # Check for direct error channel
+        channel = self.safe_string(message, "channel", "")
+        if channel == "error":
+            ret_msg = self.safe_string(message, "data", "")
+            error_msg = f"{self.id} {ret_msg}"
+            logger.error(f"[Hyperliquid WS Error] Channel error: {error_msg}")
+            # FIX: Wrap in Exception instead of passing string
+            client.reject(ExchangeError(error_msg))
+            return True
+
+        # Check response payload for errors
+        data = self.safe_dict(message, "data", {})
+        id = self.safe_string(message, "id")
+        if id is None:
+            id = self.safe_string(data, "id")
+
+        response = self.safe_dict(data, "response", {})
+        payload = self.safe_dict(response, "payload", {})
+
+        # Check for status != 'ok'
+        status = self.safe_string(payload, "status")
+        if status is not None and status != "ok":
+            error_msg = f"{self.id} {self.json(payload)}"
+            logger.error(f"[Hyperliquid WS Error] Status not ok: {error_msg}")
+            # FIX: Wrap in Exception instead of passing string
+            client.reject(InvalidOrder(error_msg), id)
+            return True
+
+        # Check for explicit error type
+        type = self.safe_string(payload, "type")
+        if type == "error":
+            error_msg = f"{self.id} {self.json(payload)}"
+            logger.error(f"[Hyperliquid WS Error] Explicit error type: {error_msg}")
+            # FIX: Wrap in Exception instead of passing string
+            client.reject(ExchangeError(error_msg), id)
+            return True
+
+        # Try standard error handling
+        try:
+            self.handle_errors(0, "", "", "", {}, self.json(payload), payload, {}, {})
+        except Exception as e:
+            logger.error(f"[Hyperliquid WS Error] handle_errors exception: {e}")
+            # This is already an Exception, so it's safe to pass
+            client.reject(e, id)
+            return True
+
+        return False
+
     async def watch_funding_rates(
         self, symbols: Optional[List[str]] = None, params: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
@@ -200,6 +263,26 @@ class HyperliquidEnhanced(CcxtFuturePatchMixin, cxp.hyperliquid):
                 if cloid and parsed.get("clientOrderId") is None:
                     parsed["clientOrderId"] = cloid
 
+                # Fix timeInForce from tif field
+                # HyperLiquid uses: "Gtc", "Ioc", "Alo"
+                tif = order_info.get("tif")
+                if tif and not parsed.get("timeInForce"):
+                    parsed["timeInForce"] = tif
+                    # logger.debug(f"[HL parse_order] Extracted timeInForce='{tif}' from order {order_info.get('oid')}")
+                # elif not tif:
+                #     oid = order_info.get("oid", "unknown")
+                # logger.warning(
+                #     f"[HL parse_order] No 'tif' field found in order {oid}, raw order_info keys: {list(order_info.keys()) if isinstance(order_info, dict) else 'not a dict'}"
+                # )
+
+                # Fix reduceOnly from reduceOnly field
+                reduce_only = order_info.get("reduceOnly")
+                if reduce_only is not None and not parsed.get("reduceOnly"):
+                    parsed["reduceOnly"] = bool(reduce_only)
+                    logger.debug(
+                        f"[HL parse_order] Extracted reduceOnly={reduce_only} from order {order_info.get('oid')}"
+                    )
+
             # Fix status from HyperLiquid status field
             hl_status = info.get("status")
             if hl_status and parsed.get("status") in [None, "open"]: