unicex 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

unicex/hyperliquid/exchange_info.py

@@ -0,0 +1,100 @@
+__all__ = ["ExchangeInfo"]
+
+from unicex._abc import IExchangeInfo
+
+from .client import Client
+
+
+class ExchangeInfo(IExchangeInfo):
+    """Предзагружает информацию о тикерах для биржи Hyperliquid."""
+
+    _spot_meta: dict = {}
+    """Словарь с метаинформацией о спотовом рынке."""
+
+    _spot_ident_to_idx: dict = {}
+    """Словарь, в котором ключ - индетефикатор тикера на бирже, например '@123', а значение - его индекс в _spot_meta."""
+
+    _spot_idx_to_name: dict = {}
+    """Словарь, в котором ключ - индекс в _spot_meta, например "123", а значение - название тикера, например 'BTC'."""
+
+    _futures_meta: dict = {}
+    """Словарь с метаинформацией о фьючерсном рынке."""
+
+    @classmethod
+    async def _load_exchange_info(cls) -> None:
+        """Загружает информацию о бирже."""
+        client = await Client.create()
+        async with client as conn:
+            cls._spot_meta = await conn.spot_metadata()
+            cls._build_spot_mappings(cls._spot_meta)
+            cls._logger.debug("Hyperliquid spot exchange info loaded")
+
+            cls._futures_meta = await conn.perp_metadata()
+            cls._logger.debug("Hyperliquid futures exchange info loaded")
+
+    @classmethod
+    def _build_spot_mappings(cls, spot_meta: dict) -> None:
+        """Строит словари соответствия '@индекс' ↔ индекс ↔ 'BTC'."""
+        universe = spot_meta["universe"]
+        tokens = spot_meta["tokens"]
+
+        number_to_idx = {}
+        for u in universe:
+            number_to_idx[u["name"]] = u["tokens"][0]
+        cls._spot_ident_to_idx = number_to_idx
+
+        idx_to_name = {}
+        for t in tokens:
+            idx_to_name[t["index"]] = t["name"]
+        cls._spot_idx_to_name = idx_to_name
+
+    @classmethod
+    def get_spot_meta(cls) -> dict:
+        """Возвращает метаинформацию о спотовом рынке."""
+        cls._check_loaded()
+        return cls._spot_meta
+
+    @classmethod
+    def get_futures_meta(cls) -> dict:
+        """Возвращает метаинформацию о фьючерсном рынке."""
+        cls._check_loaded()
+        return cls._futures_meta
+
+    @classmethod
+    def resolve_spot_symbol(cls, ident: str) -> str:
+        """Преобразует внутренний идентификатор вида '@142' в тикер, например 'BTC'.
+        Не рейзит KeyError, если тикер не найден.
+
+        Параметры:
+            token_name (str): Имя токена на бирже, например '@142' или 'BTC'.
+
+        Возвращает:
+            str | None: Название тикера (например 'BTC'), либо None, если не найден.
+        """
+        cls._check_loaded()
+
+        try:
+            return cls._spot_idx_to_name[cls._spot_ident_to_idx[ident]]
+        except KeyError:
+            return ident
+
+    @classmethod
+    def resolve_spot_ident(cls, symbol: str) -> str:
+        """Преобразует тикер (например, 'BTC') в внутренний идентификатор (например, '@142').
+
+        Параметры:
+            symbol (str): Название тикера, например 'BTC'.
+
+        Возвращает:
+            str: Внутренний идентификатор (например '@142').
+
+        Исключения:
+            KeyError: Если тикер не найден в локальном кэше биржи.
+        """
+        cls._check_loaded()
+
+        # Находим индекс по тикеру
+        idx = next(k for k, v in cls._spot_idx_to_name.items() if v == symbol)
+
+        # Возвращаем внутренний идентификатор вида "@142"
+        return next(k for k, v in cls._spot_ident_to_idx.items() if v == idx)

unicex/hyperliquid/uni_client.py

@@ -1,11 +1,14 @@
 __all__ = ["UniClient"]
 
+import time
+from typing import Self, overload
 
-from typing import overload
+import aiohttp
 
 from unicex._abc import IUniClient
