xync-client 0.0.155__py3-none-any.whl → 0.0.162__py3-none-any.whl

xync_client/Mexc/api.py

@@ -4,290 +4,47 @@ MEXC P2P OpenAPI v1.2 Async Client
 
 import hmac
 import hashlib
+import json
 import time
-from typing import Optional, List, Literal
+from typing import Optional, Literal, Callable
 from decimal import Decimal
+from urllib.parse import urlencode
 
 import aiohttp
-from pydantic import BaseModel, Field
-
-
-# ============ Enums ============
-
-
-class Side(str):
-    BUY = "BUY"
-    SELL = "SELL"
-
-
-class AdvStatus(str):
-    CLOSE = "CLOSE"
-    OPEN = "OPEN"
-    DELETE = "DELETE"
-    LOW_STOCK = "LOW_STOCK"
-
-
-class OrderDealState(str):
-    NOT_PAID = "NOT_PAID"
-    PAID = "PAID"
-    WAIT_PROCESS = "WAIT_PROCESS"
-    PROCESSING = "PROCESSING"
-    DONE = "DONE"
-    CANCEL = "CANCEL"
-    INVALID = "INVALID"
-    REFUSE = "REFUSE"
-    TIMEOUT = "TIMEOUT"
-
-
-class NotifyType(str):
-    SMS = "SMS"
-    MAIL = "MAIL"
-    GA = "GA"
-
-
-# ============ Request Models ============
-
-
-class CreateUpdateAdRequest(BaseModel):
-    advNo: Optional[str] = None
-    payTimeLimit: int
-    initQuantity: Decimal
-    supplyQuantity: Optional[Decimal] = None
-    price: Decimal
-    coinId: str
-    countryCode: Optional[str] = None
-    side: str
-    advStatus: Optional[str] = None
-    allowSys: Optional[bool] = None
-    fiatUnit: str
-    payMethod: str
-    autoReplyMsg: Optional[str] = None
-    tradeTerms: Optional[str] = None
-    minSingleTransAmount: Decimal
-    maxSingleTransAmount: Decimal
-    kycLevel: Optional[str] = None
-    requireMobile: Optional[bool] = None
-    userAllTradeCountMin: int
-    userAllTradeCountMax: int
-    exchangeCount: Optional[int] = None
-    maxPayLimit: Optional[int] = None
-    buyerRegDaysLimit: Optional[int] = None
-    creditAmount: Optional[Decimal] = None
-    blockTrade: Optional[bool] = None
-    deviceId: Optional[str] = None
-
-
-class CreateOrderRequest(BaseModel):
-    advNo: str
-    amount: Optional[Decimal] = None
-    tradableQuantity: Optional[Decimal] = None
-    userConfirmPaymentId: int
-    userConfirmPayMethodId: Optional[int] = None
-    deviceId: Optional[str] = None
-
-
-class ConfirmPaidRequest(BaseModel):
-    advOrderNo: str
-    payId: int
-
-
-class ReleaseCoinRequest(BaseModel):
-    advOrderNo: str
-    notifyType: Optional[str] = None
-    notifyCode: Optional[str] = None
-
-
-class ServiceSwitchRequest(BaseModel):
-    open: bool
-
-
-# ============ Response Models ============
-
-
-class BaseResponse(BaseModel):
-    code: int
-    msg: str
-
-
-class PaymentInfo(BaseModel):
-    id: int
-    payMethod: int
-    bankName: str
-    account: str
-    bankAddress: str
-    payee: str
-    extend: str
-
-
-class MerchantInfo(BaseModel):
-    nickName: str
-    imId: str
-    memberId: str
-    registry: int
-    vipLevel: int
-    greenDiamond: bool
-    emailAuthentication: bool
-    smsAuthentication: bool
-    identityVerification: bool
-    lastOnlineTime: int
-    badge: str
-    merchantType: str
-
-
-class MerchantStatistics(BaseModel):
-    totalBuyCount: int
-    totalSellCount: int
-    doneLastMonthCount: int
-    avgBuyHandleTime: int
-    avgSellHandleTime: int
-    lastMonthCompleteRate: str
-    completeRate: str
-    avgHandleTime: int
-
-
-class Advertisement(BaseModel):
-    advNo: str
-    payTimeLimit: int
-    quantity: int
-    price: Decimal
-    initAmount: Decimal
-    frozenQuantity: Decimal
-    availableQuantity: Decimal
-    coinId: str
-    coinName: str
-    countryCode: str
-    commissionRate: Decimal
-    advStatus: str
-    side: str
-    createTime: int
-    updateTime: int
-    fiatUnit: str
-    feeType: int
-    autoReplyMsg: str
-    tradeTerms: str
-    payMethod: str
-    paymentInfo: List[PaymentInfo]
-    minSingleTransAmount: Decimal
-    maxSingleTransAmount: Decimal
-    kycLevel: int
-    requireMobile: bool
-    userAllTradeCountMax: int
-    userAllTradeCountMin: int
-    exchangeCount: int
-    maxPayLimit: int
-    buyerRegDaysLimit: int
-    blockTrade: bool
-
-
-class MarketAdvertisement(Advertisement):
-    merchant: MerchantInfo
-    merchantStatistics: MerchantStatistics
-    orderPayCount: int
-    tags: str
-
-
-class PageInfo(BaseModel):
-    total: int
-    currPage: int
-    pageSize: int
-    totalPage: int
-
-
-class UserInfo(BaseModel):
-    nickName: str
-
-
-class Order(BaseModel):
-    advNo: str
-    advOrderNo: str
-    tradableQuantity: Decimal
-    price: Decimal
-    amount: Decimal
-    coinName: str
-    state: int
-    payTimeLimit: int
-    side: str
-    fiatUnit: str
-    createTime: int
-    updateTime: int
-    userInfo: UserInfo
-    complained: bool
-    blockUser: bool
-    unreadCount: int
-    complainId: Optional[str] = None
-
-
-class OrderDetail(Order):
-    paymentInfo: List[PaymentInfo]
-    allowComplainTime: int
-    confirmPaymentInfo: PaymentInfo
-    userInfo: dict
-    userFiatStatistics: dict
-    spotCount: int
-
-
-class CreateAdResponse(BaseResponse):
-    data: str  # advNo
-
-
-class AdListResponse(BaseResponse):
-    data: List[Advertisement]
-    page: PageInfo
-
-
-class MarketAdListResponse(BaseResponse):
-    data: List[MarketAdvertisement]
-    page: PageInfo
-
-
-class CreateOrderResponse(BaseResponse):
-    data: str  # advOrderNo
-
-
-class OrderListResponse(BaseResponse):
-    data: List[Order]
-    page: PageInfo
-
-
-class OrderDetailResponse(BaseResponse):
-    data: OrderDetail
-
-
-class ListenKeyResponse(BaseResponse):
-    listenKey: str
-
-
-class ConversationResponse(BaseResponse):
-    data: dict
-
-
-class ChatMessage(BaseModel):
-    id: int
-    content: Optional[str] = None
-    createTime: str
-    fromNickName: str
-    fromUserId: str
-    type: int
-    imageUrl: Optional[str] = None
-    imageThumbUrl: Optional[str] = None
-    videoUrl: Optional[str] = None
-    fileUrl: Optional[str] = None
-    self_: bool = Field(alias="self")
-    conversationId: int
-
-
-class ChatMessagesResponse(BaseResponse):
-    data: dict
-
-
-class UploadFileResponse(BaseResponse):
-    data: dict
+from pydantic import BaseModel
+from xync_schema import models
+from xync_schema.enums import AgentStatus, UserStatus
+
+from xync_client.Mexc.etype.order import (
+    CreateUpdateAdRequest,
+    CreateAdResponse,
+    AdListResponse,
+    MarketAdListResponse,
+    CreateOrderRequest,
+    CreateOrderResponse,
+    OrderListResponse,
+    ConfirmPaidRequest,
+    BaseResponse,
+    ReleaseCoinRequest,
+    OrderDetailResponse,
+    ServiceSwitchRequest,
+    ListenKeyResponse,
+    ConversationResponse,
+    ChatMessagesResponse,
+    UploadFileResponse,
+    ReceivedChatMessage,
+    WSRequest,
+    WSMethod,
+    SendTextMessage,
+    SendImageMessage,
+    SendVideoMessage,
+    SendFileMessage,
+    ChatMessageType,
+)
 
 
 # ============ Client ============
