walrasquant-lib 0.4.20__py3-none-any.whl

walrasquant/exchange/hyperliquid/constants.py

@@ -0,0 +1,371 @@
+from datetime import timedelta
+from typing import Dict, TypedDict, NotRequired
+from walrasquant.constants import (
+    AccountType,
+    OrderStatus,
+    PositionSide,
+    OrderSide,
+    TimeInForce,
+    OrderType,
+    KlineInterval,
+)
+from enum import Enum
+from walrasquant.error import KlineSupportedError
+from throttled.asyncio import Throttled, rate_limiter, RateLimiterType
+from throttled import Throttled as ThrottledSync
+from walrasquant.exchange.hyperliquid.error import HyperliquidRateLimitError
+
+
+def oid_to_cloid_hex(oid: str) -> str:
+    """Convert NexusTrader OidGen's decimal OID to 128-bit hex string.
+
+    Produces a lowercase hex string with a `0x` prefix and exactly 32 hex
+    characters (128 bits), e.g. `0x0000...abcd`.
+
+    Notes:
+    - OidGen always emits a positive decimal string (timestamp+seq+shard), so
+      negativity checks are unnecessary.
+    - The numeric value (currently ~20 decimal digits) is far below 2^128, so
+      overflow checks are unnecessary.
+    - No stripping is performed because OidGen-controlled inputs have no
+      surrounding whitespace.
+    """
+    n = int(oid)
+    return f"0x{n:032x}"
+
+
+class HyperLiquidAccountType(AccountType):
+    MAINNET = "mainnet"
+    TESTNET = "testnet"
+
+    @property
+    def exchange_id(self):
+        return "hyperliquid"
+
+    @property
+    def is_testnet(self):
+        return self == self.TESTNET
+
+    @property
+    def ws_url(self):
+        if self.is_testnet:
+            return "wss://api.hyperliquid-testnet.xyz/ws"
+        return "wss://api.hyperliquid.xyz/ws"
+
+    @property
+    def rest_url(self):
+        if self.is_testnet:
+            return "https://api.hyperliquid-testnet.xyz"
+        return "https://api.hyperliquid.xyz"
+
+
+class HyperLiquidTimeInForce(Enum):
+    GTC = "Gtc"
+    IOC = "Ioc"
+    ALO = "Alo"  # Post Only
+
+
+class HyperLiquidFillDirection(Enum):
+    OPEN_LONG = "Open Long"
+    OPEN_SHORT = "Open Short"
+    CLOSE_LONG = "Close Long"
+    CLOSE_SHORT = "Close Short"
+    BUY = "Buy"
+    SELL = "Sell"
+
+
+class HyperLiquidOrderSide(Enum):
+    BUY = "B"  # Bid
+    SELL = "A"  # Ask
+
+    @property
+    def is_buy(self):
+        return self == self.BUY
+
+    @property
+    def is_sell(self):
+        return self == self.SELL
+
+
+class HyperLiquidOrderStatusType(Enum):
+    """
+    https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#query-order-status-by-oid-or-cloid
+    """
+
+    OPEN = "open"
+    FILLED = "filled"
+    CANCELED = "canceled"
+    TRIGGERED = "triggered"
+    REJECTED = "rejected"
+    MARGIN_CANCELED = "marginCanceled"
+    VAULT_WITHDRAWAL_CANCELED = "vaultWithdrawalCanceled"
+    OPEN_INTEREST_CAP_CANCELED = "openInterestCapCanceled"
+    SELF_TRADE_CANCELED = "selfTradeCanceled"
+    REDUCE_ONLY_CANCELED = "reduceOnlyCanceled"
+    SIBLING_FILLED_CANCELED = "siblingFilledCanceled"
+    DELISTED_CANCELED = "delistedCanceled"
+    LIQUIDATED_CANCELED = "liquidatedCanceled"
+    SCHEDULED_CANCEL = "scheduledCancel"
+    TICK_REJECTED = "tickRejected"
+    MIN_TRADE_NTL_REJECTED = "minTradeNtlRejected"
+    PERP_MARGIN_REJECTED = "perpMarginRejected"
+    REDUCE_ONLY_REJECTED = "reduceOnlyRejected"
+    BAD_ALO_PX_REJECTED = "badAloPxRejected"
+    IOC_CANCEL_REJECTED = "iocCancelRejected"
+    BAD_TRIGGER_PX_REJECTED = "badTriggerPxRejected"
+    MARKET_ORDER_NO_LIQUIDITY_REJECTED = "marketOrderNoLiquidityRejected"
+    POSITION_INCREASE_AT_OPEN_INTEREST_CAP_REJECTED = (
+        "positionIncreaseAtOpenInterestCapRejected"
+    )
+    POSITION_FLIP_AT_OPEN_INTEREST_CAP_REJECTED = (
+        "positionFlipAtOpenInterestCapRejected"
+    )
+    TOO_AGGRESSIVE_AT_OPEN_INTEREST_CAP_REJECTED = (
+        "tooAggressiveAtOpenInterestCapRejected"
+    )
+    OPEN_INTEREST_INCREASE_REJECTED = "openInterestIncreaseRejected"
+    INSUFFICIENT_SPOT_BALANCE_REJECTED = "insufficientSpotBalanceRejected"
+    ORACLE_REJECTED = "oracleRejected"
+    PERP_MAX_POSITION_REJECTED = "perpMaxPositionRejected"
+
+
+class HyperLiquidKlineInterval(Enum):
+    MINUTE_1 = "1m"
+    MINUTE_3 = "3m"
+    MINUTE_5 = "5m"
+    MINUTE_15 = "15m"
+    MINUTE_30 = "30m"
+    HOUR_1 = "1h"
+    HOUR_2 = "2h"
+    HOUR_4 = "4h"
+    HOUR_8 = "8h"
+    HOUR_12 = "12h"
+    DAY_1 = "1d"
+    WEEK_1 = "1w"
+    MONTH_1 = "1M"
+
+
+class HyperLiquidRateLimiter:
+    """Rate limiter for Hyperliquid API"""
+
+    def __init__(self, enable_rate_limit: bool = True):
+        self._enabled = enable_rate_limit
+        self._exchange = Throttled(
+            quota=rate_limiter.per_duration(timedelta(seconds=60), limit=1200),
+            timeout=-1,
+            using=RateLimiterType.FIXED_WINDOW.value,
+        )
+        self._info = Throttled(
+            quota=rate_limiter.per_duration(timedelta(seconds=60), limit=1200),
+            timeout=-1,
+            using=RateLimiterType.FIXED_WINDOW.value,
+        )
+
+    @staticmethod
+    def _raise_if_limited(result, message: str, scope: str, cost: int | None = None):
+        if result.limited:
+            raise HyperliquidRateLimitError(
+                message,
+                retry_after=result.state.retry_after,
+                scope=scope,
+                cost=cost,
+            )
+
+    async def exchange_limit(self, cost: int = 1):
+        if not self._enabled:
+            return
+        result = await self._exchange.limit(key="exchange", cost=cost, timeout=-1)
+        self._raise_if_limited(
+            result,
+            "Hyperliquid exchange rate limit exceeded",
+            scope="uid",
+            cost=cost,
+        )
+
+    async def info_limit(self, cost: int = 1):
+        if not self._enabled:
+            return
+        result = await self._info.limit(key="info", cost=cost, timeout=60)
+        self._raise_if_limited(
+            result,
+            "Hyperliquid info rate limit exceeded",
+            scope="ip",
+            cost=cost,
+        )
+
+
+# class HyperLiquidRateLimiterSync:
+#     """Synchronous rate limiter for Hyperliquid API"""
+
+#     def __init__(self, enable_rate_limit: bool = True):
+#         self._enabled = enable_rate_limit
+#         self._info = ThrottledSync(
+#             quota=rate_limiter_sync.per_duration(timedelta(seconds=60), limit=1200),
+#             timeout=-1,
+#             using=RateLimiterType.FIXED_WINDOW.value,
+#         )
+
+#     @staticmethod
+#     def _raise_if_limited(result, message: str, scope: str, cost: int | None = None):
+#         if result.limited:
+#             raise HyperliquidRateLimitError(
+#                 message,
+#                 retry_after=result.state.retry_after,
+#                 scope=scope,
+#                 cost=cost,
+#             )
+
+#     def info_limit(self, cost: int = 1):
+#         if not self._enabled:
+#             return
+#         result = self._info.limit(key="info", cost=cost, timeout=120)
+#         self._raise_if_limited(
+#             result,
+#             "Hyperliquid info rate limit exceeded",
+#             scope="ip",
+#             cost=cost,
+#         )
+
+
+class HyperLiquidOrderLimitTypeRequest(TypedDict):
+    tif: str  # "Alo" other exchange called post only | Ioc (Immediate or Cancel) | Gtc (Good Till Cancel)
+
+
+class HyperLiquidOrderTriggerTypeRequest(TypedDict):
+    isMarket: bool  # True for market order, False for limit order
+    triggerPx: str  # Trigger price for stop orders, empty for limit orders
+    tpsl: str  # tp | sl
+
+
+class HyperLiquidOrderTypeRequest(TypedDict):
+    limit: NotRequired[HyperLiquidOrderLimitTypeRequest]  # Limit order type
+    trigger: NotRequired[HyperLiquidOrderTriggerTypeRequest]
+
+
+class HyperLiquidOrderRequest(TypedDict):
+    """
+    HyperLiquid order request schema
+
+
+    a: int  asset
+    b: bool isBuy
+    p: str  price
+    s: str  size
+    r: bool  reduceOnly
+    t: HyperLiquidOrderTypeRequest
+    c: NotRequired[str]  clientOrderId
+    """
+
+    a: int  # asset
+    b: bool  # isBuy
+    p: str  # price
+    s: str  # size
+    r: bool  # reduceOnly
+    t: HyperLiquidOrderTypeRequest
+    c: NotRequired[str]  # clientOrderId
+
+
+class HyperLiquidOrderCancelRequest(TypedDict):
+    a: int  # asset
+    o: int  # oid  # orderId
+
+
+class HyperLiquidCloidCancelRequest(TypedDict):
+    asset: int  # asset
+    cloid: str  # clientOrderId
+
+
+class HyperLiquidEnumParser:
+    _hyperliquid_order_status_map = {
+        HyperLiquidOrderStatusType.OPEN: OrderStatus.ACCEPTED,
+        HyperLiquidOrderStatusType.FILLED: OrderStatus.FILLED,
+        HyperLiquidOrderStatusType.CANCELED: OrderStatus.CANCELED,
+        HyperLiquidOrderStatusType.TRIGGERED: OrderStatus.ACCEPTED,
+        HyperLiquidOrderStatusType.REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.MARGIN_CANCELED: OrderStatus.CANCELED,
+        HyperLiquidOrderStatusType.VAULT_WITHDRAWAL_CANCELED: OrderStatus.CANCELED,
+        HyperLiquidOrderStatusType.OPEN_INTEREST_CAP_CANCELED: OrderStatus.CANCELED,
+        HyperLiquidOrderStatusType.SELF_TRADE_CANCELED: OrderStatus.CANCELED,
+        HyperLiquidOrderStatusType.REDUCE_ONLY_CANCELED: OrderStatus.CANCELED,
+        HyperLiquidOrderStatusType.SIBLING_FILLED_CANCELED: OrderStatus.CANCELED,
+        HyperLiquidOrderStatusType.DELISTED_CANCELED: OrderStatus.CANCELED,
+        HyperLiquidOrderStatusType.LIQUIDATED_CANCELED: OrderStatus.CANCELED,
+        HyperLiquidOrderStatusType.SCHEDULED_CANCEL: OrderStatus.CANCELED,
+        HyperLiquidOrderStatusType.TICK_REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.MIN_TRADE_NTL_REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.PERP_MARGIN_REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.REDUCE_ONLY_REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.BAD_ALO_PX_REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.IOC_CANCEL_REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.BAD_TRIGGER_PX_REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.MARKET_ORDER_NO_LIQUIDITY_REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.POSITION_INCREASE_AT_OPEN_INTEREST_CAP_REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.POSITION_FLIP_AT_OPEN_INTEREST_CAP_REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.TOO_AGGRESSIVE_AT_OPEN_INTEREST_CAP_REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.OPEN_INTEREST_INCREASE_REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.INSUFFICIENT_SPOT_BALANCE_REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.ORACLE_REJECTED: OrderStatus.FAILED,
+        HyperLiquidOrderStatusType.PERP_MAX_POSITION_REJECTED: OrderStatus.FAILED,
+    }
+
+    _hyperliquid_kline_interval_map = {
+        HyperLiquidKlineInterval.MINUTE_1: KlineInterval.MINUTE_1,
+        HyperLiquidKlineInterval.MINUTE_3: KlineInterval.MINUTE_3,
+        HyperLiquidKlineInterval.MINUTE_5: KlineInterval.MINUTE_5,
+        HyperLiquidKlineInterval.MINUTE_15: KlineInterval.MINUTE_15,
+        HyperLiquidKlineInterval.MINUTE_30: KlineInterval.MINUTE_30,
+        HyperLiquidKlineInterval.HOUR_1: KlineInterval.HOUR_1,
+        HyperLiquidKlineInterval.HOUR_2: KlineInterval.HOUR_2,
+        HyperLiquidKlineInterval.HOUR_4: KlineInterval.HOUR_4,
+        HyperLiquidKlineInterval.HOUR_8: KlineInterval.HOUR_8,
+        HyperLiquidKlineInterval.HOUR_12: KlineInterval.HOUR_12,
+        HyperLiquidKlineInterval.DAY_1: KlineInterval.DAY_1,
+        HyperLiquidKlineInterval.WEEK_1: KlineInterval.WEEK_1,
+        HyperLiquidKlineInterval.MONTH_1: KlineInterval.MONTH_1,
+    }
+
+    _kline_interval_to_hyperliquid_map = {
+        v: k for k, v in _hyperliquid_kline_interval_map.items()
+    }
+
+    _hyperliquid_time_in_force_map = {
+        HyperLiquidTimeInForce.GTC: TimeInForce.GTC,
+        HyperLiquidTimeInForce.IOC: TimeInForce.IOC,
+    }
+
+    _time_in_force_to_hyperliquid_map = {
+        v: k for k, v in _hyperliquid_time_in_force_map.items()
+    }
+
+    @classmethod
+    def parse_order_status(cls, status: HyperLiquidOrderStatusType) -> OrderStatus:
+        """Convert HyperLiquidOrderStatusType to OrderStatus"""
+        return cls._hyperliquid_order_status_map[status]
+
+    @classmethod
+    def parse_kline_interval(cls, interval: HyperLiquidKlineInterval) -> KlineInterval:
+        """Convert KlineInterval to HyperLiquidKlineInterval"""
+        return cls._hyperliquid_kline_interval_map[interval]
+
+    @classmethod
+    def to_hyperliquid_kline_interval(
+        cls, interval: KlineInterval
+    ) -> HyperLiquidKlineInterval:
+        """Convert KlineInterval to HyperLiquidKlineInterval"""
+        if interval not in cls._kline_interval_to_hyperliquid_map:
+            raise KlineSupportedError(
+                f"Unsupported kline interval: {interval}. Supported intervals: {list(cls._kline_interval_to_hyperliquid_map.keys())}"
+            )
+        return cls._kline_interval_to_hyperliquid_map[interval]
+
+    @classmethod
+    def parse_time_in_force(cls, time_in_force: HyperLiquidTimeInForce) -> TimeInForce:
+        """Convert HyperLiquidTimeInForce to TimeInForce"""
+        return cls._hyperliquid_time_in_force_map[time_in_force]
+
+    @classmethod
+    def to_hyperliquid_time_in_force(
+        cls, time_in_force: TimeInForce
+    ) -> HyperLiquidTimeInForce:
+        """Convert TimeInForce to HyperLiquidTimeInForce"""
+        return cls._time_in_force_to_hyperliquid_map[time_in_force]