-from unicex.enums import Timeframe
-from unicex.types import KlineDict, OpenInterestDict, OpenInterestItem, TickerDailyDict
+from unicex.enums import Exchange, MarketType, Timeframe
+from unicex.types import KlineDict, LoggerLike, OpenInterestDict, OpenInterestItem, TickerDailyDict
+from unicex.utils import batched_list
 
 from .adapter import Adapter
 from .client import Client
@@ -14,6 +17,84 @@ from .client import Client
 class UniClient(IUniClient[Client]):
     """Унифицированный клиент для работы с Hyperliquid API."""
 
+    def __init__(
+        self,
+        session: aiohttp.ClientSession,
+        private_key: str | bytes | None = None,
+        wallet_address: str | None = None,
+        vault_address: str | None = None,
+        logger: LoggerLike | None = None,
+        max_retries: int = 3,
+        retry_delay: int | float = 0.1,
+        proxies: list[str] | None = None,
+        timeout: int = 10,
+    ) -> None:
+        """Инициализация клиента.
+
+        Параметры:
+            session (`aiohttp.ClientSession`): Сессия для выполнения HTTP‑запросов.
+            private_key (`str | bytes | None`): Приватный ключ API для аутентификации (Hyperliquid).
+            wallet_address (`str | None`): Адрес кошелька для аутентификации (Hyperliquid).
+            vault_address (`str | None`): Адрес хранилища для аутентификации (Hyperliquid).
+            logger (`LoggerLike | None`): Логгер для вывода информации.
+            max_retries (`int`): Максимальное количество повторных попыток запроса.
+            retry_delay (`int | float`): Задержка между повторными попытками, сек.
+            proxies (`list[str] | None`): Список HTTP(S)‑прокси для циклического использования.
+            timeout (`int`): Максимальное время ожидания ответа от сервера, сек.
+        """
+        self._client: Client = self._client_cls(
+            private_key=private_key,
+            wallet_address=wallet_address,
+            vault_address=vault_address,
+            session=session,
+            logger=logger,
+            max_retries=max_retries,
+            retry_delay=retry_delay,
+            proxies=proxies,
+            timeout=timeout,
+        )
+
+    @classmethod
+    async def create(
+        cls,
+        private_key: str | bytes | None = None,
+        wallet_address: str | None = None,
+        vault_address: str | None = None,
+        logger: LoggerLike | None = None,
+        max_retries: int = 3,
+        retry_delay: int | float = 0.1,
+        proxies: list[str] | None = None,
+        timeout: int = 10,
+    ) -> Self:
+        """Создает инстанцию клиента.
+        Создать клиент можно и через __init__, но в таком случае session: `aiohttp.ClientSession` - обязательный параметр.
+
+        Параметры:
+            session (`aiohttp.ClientSession`): Сессия для выполнения HTTP‑запросов.
+            private_key (`str | bytes | None`): Приватный ключ API для аутентификации (Hyperliquid).
+            wallet_address (`str | None`): Адрес кошелька для аутентификации (Hyperliquid).
+            vault_address (`str | None`): Адрес хранилища для аутентификации (Hyperliquid).
+            logger (`LoggerLike | None`): Логгер для вывода информации.
+            max_retries (`int`): Максимальное количество повторных попыток запроса.
+            retry_delay (`int | float`): Задержка между повторными попытками, сек.
+            proxies (`list[str] | None`): Список HTTP(S)‑прокси для циклического использования.
+            timeout (`int`): Максимальное время ожидания ответа от сервера, сек.
+
+        Возвращает:
+            `IUniClient`: Созданный экземпляр клиента.
+        """
+        return cls(
+            session=aiohttp.ClientSession(),
+            private_key=private_key,
+            wallet_address=wallet_address,
+            vault_address=vault_address,
+            logger=logger,
+            max_retries=max_retries,
+            retry_delay=retry_delay,
+            proxies=proxies,
+            timeout=timeout,
+        )
+
     @property
     def _client_cls(self) -> type[Client]:
         """Возвращает класс клиента для Hyperliquid.
@@ -23,36 +104,65 @@ class UniClient(IUniClient[Client]):
         """
         return Client
 
