trd-utils 0.0.57__py3-none-any.whl

trd_utils/exchanges/bx_ultra/bx_utils.py

@@ -0,0 +1,51 @@
+import hashlib
+import json
+import uuid
+
+
+default_e: str = (
+    "\u0039\u0035\u0064\u0036\u0035\u0063\u0037\u0033\u0064\u0063\u0035"
+    + "\u0063\u0034\u0033\u0037"
+)
+default_se: str = "\u0030\u0061\u0065\u0039\u0030\u0031\u0038\u0066\u0062\u0037"
+default_le: str = "\u0066\u0032\u0065\u0061\u0062\u0036\u0039"
+
+long_accept_header1: str = (
+    "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,"
+    + "image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7"
+)
+
+def do_ultra_ss(
+    e_param: str,
+    se_param: str,
+    le_param: str,
+    timestamp: int,
+    trace_id: str,
+    device_id: str,
+    platform_id: str,
+    app_version: str,
+    payload_data: str = None,
+) -> str:
+    if not e_param:
+        e_param = default_e
+
+    if not se_param:
+        se_param = default_se
+
+    if not le_param:
+        le_param = default_le
+
+    first_part = f"{e_param}{se_param}{le_param}{timestamp}{trace_id}"
+    if not payload_data:
+        payload_data = "{}"
+    elif not isinstance(payload_data, str):
+        # convert to json
+        payload_data = json.dumps(payload_data, separators=(",", ":"), sort_keys=True)
+
+    if not trace_id:
+        trace_id = uuid.uuid4().hex.replace("-", "")
+
+    whole_parts = f"{first_part}{device_id}{platform_id}{app_version}{payload_data}"
+
+    # do SHA256
+    return hashlib.sha256(whole_parts.encode()).hexdigest().upper()

trd_utils/exchanges/errors.py

@@ -0,0 +1,10 @@
+
+
+
+class ExchangeError(RuntimeError):
+    """
+    Specifies an error coming from the exchange.
+    """
+    def __init__(self, *args):
+        super().__init__(*args)
+

trd_utils/exchanges/exchange_base.py

