trd-utils 0.0.57__py3-none-any.whl

trd_utils/exchanges/blofin/blofin_client.py

@@ -0,0 +1,375 @@
+import asyncio
+from decimal import Decimal
+import json
+import logging
+import httpx
+
+import time
+from pathlib import Path
+
+from trd_utils.date_utils.datetime_helpers import dt_from_ts
+from trd_utils.exchanges.base_types import (
+    UnifiedPositionInfo,
+    UnifiedTraderInfo,
+    UnifiedTraderPositions,
+)
+from trd_utils.exchanges.blofin.blofin_types import (
+    CmsColorResponse,
+    CopyTraderAllOrderHistory,
+    CopyTraderAllOrderList,
+    CopyTraderInfoResponse,
+    CopyTraderOrderHistoryResponse,
+    CopyTraderOrderListResponse,
+    ShareConfigResponse,
+)
+from trd_utils.cipher import AESCipher
+from trd_utils.exchanges.errors import ExchangeError
+from trd_utils.exchanges.exchange_base import ExchangeBase
+from trd_utils.types_helper import new_list
+
+
+BASE_PROFILE_URL = "https://blofin.com/copy-trade/details/"
+
+logger = logging.getLogger(__name__)
+
+
+class BlofinClient(ExchangeBase):
+    ###########################################################
+    # region client parameters
+    blofin_api_base_host: str = "https://\u0062lofin.co\u006d"
+    blofin_api_base_url: str = "https://\u0062lofin.co\u006d/uapi/v1"
+    origin_header: str = "https://\u0062lofin.co\u006d"
+
+    timezone: str = "Etc/UTC"
+
+    # endregion
+    ###########################################################
+    # region client constructor
+    def __init__(
+        self,
+        account_name: str = "default",
+        http_verify: bool = True,
+        fav_letter: str = "^",
+        read_session_file: bool = True,
+        sessions_dir: str = "sessions",
+        use_http1: bool = False,
+        use_http2: bool = True,
+    ):
+        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 = "blofin"
+
+        super().__init__()
+
+        if read_session_file:
+            self.read_from_session_file(f"{sessions_dir}/{self.account_name}.bf")
+
+    # endregion
+    ###########################################################
+    # region v1/cms/
+    async def get_share_config(self) -> ShareConfigResponse:
+        headers = self.get_headers()
+        return await self.invoke_get(
+            f"{self.blofin_api_base_url}/cms/share_config",
+            headers=headers,
+            model_type=ShareConfigResponse,
+        )
+
+    async def get_cms_color(self) -> CmsColorResponse:
+        headers = self.get_headers()
+        return await self.invoke_get(
+            f"{self.blofin_api_base_url}/cms/color",
+            headers=headers,
+            model_type=CmsColorResponse,
+        )
+
+    # endregion
+    ###########################################################
+    # region copy/trader
+    async def get_copy_trader_info(self, uid: int) -> CopyTraderInfoResponse:
+        payload = {
+            "uid": uid,
+        }
+        headers = self.get_headers()
+        return await self.invoke_post(
+            f"{self.blofin_api_base_url}/copy/trader/info",
+            headers=headers,
+            content=payload,
+            model_type=CopyTraderInfoResponse,
+        )
+
+    async def get_copy_trader_order_list(
+        self,
+        uid: int | str,
+        from_param: int = 0,
+        limit_param: int = 20,
+    ) -> CopyTraderOrderListResponse:
+        payload = {
+            "from": from_param,
+            "limit": limit_param,
+            "uid": int(uid),
+        }
+        headers = self.get_headers()
+        return await self.invoke_post(
+            f"{self.blofin_api_base_url}/copy/trader/order/list",
+            headers=headers,
+            content=payload,
+            model_type=CopyTraderOrderListResponse,
+        )
+
+    async def get_copy_trader_all_order_list(
+        self,
+        uid: int,
+        from_param: int = 0,
+        chunk_limit: int = 20,
+        sleep_delay: int = 0.5,
+    ) -> CopyTraderAllOrderList:
+        if chunk_limit < 1:
+            raise ValueError("chunk_limit parameter has to be more than 1")
+
+        result = CopyTraderAllOrderList(
+            code=200,
+            data=[],
+            total_count=0,
+        )
+        current_id_from = from_param
+        while True:
+            total_ignored = 0
+            current_result = await self.get_copy_trader_order_list(
+                uid=uid,
+                from_param=current_id_from,
+                limit_param=chunk_limit,
+            )
+            if current_result.code != 200:
+                if current_result.msg:
+                    raise ExchangeError(
+                        f"blofin get_copy_trader_all_order_list: {current_result.msg}; "
+                        f"code: {current_result.code}"
+                    )
+                raise ExchangeError(
+                    "blofin get_copy_trader_all_order_list: unknown error; "
+                    f"code: {current_result.code}"
+                )
+
+            if not isinstance(current_result, CopyTraderOrderListResponse):
+                raise ValueError(
+                    "get_copy_trader_order_list returned invalid value of "
+                    f"{type(current_result)}",
+                )
+            if not current_result.data:
+                # we no longer have anything else here
+                return result
+
+            if current_result.data[0].id == current_id_from:
+                if len(current_result.data) < 2:
+                    return result
+                current_result.data = current_result.data[1:]
+                total_ignored += 1
+            elif current_id_from:
+                raise ValueError(
+                    "Expected first array to have the same value as from_param: "
+                    f"current_id_from: {current_id_from}; but was: {current_result.data[0].id}"
+                )
+
+            current_id_from = current_result.data[-1].id
+            result.data.extend(current_result.data)
+            result.total_count += len(current_result.data)
+            if len(current_result.data) < chunk_limit - total_ignored:
+                # the trader doesn't have any more open orders
+                return result
+            if result.total_count > len(current_result.data) and sleep_delay:
+                # we don't want to sleep after 1 request only
+                await asyncio.sleep(sleep_delay)
+
+    async def get_copy_trader_order_history(
+        self,
+        uid: int,
+        from_param: int = 0,
+        limit_param: int = 20,
+    ) -> CopyTraderOrderHistoryResponse:
+        payload = {
+            "from": from_param,
+            "limit": limit_param,
+            "uid": uid,
+        }
+        headers = self.get_headers()
+        return await self.invoke_post(
+            f"{self.blofin_api_base_url}/copy/trader/order/history",
+            headers=headers,
+            content=payload,
+            model_type=CopyTraderOrderHistoryResponse,
+        )
+
+    async def get_copy_trader_all_order_history(
+        self,
+        uid: int,
+        from_param: int = 0,
+        chunk_limit: int = 20,
+        sleep_delay: int = 0.5,
+    ) -> CopyTraderAllOrderHistory:
+        if chunk_limit < 1:
+            raise ValueError("chunk_limit parameter has to be more than 1")
+
+        result = CopyTraderAllOrderHistory(
+            code=200,
+            data=[],
+            total_count=0,
+        )
+        current_id_from = from_param
+        while True:
+            total_ignored = 0
+            current_result = await self.get_copy_trader_order_history(
+                uid=uid,
+                from_param=current_id_from,
+                limit_param=chunk_limit,
+            )
+            if (
+                not current_result
+                or not isinstance(current_result, CopyTraderOrderHistoryResponse)
+                or not current_result.data
+            ):
+                return result
+
+            if current_result.data[0].id == current_id_from:
+                if len(current_result.data) < 2:
+                    return result
+                current_result.data = current_result.data[1:]
+                total_ignored += 1
+            elif current_id_from:
+                raise ValueError(
+                    "Expected first array to have the same value as from_param: "
+                    f"current_id_from: {current_id_from}; but was: {current_result.data[0].id}"
+                )
+
+            current_id_from = current_result.data[-1].id
+            result.data.extend(current_result.data)
+            result.total_count += len(current_result.data)
+            if len(current_result.data) < chunk_limit - total_ignored:
+                # the trader doesn't have any more orders history
+                return result
+            if result.total_count > len(current_result.data) and sleep_delay:
+                # we don't want to sleep after 1 request only
+                await asyncio.sleep(sleep_delay)
+
+    # endregion
+    ###########################################################
+    # region client helper methods
+    def get_headers(self, payload=None, needs_auth: bool = False) -> dict:
+        the_timestamp = int(time.time() * 1000)
+        the_headers = {
+            # "Host": self.blofin_api_base_host,
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Origin": self.origin_header,
+            "X-Tz": self.timezone,
+            "Fp-Request-Id": f"{the_timestamp}.n1fDrN",
+            "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.timezone = json_data.get("timezone", self.timezone)
+        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,
+            "timezone": self.timezone,
+            "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_copy_trader_all_order_list(
+            uid=uid,
+        )
+        unified_result = UnifiedTraderPositions()
+        unified_result.positions = new_list()
+        for position in result.data:
+            unified_pos = UnifiedPositionInfo()
+            unified_pos.position_id = position.id or position.order_id
+            unified_pos.position_pnl = position.real_pnl or position.pnl
+            unified_pos.position_side = (
+                "LONG" if position.order_side in ("LONG", "BUY") else "SHORT"
+            )
+            unified_pos.margin_mode = position.margin_mode
+            unified_pos.position_leverage = Decimal(position.leverage)
+            unified_pos.position_pair = position.symbol.replace("-", "/")
+            unified_pos.open_time = dt_from_ts(position.open_time)
+            unified_pos.open_price = position.avg_open_price
+            unified_pos.open_price_unit = position.symbol.split("-")[-1]
+            unified_pos.initial_margin = position.get_initial_margin()
+            if min_margin and (
+                not unified_pos.initial_margin
+                or unified_pos.initial_margin < min_margin
+            ):
+                continue
+
+            unified_result.positions.append(unified_pos)
+
+        return unified_result
+
+    async def get_unified_trader_info(
+        self,
+        uid: int | str,
+    ) -> UnifiedTraderInfo:
+        info_resp = await self.get_copy_trader_info(
+            uid=uid,
+        )
+        info = info_resp.data
+        unified_info = UnifiedTraderInfo()
+        unified_info.trader_id = info.uid
+        unified_info.trader_name = info.nick_name
+        unified_info.trader_url = f"{BASE_PROFILE_URL}{info.uid}"
+        unified_info.win_rate = info.win_rate
+
+        return unified_info
+
+    # endregion
+    ###########################################################