-    async def tickers(self, only_usdt: bool = True) -> list[str]:
+    async def tickers(self, resolve_symbols: bool = False) -> list[str]:
         """Возвращает список тикеров.
 
         Параметры:
-            only_usdt (bool): Если True, возвращает только тикеры в паре к USDT.
+            resolve_symbols (bool): Если True, тикеры маппятся из вида "@123" в "BTC".
 
         Возвращает:
             list[str]: Список тикеров.
         """
-        raise NotImplementedError()
+        raw_data = await self._client.spot_metadata()
+        return Adapter.tickers(raw_data, resolve_symbols)
 
-    async def futures_tickers(self, only_usdt: bool = True) -> list[str]:
-        """Возвращает список тикеров.
+    async def tickers_batched(
+        self, resolve_symbols: bool = False, batch_size: int = 20
+    ) -> list[list[str]]:
+        """Возвращает список тикеров в чанках.
 
         Параметры:
-            only_usdt (bool): Если True, возвращает только тикеры в паре к USDT.
+            resolve_symbols (bool): Если True, тикеры маппятся из вида "@123" в "BTC".
+            batch_size (`int`): Размер чанка.
+
+        Возвращает:
+            `list[list[str]]`: Список тикеров в чанках.
+        """
+        tickers = await self.tickers(resolve_symbols)
+        return batched_list(tickers, batch_size)
+
+    async def futures_tickers(self) -> list[str]:
+        """Возвращает список тикеров.
 
         Возвращает:
             list[str]: Список тикеров.
         """
-        raw_data = await self._client.perp_asset_contexts()
+        raw_data = await self._client.perp_metadata()
         return Adapter.futures_tickers(raw_data)
 
-    async def last_price(self) -> dict[str, float]:
+    async def futures_tickers_batched(self, batch_size: int = 20) -> list[list[str]]:
+        """Возвращает список тикеров в чанках.
+
+        Параметры:
+            batch_size (`int`): Размер чанка.
+
+        Возвращает:
+            `list[list[str]]`: Список тикеров в чанках.
+        """
+        tickers = await self.futures_tickers()
+        return batched_list(tickers, batch_size)
+
+    async def last_price(self, resolve_symbols: bool = False) -> dict[str, float]:
         """Возвращает последнюю цену для каждого тикера.
 
+        Параметры:
+            resolve_symbols (bool): Если True, тикеры маппятся из вида "@123" в "BTC".
+
         Возвращает:
             dict[str, float]: Словарь с последними ценами для каждого тикера.
         """
-        raise NotImplementedError()
+        raw_data = await self._client.all_mids()
+        return Adapter.last_price(raw_data, resolve_symbols)
 
     async def futures_last_price(self) -> dict[str, float]:
         """Возвращает последнюю цену для каждого тикера.
@@ -60,16 +170,20 @@ class UniClient(IUniClient[Client]):
         Возвращает:
             dict[str, float]: Словарь с последними ценами для каждого тикера.
         """
-        raw_data = await self._client.perp_asset_contexts()
+        raw_data = await self._client.all_mids()
         return Adapter.futures_last_price(raw_data)
 
-    async def ticker_24hr(self) -> TickerDailyDict:
+    async def ticker_24hr(self, resolve_symbols: bool = False) -> TickerDailyDict:
         """Возвращает статистику за последние 24 часа для каждого тикера.
 
+        Параметры:
+            resolve_symbols (bool): Если True, тикеры маппятся из вида "@123" в "BTC".
+
         Возвращает:
             TickerDailyDict: Словарь с статистикой за последние 24 часа для каждого тикера.
         """
-        raise NotImplementedError()
+        raw_data = await self._client.spot_meta_and_asset_contexts()
+        return Adapter.ticker_24hr(raw_data, resolve_symbols)
 
     async def futures_ticker_24hr(self) -> TickerDailyDict:
         """Возвращает статистику за последние 24 часа для каждого тикера.