@@ -0,0 +1,301 @@
+import asyncio
+from decimal import Decimal
+import inspect
+import json
+import logging
+from typing import Callable, Type
+from abc import ABC
+
+import base64
+import time
+
+import httpx
+from websockets.asyncio.connection import Connection as WSConnection
+
+from trd_utils.exchanges.base_types import (
+    UnifiedFuturesMarketInfo,
+    UnifiedTraderInfo,
+    UnifiedTraderPositions,
+)
+from trd_utils.types_helper.base_model import BaseModel
+
+logger = logging.getLogger(__name__)
+
+
+class JWTManager:
+    _jwt_string: str = None
+
+    def __init__(self, jwt_string: str):
+        self._jwt_string = jwt_string
+        try:
+            payload_b64 = self._jwt_string.split(".")[1]
+            payload_bytes = base64.urlsafe_b64decode(payload_b64 + "==")
+            self.payload = json.loads(payload_bytes)
+        except Exception:
+            self.payload = {}
+
+    def is_expired(self):
+        if "exp" not in self.payload:
+            return False
+
+        return time.time() > self.payload["exp"]
+
+
+class ExchangeBase(ABC):
+    ###########################################################
+    # region client parameters
+    user_agent: str = "okhttp/4.12.0"
+    x_requested_with: str = None
+    httpx_client: httpx.AsyncClient = None
+    account_name: str = "default"
+    sessions_dir: str = "sessions"
+
+    authorization_token: str = None
+    device_id: str = None
+    trace_id: str = None
+    app_version: str = "4.28.3"
+    x_router_tag: str = "gray-develop"
+    platform_id: str = "10"
+    install_channel: str = "officialAPK"
+    channel_header: str = "officialAPK"
+
+    # The name of the exchange.
+    exchange_name: str = None
+
+    jwt_manager: JWTManager = None
+
+    _fav_letter: str = "^"
+
+    # the lock for internal operations.
+    _internal_lock: asyncio.Lock = None
+
+    # extra tasks to be cancelled when the client closes.
+    extra_tasks: list[asyncio.Task] = None
+
+    # the price ws connection to be closed when this client is closed.
+    price_ws_connection: WSConnection = None
+    # endregion
+    ###########################################################
+    # region constructor method
+
+    def __init__(self):
+        self._internal_lock = asyncio.Lock()
+        self.extra_tasks = []
+
+    # endregion
+    ###########################################################
+    # region abstract trading methods
+
+    async def get_unified_trader_positions(
+        self,
+        uid: int | str,
+        min_margin: Decimal = 0,
+    ) -> UnifiedTraderPositions:
+        """
+        Returns the unified version of all currently open positions of the specific
+        trader. Note that different exchanges might fill different fields, according to the
+        data they provide in their public APIs.
+        If you want to fetch past positions history, you have to use another method.
+        """
+        raise NotImplementedError(
+            "This method is not implemented in ExchangeBase class. "
+            "Please use a real exchange class inheriting and implementing this method."
+        )
+
+    async def get_unified_trader_info(self, uid: int | str) -> UnifiedTraderInfo:
+        """
+        Returns information about a specific trader.
+        Different exchanges might return and fill different information according to the
+        data returned from their public APIs.
+        """
+        raise NotImplementedError(
+            "This method is not implemented in ExchangeBase class. "
+            "Please use a real exchange class inheriting and implementing this method."
+        )
+
+    async def get_unified_futures_market_info(
+        self,
+        sort_by: str = "percentage_change_24h",
+        descending: bool = True,
+        allow_delisted: bool = False,
+        filter_quote_token: str | None = None,
+        raise_on_invalid: bool = False,
+        filter_func: Callable | None = None,
+    ) -> UnifiedFuturesMarketInfo:
+        """
+        Returns the unified version of futures market information.
+        Different exchanges might return and fill different information according to the
+        data returned from their public APIs.
+        """
+        raise NotImplementedError(
+            "This method is not implemented in ExchangeBase class. "
+            "Please use a real exchange class inheriting and implementing this method."
+        )
+
+    # endregion
+    ###########################################################
+    # region client helper methods
+    def get_headers(self, payload=None, needs_auth: bool = False) -> dict:
+        pass
+
+    async def invoke_get(
+        self,
+        url: str,
+        headers: dict | None = None,
+        params: dict | None = None,
+        model_type: Type[BaseModel] | None = None,
+        parse_float=Decimal,
+        raw_data: bool = False,
+    ) -> "BaseModel":
+        """
+        Invokes the specific request to the specific url with the specific params and headers.
+        """
+        response = await self.httpx_client.get(
+            url=url,
+            headers=headers,
+            params=params,
+        )
+        return self._handle_response(
+            response=response,
+            model_type=model_type,
+            parse_float=parse_float,
+            raw_data=raw_data,
+        )
+
+    async def invoke_post(
+        self,
+        url: str,
+        headers: dict | None = None,
+        params: dict | None = None,
+        content: dict | str | bytes = "",
+        model_type: Type[BaseModel] | None = None,
+        parse_float=Decimal,
+        raw_data: bool = False,
+    ) -> "BaseModel":
+        """
+        Invokes the specific request to the specific url with the specific params and headers.
+        """
+
+        if isinstance(content, dict):
+            content = json.dumps(content, separators=(",", ":"), sort_keys=True)
+
+        response = await self.httpx_client.post(
+            url=url,
+            headers=headers,
+            params=params,
+            content=content,
+        )
+        return self._handle_response(
+            response=response,
+            model_type=model_type,
+            parse_float=parse_float,
+            raw_data=raw_data,
+        )
+
+    def _handle_response(
+        self,
+        response: httpx.Response,
+        model_type: Type[BaseModel] | None = None,
+        parse_float=Decimal,
+        raw_data: bool = False,
+    ) -> "BaseModel":
+        if raw_data:
+            return response.content
+
+        j_obj = self._resp_to_json(
+            response=response,
+            parse_float=parse_float,
+        )
+        if not model_type:
+            return j_obj
+
+        return model_type.deserialize(j_obj)
+
+    def _resp_to_json(
+        self,
+        response: httpx.Response,
+        parse_float=None,
+    ) -> dict:
+        try:
+            return response.json(parse_float=parse_float)
+        except UnicodeDecodeError:
+            # try to decompress manually
+            import gzip
+            import brotli
+
+            content_encoding = response.headers.get("Content-Encoding", "").lower()
+            content = response.content
+
+            if "gzip" in content_encoding:
+                content = gzip.decompress(content)
+            elif "br" in content_encoding:
+                content = brotli.decompress(content)
+            elif "deflate" in content_encoding:
+                import zlib
+
+                content = zlib.decompress(content, -zlib.MAX_WBITS)
+            else:
+                raise ValueError(
+                    f"failed to detect content encoding: {content_encoding}"
+                )
+
+            # Now parse the decompressed content
+            return json.loads(content.decode("utf-8"), parse_float=parse_float)
+
+    async def _apply_filter_func(
+        self,
+        filter_func: Callable,
+        func_args: dict,
+    ) -> bool:
+        if inspect.iscoroutinefunction(filter_func):
+            return await filter_func(**func_args)
+        elif inspect.isfunction(filter_func) or callable(filter_func):
+            result = filter_func(**func_args)
+            
+            if inspect.iscoroutine(result):
+                return await result
+            return result
+        else:
+            raise ValueError("filter_func must be a function or coroutine function.")
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type=None,
+        exc_value=None,
+        traceback=None,
+    ) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        await self._internal_lock.acquire()
+        await self.httpx_client.aclose()
+
+        if self.price_ws_connection:
+            try:
+                await self.price_ws_connection.close()
+            except Exception as ex:
+                logger.warning(f"failed to close ws connection: {ex}")
+
+        self._internal_lock.release()
+
+    # endregion
+    ###########################################################
+    # region data-files related methods
+
+    def read_from_session_file(self, file_path: str) -> None:
+        """
+        Reads from session file; if it doesn't exist, creates it.
+        """
+        pass
+
+    def _save_session_file(self, file_path: str) -> None:
+        """
+        Saves current information to the session file.
+        """
+        pass
+
+    # endregion
+    ###########################################################