walrasquant/exchange/hyperliquid/ems.py

@@ -0,0 +1,156 @@
+from decimal import Decimal
+from typing import Dict, List, cast
+from walrasquant.constants import AccountType
+from walrasquant.schema import (
+    CreateOrderSubmit,
+    InstrumentId,
+    BatchOrderSubmit,
+    BaseMarket,
+)
+from walrasquant.core.cache import AsyncCache
+from walrasquant.core.nautilius_core import MessageBus, LiveClock
+from walrasquant.core.entity import TaskManager
+from walrasquant.core.registry import OrderRegistry
+from walrasquant.exchange.hyperliquid import HyperLiquidAccountType
+from walrasquant.exchange.hyperliquid.schema import HyperLiquidMarket
+from walrasquant.exchange.hyperliquid.constants import oid_to_cloid_hex
+from walrasquant.base import ExecutionManagementSystem
+from walrasquant.base.ems import PriorityOrderQueue
+
+
+class HyperLiquidExecutionManagementSystem(ExecutionManagementSystem):
+    _market: Dict[str, HyperLiquidMarket]
+
+    HYPER_LIQUID_ACCOUNT_TYPE_PRIORITY = [
+        HyperLiquidAccountType.MAINNET,
+        HyperLiquidAccountType.TESTNET,
+    ]
+
+    def __init__(
+        self,
+        market: Dict[str, HyperLiquidMarket],
+        cache: AsyncCache,
+        msgbus: MessageBus,
+        clock: LiveClock,
+        task_manager: TaskManager,
+        registry: OrderRegistry,
+        queue_maxsize: int = 100_000,
+    ):
+        super().__init__(
+            market=market,
+            cache=cache,
+            msgbus=msgbus,
+            clock=clock,
+            task_manager=task_manager,
+            registry=registry,
+            queue_maxsize=queue_maxsize,
+        )
+        self._hyperliquid_account_type: HyperLiquidAccountType | None = None
+
+    def _build_order_submit_queues(self):
+        for account_type in self._private_connectors.keys():
+            if isinstance(account_type, HyperLiquidAccountType):
+                self._order_submit_queues[account_type] = PriorityOrderQueue(
+                    maxsize=self._queue_maxsize
+                )
+                break
+
+    def _set_account_type(self):
+        account_types = self._private_connectors.keys()
+        for account_type in self.HYPER_LIQUID_ACCOUNT_TYPE_PRIORITY:
+            if account_type in account_types:
+                self._hyperliquid_account_type = account_type
+                break
+
+    def _instrument_id_to_account_type(
+        self, instrument_id: InstrumentId
+    ) -> AccountType:
+        if self._hyperliquid_account_type is None:
+            raise ValueError("No HyperLiquid account type configured")
+        return self._hyperliquid_account_type
+
+    def _get_min_order_amount(
+        self, symbol: str, market: BaseMarket, px: float
+    ) -> Decimal:
+        # book = self._cache.bookl1(symbol)
+        hyperliquid_market = cast(HyperLiquidMarket, market)
+        cost_limits = hyperliquid_market.limits.cost
+        min_order_cost = cost_limits.min if cost_limits is not None else 0.0
+        min_order_cost = min_order_cost or 0.0
+        min_order_amount = super()._amount_to_precision(
+            symbol, min_order_cost / px * 1.01, mode="ceil"
+        )
+        return min_order_amount
+
+    async def _create_order(
+        self, order_submit: CreateOrderSubmit, account_type: AccountType
+    ):
+        """
+        Create an order
+        """
+        oid = oid_to_cloid_hex(order_submit.oid)
+        self._registry.register_order(oid)
+        self._cache.add_inflight_order(order_submit.symbol, oid)
+        await self._private_connectors[account_type]._oms.create_order(
+            oid=oid,
+            symbol=order_submit.symbol,
+            side=order_submit.side,
+            type=order_submit.type,
+            amount=order_submit.amount,
+            price=order_submit.price,
+            time_in_force=order_submit.time_in_force,
+            reduce_only=order_submit.reduce_only,
+            **order_submit.kwargs,
+        )
+
+    async def _create_batch_orders(
+        self, batch_orders: List[BatchOrderSubmit], account_type: AccountType
+    ):
+        new_batch_orders = []
+        for order in batch_orders:
+            oid = oid_to_cloid_hex(order.oid)
+            self._registry.register_order(oid=oid)
+            self._cache.add_inflight_order(order.symbol, oid)
+            new_batch_orders.append(
+                BatchOrderSubmit(
+                    symbol=order.symbol,
+                    instrument_id=order.instrument_id,
+                    side=order.side,
+                    type=order.type,
+                    amount=order.amount,
+                    price=order.price,
+                    time_in_force=order.time_in_force,
+                    reduce_only=order.reduce_only,
+                    oid=oid,
+                    kwargs=order.kwargs,
+                )
+            )
+        await self._private_connectors[account_type]._oms.create_batch_orders(
+            orders=new_batch_orders,
+        )
+
+    async def _create_order_ws(
+        self, order_submit: CreateOrderSubmit, account_type: AccountType
+    ):
+        """
+        Create an order
+        """
+        oid = oid_to_cloid_hex(order_submit.oid)
+        self._registry.register_order(oid)
+        self._cache.add_inflight_order(order_submit.symbol, oid)
+        await self._private_connectors[account_type]._oms.create_order_ws(
+            oid=oid,
+            symbol=order_submit.symbol,
+            side=order_submit.side,
+            type=order_submit.type,
+            amount=order_submit.amount,
+            price=order_submit.price,
+            time_in_force=order_submit.time_in_force,
+            reduce_only=order_submit.reduce_only,
+            **order_submit.kwargs,
+        )
+
+    def _get_max_order_amount(
+        self, symbol: str, market: BaseMarket, is_market: bool, px: float
+    ) -> Decimal:
+        return Decimal("Infinity")