@@ -77,7 +191,7 @@ class UniClient(IUniClient[Client]):
         Возвращает:
             TickerDailyDict: Словарь с статистикой за последние 24 часа для каждого тикера.
         """
-        raw_data = await self._client.perp_asset_contexts()
+        raw_data = await self._client.perp_meta_and_asset_contexts()
         return Adapter.futures_ticker_24hr(raw_data)
 
     async def klines(
@@ -87,20 +201,41 @@ class UniClient(IUniClient[Client]):
         limit: int | None = None,
         start_time: int | None = None,
         end_time: int | None = None,
+        resolve_symbols: bool = False,
     ) -> list[KlineDict]:
         """Возвращает список свечей для тикера.
 
         Параметры:
-            symbol (str): Название тикера.
+            symbol (str): Название тикера. Например "@1".
             limit (int | None): Количество свечей.
             interval (Timeframe | str): Таймфрейм свечей.
             start_time (int | None): Время начала периода в миллисекундах.
             end_time (int | None): Время окончания периода в миллисекундах.
+            resolve_symbols (bool): Если True, тикер маппится из вида "@123" в "BTC".
 
         Возвращает:
             list[KlineDict]: Список свечей для тикера.
         """
-        raise NotImplementedError("Hyperliquid does not support klines")
+        if not limit and not all([start_time, end_time]):
+            raise ValueError("limit and (start_time and end_time) must be provided")
+
+        if limit:  # Перезаписываем start_time и end_time если указан limit, т.к. по умолчанию HyperLiquid не принимают этот параметр
+            if not isinstance(interval, Timeframe):
+                raise ValueError("interval must be a Timeframe if limit param provided")
+            end_time = int(time.time() * 1000)
+            start_time = end_time - (limit * interval.to_seconds * 1000)  # type: ignore[reportOptionalOperand]
+        interval = (
+            interval.to_exchange_format(Exchange.HYPERLIQUID, MarketType.SPOT)
+            if isinstance(interval, Timeframe)
+            else interval
+        )
+        raw_data = await self._client.candle_snapshot(
+            coin=symbol,
+            interval=interval,
+            start_time=start_time,  # type: ignore[reportArgumentType]
+            end_time=end_time,  # type: ignore[reportArgumentType]
+        )
+        return Adapter.klines(raw_data=raw_data, resolve_symbols=resolve_symbols)
 
     async def futures_klines(
         self,
@@ -113,7 +248,7 @@ class UniClient(IUniClient[Client]):
         """Возвращает список свечей для тикера.
 
         Параметры:
-            symbol (str): Название тикера.
+            symbol (str): Название тикера. Например "BTC".
             limit (int | None): Количество свечей.
             interval (Timeframe | str): Таймфрейм свечей.
             start_time (int | None): Время начала периода в миллисекундах.
@@ -122,7 +257,26 @@ class UniClient(IUniClient[Client]):
         Возвращает:
             list[KlineDict]: Список свечей для тикера.
         """
-        raise NotImplementedError("Hyperliquid does not support klines")
+        if not limit and not all([start_time, end_time]):
+            raise ValueError("limit and (start_time and end_time) must be provided")
+
+        if limit:  # Перезаписываем start_time и end_time если указан limit, т.к. по умолчанию HyperLiquid не принимают этот параметр
+            if not isinstance(interval, Timeframe):
+                raise ValueError("interval must be a Timeframe if limit param provided")
+            end_time = int(time.time() * 1000)
+            start_time = end_time - (limit * interval.to_seconds * 1000)  # type: ignore[reportOptionalOperand]
+        interval = (
+            interval.to_exchange_format(Exchange.HYPERLIQUID, MarketType.FUTURES)
+            if isinstance(interval, Timeframe)
+            else interval
+        )
+        raw_data = await self._client.candle_snapshot(
+            coin=symbol,
+            interval=interval,
+            start_time=start_time,  # type: ignore[reportArgumentType]
+            end_time=end_time,  # type: ignore[reportArgumentType]
+        )
+        return Adapter.futures_klines(raw_data)
 
     @overload
     async def funding_rate(self, symbol: str) -> float: ...
@@ -142,7 +296,7 @@ class UniClient(IUniClient[Client]):
         Возвращает:
             `dict[str, float] | float`: Ставка финансирования для тикера или словарь со ставками для всех тикеров.
         """
-        raw_data = await self._client.perp_asset_contexts()
+        raw_data = await self._client.perp_meta_and_asset_contexts()
         adapted_data = Adapter.funding_rate(raw_data)
         return adapted_data[symbol] if symbol else adapted_data
 