trd_utils/exchanges/hyperliquid/README.md

@@ -0,0 +1,3 @@
+# Hyperdash
+
+NOTE: [Hyperdash](https://hyperdash.info) is not an exchange, but a tracker for HyperLiquid.

trd_utils/exchanges/hyperliquid/__init__.py

@@ -0,0 +1,7 @@
+
+from .hyperliquid_client import HyperLiquidClient
+
+
+__all__ = [
+    "HyperLiquidClient",
+]

trd_utils/exchanges/hyperliquid/hyperliquid_client.py

@@ -0,0 +1,292 @@
+from datetime import datetime
+from decimal import Decimal
+import json
+import logging
+from typing import Callable
+import httpx
+
+from pathlib import Path
+
+import pytz
+
+from trd_utils.cipher import AESCipher
+from trd_utils.common_utils.wallet_utils import shorten_wallet_address
+from trd_utils.exchanges.base_types import (
+    UnifiedFuturesMarketInfo,
+    UnifiedPositionInfo,
+    UnifiedSingleFutureMarketInfo,
+    UnifiedTraderInfo,
+    UnifiedTraderPositions,
+)
+from trd_utils.exchanges.exchange_base import ExchangeBase
+from trd_utils.exchanges.hyperliquid.hyperliquid_types import (
+    MetaAssetCtxResponse,
+    TraderPositionsInfoResponse,
+)
+from trd_utils.types_helper import new_list
+
+logger = logging.getLogger(__name__)
+
+BASE_PROFILE_URL = "https://hypurrscan.io/address/"
+
+
+class HyperLiquidClient(ExchangeBase):
+    ###########################################################
+    # region client parameters
+    hyperliquid_api_base_host: str = "https://api.hyperliquid.xyz"
+    hyperliquid_api_base_url: str = "https://api.hyperliquid.xyz"
+    origin_header: str = "app.hyperliquid.xy"
+    default_quote_token: str = "USDC"
+
+    # endregion
+    ###########################################################
+    # region client constructor
+    def __init__(
+        self,
+        account_name: str = "default",
+        http_verify: bool = True,
+        fav_letter: str = "^",
+        read_session_file: bool = False,
+        sessions_dir: str = "sessions",
+        use_http1: bool = True,
+        use_http2: bool = False,
+    ):
+        # it looks like hyperliquid's api endpoints don't support http2 :(
+        self.httpx_client = httpx.AsyncClient(
+            verify=http_verify,
+            http1=use_http1,
+            http2=use_http2,
+        )
+        self.account_name = account_name
+        self._fav_letter = fav_letter
+        self.sessions_dir = sessions_dir
+        self.exchange_name = "hyperliquid"
+
+        super().__init__()
+
+        if read_session_file:
+            self.read_from_session_file(f"{sessions_dir}/{self.account_name}.hl")
+
+    # endregion
+    ###########################################################
+    # region info endpoints
+    async def get_trader_positions_info(
+        self,
+        uid: int | str,
+    ) -> TraderPositionsInfoResponse:
+        payload = {
+            "type": "clearinghouseState",
+            "user": f"{uid}",
+        }
+        headers = self.get_headers()
+        return await self.invoke_post(
+            f"{self.hyperliquid_api_base_host}/info",
+            headers=headers,
+            content=payload,
+            model_type=TraderPositionsInfoResponse,
+        )
+
+    async def get_meta_asset_ctx_info(
+        self,
+        allow_delisted: bool = False,
+    ) -> MetaAssetCtxResponse:
+        payload = {
+            "type": "metaAndAssetCtxs",
+        }
+        headers = self.get_headers()
+        data = await self.invoke_post(
+            f"{self.hyperliquid_api_base_host}/info",
+            headers=headers,
+            content=payload,
+            model_type=None,  # it has a weird response structure
+        )
+
+        return MetaAssetCtxResponse.parse_from_api_resp(
+            data=data,
+            allow_delisted=allow_delisted,
+        )
+
+    # endregion
+    ###########################################################
+    # region another-thing
+    # async def get_another_thing_info(self, uid: int) -> AnotherThingInfoResponse:
+    #     payload = {
+    #         "uid": uid,
+    #     }
+    #     headers = self.get_headers()
+    #     return await self.invoke_post(
+    #         f"{self.hyperliquid_api_base_url}/another-thing/info",
+    #         headers=headers,
+    #         content=payload,
+    #         model_type=CopyTraderInfoResponse,
+    #     )
+
+    # endregion
+    ###########################################################
+    # region client helper methods
+    def get_headers(self, payload=None, needs_auth: bool = False) -> dict:
+        the_headers = {
+            # "Host": self.hyperliquid_api_base_host,
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "User-Agent": self.user_agent,
+            "Connection": "close",
+            "appsiteid": "0",
+        }
+
+        if self.x_requested_with:
+            the_headers["X-Requested-With"] = self.x_requested_with
+
+        if needs_auth:
+            the_headers["Authorization"] = f"Bearer {self.authorization_token}"
+        return the_headers
+
+    def read_from_session_file(self, file_path: str) -> None:
+        """
+        Reads from session file; if it doesn't exist, creates it.
+        """
+        # check if path exists
+        target_path = Path(file_path)
+        if not target_path.exists():
+            return self._save_session_file(file_path=file_path)
+
+        aes = AESCipher(key=f"bf_{self.account_name}_bf", fav_letter=self._fav_letter)
+        content = aes.decrypt(target_path.read_text()).decode("utf-8")
+        json_data: dict = json.loads(content)
+
+        self.authorization_token = json_data.get(
+            "authorization_token",
+            self.authorization_token,
+        )
+        self.user_agent = json_data.get("user_agent", self.user_agent)
+
+    def _save_session_file(self, file_path: str) -> None:
+        """
+        Saves current information to the session file.
+        """
+
+        json_data = {
+            "authorization_token": self.authorization_token,
+            "user_agent": self.user_agent,
+        }
+        aes = AESCipher(key=f"bf_{self.account_name}_bf", fav_letter=self._fav_letter)
+        target_path = Path(file_path)
+        if not target_path.exists():
+            target_path.mkdir(parents=True)
+        target_path.write_text(aes.encrypt(json.dumps(json_data)))
+
+    # endregion
+    ###########################################################
+    # region unified methods
+    async def get_unified_trader_positions(
+        self,
+        uid: int | str,
+        min_margin: Decimal = 0,
+    ) -> UnifiedTraderPositions:
+        result = await self.get_trader_positions_info(
+            uid=uid,
+        )
+        unified_result = UnifiedTraderPositions()
+        unified_result.positions = new_list()
+        for position_container in result.asset_positions:
+            position = position_container.position
+            if min_margin and (
+                not position.margin_used or position.margin_used < min_margin
+            ):
+                continue
+
+            unified_pos = UnifiedPositionInfo()
+            unified_pos.position_id = position.get_position_id()
+            unified_pos.position_pnl = round(position.unrealized_pnl, 3)
+            unified_pos.position_side = position.get_side()
+            unified_pos.margin_mode = position.leverage.type
+            unified_pos.position_leverage = Decimal(position.leverage.value)
+            unified_pos.position_pair = f"{position.coin}/{self.default_quote_token}"
+            unified_pos.open_time = datetime.now(
+                pytz.UTC
+            )  # hyperliquid doesn't provide this...
+            unified_pos.open_price = position.entry_px
+            unified_pos.open_price_unit = self.default_quote_token
+            unified_pos.position_size = abs(position.szi)
+            unified_pos.initial_margin = position.margin_used
+            unified_result.positions.append(unified_pos)
+
+        return unified_result
+
+    async def get_unified_trader_info(
+        self,
+        uid: int | str,
+    ) -> UnifiedTraderInfo:
+        if not isinstance(uid, str):
+            uid = str(uid)
+        # sadly hyperliquid doesn't really have an endpoint to fetch information
+        # so we have to somehow *fake* these...
+        # maybe in future try to find a better way?
+        unified_info = UnifiedTraderInfo()
+        unified_info.trader_id = uid
+        unified_info.trader_name = shorten_wallet_address(uid)
+        unified_info.trader_url = f"{BASE_PROFILE_URL}{uid}"
+        unified_info.win_rate = None
+
+        return unified_info
+
+    async def get_unified_futures_market_info(
+        self,
+        sort_by: str = "percentage_change_24h",
+        descending: bool = True,
+        allow_delisted: bool = False,
+        filter_quote_token: str | None = None,
+        raise_on_invalid: bool = False,
+        filter_func: Callable | None = None,
+    ) -> UnifiedFuturesMarketInfo:
+        asset_ctxs = await self.get_meta_asset_ctx_info(
+            allow_delisted=allow_delisted,
+        )
+        unified_info = UnifiedFuturesMarketInfo()
+        unified_info.sorted_markets = []
+
+        for current_asset in asset_ctxs.assets:
+            current_market = UnifiedSingleFutureMarketInfo()
+            current_market.name = current_asset.symbol
+            current_market.pair = f"{current_asset.symbol}/{self.default_quote_token}"
+            current_market.price = current_asset.mark_px
+            current_market.previous_day_price = current_asset.prev_day_px
+            current_market.absolute_change_24h = current_asset.change_abs
+            current_market.percentage_change_24h = current_asset.change_pct
+            current_market.funding_rate = current_asset.funding
+            current_market.daily_volume = current_asset.day_ntl_vlm
+            current_market.open_interest = current_asset.open_interest
+
+            if filter_func:
+                filter_args = {
+                    "pair": current_market.pair,
+                    "market_info": current_market,
+                    "exchange_client": self,
+                }
+                # this is defined in exchange base.
+                should_include = await self._apply_filter_func(
+                    filter_func=filter_func,
+                    func_args=filter_args,
+                )
+                if not should_include:
+                    continue
+
+            unified_info.sorted_markets.append(current_market)
+
+        if not sort_by:
+            # we won't sort anything
+            return unified_info
+
+        def key_fn(market: UnifiedSingleFutureMarketInfo):
+            return getattr(market, sort_by, Decimal(0))
+
+        unified_info.sorted_markets = new_list(sorted(
+            unified_info.sorted_markets,
+            key=key_fn,
+            reverse=descending,
+        ))
+        return unified_info
+
+    # endregion
+    ###########################################################