trd_utils/exchanges/blofin/blofin_types.py

@@ -0,0 +1,173 @@
+from decimal import Decimal
+from typing import Any
+from trd_utils.types_helper import BaseModel
+
+
+###########################################################
+
+# region common types
+
+
+class BlofinApiResponse(BaseModel):
+    code: int = None
+    timestamp: int = None
+    msg: str = None
+
+    def __str__(self):
+        return f"code: {self.code}; timestamp: {self.timestamp}"
+
+    def __repr__(self):
+        return f"code: {self.code}; timestamp: {self.timestamp}"
+
+
+# endregion
+
+###########################################################
+
+# region api-config types
+
+
+class PnlShareListInfo(BaseModel):
+    background_color: str = None
+    background_img_up: str = None
+    background_img_down: str = None
+
+
+class ShareConfigResult(BaseModel):
+    pnl_share_list: list[PnlShareListInfo] = None
+
+
+class ShareConfigResponse(BlofinApiResponse):
+    data: ShareConfigResult = None
+
+
+class CmsColorResult(BaseModel):
+    color: str = None
+    city: str = None
+    country: str = None
+    ip: str = None
+
+
+class CmsColorResponse(BlofinApiResponse):
+    data: CmsColorResult = None
+
+
+# endregion
+
+###########################################################
+
+# region copy-trader types
+
+
+class CopyTraderInfoResult(BaseModel):
+    aum: str = None
+    can_copy: bool = None
+    copier_whitelist: bool = None
+    follow_state: int = None
+    followers: int = None
+    followers_max: int = None
+    forbidden_follow_type: int = None
+    hidden_all: bool = None
+    hidden_order: bool = None
+    joined_date: int = None
+    max_draw_down: Decimal = None
+    nick_name: str = None
+    order_amount_limit: Any = None
+    profile: str = None
+    profit_sharing_ratio: Decimal = None
+    real_pnl: Decimal = None
+    roi_d7: Decimal = None
+    self_introduction: str = None
+    sharing_period: str = None
+    source: int = None
+    uid: int = None
+    whitelist_copier: bool = None
+    win_rate: Decimal = None
+
+    def get_profile_url(self) -> str:
+        return f"https://blofin.com/copy-trade/details/{self.uid}"
+
+
+class CopyTraderInfoResponse(BlofinApiResponse):
+    data: CopyTraderInfoResult = None
+
+
+class CopyTraderSingleOrderInfo(BaseModel):
+    id: int = None
+    symbol: str = None
+    leverage: int = None
+    order_side: str = None
+    avg_open_price: Decimal = None
+    quantity: Decimal = None
+    quantity_cont: Any = None
+    open_time: int = None
+    close_time: Any = None
+    avg_close_price: Decimal = None
+    real_pnl: Any = None
+    close_type: Any = None
+    roe: Decimal = None
+    followers_profit: Decimal = None
+    followers: Any = None
+    order_id: Any = None
+    sharing: Any = None
+    order_state: Any = None
+    trader_name: Any = None
+    mark_price: Any = None
+    tp_trigger_price: Any = None
+    tp_order_type: Any = None
+    sl_trigger_price: Any = None
+    sl_order_type: Any = None
+    margin_mode: str = None
+    time_in_force: Any = None
+    position_side: str = None
+    order_category: Any = None
+    price: Any = None
+    fill_quantity: Any = None
+    fill_quantity_cont: Any = None
+    pnl: Decimal = None
+    cancel_source: Any = None
+    order_type: Any = None
+    order_open_state: Any = None
+    amount: Any = None
+    filled_amount: Any = None
+    create_time: Any = None
+    update_time: Any = None
+    open_fee: Any = None
+    close_fee: Any = None
+    id_md5: Any = None
+    tp_sl: Any = None
+    trader_uid: Any = None
+    available_quantity: Any = None
+    available_quantity_cont: Any = None
+    show_in_kline: Any = None
+    unrealized_pnl: Any = None
+    unrealized_pnl_ratio: Any = None
+    broker_id: Any = None
+    position_change_history: Any = None
+    user_id: Any = None
+
+    def get_initial_margin(self) -> Decimal:
+        if not self.avg_open_price or not self.quantity or not self.leverage:
+            return None
+        return (self.avg_open_price * self.quantity) / self.leverage
+
+
+class CopyTraderOrderListResponse(BlofinApiResponse):
+    data: list[CopyTraderSingleOrderInfo] = None
+
+
+class CopyTraderAllOrderList(CopyTraderOrderListResponse):
+    total_count: int = None
+
+
+class CopyTraderOrderHistoryResponse(BlofinApiResponse):
+    data: list[CopyTraderSingleOrderInfo] = None
+
+
+class CopyTraderAllOrderHistory(CopyTraderOrderHistoryResponse):
+    total_count: int = None
+
+
+# endregion
+
+###########################################################

trd_utils/exchanges/bx_ultra/__init__.py

@@ -0,0 +1,6 @@
+
+from .bx_ultra_client import BXUltraClient
+
+__all__ = [
+    "BXUltraClient",
+]