@@ -166,6 +320,6 @@ class UniClient(IUniClient[Client]):
                 открытого интереса в монетах. Если нет передан - то словарь, в котором ключ - тикер,
                 а значение - словарь с временем и объемом открытого интереса в монетах.
         """
-        raw_data = await self._client.perp_asset_contexts()
+        raw_data = await self._client.perp_meta_and_asset_contexts()
         adapted_data = Adapter.open_interest(raw_data)
         return adapted_data[symbol] if symbol else adapted_data

unicex/mapper.py

@@ -3,81 +3,68 @@
 __all__ = [
     "get_uni_client",
     "get_uni_websocket_manager",
+    "get_exchange_info",
 ]
 
 
-from ._abc import IUniClient, IUniWebsocketManager
+from ._abc import IExchangeInfo, IUniClient, IUniWebsocketManager
+from .binance import ExchangeInfo as BinanceExchangeInfo
 from .binance import UniClient as BinanceUniClient
 from .binance import UniWebsocketManager as BinanceUniWebsocketManager
+from .bitget import ExchangeInfo as BitgetExchangeInfo
 from .bitget import UniClient as BitgetUniClient
 from .bitget import UniWebsocketManager as BitgetUniWebsocketManager
-from .bitrue import UniClient as BitrueUniClient
-from .bitrue import UniWebsocketManager as BitrueUniWebsocketManager
-from .bitunix import UniClient as BitunixUniClient
-from .bitunix import UniWebsocketManager as BitunixUniWebsocketManager
-from .btse import UniClient as BtseUniClient
-from .btse import UniWebsocketManager as BtseUniWebsocketManager
+from .bybit import ExchangeInfo as BybitExchangeInfo
 from .bybit import UniClient as BybitUniClient
 from .bybit import UniWebsocketManager as BybitUniWebsocketManager
 from .enums import Exchange
 from .exceptions import NotSupported
+from .gateio import ExchangeInfo as GateioExchangeInfo
 from .gateio import UniClient as GateioUniClient
 from .gateio import UniWebsocketManager as GateioUniWebsocketManager
+from .hyperliquid import ExchangeInfo as HyperliquidExchangeInfo
 from .hyperliquid import UniClient as HyperliquidUniClient
 from .hyperliquid import UniWebsocketManager as HyperliquidUniWebsocketManager
-from .kcex import UniClient as KcexUniClient
-from .kcex import UniWebsocketManager as KcexUniWebsocketManager
-from .kraken import UniClient as KrakenUniClient
-from .kraken import UniWebsocketManager as KrakenUniWebsocketManager
-from .kucoin import UniClient as KucoinUniClient
-from .kucoin import UniWebsocketManager as KucoinUniWebsocketManager
+from .mexc import ExchangeInfo as MexcExchangeInfo
 from .mexc import UniClient as MexcUniClient
 from .mexc import UniWebsocketManager as MexcUniWebsocketManager
+from .okx import ExchangeInfo as OkxExchangeInfo
 from .okx import UniClient as OkxUniClient
 from .okx import UniWebsocketManager as OkxUniWebsocketManager
-from .weex import UniClient as WeexUniClient
-from .weex import UniWebsocketManager as WeexUniWebsocketManager
-from .xt import UniClient as XtUniClient
-from .xt import UniWebsocketManager as XtUniWebsocketManager
 
 _UNI_CLIENT_MAPPER: dict[Exchange, type[IUniClient]] = {
     Exchange.BINANCE: BinanceUniClient,
     Exchange.BITGET: BitgetUniClient,
-    Exchange.BITRUE: BitrueUniClient,
-    Exchange.BITUNIX: BitunixUniClient,
-    Exchange.BTSE: BtseUniClient,
     Exchange.BYBIT: BybitUniClient,
     Exchange.GATEIO: GateioUniClient,
     Exchange.HYPERLIQUID: HyperliquidUniClient,
-    Exchange.KCEX: KcexUniClient,
-    Exchange.KRAKEN: KrakenUniClient,
-    Exchange.KUCOIN: KucoinUniClient,
     Exchange.MEXC: MexcUniClient,
     Exchange.OKX: OkxUniClient,
-    Exchange.WEEX: WeexUniClient,
-    Exchange.XT: XtUniClient,
 }
 """Маппер, который связывает биржу и реализацию унифицированного клиента."""
 
 _UNI_WS_MANAGER_MAPPER: dict[Exchange, type[IUniWebsocketManager]] = {
     Exchange.BINANCE: BinanceUniWebsocketManager,
     Exchange.BITGET: BitgetUniWebsocketManager,
-    Exchange.BITRUE: BitrueUniWebsocketManager,
-    Exchange.BITUNIX: BitunixUniWebsocketManager,
-    Exchange.BTSE: BtseUniWebsocketManager,
     Exchange.BYBIT: BybitUniWebsocketManager,
     Exchange.GATEIO: GateioUniWebsocketManager,
     Exchange.HYPERLIQUID: HyperliquidUniWebsocketManager,
-    Exchange.KCEX: KcexUniWebsocketManager,
-    Exchange.KRAKEN: KrakenUniWebsocketManager,
-    Exchange.KUCOIN: KucoinUniWebsocketManager,
     Exchange.MEXC: MexcUniWebsocketManager,
     Exchange.OKX: OkxUniWebsocketManager,
-    Exchange.WEEX: WeexUniWebsocketManager,
-    Exchange.XT: XtUniWebsocketManager,
 }
 """Маппер, который связывает биржу и реализацию унифицированного вебсокет-менеджера."""
 
+_EXCHANGE_INFO_MAPPER: dict[Exchange, type[IExchangeInfo]] = {
+    Exchange.BINANCE: BinanceExchangeInfo,
+    Exchange.BITGET: BitgetExchangeInfo,
+    Exchange.BYBIT: BybitExchangeInfo,
+    Exchange.GATEIO: GateioExchangeInfo,
+    Exchange.HYPERLIQUID: HyperliquidExchangeInfo,
+    Exchange.MEXC: MexcExchangeInfo,
+    Exchange.OKX: OkxExchangeInfo,
+}
+"""Маппер, который связывает биржу и реализацию сборщика информации о тикерах на бирже."""
+
 
 def get_uni_client(exchange: Exchange) -> type[IUniClient]:
     """Возвращает унифицированный клиент для указанной биржи.