walrasquant/exchange/hyperliquid/error.py

@@ -0,0 +1,48 @@
+from typing import Any
+
+
+class HyperLiquidHttpError(Exception):
+    def __init__(self, status_code: int, message: str, headers: dict[str, Any]):
+        super().__init__(message)
+        self.status_code = status_code
+        self.message = message
+        self.headers = headers
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(status_code={self.status_code}, message='{self.message}')"
+
+    __str__ = __repr__
+
+
+class HyperLiquidOrderError(Exception):
+    """
+    The base class for all HyperLiquid specific errors.
+    """
+
+    def __init__(self, error_type: str, message: str):
+        super().__init__(message)
+        self.error_type = error_type
+        self.message = message
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(error_type={self.error_type}, message='{self.message}')"
+
+    __str__ = __repr__
+
+
+class HyperliquidRateLimitError(Exception):
+    """
+    Raised when Hyperliquid API rate limit is exceeded.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        retry_after: float = 0.0,
+        scope: str | None = None,
+        cost: int | None = None,
+    ):
+        super().__init__(message)
+        self.retry_after = retry_after
+        self.scope = scope
+        self.cost = cost

walrasquant/exchange/hyperliquid/exchange.py

@@ -0,0 +1,120 @@
+import ccxt
+import msgspec
+from typing import Any, Dict, cast
+from walrasquant.base import ExchangeManager
+from walrasquant.config import BasicConfig
+from walrasquant.constants import ConfigType
+
+from walrasquant.constants import AccountType
+from walrasquant.schema import InstrumentId
+from walrasquant.error import EngineBuildError
+from walrasquant.exchange.hyperliquid.schema import HyperLiquidMarket
+from walrasquant.exchange.hyperliquid.constants import HyperLiquidAccountType
+
+
+class HyperLiquidExchangeManager(ExchangeManager):
+    api: ccxt.hyperliquid
+    market: Dict[str, HyperLiquidMarket]
+    market_id: Dict[str, str]
+
+    def __init__(self, config: ConfigType | None = None):
+        resolved_config: ConfigType = {
+            "apiKey": config.get("apiKey", "") if config else "",
+            "secret": config.get("secret", "") if config else "",
+            "exchange_id": config.get("exchange_id", "hyperliquid")
+            if config
+            else "hyperliquid",
+            "sandbox": config.get("sandbox", False) if config else False,
+        }
+        if config and "password" in config:
+            resolved_config["password"] = config["password"]
+
+        super().__init__(resolved_config)
+        extra_config = cast(dict[str, Any], self.config)
+        extra_config["walletAddress"] = self.config.get("apiKey")
+        extra_config["privateKey"] = self.config.get("secret")
+        self._public_conn_account_type: HyperLiquidAccountType | None = None
+
+    def load_markets(self, reload: bool = False) -> None:
+        # NOTE: do not know why ccxt commented out the following code
+        # 'hip3': {
+        #     'limit': 5,  # how many dexes to load max if dexes are not specified
+        #     'dex': ['xyz'],
+        # },
+        options = cast(dict[str, Any], self.api.options or {})
+        self.api.options = options
+        fetch_markets = cast(dict[str, Any], options.setdefault("fetchMarkets", {}))
+        hip3 = cast(dict[str, Any], fetch_markets.setdefault("hip3", {}))
+        hip3["dex"] = ["xyz"]
+        market = self.api.load_markets(reload=reload)
+        mapping = cast(dict[str, Any], options.get("spotCurrencyMapping", {}))
+        for symbol, mkt in market.items():
+            try:
+                mkt_json = msgspec.json.encode(mkt)
+                mkt = msgspec.json.decode(mkt_json, type=HyperLiquidMarket)
+
+                if (
+                    mkt.spot or mkt.linear or mkt.inverse or mkt.future
+                ) and not mkt.option:
+                    if mkt.spot and mkt.base in mapping:
+                        continue
+
+                    symbol = self._parse_symbol(mkt, exchange_suffix="HYPERLIQUID")
+                    mkt.symbol = symbol
+                    self.market[symbol] = mkt
+                    self.market_id[mkt.baseName if mkt.swap else mkt.id] = symbol
+
+            except msgspec.ValidationError as ve:
+                self._log.warning(f"Symbol Format Error: {ve}, {symbol}, {mkt}")
+                continue
+
+    def validate_public_connector_config(
+        self, account_type: AccountType, basic_config: BasicConfig | None = None
+    ) -> None:
+        if basic_config is None:
+            raise EngineBuildError("basic_config is required for HyperLiquid")
+        if not isinstance(account_type, HyperLiquidAccountType):
+            raise EngineBuildError(
+                f"Expected HyperLiquidAccountType, got {type(account_type)}"
+            )
+
+        if basic_config.testnet != account_type.is_testnet:
+            raise EngineBuildError(
+                f"The `testnet` setting of HyperLiquid is not consistent with the public connector's account type `{account_type}`."
+            )
+
+    def validate_public_connector_limits(
+        self, existing_connectors: Dict[AccountType, Any]
+    ) -> None:
+        hyperliquid_connectors = [
+            c
+            for c in existing_connectors.values()
+            if hasattr(c, "account_type")
+            and isinstance(c.account_type, HyperLiquidAccountType)
+        ]
+        if len(hyperliquid_connectors) > 1:
+            raise EngineBuildError(
+                "Only one public connector is supported for HyperLiquid, please remove the extra public connector config."
+            )
+
+    def set_public_connector_account_type(
+        self, account_type: HyperLiquidAccountType
+    ) -> None:
+        """Set the account type for public connector configuration"""
+        self._public_conn_account_type = account_type
+
+    def instrument_id_to_account_type(self, instrument_id: InstrumentId) -> AccountType:
+        if self._public_conn_account_type is None:
+            raise EngineBuildError(
+                "Public connector account type not set for HyperLiquid. Please add HyperLiquid in public_conn_config."
+            )
+        return self._public_conn_account_type
+
+
+def main():
+    exchange_manager = HyperLiquidExchangeManager()
+    print("Markets loaded:", exchange_manager.market)
+
+
+if __name__ == "__main__":
+    main()