walrasquant-lib 0.4.20__py3-none-any.whl

walrasquant/exchange/hyperliquid/rest_api.py

@@ -0,0 +1,348 @@
+import msgspec
+import eth_account
+from eth_account.signers.local import LocalAccount
+from eth_account.messages import encode_typed_data
+from typing import Dict, Any, List, Literal, cast
+from urllib.parse import urljoin
+import asyncio
+import aiohttp
+from Crypto.Hash import keccak
+
+from walrasquant.base.api_client import ApiClient
+from walrasquant.exchange.hyperliquid.constants import (
+    HyperLiquidAccountType,
+    HyperLiquidRateLimiter,
+    HyperLiquidOrderRequest,
+    HyperLiquidOrderCancelRequest,
+    HyperLiquidCloidCancelRequest,
+)
+from walrasquant.exchange.hyperliquid.schema import (
+    HyperLiquidOrderResponse,
+    HyperLiquidCancelResponse,
+    HyperLiquidUserOrder,
+    HyperLiquidUserPerpsSummary,
+    HyperLiquidKline,
+    HyperLiquidTrade,
+    HyperLiquidOrderBook,
+    HyperLiquidTicker,
+    HyperLiquidUserSpotSummary,
+)
+from walrasquant.exchange.hyperliquid.error import HyperLiquidHttpError
+from walrasquant.core.nautilius_core import LiveClock
+
+
+class HyperLiquidApiClient(ApiClient):
+    """REST API client for Hyperliquid exchange"""
+
+    _limiter: HyperLiquidRateLimiter
+
+    def __init__(
+        self,
+        clock: LiveClock,
+        api_key: str | None = None,
+        secret: str | None = None,
+        timeout: int = 10,
+        testnet: bool = False,
+        enable_rate_limit: bool = True,
+    ):
+        super().__init__(
+            clock=clock,
+            api_key=api_key,
+            secret=secret,
+            timeout=timeout,
+            rate_limiter=cast(Any, HyperLiquidRateLimiter(enable_rate_limit)),
+        )
+
+        self._account_type = (
+            HyperLiquidAccountType.TESTNET
+            if testnet
+            else HyperLiquidAccountType.MAINNET
+        )
+        if secret:
+            self._eth_account: LocalAccount = eth_account.Account.from_key(secret)
+        self._base_url = self._account_type.rest_url
+        self._testnet = testnet
+        self._headers = {
+            "Content-Type": "application/json",
+            # "User-Agent": "NexusTrader/1.0",
+        }
+
+        # Decoders for different response types
+        self._msg_decoder = msgspec.json.Decoder()
+        self._msg_encoder = msgspec.json.Encoder()
+        self._order_response_decoder = msgspec.json.Decoder(HyperLiquidOrderResponse)
+        self._cancel_response_decoder = msgspec.json.Decoder(HyperLiquidCancelResponse)
+        self._user_perps_summary_decoder = msgspec.json.Decoder(
+            HyperLiquidUserPerpsSummary
+        )
+        self._user_spot_summary_decoder = msgspec.json.Decoder(
+            HyperLiquidUserSpotSummary
+        )
+
+        self._kline_decoder = msgspec.json.Decoder(list[HyperLiquidKline])
+        self._trade_decoder = msgspec.json.Decoder(HyperLiquidTrade)
+        self._orderbook_decoder = msgspec.json.Decoder(HyperLiquidOrderBook)
+        self._ticker_decoder = msgspec.json.Decoder(HyperLiquidTicker)
+        self._user_order_decoder = msgspec.json.Decoder(list[HyperLiquidUserOrder])
+
+    def _get_rate_limit_cost(self, cost: int = 1, length: int = 0) -> int:
+        """Get rate limit cost for an operation
+
+        Please refer to https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/rate-limits-and-user-limits
+        """
+        return cost + length // 40
+
+    async def _fetch(
+        self,
+        method: str,
+        base_url: str,
+        endpoint: str,
+        payload: Dict[str, Any],
+    ) -> bytes:
+        """Asynchronous HTTP request"""
+        await self._init_session()
+        session = self._session
+        if session is None:
+            raise ValueError("HTTP session initialization failed")
+
+        url = urljoin(base_url, endpoint)
+        data = msgspec.json.encode(payload)
+
+        self._log.debug(f"Request: {method} {url}")
+
+        try:
+            async with session.request(
+                method=method,
+                url=url,
+                headers=self._headers,
+                data=data,
+            ) as response:
+                raw = await response.read()
+
+                if response.status >= 400:
+                    raise HyperLiquidHttpError(
+                        status_code=response.status,
+                        message=raw.decode() if isinstance(raw, bytes) else str(raw),
+                        headers=dict(response.headers),
+                    )
+
+                return raw
+        except asyncio.TimeoutError as e:
+            self._log.error(f"Timeout {method} {url} {e}")
+            raise
+        except aiohttp.ClientError as e:
+            self._log.error(f"Request Error {method} {url} {e}")
+            raise
+        except Exception as e:
+            self._log.error(f"Error {method} {url} {e}")
+            raise
+
+    # Market Data Endpoints
+    async def get_user_perps_summary(self) -> HyperLiquidUserPerpsSummary:
+        """Get user perps summary"""
+        endpoint = "/info"
+        api_key = self._api_key
+        base_url = self._base_url
+        if api_key is None or base_url is None:
+            raise ValueError("api_key and base_url are required")
+        payload = {"type": "clearinghouseState", "user": self._api_key, "dex": ""}
+        await self._limiter.info_limit(cost=2)
+        raw = await self._fetch("POST", base_url, endpoint, payload)
+        return self._user_perps_summary_decoder.decode(raw)
+
+    async def get_user_spot_summary(self) -> HyperLiquidUserSpotSummary:
+        """Get user spot summary"""
+        endpoint = "/info"
+        api_key = self._api_key
+        base_url = self._base_url
+        if api_key is None or base_url is None:
+            raise ValueError("api_key and base_url are required")
+        payload = {"type": "spotClearinghouseState", "user": api_key}
+        await self._limiter.info_limit(cost=2)
+        raw = await self._fetch("POST", base_url, endpoint, payload)
+        return self._user_spot_summary_decoder.decode(raw)
+
+    async def get_order_status(self, oid: str | int) -> dict[str, Any]:
+        """
+        Query order status by exchange oid or client order id (cloid).
+        """
+        endpoint = "/info"
+        api_key = self._api_key
+        base_url = self._base_url
+        if api_key is None or base_url is None:
+            raise ValueError("api_key and base_url are required")
+        payload = {"type": "orderStatus", "user": api_key, "oid": oid}
+        await self._limiter.info_limit(cost=2)
+        raw = await self._fetch("POST", base_url, endpoint, payload)
+        return self._msg_decoder.decode(raw)
+
+    async def get_klines(
+        self,
+        coin: str,
+        interval: str,
+        startTime: int | None = None,
+        endTime: int | None = None,
+    ) -> List[HyperLiquidKline]:
+        """
+        Get kline/candlestick data
+        https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#candle-snapshot
+        """
+        endpoint = "/info"
+        base_url = self._base_url
+        if base_url is None:
+            raise ValueError("base_url is required")
+        req: dict[str, str | int] = {
+            "coin": coin,
+            "interval": interval,
+        }
+        if startTime is not None:
+            req["startTime"] = startTime
+        if endTime is not None:
+            req["endTime"] = endTime
+        payload = {"type": "candleSnapshot", "req": req}
+
+        await self._limiter.info_limit(cost=20)
+        raw = await self._fetch("POST", base_url, endpoint, payload)
+        return self._kline_decoder.decode(raw)
+
+    def _construct_phantom_agent(
+        self, hash: bytes, is_testnet: bool = False
+    ) -> Dict[str, Any]:
+        return {"source": "b" if is_testnet else "a", "connectionId": hash}
+
+    def _action_hash(
+        self, action: Dict[str, Any], nonce: int, vaultAddress: str | None = None
+    ) -> bytes:
+        data = msgspec.msgpack.encode(action)
+        data += nonce.to_bytes(8, "big")
+        if vaultAddress is None:
+            data += b"\x00"
+        else:
+            data += b"\x01"
+            data += bytes.fromhex(
+                vaultAddress[2:] if vaultAddress.startswith("0x") else vaultAddress
+            )
+        return keccak.new(digest_bits=256, data=data).digest()
+
+    def _sign_l1_action(
+        self, action: Dict[str, Any], nonce: int, vaultAddress: str | None = None
+    ) -> dict[str, str | int]:
+        if not hasattr(self, "_eth_account"):
+            raise ValueError("secret is required for signed HyperLiquid actions")
+        hash = self._action_hash(action, nonce, vaultAddress)
+        phantom_agent = self._construct_phantom_agent(hash, is_testnet=self._testnet)
+        encoded_data = encode_typed_data(
+            full_message={
+                "domain": {
+                    "chainId": 1337,
+                    "name": "Exchange",
+                    "verifyingContract": "0x0000000000000000000000000000000000000000",
+                    "version": "1",
+                },
+                "types": {
+                    "Agent": [
+                        {"name": "source", "type": "string"},
+                        {"name": "connectionId", "type": "bytes32"},
+                    ],
+                    "EIP712Domain": [
+                        {"name": "name", "type": "string"},
+                        {"name": "version", "type": "string"},
+                        {"name": "chainId", "type": "uint256"},
+                        {"name": "verifyingContract", "type": "address"},
+                    ],
+                },
+                "primaryType": "Agent",
+                "message": phantom_agent,
+            }
+        )
+        signed = self._eth_account.sign_message(encoded_data)
+        return {
+            "r": f"{signed.r:#x}",
+            "s": f"{signed.s:#x}",
+            "v": signed.v,
+        }
+
+    # Trading Endpoints
+    async def place_orders(
+        self,
+        orders: List[HyperLiquidOrderRequest],
+        grouping: Literal["na", "normalTpsl", "positionTpsl"] = "na",
+    ) -> HyperLiquidOrderResponse:
+        nounce = self._clock.timestamp_ms()
+        base_url = self._base_url
+        if base_url is None:
+            raise ValueError("base_url is required")
+        orderAction = {
+            "type": "order",
+            "orders": orders,
+            "grouping": grouping,
+        }
+        signature = self._sign_l1_action(orderAction, nounce)
+        cost = self._get_rate_limit_cost(cost=1, length=len(orders))
+        await self._limiter.exchange_limit(cost=cost)
+        res = await self._fetch(
+            "POST",
+            base_url,
+            "/exchange",
+            {
+                "action": orderAction,
+                "nonce": nounce,
+                "signature": signature,
+            },
+        )
+        order = self._order_response_decoder.decode(res)
+        return order
+
+    async def cancel_orders(
+        self,
+        cancels: List[HyperLiquidOrderCancelRequest],
+    ):
+        nounce = self._clock.timestamp_ms()
+        base_url = self._base_url
+        if base_url is None:
+            raise ValueError("base_url is required")
+        orderAction = {
+            "type": "cancel",
+            "cancels": cancels,
+        }
+        signature = self._sign_l1_action(orderAction, nounce)
+        # cost = self._get_rate_limit_cost(cost=1, length=len(cancels))
+        # await self._limiter.exchange_limit(cost=cost)
+        res = await self._fetch(
+            "POST",
+            base_url,
+            "/exchange",
+            {
+                "action": orderAction,
+                "nonce": nounce,
+                "signature": signature,
+            },
+        )
+        return self._cancel_response_decoder.decode(res)
+
+    async def cancel_orders_by_cloid(
+        self,
+        cancels: List[HyperLiquidCloidCancelRequest],
+    ):
+        nounce = self._clock.timestamp_ms()
+        base_url = self._base_url
+        if base_url is None:
+            raise ValueError("base_url is required")
+        orderAction = {
+            "type": "cancelByCloid",
+            "cancels": cancels,
+        }
+        signature = self._sign_l1_action(orderAction, nounce)
+        # cost = self._get_rate_limit_cost(cost=1, length=len(cancels))
+        # await self._limiter.exchange_limit(cost=cost)
+        res = await self._fetch(
+            "POST",
+            base_url,
+            "/exchange",
+            {
+                "action": orderAction,
+                "nonce": nounce,
+                "signature": signature,
+            },
+        )
+        return self._cancel_response_decoder.decode(res)