hypertrader 0.1.4__tar.gz → 0.1.6__tar.gz

{hypertrader-0.1.4 → hypertrader-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypertrader
-Version: 0.1.4
+Version: 0.1.6
 Summary: Async Hyperliquid trading helper built on the async SDK.
 Author: darkerego
 License: MIT

{hypertrader-0.1.4 → hypertrader-0.1.6}/hypertrader.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypertrader
-Version: 0.1.4
+Version: 0.1.6
 Summary: Async Hyperliquid trading helper built on the async SDK.
 Author: darkerego
 License: MIT

{hypertrader-0.1.4 → hypertrader-0.1.6}/hypertrader.py

@@ -23,10 +23,9 @@ import os
 import sys
 from typing import Any, Dict, List, Optional
 
-import uvloop
+
 from hyperliquid.info import Info
 
-from modes.auto_trader import run_auto_trader
 from modes.market_maker import run_market_maker
 from modes.position_management import run_bracket_entry
 from modes.position_watcher import run_position_watcher
@@ -35,18 +34,16 @@ from utils.constants import DEFAULT_LOG_FILE, INTERVAL_TO_MS
 from utils.helpers import parse_fractional_pct
 from utils.style import install_pretty_stdout
 
-try:
-    import numpy as np
-    import talib
-except Exception:  # TA-Lib is only required for the auto command.
-    np = None  # type: ignore[assignment]
-    talib = None  # type: ignore[assignment]
-
 try:
     os.mkdir("logs")
 except FileExistsError:
     pass
 
+try:
+    import uvloop
+except ImportError:
+    uvloop = None
+
 decimal.getcontext().prec = 4
 install_pretty_stdout()
 
@@ -525,6 +522,8 @@ async def async_main(argv: Optional[List[str]] = None) -> None:
         return
 
     if args.command == "auto":
+        from modes.auto_trader import run_auto_trader
+
         if args.size is not None and args.size <= 0.0:
             print("[ERROR] --size must be > 0.")
             sys.exit(1)
@@ -744,5 +743,8 @@ def main(argv: Optional[List[str]] = None) -> None:
 
 
 if __name__ == "__main__":
-    uvloop.install()
+    if uvloop:
+        uvloop.install()
+    else:
+        print('[WARN]: Please install uvloop for increased performance. Reverting to standard event loop.')
     main()

{hypertrader-0.1.4 → hypertrader-0.1.6}/modes/auto_trader.py

@@ -5,8 +5,6 @@ import logging
 import math
 import os
 import time
-import numpy as np
-import talib
 from dataclasses import dataclass
 from typing import Optional, List, Dict, Any, Tuple
 
@@ -18,11 +16,18 @@ from utils.constants import AUTO_TRADES_LOG_FILE, INTERVAL_TO_MS, cp
 from utils.helpers import parse_interval_list, init_clients, _try_float, parse_fractional_pct, \
     extract_account_balance_from_user_state, round_size_for_hyperliquid, get_user_state_with_retry, get_all_mids, \
     fetch_recent_candles, compute_position_unrealized_pnl, close_clients, compute_default_stop_loss_pct, \
-    extract_closed_pnl_from_fill, is_rate_limit_error
+    extract_closed_pnl_from_fill, is_rate_limit_error, get_user_fills_since
 
 logger = logging.getLogger(__name__)
 _AUTO_TRADES_LOGGER: Optional[logging.Logger] = None
 
+try:
+    import numpy as np
+    import talib
+except Exception:  # TA-Lib is only required for the auto command.
+    np = None  # type: ignore[assignment]
+    talib = None  # type: ignore[assignment]
+
 
 def get_auto_trades_logger() -> logging.Logger:
     """Return the dedicated auto-trade completion logger."""
@@ -825,7 +830,7 @@ async def build_auto_scan_loop_snapshot(
     account_balance = extract_account_balance_from_user_state(user_state)
 
     mids_task = asyncio.create_task(get_all_mids(info))
-    fills_task = asyncio.create_task(info.user_fills_by_time(account_address, metrics_start_time_ms))
+    fills_task = asyncio.create_task(get_user_fills_since(info, account_address, metrics_start_time_ms))
 
     mids = await mids_task
 
@@ -2410,7 +2415,12 @@ async def run_auto_trader(
                     launch_specs.append((candidate.coin, candidate.decision, resolved_size))
                     reserved_coins.add(candidate.coin)
                     if len(launch_specs) >= available_slots:
-                        continue
+                        print(
+                            f"[AUTO] Reached max new launches for this scan batch "
+                            f"({len(launch_specs)}/{available_slots} available slot(s)); "
+                            f"deferring remaining candidates."
+                        )
+                        break
             except Exception as exc:
                 logger.error(exc)
 

{hypertrader-0.1.4 → hypertrader-0.1.6}/modes/position_management.py

@@ -13,7 +13,7 @@ from utils.helpers import init_clients, get_position_for_coin, \
     position_is_directional_add, \
     fmt_optional_float, format_account_metrics, is_rate_limit_error, \
     round_size_for_hyperliquid, get_position_size_for_coin, AccountRuntimeMetrics, get_best_bid_ask, \
-    round_price_for_hyperliquid, extract_order_error, close_clients, fetch_recent_candles
+    round_price_for_hyperliquid, extract_order_error, close_clients, fetch_recent_candles, get_ws_cache
 
 try:
     import numpy as np
@@ -57,10 +57,17 @@ async def get_frontend_open_orders_for_coin(
         info: Info,
         account_address: str,
         coin: str,
+        *,
+        force_http: bool = False,
 ) -> List[Dict[str, Any]]:
     """Return frontend open orders for a coin, including reduceOnly/isTrigger fields."""
     try:
-        orders = await info.frontend_open_orders(account_address)
+        cache = get_ws_cache(info)
+        if cache is not None and not force_http:
+            cached_orders = await cache.get_frontend_open_orders(force_refresh=False)
+            orders = cached_orders if cached_orders is not None else await info.frontend_open_orders(account_address)
+        else:
+            orders = await info.frontend_open_orders(account_address)
     except Exception:
         logging.getLogger("hypertrader").exception(
             "[WARN] Failed to fetch frontend open orders for %s.",
@@ -308,7 +315,7 @@ async def cancel_entry_orders_for_coin(
     order snapshot and removes any leftover non-reduce-only orders for the same
     coin/side. Reduce-only TP orders are intentionally left alone.
     """
-    orders = await get_frontend_open_orders_for_coin(info, account_address, coin)
+    orders = await get_frontend_open_orders_for_coin(info, account_address, coin, force_http=True)
     oids: List[int] = []
     for order in orders:
         try:
@@ -327,7 +334,7 @@ async def cancel_entry_orders_for_coin(
     # limit orders, so anything found here before market fallback is treated as
     # an entry-order candidate.
     if not oids:
-        fallback_orders = await get_open_orders_for_coin(info, account_address, coin)
+        fallback_orders = await get_open_orders_for_coin(info, account_address, coin, force_http=True)
         for order in fallback_orders:
             try:
                 if is_buy is not None and not order_side_matches(order, is_buy):
@@ -395,7 +402,7 @@ async def cancel_reduce_only_orders_for_coin(
         only_tpsl: bool = False,
 ) -> None:
     """Cancel reduce-only orders for a coin, optionally limiting to TP/SL trigger orders."""
-    orders = await get_frontend_open_orders_for_coin(info, account_address, coin)
+    orders = await get_frontend_open_orders_for_coin(info, account_address, coin, force_http=True)
     oids: List[int] = []
     for order in orders:
         try:
@@ -418,7 +425,7 @@ async def get_open_reduce_only_take_profit_orders_for_coin(
         coin: str,
 ) -> List[Dict[str, Any]]:
     """Return open reduce-only non-trigger TP limit orders for a coin."""
-    orders = await get_frontend_open_orders_for_coin(info, account_address, coin)
+    orders = await get_frontend_open_orders_for_coin(info, account_address, coin, force_http=False)
     tp_orders: List[Dict[str, Any]] = []
     for order in orders:
         try:
@@ -532,7 +539,7 @@ async def exit_on_tp_reversal(
     limit_oids = extract_resting_oids(limit_resp)
 
     await asyncio.sleep(min(max(poll_interval * 0.25, 0.1), 0.5))
-    live_pos = await get_position_for_coin(info, account_address, coin)
+    live_pos = await get_position_for_coin(info, account_address, coin, force_http=True)
     if live_pos is None:
         print(f"[TP-REVERSAL EXIT] {coin} fully closed on the limit order.")
         return True
@@ -568,7 +575,7 @@ async def exit_on_tp_reversal(
     deadline = time.time() + wait_seconds
     while time.time() < deadline:
         await asyncio.sleep(min(max(poll_interval, 0.2), 1.0))
-        live_pos = await get_position_for_coin(info, account_address, coin)
+        live_pos = await get_position_for_coin(info, account_address, coin, force_http=True)
         if live_pos is None:
             print(f"[TP-REVERSAL EXIT] {coin} flat after paired limit/stop exit.")
             return True
@@ -587,7 +594,7 @@ async def exit_on_tp_reversal(
     if stop_oid is not None:
         await cancel_oids(exchange, coin, [stop_oid], "tp reversal stop orders")
 
-    live_pos = await get_position_for_coin(info, account_address, coin)
+    live_pos = await get_position_for_coin(info, account_address, coin, force_http=True)
     if live_pos is None:
         print(f"[TP-REVERSAL EXIT] {coin} flat after canceling remaining exit orders.")
         return True
@@ -621,7 +628,7 @@ async def close_position_remainder_with_market_retries(
         await cancel_reduce_only_orders_for_coin(info, exchange, account_address, coin, only_tpsl=False)
         await asyncio.sleep(settle_before_close)
 
-        remainder_pos = await get_position_for_coin(info, account_address, coin)
+        remainder_pos = await get_position_for_coin(info, account_address, coin, force_http=True)
         if remainder_pos is None:
             print(f"[{label}] {coin} is already flat after cleanup.")
             return True
@@ -651,7 +658,7 @@ async def close_position_remainder_with_market_retries(
             continue
 
         await asyncio.sleep(settle_after_close)
-        final_remainder_pos = await get_position_for_coin(info, account_address, coin)
+        final_remainder_pos = await get_position_for_coin(info, account_address, coin, force_http=True)
         if final_remainder_pos is None:
             print(f"[{label}] {coin} fully closed after residual market exit.")
             return True
@@ -763,7 +770,7 @@ async def enter_position_with_reposting_limit(
         raise RuntimeError("entry_tif must be Alo or Gtc.")
 
     size = await round_size_for_hyperliquid(info, coin, size)
-    initial_pos = await get_position_size_for_coin(info, account_address, coin)
+    initial_pos = await get_position_size_for_coin(info, account_address, coin, force_http=True)
     direction_label = "LONG" if is_buy else "SHORT"
 
     if initial_pos != 0.0:
@@ -789,11 +796,11 @@ async def enter_position_with_reposting_limit(
 
     async def get_entry_progress() -> Tuple[float, float, float, str, AccountRuntimeMetrics]:
         """Return current_pos, filled_delta, remaining_size, formatted uPnL, account metrics."""
-        _current_pos = await get_position_size_for_coin(info, account_address, coin)
+        _current_pos = await get_position_size_for_coin(info, account_address, coin, force_http=True)
         filled_delta = signed_position_delta(initial_pos, _current_pos, is_buy)
         remaining_size = max(0.0, size - filled_delta)
 
-        pos_snapshot = await get_position_for_coin(info, account_address, coin)
+        pos_snapshot = await get_position_for_coin(info, account_address, coin, force_http=True)
         mids = await get_all_mids(info)
         mid_price_raw = mids.get(coin)
         _upnl_str = "N/A"
@@ -872,6 +879,7 @@ async def enter_position_with_reposting_limit(
                 f"[ENTRY {attempt}/{retries}] modifying oid={active_oid} -> "
                 f"{side} {remaining:.8f} {coin} @ {limit_px:.8f} ({entry_tif}, top-of-book)"
             )
+            prev_active_oid = active_oid
             try:
                 resp = await exchange.modify_order(
                     active_oid,
@@ -899,6 +907,24 @@ async def enter_position_with_reposting_limit(
                 await asyncio.sleep(repost_interval)
                 continue
 
+            resting_oids = extract_resting_oids(resp)
+            if resting_oids:
+                new_oid = int(resting_oids[0])
+                if new_oid != active_oid:
+                    print(f"[ENTRY {attempt}] active entry oid updated {active_oid} -> {new_oid}")
+                active_oid = new_oid
+            else:
+                filled_now = extract_filled_qty(resp)
+                if filled_now > 0.0:
+                    print(f"[ENTRY {attempt}] modify filled {filled_now:.8f}; clearing active oid.")
+                    active_oid = None
+                else:
+                    print(
+                        f"[ENTRY {attempt}] modify returned no resting oid or fill for prior oid={prev_active_oid}; "
+                        "will re-check position before another modify."
+                    )
+                    active_oid = None
+
         await asyncio.sleep(repost_interval)
 
     current_pos, filled, remaining, upnl_str, metrics = await get_entry_progress()
@@ -965,7 +991,7 @@ async def enter_position_with_reposting_limit(
             )
 
     await asyncio.sleep(max(0.25, repost_interval))
-    final_pos = await get_position_for_coin(info, account_address, coin)
+    final_pos = await get_position_for_coin(info, account_address, coin, force_http=True)
     if final_pos is None:
         raise RuntimeError(f"No open {coin} position found after entry attempts.")
 
@@ -1213,6 +1239,8 @@ async def monitor_bracket_position(
     favorable_extreme: Optional[float] = None
     tp_zone_seen = False
     tp_remainder_close_in_progress = False
+    tp_remainder_baseline_abs = abs(managed_signed_size)
+    tp_remainder_fill_confirmed = False
 
     try:
         while True:
@@ -1284,6 +1312,8 @@ async def monitor_bracket_position(
                     hidden_tp_oids.clear()
                     tp_level_to_oid = build_tp_level_to_oid_map(tp_orders, tp_oids)
                     tp_remainder_close_in_progress = False
+                    tp_remainder_baseline_abs = live_pos_abs
+                    tp_remainder_fill_confirmed = False
                     if hide_orders:
                         local_stop_px, stop_source = resolve_stop_loss_trigger_px(
                             side,
@@ -1295,6 +1325,9 @@ async def monitor_bracket_position(
                     managed_signed_size = live_signed_size
                     entry_px = live_entry_px
 
+                if live_pos_abs + PRICE_EPS < tp_remainder_baseline_abs:
+                    tp_remainder_fill_confirmed = True
+
                 if dynamic_auto_sar_stop_enabled:
                     try:
                         updated_sar_stop_px, latest_sar_px, latest_sar_close_px, sar_flip_exit = await compute_auto_sar_stop_state(
@@ -1495,6 +1528,13 @@ async def monitor_bracket_position(
                         tp_levels_exhausted = len(open_tp_orders) == 0 and not trailing_tp_armed
 
                     if tp_levels_exhausted and not tp_remainder_close_in_progress:
+                        if not tp_remainder_fill_confirmed:
+                            print(
+                                f"[TP-REMAINDER-WARN] {coin} TP ladder is absent but no TP fill was confirmed "
+                                f"(live_abs={live_pos_abs:.8f}, baseline_abs={tp_remainder_baseline_abs:.8f}). "
+                                "Leaving the position open."
+                            )
+                            continue
                         tp_remainder_close_in_progress = True
                         print(
                             f"[TP-REMAINDER] {coin} take-profit ladder is exhausted; "

{hypertrader-0.1.4 → hypertrader-0.1.6}/modes/position_watcher.py

@@ -6,11 +6,11 @@ from typing import Optional, List, Dict, Any
 from hyperliquid.exchange import Exchange
 from hyperliquid.info import Info
 
-from modes.auto_trader import compute_default_stop_loss_pct
 from modes.position_management import monitor_bracket_position, rebuild_bracket_orders
 from utils.constants import WATCH_RETRY_SLEEP_SECONDS
 from utils.helpers import init_clients, get_all_open_positions, get_all_mids, compute_position_unrealized_pnl, \
-    get_account_runtime_metrics, format_account_metrics, is_rate_limit_error, close_clients
+    get_account_runtime_metrics, format_account_metrics, is_rate_limit_error, close_clients, \
+    compute_default_stop_loss_pct
 
 
 async def attach_bracket_to_existing_position(

{hypertrader-0.1.4 → hypertrader-0.1.6}/setup.py

@@ -9,7 +9,7 @@ README = ROOT / "README.md"
 
 setup(
     name="hypertrader",
-    version="0.1.4",
+    version="0.1.6",
     description="Async Hyperliquid trading helper built on the async SDK.",
     long_description=README.read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",

{hypertrader-0.1.4 → hypertrader-0.1.6}/utils/helpers.py

@@ -7,8 +7,6 @@ from dataclasses import dataclass
 from typing import List, Any, Tuple, Optional, Dict, Awaitable
 
 import eth_account
-import numpy as np
-import talib
 from dotenv import load_dotenv
 from eth_account.signers.local import LocalAccount
 from hyperliquid.exchange import Exchange
@@ -69,11 +67,13 @@ def parse_fractional_pct(value: Any, *, field_name: str) -> float:
 # Credentials / clients
 # ---------------------------------------------------------------------------
 
-def load_credentials() -> Tuple[str, str]:
+def load_credentials(testnet: bool =False) -> Tuple[str, str]:
     """Load Hyperliquid credentials from environment variables."""
     load_dotenv()
-
-    secret_key = os.getenv("HYPERLIQUID_SECRET_KEY")
+    if testnet:
+        secret_key = os.getenv("HYPERLIQUID_TESTNET_SECRET_KEY")
+    else:
+        secret_key = os.getenv("HYPERLIQUID_SECRET_KEY")
     account_address = os.getenv("HYPERLIQUID_ACCOUNT_ADDRESS")
 
     if not secret_key:
@@ -102,8 +102,9 @@ class HyperliquidWebsocketCache:
       * userEvents    -> cached for diagnostics / future event-driven position refresh
       * orderUpdates  -> cached for diagnostics / future order-state refresh
 
-    Position snapshots still use user_state over HTTP because the bracket logic needs
-    authoritative size and average-entry data before rebuilding TP/SL orders.
+    There is no native websocket subscription for clearinghouseState or openOrders in
+    the async SDK. For those, this class keeps REST-backed snapshots that are marked
+    dirty by userEvents / userFills / orderUpdates and refreshed on demand.
     """
 
     def __init__(
@@ -131,9 +132,36 @@ class HyperliquidWebsocketCache:
         self._bbo_sub_ids: Dict[str, int] = {}
 
         self._user_events_sub_id: Optional[int] = None
+        self._user_fills_sub_id: Optional[int] = None
         self._order_updates_sub_id: Optional[int] = None
         self.last_user_event: Optional[Dict[str, Any]] = None
+        self.last_user_fills: Optional[Dict[str, Any]] = None
         self.last_order_update: Optional[Dict[str, Any]] = None
+
+        self._user_state: Optional[Dict[str, Any]] = None
+        self._user_state_updated_at = 0.0
+        self._user_state_ready = asyncio.Event()
+        self._user_state_lock = asyncio.Lock()
+        self._user_state_dirty = True
+
+        self._open_orders: List[Dict[str, Any]] = []
+        self._open_orders_updated_at = 0.0
+        self._open_orders_ready = asyncio.Event()
+        self._open_orders_lock = asyncio.Lock()
+        self._open_orders_dirty = True
+
+        self._frontend_open_orders: List[Dict[str, Any]] = []
+        self._frontend_open_orders_updated_at = 0.0
+        self._frontend_open_orders_ready = asyncio.Event()
+        self._frontend_open_orders_lock = asyncio.Lock()
+        self._frontend_open_orders_dirty = True
+
+        self._user_fills: List[Dict[str, Any]] = []
+        self._user_fill_keys: set[Tuple[Any, ...]] = set()
+        self._user_fills_updated_at = 0.0
+        self._user_fills_ready = asyncio.Event()
+        self._user_fills_lock = asyncio.Lock()
+        self._user_fills_seed_start_ms: Optional[int] = None
         self._candle_buffers: Dict[Tuple[str, str], List[Dict[str, Any]]] = {}
         self._candle_requested_periods: Dict[Tuple[str, str], int] = {}
         self._candle_updated_at: Dict[Tuple[str, str], float] = {}
@@ -224,6 +252,8 @@ class HyperliquidWebsocketCache:
         for sub, attr_name, label, callback in (
                 ({"type": "userEvents", "user": self.account_address}, "_user_events_sub_id", "userEvents",
                  self._on_user_event),
+                ({"type": "userFills", "user": self.account_address}, "_user_fills_sub_id", "userFills",
+                 self._on_user_fills),
                 ({"type": "orderUpdates", "user": self.account_address}, "_order_updates_sub_id", "orderUpdates",
                  self._on_order_update),
         ):
@@ -242,6 +272,7 @@ class HyperliquidWebsocketCache:
         unsubscribe_specs: List[Tuple[Dict[str, Any], Optional[int], str]] = [
             ({"type": "allMids"}, self._mids_sub_id, "allMids"),
             ({"type": "userEvents", "user": self.account_address}, self._user_events_sub_id, "userEvents"),
+            ({"type": "userFills", "user": self.account_address}, self._user_fills_sub_id, "userFills"),
             ({"type": "orderUpdates", "user": self.account_address}, self._order_updates_sub_id, "orderUpdates"),
         ]
         for coin, sub_id in list(self._bbo_sub_ids.items()):
@@ -306,9 +337,30 @@ class HyperliquidWebsocketCache:
 
     def _on_user_event(self, msg: Dict[str, Any]) -> None:
         self.last_user_event = msg
+        data = msg.get("data", {}) if isinstance(msg, dict) else {}
+        if isinstance(data, dict):
+            fills = data.get("fills")
+            if isinstance(fills, list) and fills:
+                self._merge_user_fills(fills, replace=False)
+        self._user_state_dirty = True
+        self._open_orders_dirty = True
+        self._frontend_open_orders_dirty = True
+
+    def _on_user_fills(self, msg: Dict[str, Any]) -> None:
+        self.last_user_fills = msg
+        data = msg.get("data", {}) if isinstance(msg, dict) else {}
+        if not isinstance(data, dict):
+            return
+        fills = data.get("fills")
+        if isinstance(fills, list):
+            self._merge_user_fills(fills, replace=bool(data.get("isSnapshot")))
+        self._user_state_dirty = True
 
     def _on_order_update(self, msg: Dict[str, Any]) -> None:
         self.last_order_update = msg
+        self._open_orders_dirty = True
+        self._frontend_open_orders_dirty = True
+        self._user_state_dirty = True
 
     def _on_candle(self, requested_coin: str, requested_interval: str, msg: Dict[str, Any]) -> None:
         data = msg.get("data", {}) if isinstance(msg, dict) else {}
@@ -423,6 +475,157 @@ class HyperliquidWebsocketCache:
             return None
         return [dict(candle) for candle in candles[-periods:]]
 
+    @staticmethod
+    def _extract_fill_time_ms(fill: Dict[str, Any]) -> int:
+        for key in ("time", "timestamp"):
+            try:
+                value = fill.get(key)
+                if value is not None:
+                    return int(float(value))
+            except (AttributeError, TypeError, ValueError):
+                continue
+        return 0
+
+    @classmethod
+    def _fill_cache_key(cls, fill: Dict[str, Any]) -> Tuple[Any, ...]:
+        return (
+            fill.get("tid"),
+            fill.get("hash"),
+            fill.get("oid"),
+            fill.get("coin"),
+            fill.get("px"),
+            fill.get("sz"),
+            cls._extract_fill_time_ms(fill),
+        )
+
+    def _merge_user_fills(self, fills: List[Dict[str, Any]], replace: bool) -> None:
+        if replace:
+            self._user_fills = []
+            self._user_fill_keys.clear()
+
+        changed = False
+        for fill in fills:
+            if not isinstance(fill, dict):
+                continue
+            fill_copy = dict(fill)
+            cache_key = self._fill_cache_key(fill_copy)
+            if cache_key in self._user_fill_keys:
+                continue
+            self._user_fill_keys.add(cache_key)
+            self._user_fills.append(fill_copy)
+            changed = True
+
+        if changed or replace:
+            self._user_fills.sort(key=self._extract_fill_time_ms)
+            self._user_fills_updated_at = time.monotonic()
+            self._user_fills_ready.set()
+
+    async def get_user_state(self, *, force_refresh: bool = False) -> Optional[Dict[str, Any]]:
+        if not self.enabled:
+            return None
+        if (
+            not force_refresh
+            and not self._user_state_dirty
+            and self._is_fresh(self._user_state_updated_at, self.max_age_seconds)
+            and self._user_state is not None
+        ):
+            return dict(self._user_state)
+
+        async with self._user_state_lock:
+            if (
+                not force_refresh
+                and not self._user_state_dirty
+                and self._is_fresh(self._user_state_updated_at, self.max_age_seconds)
+                and self._user_state is not None
+            ):
+                return dict(self._user_state)
+
+            user_state = await self.info.user_state(self.account_address)
+            if not isinstance(user_state, dict):
+                return None
+            self._user_state = dict(user_state)
+            self._user_state_updated_at = time.monotonic()
+            self._user_state_dirty = False
+            self._user_state_ready.set()
+            return dict(self._user_state)
+
+    async def get_open_orders(self, *, force_refresh: bool = False) -> Optional[List[Dict[str, Any]]]:
+        if not self.enabled:
+            return None
+        if (
+            not force_refresh
+            and not self._open_orders_dirty
+            and self._is_fresh(self._open_orders_updated_at, self.max_age_seconds)
+        ):
+            return [dict(order) for order in self._open_orders]
+
+        async with self._open_orders_lock:
+            if (
+                not force_refresh
+                and not self._open_orders_dirty
+                and self._is_fresh(self._open_orders_updated_at, self.max_age_seconds)
+            ):
+                return [dict(order) for order in self._open_orders]
+
+            open_orders = await self.info.open_orders(self.account_address)
+            if not isinstance(open_orders, list):
+                return None
+            self._open_orders = [dict(order) for order in open_orders if isinstance(order, dict)]
+            self._open_orders_updated_at = time.monotonic()
+            self._open_orders_dirty = False
+            self._open_orders_ready.set()
+            return [dict(order) for order in self._open_orders]
+
+    async def get_frontend_open_orders(self, *, force_refresh: bool = False) -> Optional[List[Dict[str, Any]]]:
+        if not self.enabled:
+            return None
+        if (
+            not force_refresh
+            and not self._frontend_open_orders_dirty
+            and self._is_fresh(self._frontend_open_orders_updated_at, self.max_age_seconds)
+        ):
+            return [dict(order) for order in self._frontend_open_orders]
+
+        async with self._frontend_open_orders_lock:
+            if (
+                not force_refresh
+                and not self._frontend_open_orders_dirty
+                and self._is_fresh(self._frontend_open_orders_updated_at, self.max_age_seconds)
+            ):
+                return [dict(order) for order in self._frontend_open_orders]
+
+            frontend_orders = await self.info.frontend_open_orders(self.account_address)
+            if not isinstance(frontend_orders, list):
+                return None
+            self._frontend_open_orders = [dict(order) for order in frontend_orders if isinstance(order, dict)]
+            self._frontend_open_orders_updated_at = time.monotonic()
+            self._frontend_open_orders_dirty = False
+            self._frontend_open_orders_ready.set()
+            return [dict(order) for order in self._frontend_open_orders]
+
+    async def get_user_fills_since(self, start_time_ms: int) -> Optional[List[Dict[str, Any]]]:
+        if not self.enabled:
+            return None
+
+        async with self._user_fills_lock:
+            need_seed = (
+                self._user_fills_seed_start_ms is None
+                or start_time_ms < self._user_fills_seed_start_ms
+                or not self._user_fills_ready.is_set()
+            )
+            if need_seed:
+                fills = await self.info.user_fills_by_time(self.account_address, start_time_ms)
+                if not isinstance(fills, list):
+                    return None
+                self._user_fills_seed_start_ms = start_time_ms
+                self._merge_user_fills([dict(fill) for fill in fills if isinstance(fill, dict)], replace=True)
+
+            return [
+                dict(fill)
+                for fill in self._user_fills
+                if self._extract_fill_time_ms(fill) >= start_time_ms
+            ]
+
 
 def get_ws_cache(info: Info) -> Optional[HyperliquidWebsocketCache]:
     cache = getattr(info, "ws_cache", None)
@@ -433,7 +636,7 @@ def get_ws_cache(info: Info) -> Optional[HyperliquidWebsocketCache]:
 
 async def init_clients(use_testnet: bool, use_websocket: bool = True) -> Tuple[str, Info, Exchange]:
     """Initialize async Info and Exchange clients for Hyperliquid."""
-    secret_key, account_address = load_credentials()
+    secret_key, account_address = load_credentials(use_testnet)
     api_url = constants.TESTNET_API_URL if use_testnet else constants.MAINNET_API_URL
     account: LocalAccount = eth_account.Account.from_key(secret_key)
 
@@ -585,10 +788,22 @@ async def get_best_bid_ask(info: Info, coin: str) -> Tuple[Optional[float], Opti
     return best_bid, best_ask
 
 
-async def get_open_orders_for_coin(info: Info, account_address: str, coin: str) -> List[Dict[str, Any]]:
+async def get_open_orders_for_coin(
+        info: Info,
+        account_address: str,
+        coin: str,
+        *,
+        force_http: bool = False,
+) -> List[Dict[str, Any]]:
     """Return open orders for a specific coin."""
     try:
-        open_orders = await info.open_orders(account_address)
+        open_orders: Any
+        cache = get_ws_cache(info)
+        if cache is not None and not force_http:
+            cached_orders = await cache.get_open_orders(force_refresh=False)
+            open_orders = cached_orders if cached_orders is not None else await info.open_orders(account_address)
+        else:
+            open_orders = await info.open_orders(account_address)
     except Exception:
         logging.getLogger("hypertrader").exception(
             "[WARN] Failed to fetch open orders for %s.",
@@ -627,6 +842,7 @@ async def get_user_state_with_retry(
         context_label: str,
         coin: Optional[str] = None,
         retry_sleep: float = WATCH_RETRY_SLEEP_SECONDS,
+        force_http: bool = False,
 ) -> Dict[str, Any]:
     """Fetch user_state and keep retrying on Hyperliquid rate limits."""
     coin_label = coin.upper() if coin else "ALL"
@@ -634,7 +850,12 @@ async def get_user_state_with_retry(
     while True:
         attempt += 1
         try:
-            user_state = await info.user_state(account_address)
+            cache = get_ws_cache(info)
+            if cache is not None and not force_http:
+                cached_state = await cache.get_user_state(force_refresh=False)
+                user_state = cached_state if cached_state is not None else await info.user_state(account_address)
+            else:
+                user_state = await info.user_state(account_address)
         except asyncio.CancelledError:
             raise
         except Exception as exc:
@@ -656,12 +877,18 @@ async def get_user_state_with_retry(
 # Position helpers
 # ---------------------------------------------------------------------------
 
-async def get_all_open_positions(info: Info, account_address: str) -> List[Dict[str, Any]]:
+async def get_all_open_positions(
+        info: Info,
+        account_address: str,
+        *,
+        force_http: bool = False,
+) -> List[Dict[str, Any]]:
     """Return a list of open perp positions for the account."""
     user_state = await get_user_state_with_retry(
         info,
         account_address,
         context_label="get_all_open_positions",
+        force_http=force_http,
     )
     asset_positions = user_state.get("assetPositions", [])
     open_positions: List[Dict[str, Any]] = []
@@ -678,13 +905,20 @@ async def get_all_open_positions(info: Info, account_address: str) -> List[Dict[
     return open_positions
 
 
-async def get_position_size_for_coin(info: Info, account_address: str, coin: str) -> float:
+async def get_position_size_for_coin(
+        info: Info,
+        account_address: str,
+        coin: str,
+        *,
+        force_http: bool = False,
+) -> float:
     """Return signed position size for a coin, or 0.0 if flat/not found."""
     user_state = await get_user_state_with_retry(
         info,
         account_address,
         context_label="get_position_size_for_coin",
         coin=coin,
+        force_http=force_http,
     )
     asset_positions = user_state.get("assetPositions", [])
     for asset_pos in asset_positions:
@@ -701,6 +935,8 @@ async def get_position_for_coin(
         info: Info,
         account_address: str,
         coin: str,
+        *,
+        force_http: bool = False,
 ) -> Optional[Dict[str, Any]]:
     """Return full position dict for a coin if the account has a non-zero position."""
     user_state = await get_user_state_with_retry(
@@ -708,6 +944,7 @@ async def get_position_for_coin(
         account_address,
         context_label="get_position_for_coin",
         coin=coin,
+        force_http=force_http,
     )
     for asset_pos in user_state.get("assetPositions", []):
         pos = asset_pos.get("position", {})
@@ -859,7 +1096,7 @@ async def get_realized_pnl_since(
         return None
 
     try:
-        fills = await info.user_fills_by_time(account_address, start_time_ms)
+        fills = await get_user_fills_since(info, account_address, start_time_ms)
     except Exception:
         logging.getLogger("hypertrader").exception(
             "[METRICS] Failed to fetch user fills since %s for coin=%s.",
@@ -886,6 +1123,29 @@ async def get_realized_pnl_since(
             found = True
     return total if found or fills else 0.0
 
+
+async def get_user_fills_since(
+        info: Info,
+        account_address: str,
+        start_time_ms: int,
+        *,
+        end_time_ms: Optional[int] = None,
+        aggregate_by_time: bool = False,
+        force_http: bool = False,
+) -> Any:
+    """Return fills since start_time_ms, using the websocket-backed cache when safe."""
+    cache = get_ws_cache(info)
+    if cache is not None and not force_http and end_time_ms is None and not aggregate_by_time:
+        cached_fills = await cache.get_user_fills_since(start_time_ms)
+        if cached_fills is not None:
+            return cached_fills
+    return await info.user_fills_by_time(
+        account_address,
+        start_time_ms,
+        end_time_ms,
+        aggregate_by_time=aggregate_by_time,
+    )
+
 def extract_account_balance_from_user_state(user_state: Dict[str, Any]) -> Optional[float]:
     """Extract current Hyperliquid account value from a clearinghouseState response."""
     candidate_paths = (