-
-
-class MEXCP2PClient:
+class MEXCP2PApiClient:
     """Асинхронный клиент для MEXC P2P API v1.2"""
 
     BASE_URL = "https://api.mexc.com"
@@ -295,23 +52,11 @@ class MEXCP2PClient:
     def __init__(self, api_key: str, api_secret: str):
         self.api_key = api_key
         self.api_secret = api_secret
-        self.session: Optional[aiohttp.ClientSession] = None
-
-    async def __aenter__(self):
-        self.session = aiohttp.ClientSession()
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        if self.session:
-            await self.session.close()
+        self.session: Optional[aiohttp.ClientSession] = aiohttp.ClientSession()
 
     def _generate_signature(self, query_string: str) -> str:
         """Генерация HMAC SHA256 подписи"""
-        return hmac.new(self.api_secret.encode("utf-8"), query_string.encode("utf-8"), hashlib.sha256).hexdigest()
-
-    def _get_timestamp(self) -> int:
-        """Получение текущего timestamp в миллисекундах"""
-        return int(time.time() * 1000)
+        return hmac.new(self.api_secret.encode(), query_string.encode(), hashlib.sha256).hexdigest()
 
     async def _request(
         self, method: str, endpoint: str, params: Optional[dict] = None, data: Optional[BaseModel] = None
@@ -320,24 +65,26 @@ class MEXCP2PClient:
         if not self.session:
             raise RuntimeError("Client not initialized. Use async context manager.")
 
-        timestamp = self._get_timestamp()
-
+        params = params or {}
         # Формирование query string для подписи
-        query_params = params.copy() if params else {}
-        query_params["timestamp"] = timestamp
+        params["recvWindow"] = 5000
+        params["timestamp"] = int(time.time() * 1000)
+        params = {k: v for k, v in sorted(params.items())}
 
-        query_string = "&".join(f"{k}={v}" for k, v in sorted(query_params.items()))
+        query_string = urlencode(params, doseq=True).replace("+", "%20")
         signature = self._generate_signature(query_string)
 
-        query_params["signature"] = signature
+        params["signature"] = signature
 
-        headers = {"X-MEXC-APIKEY": self.api_key, "Content-Type": "application/json"}
+        headers = {"X-MEXC-APIKEY": self.api_key}
+        if method in ("POST", "PUT", "PATCH"):
+            headers["Content-Type"] = "application/json"
 
         url = f"{self.BASE_URL}{endpoint}"
 
         json_data = data.model_dump(exclude_none=True) if data else None
 
-        async with self.session.request(method, url, params=query_params, json=json_data, headers=headers) as response:
+        async with self.session.request(method, url, params=params, json=json_data, headers=headers) as response:
             return await response.json()
 
     # ============ Advertisement Methods ============
@@ -421,10 +168,9 @@ class MEXCP2PClient:
             params["follow"] = follow
 
         result = await self._request("GET", "/api/v3/fiat/market/ads/pagination", params=params)
-        return MarketAdListResponse(**result)
+        return not result["code"] and MarketAdListResponse(**result)
 
     # ============ Order Methods ============
-
     async def create_order(self, request: CreateOrderRequest) -> CreateOrderResponse:
         """Создание ордера (захват объявления)"""
         result = await self._request("POST", "/api/v3/fiat/merchant/order/deal", data=request)
@@ -504,14 +250,12 @@ class MEXCP2PClient:
         return OrderDetailResponse(**result)
 
     # ============ Service Methods ============
-
     async def switch_service(self, request: ServiceSwitchRequest) -> BaseResponse:
         """Открытие/закрытие торговли"""
         result = await self._request("POST", "/api/v3/fiat/merchant/service/switch", data=request)
         return BaseResponse(**result)
 
     # ============ WebSocket Methods ============
-
     async def generate_listen_key(self) -> ListenKeyResponse:
         """Генерация listenKey для WebSocket"""
         result = await self._request("POST", "/api/v3/userDataStream")
@@ -580,55 +324,930 @@ class MEXCP2PClient:
         return result
 
 
-# ============ Usage Example ============
-async def main():
-    """Пример использования клиента"""
+"""
+MEXC P2P WebSocket Client для чата
+"""
+
+
+class MEXCWebSocketClient:
+    """
+    Асинхронный WebSocket клиент для MEXC P2P
+    Поддерживает:
+    - Автоматический heartbeat (PING/PONG)
+    - Переподключение при разрыве соединения
+    """
+
+    WS_URL = "wss://wbs.mexc.com/ws"
+    PING_INTERVAL = 5  # секунды
+    PING_TIMEOUT = 60  # если нет PONG 60 сек - разрыв
+
+    def __init__(
+        self,
+        ws_token: str,
+        on_message: Optional[Callable[[ReceivedChatMessage], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None,
+        on_close: Optional[Callable[[], None]] = None,
+        auto_reconnect: bool = True,
+    ):
+        """
+        Args:
+            ws_token: Ключ авторизации
+            on_message: Callback для входящих сообщений
+            on_error: Callback для ошибок
+            on_close: Callback при закрытии соединения
+            auto_reconnect: Автоматическое переподключение
+        """
+        self.wsToken = ws_token
+        self.on_message = on_message
+        self.on_error = on_error
+        self.on_close = on_close
+        self.auto_reconnect = auto_reconnect
+
+        self._ws: Optional[aiohttp.ClientWebSocketResponse] = None
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._running = False
+        self._ping_task: Optional[asyncio.Task] = None
+        self._receive_task: Optional[asyncio.Task] = None
+        self._last_pong_time = 0
+
+    @property
+    def is_connected(self) -> bool:
+        """Проверка активного соединения"""
+        return self._ws is not None and not self._ws.closed
+
+    async def connect(self):
+        """Установка WebSocket соединения"""
+        if self.is_connected:
+            return
+
+        url = f"{self.WS_URL}?wsToken={self.wsToken}&platform=web"
+
+        self._session = aiohttp.ClientSession()
+
+        try:
+            self._ws = await self._session.ws_connect(url)
+            self._running = True
+            self._last_pong_time = asyncio.get_event_loop().time()
+
+            # Запуск фоновых задач
+            self._ping_task = asyncio.create_task(self._heartbeat_loop())
+            self._receive_task = asyncio.create_task(self._receive_loop())
+
+            print("✓ WebSocket connected")
+
+        except Exception as e:
+            await self._cleanup()
+            raise Exception(f"Failed to connect WebSocket: {e}")
+
+    async def disconnect(self):
+        """Закрытие WebSocket соединения"""
+        self._running = False
+
+        if self._ping_task:
+            self._ping_task.cancel()
+        if self._receive_task:
+            self._receive_task.cancel()
+
+        await self._cleanup()
+
+        if self.on_close:
+            self.on_close()
+
+        print("✓ WebSocket disconnected")
+
+    async def _cleanup(self):
+        """Очистка ресурсов"""
+        if self._ws and not self._ws.closed:
+            await self._ws.close()
+
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+        self._ws = None
+        self._session = None
+
+    async def _send_raw(self, request: WSRequest):
+        """Отправка сырого WebSocket сообщения"""
+        if not self.is_connected:
+            raise ConnectionError("WebSocket not connected")
+
+        message = request.model_dump_json()
+        await self._ws.send_str(message)
+
+    async def _heartbeat_loop(self):
+        """Фоновая задача для PING/PONG"""
+        try:
+            while self._running and self.is_connected:
+                await asyncio.sleep(self.PING_INTERVAL)
+
+                # Проверка таймаута PONG
+                current_time = asyncio.get_event_loop().time()
+                if current_time - self._last_pong_time > self.PING_TIMEOUT:
+                    print("⚠ PING timeout, reconnecting...")
+                    if self.auto_reconnect:
+                        await self._reconnect()
+                    else:
+                        await self.disconnect()
+                    break
+
+                # Отправка PING
+                await self._send_ping()
+
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            print(f"❌ Heartbeat error: {e}")
+            if self.on_error:
+                self.on_error(e)
+
+    async def _receive_loop(self):
+        """Фоновая задача для получения сообщений"""
+        try:
+            async for msg in self._ws:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    await self._handle_message(msg.data)
+
+                elif msg.type == aiohttp.WSMsgType.ERROR:
+                    print(f"❌ WebSocket error: {self._ws.exception()}")
+                    break
+
+                elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.CLOSING):
+                    print("⚠ WebSocket closed by server")
+                    break
+
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            print(f"❌ Receive loop error: {e}")
+            if self.on_error:
+                self.on_error(e)
+
+        finally:
+            # Переподключение при разрыве
+            if self._running and self.auto_reconnect:
+                print("⚠ Connection lost, reconnecting...")
+                await self._reconnect()
+            else:
+                await self.disconnect()
+
+    async def _handle_message(self, data: str):
+        """Обработка входящего сообщения"""
+        try:
+            response = json.loads(data)
+
+            method = response.get("method")
+
+            # PONG ответ
+            if method == "PING":
+                self._last_pong_time = asyncio.get_event_loop().time()
+                if response.get("data") == "PONG":
+                    print("♥ PONG received")
+                    pass
+
+            # Входящее сообщение
+            elif method == "RECEIVE_MESSAGE":
+                if response.get("success") and self.on_message:
+                    message_data = json.loads(response.get("data", "{}"))
+                    message = ReceivedChatMessage(**message_data)
+                    self.on_message(message)
+
+            # Ответ на отправку
+            elif method == "SEND_MESSAGE":
+                if not response.get("success"):
+                    print(f"⚠ Send failed: {response.get('msg')}")
+
+        except Exception as e:
+            print(f"❌ Error handling message: {e}")
+            if self.on_error:
+                self.on_error(e)
+
+    async def _reconnect(self):
+        """Переподключение WebSocket"""
+        print("🔄 Reconnecting...")
+        await self._cleanup()
+
+        max_retries = 5
+        retry_delay = 2
+
+        for attempt in range(max_retries):
+            try:
+                await asyncio.sleep(retry_delay * (attempt + 1))
+                await self.connect()
+                print("✓ Reconnected successfully")
+                return
+
+            except Exception as e:
+                print(f"❌ Reconnect attempt {attempt + 1} failed: {e}")
+
+        print("❌ Failed to reconnect after max retries")
+        await self.disconnect()
+
+    async def _send_ping(self):
+        """Отправка PING"""
+        request = WSRequest(method=WSMethod.PING)
+        await self._send_raw(request)
+        print(end="p")
+
+
+# ============ WebSocket Client ============
+class MEXCP2PWebSocketClient:
+    """
+    Асинхронный WebSocket клиент для чата MEXC P2P
+
+    Поддерживает:
+    - Отправку/получение текстовых сообщений
+    - Отправку/получение медиа (изображения, видео, файлы)
+    - Автоматический heartbeat (PING/PONG)
+    - Переподключение при разрыве соединения
+    """
+
+    WS_URL = "wss://fiat.mexc.com/ws"
+    PING_INTERVAL = 5  # секунды
+    PING_TIMEOUT = 60  # если нет PONG 60 сек - разрыв
+
+    def __init__(
+        self,
+        listen_key: str,
+        conversation_id: int = None,
+        on_message: Optional[Callable[[ReceivedChatMessage], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None,
+        on_close: Optional[Callable[[], None]] = None,
+        auto_reconnect: bool = True,
+    ):
+        """
+        Args:
+            listen_key: Ключ авторизации (из HTTP API)
+            conversation_id: ID чат-сессии
+            on_message: Callback для входящих сообщений
+            on_error: Callback для ошибок
+            on_close: Callback при закрытии соединения
+            auto_reconnect: Автоматическое переподключение
+        """
+        self.listen_key = listen_key
+        self.conversation_id = conversation_id
+        self.on_message = on_message
+        self.on_error = on_error
+        self.on_close = on_close
+        self.auto_reconnect = auto_reconnect
+
+        self._ws: Optional[aiohttp.ClientWebSocketResponse] = None
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._running = False
+        self._ping_task: Optional[asyncio.Task] = None
+        self._receive_task: Optional[asyncio.Task] = None
+        self._last_pong_time = 0
+
+    @property
+    def is_connected(self) -> bool:
+        """Проверка активного соединения"""
+        return self._ws is not None and not self._ws.closed
+
+    async def connect(self):
+        """Установка WebSocket соединения"""
+        if self.is_connected:
+            return
+
+        url = f"{self.WS_URL}?listenKey={self.listen_key}"
+        if self.conversation_id:
+            url += f"&conversationId={self.conversation_id}"
+
+        self._session = aiohttp.ClientSession()
+
+        try:
+            self._ws = await self._session.ws_connect(url)
+            self._running = True
+            self._last_pong_time = asyncio.get_event_loop().time()
+
+            # Запуск фоновых задач
+            self._ping_task = asyncio.create_task(self._heartbeat_loop())
+            self._receive_task = asyncio.create_task(self._receive_loop())
+
+            print(f"✓ WebSocket connected to conversation {self.conversation_id}")
+
+        except Exception as e:
+            await self._cleanup()
+            raise Exception(f"Failed to connect WebSocket: {e}")
+
+    async def disconnect(self):
+        """Закрытие WebSocket соединения"""
+        self._running = False
+
+        if self._ping_task:
+            self._ping_task.cancel()
+        if self._receive_task:
+            self._receive_task.cancel()
+
+        await self._cleanup()
+
+        if self.on_close:
+            self.on_close()
+
+        print("✓ WebSocket disconnected")
+
+    async def _cleanup(self):
+        """Очистка ресурсов"""
+        if self._ws and not self._ws.closed:
+            await self._ws.close()
+
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+        self._ws = None
+        self._session = None
+
+    async def _send_raw(self, request: WSRequest):
+        """Отправка сырого WebSocket сообщения"""
+        if not self.is_connected:
+            raise ConnectionError("WebSocket not connected")
+
+        message = request.model_dump_json()
+        await self._ws.send_str(message)
+
+    async def _heartbeat_loop(self):
+        """Фоновая задача для PING/PONG"""
+        try:
+            while self._running and self.is_connected:
+                await asyncio.sleep(self.PING_INTERVAL)
+
+                # Проверка таймаута PONG
+                current_time = asyncio.get_event_loop().time()
+                if current_time - self._last_pong_time > self.PING_TIMEOUT:
+                    print("⚠ PING timeout, reconnecting...")
+                    if self.auto_reconnect:
+                        await self._reconnect()
+                    else:
+                        await self.disconnect()
+                    break
+
+                # Отправка PING
+                await self._send_ping()
+
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            print(f"❌ Heartbeat error: {e}")
+            if self.on_error:
+                self.on_error(e)
+
+    async def _receive_loop(self):
+        """Фоновая задача для получения сообщений"""
+        try:
+            async for msg in self._ws:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    await self._handle_message(msg.data)
+
+                elif msg.type == aiohttp.WSMsgType.ERROR:
+                    print(f"❌ WebSocket error: {self._ws.exception()}")
+                    break
+
+                elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.CLOSING):
+                    print("⚠ WebSocket closed by server")
+                    break
+
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            print(f"❌ Receive loop error: {e}")
+            if self.on_error:
+                self.on_error(e)
+
+        finally:
+            # Переподключение при разрыве
+            if self._running and self.auto_reconnect:
+                print("⚠ Connection lost, reconnecting...")
+                await self._reconnect()
+            else:
+                await self.disconnect()
+
+    async def _handle_message(self, data: str):
+        """Обработка входящего сообщения"""
+        try:
+            response = json.loads(data)
+
+            method = response.get("method")
+
+            # PONG ответ
+            if method == "PING":
+                self._last_pong_time = asyncio.get_event_loop().time()
+                if response.get("data") == "PONG":
+                    print("♥ PONG received")
+                    pass
+
+            # Входящее сообщение
+            elif method == "RECEIVE_MESSAGE":
+                if response.get("success") and self.on_message:
+                    message_data = json.loads(response.get("data", "{}"))
+                    message = ReceivedChatMessage(**message_data)
+                    self.on_message(message)
+
+            # Ответ на отправку
+            elif method == "SEND_MESSAGE":
+                if not response.get("success"):
+                    print(f"⚠ Send failed: {response.get('msg')}")
+
+        except Exception as e:
+            print(f"❌ Error handling message: {e}")
+            if self.on_error:
+                self.on_error(e)
+
+    async def _reconnect(self):
+        """Переподключение WebSocket"""
+        print("🔄 Reconnecting...")
+        await self._cleanup()
+
+        max_retries = 5
+        retry_delay = 2
+
+        for attempt in range(max_retries):
+            try:
+                await asyncio.sleep(retry_delay * (attempt + 1))
+                await self.connect()
+                print("✓ Reconnected successfully")
+                return
+
+            except Exception as e:
+                print(f"❌ Reconnect attempt {attempt + 1} failed: {e}")
+
+        print("❌ Failed to reconnect after max retries")
+        await self.disconnect()
+
+    async def _send_ping(self):
+        """Отправка PING"""
+        request = WSRequest(method=WSMethod.PING)
+        await self._send_raw(request)
+        print(end="p")
+
+    # ============ Public Message Sending Methods ============
+
+    async def send_text(self, content: str) -> bool:
+        """
+        Отправка текстового сообщения
+
+        Args:
+            content: Текст сообщения
+
+        Returns:
+            bool: Успешность отправки
+        """
+        message = SendTextMessage(content=content, conversationId=self.conversation_id)
+
+        request = WSRequest(method=WSMethod.SEND_MESSAGE, params=message.model_dump())
+
+        try:
+            await self._send_raw(request)
+            return True
+        except Exception as e:
+            print(f"❌ Failed to send text: {e}")
+            return False
+
+    async def send_image(self, image_url: str, thumb_url: str) -> bool:
+        """
+        Отправка изображения
+
+        Args:
+            image_url: URL полного изображения
+            thumb_url: URL превью
+
+        Returns:
+            bool: Успешность отправки
+        """
+        message = SendImageMessage(imageUrl=image_url, imageThumbUrl=thumb_url, conversationId=self.conversation_id)
+
+        request = WSRequest(method=WSMethod.SEND_MESSAGE, params=message.model_dump_json())
+
+        try:
+            await self._send_raw(request)
+            return True
+        except Exception as e:
+            print(f"❌ Failed to send image: {e}")
+            return False
+
+    async def send_video(self, video_url: str, thumb_url: str) -> bool:
+        """
+        Отправка видео
+
+        Args:
+            video_url: URL видео
+            thumb_url: URL превью
+
+        Returns:
+            bool: Успешность отправки
+        """
+        message = SendVideoMessage(videoUrl=video_url, imageThumbUrl=thumb_url, conversationId=self.conversation_id)
+
+        request = WSRequest(method=WSMethod.SEND_MESSAGE, params=message.model_dump_json())
+
+        try:
+            await self._send_raw(request)
+            return True
+        except Exception as e:
+            print(f"❌ Failed to send video: {e}")
+            return False
+
+    async def send_file(self, file_url: str) -> bool:
+        """
+        Отправка файла
+
+        Args:
+            file_url: URL файла
+
+        Returns:
+            bool: Успешность отправки
+        """
+        message = SendFileMessage(fileUrl=file_url, conversationId=self.conversation_id)
+
+        request = WSRequest(method=WSMethod.SEND_MESSAGE, params=message.model_dump_json())
+
+        try:
+            await self._send_raw(request)
+            return True
+        except Exception as e:
+            print(f"❌ Failed to send file: {e}")
+            return False
+
+    async def send_message(
+        self,
+        content: Optional[str] = None,
+        image_url: Optional[str] = None,
+        image_thumb_url: Optional[str] = None,
+        video_url: Optional[str] = None,
+        file_url: Optional[str] = None,
+    ) -> bool:
+        """
+        Универсальная отправка сообщения (автоопределение типа)
+
+        Args:
+            content: Текст (для TEXT)
+            image_url: URL изображения (для IMAGE)
+            image_thumb_url: URL превью (для IMAGE/VIDEO)
+            video_url: URL видео (для VIDEO)
+            file_url: URL файла (для FILE)
+
+        Returns:
+            bool: Успешность отправки
+        """
+        if content:
+            return await self.send_text(content)
+        elif image_url and image_thumb_url:
+            return await self.send_image(image_url, image_thumb_url)
+        elif video_url and image_thumb_url:
+            return await self.send_video(video_url, image_thumb_url)
+        elif file_url:
+            return await self.send_file(file_url)
+        else:
+            raise ValueError("No valid message content provided")
+
+
+# ============ Context Manager для удобства ============
+class MEXCP2PChatSession:
+    """
+    Высокоуровневая обертка для чат-сессии
+    Автоматически управляет HTTP и WebSocket клиентами
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        api_secret: str,
+        order_no: str,
+        on_message: Optional[Callable[[ReceivedChatMessage], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None,
+        auto_reconnect: bool = True,
+    ):
+        self.api_key = api_key
+        self.api_secret = api_secret
+        self.order_no = order_no
+        self.on_message = on_message
+        self.on_error = on_error
+        self.auto_reconnect = auto_reconnect
+
+        self.http_client: Optional[MEXCP2PApiClient] = None
+        self.ws_client: Optional[MEXCP2PWebSocketClient] = None
+        self.conversation_id: Optional[int] = None
+
+    async def __aenter__(self):
+        # Инициализация HTTP клиента
+        self.http_client = MEXCP2PApiClient(self.api_key, self.api_secret)
+        await self.http_client.__aenter__()
+
+        # Получение conversation ID
+        conv_response = await self.http_client.get_chat_conversation(self.order_no)
+        self.conversation_id = conv_response.data.get("conversationId")
+
+        if not self.conversation_id:
+            raise ValueError("Failed to get conversation ID")
+
+        # Генерация listenKey
+        listen_key_response = await self.http_client.generate_listen_key()
+        listen_key = listen_key_response.listenKey
+
+        # Подключение WebSocket
+        self.ws_client = MEXCP2PWebSocketClient(
+            listen_key=listen_key,
+            conversation_id=self.conversation_id,
+            on_message=self.on_message,
+            on_error=self.on_error,
+            auto_reconnect=self.auto_reconnect,
+        )
+
+        await self.ws_client.connect()
+
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self.ws_client:
+            await self.ws_client.disconnect()
+
+        if self.http_client:
+            await self.http_client.__aexit__(exc_type, exc_val, exc_tb)
+
+    async def send_text(self, text: str) -> bool:
+        """Отправка текста"""
+        return await self.ws_client.send_text(text)
+
+    async def send_image(self, image_url: str, thumb_url: str) -> bool:
+        """Отправка изображения"""
+        return await self.ws_client.send_image(image_url, thumb_url)
+
+    async def send_video(self, video_url: str, thumb_url: str) -> bool:
+        """Отправка видео"""
+        return await self.ws_client.send_video(video_url, thumb_url)
+
+    async def send_file(self, file_url: str) -> bool:
+        """Отправка файла"""
+        return await self.ws_client.send_file(file_url)
+
+    async def upload_and_send_file(self, file_data: bytes, filename: str) -> bool:
+        """
+        Загрузка файла через HTTP API и отправка в чат
+
+        Args:
+            file_data: Бинарные данные файла
+            filename: Имя файла
+
+        Returns:
+            bool: Успешность операции
+        """
+        # Загрузка файла
+        upload_response = await self.http_client.upload_file(file_data, filename)
+
+        if upload_response.code != 0:
+            print(f"❌ File upload failed: {upload_response.msg}")
+            return False
+
+        file_id = upload_response.data.get("fileId")
+
+        # Получение URL файла
+        download_response = await self.http_client.download_file(file_id)
+
+        if download_response.get("code") != 0:
+            print("❌ File URL retrieval failed")
+            return False
+
+        file_url = download_response["data"]["fileUrl"]
+
+        # Отправка в чат
+        return await self.send_file(file_url)
+
+    async def get_message_history(self, limit: int = 20, page: int = 1) -> list[ReceivedChatMessage]:
+        """
+        Получение истории сообщений
+
+        Args:
+            limit: Количество сообщений
+            page: Номер страницы
+
+        Returns:
+            List[ReceivedChatMessage]: Список сообщений
+        """
+        response = await self.http_client.get_chat_messages(
+            conversation_id=self.conversation_id, page=page, limit=limit
+        )
+
+        messages_data = response.data.get("messages", [])
+        return [ReceivedChatMessage(**msg) for msg in messages_data]
+
+
+# ============ Usage Examples ============
+async def example_simple_chat():
+    """Простой пример чата"""
+
+    def on_message(msg: ReceivedChatMessage):
+        if msg.type == ChatMessageType.TEXT:
+            print(f"📩 [{msg.fromNickName}]: {msg.content}")
+        elif msg.type == ChatMessageType.IMAGE:
+            print(f"📷 [{msg.fromNickName}] sent image: {msg.imageUrl}")
+        elif msg.type == ChatMessageType.VIDEO:
+            print(f"🎥 [{msg.fromNickName}] sent video: {msg.videoUrl}")
+        elif msg.type == ChatMessageType.FILE:
+            print(f"📎 [{msg.fromNickName}] sent file: {msg.fileUrl}")
+
+    def on_error(error: Exception):
+        print(f"❌ Error: {error}")
 
     api_key = "your_api_key"
     api_secret = "your_api_secret"
+    order_no = "your_order_no"
 
-    async with MEXCP2PClient(api_key, api_secret) as client:
-        # Создание объявления
-        ad_request = CreateUpdateAdRequest(
-            payTimeLimit=15,
-            initQuantity=Decimal("100"),
-            price=Decimal("70000"),
-            coinId="5989b56ba96a43599dbeeca5bb053f43",
-            side=Side.BUY,
-            fiatUnit="USD",
-            payMethod="1",
-            minSingleTransAmount=Decimal("10"),
-            maxSingleTransAmount=Decimal("1000"),
-            userAllTradeCountMin=0,
-            userAllTradeCountMax=100,
-        )
+    async with MEXCP2PChatSession(
+        api_key=api_key,
+        api_secret=api_secret,
+        order_no=order_no,
+        on_message=on_message,
+        on_error=on_error,
+        auto_reconnect=True,
+    ) as chat:
+        # Отправка текста
+        await chat.send_text("Hello! How are you?")
 
-        ad_response = await client.create_or_update_ad(ad_request)
-        print(f"Created ad: {ad_response.data}")
+        # Получение истории
+        history = await chat.get_message_history(limit=10)
+        print(f"📜 Loaded {len(history)} messages from history")
 
-        # Получение рыночных объявлений
-        market_ads = await client.get_market_ads(
-            fiat_unit="USD", coin_id="5989b56ba96a43599dbeeca5bb053f43", side=Side.SELL, page=1
+        # Держим соединение открытым
+        await asyncio.sleep(60)
+
+
+async def example_manual_websocket():
+    """Пример ручного управления WebSocket"""
+
+    api_key = "your_api_key"
+    api_secret = "your_api_secret"
+
+    # Получаем listenKey и conversation_id через HTTP API
+    async with MEXCP2PApiClient(api_key, api_secret) as http_client:
+        # Получение conversation ID
+        conv = await http_client.get_chat_conversation("order_123")
+        conversation_id = conv.data["conversationId"]
+
+        # Получение listenKey
+        key_response = await http_client.generate_listen_key()
+        listen_key = key_response.listenKey
+
+        # Создание WebSocket клиента
+        def on_message(msg: ReceivedChatMessage):
+            print(f"Received: {msg.content}")
+
+        ws_client = MEXCP2PWebSocketClient(
+            listen_key=listen_key, conversation_id=conversation_id, on_message=on_message, auto_reconnect=True
         )
 
-        print(f"Found {len(market_ads.data)} ads")
+        await ws_client.connect()
 
-        # Создание ордера
-        if market_ads.data:
-            first_ad = market_ads.data[0]
-            order_request = CreateOrderRequest(advNo=first_ad.advNo, amount=Decimal("100"), userConfirmPaymentId=123)
+        try:
+            # Отправка сообщений
+            await ws_client.send_text("Test message 1")
+            await asyncio.sleep(1)
+            await ws_client.send_text("Test message 2")
+
+            # Ожидание входящих сообщений
+            await asyncio.sleep(30)
+
+        finally:
+            await ws_client.disconnect()
+
+
+async def example_file_sending():
+    """Пример отправки файла"""
+
+    api_key = "your_api_key"
+    api_secret = "your_api_secret"
+    order_no = "your_order_no"
+
+    async with MEXCP2PChatSession(api_key=api_key, api_secret=api_secret, order_no=order_no) as chat:
+        # Загрузка и отправка файла
+        with open("document.pdf", "rb") as f:
+            file_data = f.read()
+
+        success = await chat.upload_and_send_file(file_data=file_data, filename="document.pdf")
+
+        if success:
+            print("✓ File sent successfully")
+        else:
+            print("❌ Failed to send file")
 
-            order_response = await client.create_order(order_request)
-            print(f"Created order: {order_response.data}")
 
-        # Получение деталей ордера
-        order_detail = await client.get_order_detail("order_id_here")
-        print(f"Order state: {order_detail.data.state}")
+async def example_bot():
+    """Пример простого бота для автоответов"""
 
+    async def handle_message(msg: ReceivedChatMessage):
+        # Игнорируем свои сообщения
+        if msg.self_:
+            return
+
+        # Автоответ на текст
+        if msg.type == ChatMessageType.TEXT:
+            if "price" in msg.content.lower():
+                await chat.send_text("Our current price is 70,000 USD")
+            elif "hello" in msg.content.lower():
+                await chat.send_text("Hello! How can I help you?")
+
+    api_key = "your_api_key"
+    api_secret = "your_api_secret"
+    order_no = "your_order_no"
+
+    async with MEXCP2PChatSession(
+        api_key=api_key, api_secret=api_secret, order_no=order_no, on_message=handle_message, auto_reconnect=True
+    ) as chat:
+        # Бот работает бесконечно
+        while True:
+            await asyncio.sleep(1)
+
+
+# ============ Usage Example ============
+async def main():
+    # Выбери пример для запуска:
+
+    # asyncio.run(example_simple_chat())
+    # asyncio.run(example_manual_websocket())
+    # asyncio.run(example_file_sending())
+    # asyncio.run(example_bot())
+
+    """Пример использования клиента"""
+    from x_model import init_db
+    from xync_client.loader import TORM
+
+    await init_db(TORM, True)
+
+    ex = await models.Ex[12]
+    agent = (
+        await models.Agent.filter(
+            actor__ex=ex,
+            status__gte=AgentStatus.race,
+            auth__isnull=False,
+            actor__person__user__status=UserStatus.ACTIVE,
+            actor__person__user__pm_agents__isnull=False,
+        )
+        .prefetch_related("actor__ex", "actor__person__user__gmail")
+        .first()
+    )
+
+    async with MEXCP2PApiClient(agent.auth["key"], agent.auth["sec"]) as client:
         # Генерация listenKey для WebSocket
         listen_key = await client.generate_listen_key()
         print(f"ListenKey: {listen_key.listenKey}")
 
+        # await ws_prv(listen_key.listenKey)
+        # Получение рыночных объявлений
+        # market_ads = await client.get_market_ads(
+        #     fiat_unit="RUB", coin_id="128f589271cb4951b03e71e6323eb7be", side=Side.SELL.name, page=1
+        # )
+
+        # print(f"Found {len(market_ads.data)} ads")
+
+        # Создание ордера
+        # if market_ads.data:
+        #     first_ad = market_ads.data[0]
+        #     order_request = CreateOrderRequest(advNo=first_ad.advNo, amount=Decimal("100"), userConfirmPaymentId=123)
+        #
+        #     order_response = await client.create_order(order_request)
+        #     print(f"Created order: {order_response.data}")
+        #
+        # # Получение деталей ордера
+        # order_detail = await client.get_order_detail("order_id_here")
+        # print(f"Order state: {order_detail.data.state}")
+
+        # Создание WebSocket клиента
+        def on_message(msg: ReceivedChatMessage):
+            print(f"Received: {msg.content}")
+
+        ws_client = MEXCWebSocketClient(
+            ws_token="d9381d8193ad0859f1ea240041bd7004493d2030a4b4a2c861e4fd9c1b08fdcc",
+            on_message=on_message,
+            auto_reconnect=True,
+        )
+
+        await ws_client.connect()
+
+        try:
+            # Отправка сообщений
+            wsr = WSRequest(method="SUBSCRIPTION", params=["otc@private.p2p.orders.pb"], id=12)
+
+            await ws_client._send_raw(wsr)
+
+            # Ожидание входящих сообщений
+            await asyncio.sleep(12)
+
+        finally:
+            await ws_client.disconnect()
+
+        # # Создание объявления
+        # ad_request = CreateUpdateAdRequest(
+        #     payTimeLimit=15,
+        #     initQuantity=100,
+        #     price=87,
+        #     coinId="5989b56ba96a43599dbeeca5bb053f43",
+        #     side=Side.BUY.name,
+        #     fiatUnit="USD",
+        #     payMethod="1",
+        #     minSingleTransAmount=500,
+        #     maxSingleTransAmount=150000,
+        #     userAllTradeCountMin=0,
+        #     userAllTradeCountMax=100,
+        # )
+        # ad_response = await client.create_or_update_ad(ad_request)
+        # print(f"Created ad: {ad_response.data}")
+
 
 if __name__ == "__main__":
     import asyncio