@@ -107,3 +94,18 @@ def get_uni_websocket_manager(exchange: Exchange) -> type[IUniWebsocketManager]:
         return _UNI_WS_MANAGER_MAPPER[exchange]
     except KeyError as e:
         raise NotSupported(f"Unsupported exchange: {exchange}") from e
+
+
+def get_exchange_info(exchange: Exchange) -> type[IExchangeInfo]:
+    """Возвращает унифицированный интерфейс для получения информации о бирже.
+
+    Параметры:
+        exchange (`Exchange`): Биржа.
+
+    Возвращает:
+        `type[IExchangeInfo]`: Унифицированный интерфейс для получения информации о бирже.
+    """
+    try:
+        return _EXCHANGE_INFO_MAPPER[exchange]
+    except KeyError as e:
+        raise NotSupported(f"Unsupported exchange: {exchange}") from e

unicex/mexc/__init__.py

@@ -6,10 +6,22 @@ __all__ = [
     "UserWebsocket",
     "WebsocketManager",
     "UniWebsocketManager",
+    "ExchangeInfo",
 ]
 
 from .client import Client
+from .exchange_info import ExchangeInfo
 from .uni_client import UniClient
 from .uni_websocket_manager import UniWebsocketManager
 from .user_websocket import UserWebsocket
 from .websocket_manager import WebsocketManager
+
+
+async def load_exchange_info() -> None:
+    """Загружает информацию о бирже Mexc."""
+    await ExchangeInfo.load_exchange_info()
+
+
+async def start_exchange_info(parse_interval_seconds: int = 60 * 60) -> None:
+    """Запускает процесс обновления информации о бирже Mexc."""
+    await ExchangeInfo.start(parse_interval_seconds)

unicex/mexc/adapter.py

@@ -9,6 +9,8 @@ from unicex.types import (
 )
 from unicex.utils import catch_adapter_errors, decorate_all_methods
 
+from .exchange_info import ExchangeInfo
+
 
 @decorate_all_methods(catch_adapter_errors)
 class Adapter:
@@ -25,7 +27,9 @@ class Adapter:
         Возвращает:
             list[str]: Список тикеров.
         """
-        return [item["symbol"] for item in raw_data if only_usdt or item["symbol"].endswith("USDT")]
+        return [
+            item["symbol"] for item in raw_data if item["symbol"].endswith("USDT") or not only_usdt
+        ]
 
     @staticmethod
     def futures_tickers(raw_data: dict, only_usdt: bool = True) -> list[str]:
@@ -41,7 +45,7 @@ class Adapter:
         return [
             item["symbol"]
             for item in raw_data["data"]
-            if only_usdt or item["symbol"].endswith("USDT")
+            if item["symbol"].endswith("USDT") or not only_usdt
         ]
 
     @staticmethod
@@ -97,14 +101,15 @@ class Adapter:
         Возвращает:
             TickerDailyDict: Словарь, где ключ - тикер, а значение - статистика за последние 24 часа.
         """
-        return {
-            item["symbol"]: TickerDailyItem(
+        result = {}
+        for item in raw_data["data"]:
+            symbol = item["symbol"]
+            result[symbol] = TickerDailyItem(
                 p=float(item["riseFallRate"]) * 100,
-                v=float(item["volume24"]),
+                v=float(item["volume24"]) * Adapter._get_contract_size(symbol),
                 q=float(item["amount24"]),
             )
-            for item in raw_data["data"]
-        }
+        return result
 
     @staticmethod
     def open_interest(raw_data: dict) -> OpenInterestDict:
@@ -116,10 +121,14 @@ class Adapter:
         Возвращает:
             OpenInterestDict: Словарь, где ключ - тикер, а значение - агрегированные данные открытого интереса.
         """
-        return {
-            item["symbol"]: OpenInterestItem(t=item["timestamp"], v=float(item["holdVol"]))
-            for item in raw_data["data"]
-        }
+        result = {}
+        for item in raw_data["data"]:
+            symbol = item["symbol"]
+            result[symbol] = OpenInterestItem(
+                t=item["timestamp"],
+                v=float(item["holdVol"]) * Adapter._get_contract_size(symbol),
+            )
+        return result
 
     @staticmethod
     def funding_rate(raw_data: dict) -> dict[str, float]:
@@ -220,3 +229,11 @@ class Adapter:
             )
 
         return sorted(klines, key=lambda kline_item: kline_item["t"])
+
+    @staticmethod
+    def _get_contract_size(symbol: str) -> float:
+        """Возвращает размер контракта для указанного символа тикера."""
+        try:
+            return ExchangeInfo.get_futures_ticker_info(symbol)["contract_size"] or 1
+        except:  # noqa
+            return 1

unicex/mexc/exchange_info.py

@@ -0,0 +1,32 @@
+__all__ = ["ExchangeInfo"]
+
+import aiohttp
+
+from unicex._abc import IExchangeInfo
+from unicex.types import TickerInfoItem
+
+
+class ExchangeInfo(IExchangeInfo):
+    """Предзагружает информацию о тикерах для биржи Mexc."""
+
+    @classmethod
+    async def _load_exchange_info(cls) -> None:
+        """Загружает информацию о бирже."""
+        futures_tickers_info = {}
+        async with aiohttp.ClientSession() as session:
+            url = "https://contract.mexc.com/api/v1/contract/detail"
+            async with session.get(url) as response:
+                data = await response.json()
+                for el in data["data"]:
+                    futures_tickers_info[el["symbol"]] = TickerInfoItem(
+                        tick_precision=cls._step_size_to_precision(el["priceUnit"]),
+                        size_precision=el["amountScale"],
+                        contract_size=el["contractSize"],
+                        min_market_size=el["minVol"],
+                        max_market_size=el["maxVol"],
+                        min_limit_size=el["minVol"],
+                        max_limit_size=el["maxVol"],
+                    )
+
+            cls._futures_tickers_info = futures_tickers_info
+            cls._logger.debug("Mexc futures exchange info loaded")