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

xync_client/Mexc/etype/order.py

@@ -1,59 +1,44 @@
-"""
-MEXC P2P OpenAPI v1.2 Async Client
-"""
+from enum import IntEnum
+from typing import Optional, Literal
 
-import hmac
-import hashlib
-import time
-from typing import Optional, List, Literal
-from decimal import Decimal
-
-import aiohttp
 from pydantic import BaseModel, Field
 
-
 # ============ Enums ============
+Side = Literal["BUY", "SELL"]
 
 
-class Side(str):
-    BUY = "BUY"
-    SELL = "SELL"
-
+class AdvStatus(IntEnum):
+    CLOSE = 0
+    OPEN = 1
+    DELETE = 2
+    LOW_STOCK = 3
 
-class AdvStatus(str):
-    CLOSE = "CLOSE"
-    OPEN = "OPEN"
-    DELETE = "DELETE"
-    LOW_STOCK = "LOW_STOCK"
 
+class OrderDealState(IntEnum):
+    NOT_PAID = 0
+    PAID = 1
+    WAIT_PROCESS = 2
+    PROCESSING = 3
+    DONE = 4
+    CANCEL = 5
+    INVALID = 6
+    REFUSE = 7
+    TIMEOUT = 8
 
-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"
+class NotifyType(IntEnum):
+    SMS = 0
+    MAIL = 1
+    GA = 2
 
 
 # ============ Request Models ============
-
-
 class CreateUpdateAdRequest(BaseModel):
     advNo: Optional[str] = None
     payTimeLimit: int
-    initQuantity: Decimal
-    supplyQuantity: Optional[Decimal] = None
-    price: Decimal
+    initQuantity: float
+    supplyQuantity: Optional[float] = None
+    price: float
     coinId: str
     countryCode: Optional[str] = None
     side: str
@@ -63,8 +48,8 @@ class CreateUpdateAdRequest(BaseModel):
     payMethod: str
     autoReplyMsg: Optional[str] = None
     tradeTerms: Optional[str] = None
-    minSingleTransAmount: Decimal
-    maxSingleTransAmount: Decimal
+    minSingleTransAmount: float
+    maxSingleTransAmount: float
     kycLevel: Optional[str] = None
     requireMobile: Optional[bool] = None
     userAllTradeCountMin: int
@@ -72,15 +57,15 @@ class CreateUpdateAdRequest(BaseModel):
     exchangeCount: Optional[int] = None
     maxPayLimit: Optional[int] = None
     buyerRegDaysLimit: Optional[int] = None
-    creditAmount: Optional[Decimal] = None
+    creditAmount: Optional[float] = None
     blockTrade: Optional[bool] = None
     deviceId: Optional[str] = None
 
 
 class CreateOrderRequest(BaseModel):
     advNo: str
-    amount: Optional[Decimal] = None
-    tradableQuantity: Optional[Decimal] = None
+    amount: Optional[float] = None
+    tradableQuantity: Optional[float] = None
     userConfirmPaymentId: int
     userConfirmPayMethodId: Optional[int] = None
     deviceId: Optional[str] = None
@@ -102,8 +87,6 @@ class ServiceSwitchRequest(BaseModel):
 
 
 # ============ Response Models ============
-
-
 class BaseResponse(BaseModel):
     code: int
     msg: str
@@ -112,11 +95,11 @@ class BaseResponse(BaseModel):
 class PaymentInfo(BaseModel):
     id: int
     payMethod: int
-    bankName: str
-    account: str
-    bankAddress: str
-    payee: str
-    extend: str
+    bankName: str = None
+    account: str = None
+    bankAddress: str = None
+    payee: str = None
+    extend: str = None
 
 
 class MerchantInfo(BaseModel):
@@ -138,38 +121,41 @@ class MerchantStatistics(BaseModel):
     totalBuyCount: int
     totalSellCount: int
     doneLastMonthCount: int
-    avgBuyHandleTime: int
-    avgSellHandleTime: int
+    avgBuyHandleTime: float
+    avgSellHandleTime: float
     lastMonthCompleteRate: str
     completeRate: str
-    avgHandleTime: int
+    avgHandleTime: float
+
+
+2
 
 
 class Advertisement(BaseModel):
     advNo: str
     payTimeLimit: int
-    quantity: int
-    price: Decimal
-    initAmount: Decimal
-    frozenQuantity: Decimal
-    availableQuantity: Decimal
-    coinId: str
+    quantity: int = None
+    price: float
+    initAmount: float = None
+    frozenQuantity: float = None
+    availableQuantity: float
+    coinId: str = None
     coinName: str
     countryCode: str
-    commissionRate: Decimal
-    advStatus: str
+    commissionRate: float = None
+    advStatus: str = None
     side: str
-    createTime: int
+    createTime: int = None
     updateTime: int
     fiatUnit: str
-    feeType: int
+    feeType: int = None
     autoReplyMsg: str
     tradeTerms: str
     payMethod: str
-    paymentInfo: List[PaymentInfo]
-    minSingleTransAmount: Decimal
-    maxSingleTransAmount: Decimal
-    kycLevel: int
+    paymentInfo: list[PaymentInfo]
+    minSingleTransAmount: float
+    maxSingleTransAmount: float
+    kycLevel: Literal["PRIMARY", "ADVANCED"]
     requireMobile: bool
     userAllTradeCountMax: int
     userAllTradeCountMin: int
@@ -200,30 +186,30 @@ class UserInfo(BaseModel):
 class Order(BaseModel):
     advNo: str
     advOrderNo: str
-    tradableQuantity: Decimal
-    price: Decimal
-    amount: Decimal
+    tradableQuantity: float
+    price: float
+    amount: float
     coinName: str
-    state: int
+    state: Literal["DONE", "PAID", "NOT_PAID", "PROCESSING"]
     payTimeLimit: int
-    side: str
+    side: Side
     fiatUnit: str
     createTime: int
     updateTime: int
     userInfo: UserInfo
     complained: bool
-    blockUser: bool
+    blockUser: bool = None
     unreadCount: int
     complainId: Optional[str] = None
 
 
 class OrderDetail(Order):
-    paymentInfo: List[PaymentInfo]
-    allowComplainTime: int
+    paymentInfo: list[PaymentInfo]
+    allowComplainTime: int = None
     confirmPaymentInfo: PaymentInfo
     userInfo: dict
-    userFiatStatistics: dict
-    spotCount: int
+    userFiatStatistics: dict = None
+    spotCount: int = None
 
 
 class CreateAdResponse(BaseResponse):
@@ -231,12 +217,12 @@ class CreateAdResponse(BaseResponse):
 
 
 class AdListResponse(BaseResponse):
-    data: List[Advertisement]
+    data: list[Advertisement]
     page: PageInfo
 
 
 class MarketAdListResponse(BaseResponse):
-    data: List[MarketAdvertisement]
+    data: list[MarketAdvertisement]
     page: PageInfo
 
 
@@ -245,7 +231,7 @@ class CreateOrderResponse(BaseResponse):
 
 
 class OrderListResponse(BaseResponse):
-    data: List[Order]
+    data: list[Order]
     page: PageInfo
 
 
@@ -253,7 +239,7 @@ class OrderDetailResponse(BaseResponse):
     data: OrderDetail
 
 
-class ListenKeyResponse(BaseResponse):
+class ListenKeyResponse(BaseModel):
     listenKey: str
 
 
@@ -284,356 +270,85 @@ class UploadFileResponse(BaseResponse):
     data: dict
 
 
-# ============ Client ============
-
-
-class MEXCP2PClient:
-    """Асинхронный клиент для MEXC P2P API v1.2"""
-
-    BASE_URL = "https://api.mexc.com"
-
-    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()
-
-    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)
-
-    async def _request(
-        self, method: str, endpoint: str, params: Optional[dict] = None, data: Optional[BaseModel] = None
-    ) -> dict:
-        """Базовый метод для HTTP запросов"""
-        if not self.session:
-            raise RuntimeError("Client not initialized. Use async context manager.")
-
-        timestamp = self._get_timestamp()
-
-        # Формирование query string для подписи
-        query_params = params.copy() if params else {}
-        query_params["timestamp"] = timestamp
-
-        query_string = "&".join(f"{k}={v}" for k, v in sorted(query_params.items()))
-        signature = self._generate_signature(query_string)
-
-        query_params["signature"] = signature
-
-        headers = {"X-MEXC-APIKEY": self.api_key, "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:
-            return await response.json()
-
-    # ============ Advertisement Methods ============
-
-    async def create_or_update_ad(self, request: CreateUpdateAdRequest) -> CreateAdResponse:
-        """Создание или обновление объявления"""
-        result = await self._request("POST", "/api/v3/fiat/merchant/ads/save_or_update", data=request)
-        return CreateAdResponse(**result)
-
-    async def get_my_ads(
-        self,
-        coin_id: Optional[str] = None,
-        adv_status: Optional[str] = None,
-        merchant_id: Optional[str] = None,
-        fiat_unit: Optional[str] = None,
-        side: Optional[str] = None,
-        kyc_level: Optional[str] = None,
-        start_time: Optional[int] = None,
-        end_time: Optional[int] = None,
-        page: int = 1,
-        limit: int = 10,
-    ) -> AdListResponse:
-        """Получение списка моих объявлений с пагинацией"""
-        params = {"page": page, "limit": limit}
-
-        if coin_id:
-            params["coinId"] = coin_id
-        if adv_status:
-            params["advStatus"] = adv_status
-        if merchant_id:
-            params["merchantId"] = merchant_id
-        if fiat_unit:
-            params["fiatUnit"] = fiat_unit
-        if side:
-            params["side"] = side
-        if kyc_level:
-            params["kycLevel"] = kyc_level
-        if start_time:
-            params["startTime"] = start_time
-        if end_time:
-            params["endTime"] = end_time
-
-        result = await self._request("GET", "/api/v3/fiat/merchant/ads/pagination", params=params)
-        return AdListResponse(**result)
-
-    async def get_market_ads(
-        self,
-        fiat_unit: str,
-        coin_id: str,
-        country_code: Optional[str] = None,
-        side: Optional[str] = None,
-        amount: Optional[Decimal] = None,
-        quantity: Optional[Decimal] = None,
-        pay_method: Optional[str] = None,
-        block_trade: Optional[bool] = None,
-        allow_trade: Optional[bool] = None,
-        have_trade: Optional[bool] = None,
-        follow: Optional[bool] = None,
-        page: int = 1,
-    ) -> MarketAdListResponse:
-        """Получение рыночных объявлений"""
-        params = {"fiatUnit": fiat_unit, "coinId": coin_id, "page": page}
-
-        if country_code:
-            params["countryCode"] = country_code
-        if side:
-            params["side"] = side
-        if amount:
-            params["amount"] = str(amount)
-        if quantity:
-            params["quantity"] = str(quantity)
-        if pay_method:
-            params["payMethod"] = pay_method
-        if block_trade is not None:
-            params["blockTrade"] = block_trade
-        if allow_trade is not None:
-            params["allowTrade"] = allow_trade
-        if have_trade is not None:
-            params["haveTrade"] = have_trade
-        if follow is not None:
-            params["follow"] = follow
-
-        result = await self._request("GET", "/api/v3/fiat/market/ads/pagination", params=params)
-        return 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)
-        return CreateOrderResponse(**result)
-
-    async def get_my_orders(
-        self,
-        start_time: int,
-        end_time: int,
-        coin_id: Optional[str] = None,
-        adv_order_no: Optional[str] = None,
-        side: Optional[str] = None,
-        order_deal_state: Optional[str] = None,
-        page: int = 1,
-        limit: int = 10,
-    ) -> OrderListResponse:
-        """Получение моих ордеров (только как maker)"""
-        params = {"startTime": start_time, "endTime": end_time, "page": page, "limit": limit}
-
-        if coin_id:
-            params["coinId"] = coin_id
-        if adv_order_no:
-            params["advOrderNo"] = adv_order_no
-        if side:
-            params["side"] = side
-        if order_deal_state:
-            params["orderDealState"] = order_deal_state
-
-        result = await self._request("GET", "/api/v3/fiat/merchant/order/pagination", params=params)
-        return OrderListResponse(**result)
-
-    async def get_market_orders(
-        self,
-        coin_id: Optional[str] = None,
-        adv_order_no: Optional[str] = None,
-        side: Optional[str] = None,
-        order_deal_state: Optional[str] = None,
-        start_time: Optional[int] = None,
-        end_time: Optional[int] = None,
-        page: int = 1,
-        limit: int = 10,
-    ) -> OrderListResponse:
-        """Получение всех ордеров (как maker и taker)"""
-        params = {"page": page, "limit": limit}
-
-        if coin_id:
-            params["coinId"] = coin_id
-        if adv_order_no:
-            params["advOrderNo"] = adv_order_no
-        if side:
-            params["side"] = side
-        if order_deal_state:
-            params["orderDealState"] = order_deal_state
-        if start_time:
-            params["startTime"] = start_time
-        if end_time:
-            params["endTime"] = end_time
-
-        result = await self._request("GET", "/api/v3/fiat/market/order/pagination", params=params)
-        return OrderListResponse(**result)
-
-    async def confirm_paid(self, request: ConfirmPaidRequest) -> BaseResponse:
-        """Подтверждение оплаты"""
-        result = await self._request("POST", "/api/v3/fiat/confirm_paid", data=request)
-        return BaseResponse(**result)
-
-    async def release_coin(self, request: ReleaseCoinRequest) -> BaseResponse:
-        """Релиз криптовалюты"""
-        result = await self._request("POST", "/api/v3/fiat/release_coin", data=request)
-        return BaseResponse(**result)
-
-    async def get_order_detail(self, adv_order_no: str) -> OrderDetailResponse:
-        """Получение деталей ордера"""
-        params = {"advOrderNo": adv_order_no}
-
-        result = await self._request("GET", "/api/v3/fiat/order/detail", params=params)
-        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")
-        return ListenKeyResponse(**result)
-
-    async def get_listen_key(self) -> ListenKeyResponse:
-        """Получение существующего listenKey"""
-        result = await self._request("GET", "/api/v3/userDataStream")
-        return ListenKeyResponse(**result)
-
-    # ============ Chat Methods ============
-
-    async def get_chat_conversation(self, order_no: str) -> ConversationResponse:
-        """Получение ID чат-сессии для ордера"""
-        params = {"orderNo": order_no}
-
-        result = await self._request("GET", "/api/v3/fiat/retrieveChatConversation", params=params)
-        return ConversationResponse(**result)
-
-    async def get_chat_messages(
-        self,
-        conversation_id: int,
-        page: int = 1,
-        limit: int = 20,
-        chat_message_type: Optional[str] = None,
-        message_id: Optional[int] = None,
-        sort: Literal["DESC", "ASC"] = "DESC",
-    ) -> ChatMessagesResponse:
-        """Получение истории чата с пагинацией"""
-        params = {"conversationId": conversation_id, "page": page, "limit": limit, "sort": sort}
-
-        if chat_message_type:
-            params["chatMessageType"] = chat_message_type
-        if message_id:
-            params["id"] = message_id
-
-        result = await self._request("GET", "/api/v3/fiat/retrieveChatMessageWithPagination", params=params)
-        return ChatMessagesResponse(**result)
-
-    async def upload_file(self, file_data: bytes, filename: str) -> UploadFileResponse:
-        """Загрузка файла"""
-        if not self.session:
-            raise RuntimeError("Client not initialized.")
-
-        timestamp = self._get_timestamp()
-        query_string = f"timestamp={timestamp}"
-        signature = self._generate_signature(query_string)
-
-        url = f"{self.BASE_URL}/api/v3/fiat/uploadFile"
-        params = {"timestamp": timestamp, "signature": signature}
-
-        headers = {"X-MEXC-APIKEY": self.api_key}
-
-        form = aiohttp.FormData()
-        form.add_field("file", file_data, filename=filename)
+# ============ WebSocket Message Models ============
+class ChatMessageType(IntEnum):
+    TEXT = 1
+    IMAGE = 2
+    VIDEO = 3
+    FILE = 4
 
-        async with self.session.post(url, params=params, data=form, headers=headers) as response:
-            result = await response.json()
 
-        return UploadFileResponse(**result)
+class WSMethod(str):
+    SUBSCRIPTION = "SUBSCRIPTION"
+    UNSUBSCRIPTION = "UNSUBSCRIPTION"
+    SEND_MESSAGE = "SEND_MESSAGE"
+    RECEIVE_MESSAGE = "RECEIVE_MESSAGE"
+    PING = "PING"
 
-    async def download_file(self, file_id: str) -> dict:
-        """Скачивание файла"""
-        params = {"fileId": file_id}
 
-        result = await self._request("GET", "/api/v3/fiat/downloadFile", params=params)
-        return result
+class SendTextMessage(BaseModel):
+    """Отправка текстового сообщения"""
 
+    content: str
+    conversationId: int
+    type: int = ChatMessageType.TEXT
 
-# ============ Usage Example ============
 
+class SendImageMessage(BaseModel):
+    """Отправка изображения"""
 
-async def main():
-    """Пример использования клиента"""
+    imageUrl: str
+    imageThumbUrl: str
+    conversationId: int
+    type: int = ChatMessageType.IMAGE
 
-    api_key = "your_api_key"
-    api_secret = "your_api_secret"
 
-    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,
-        )
+class SendVideoMessage(BaseModel):
+    """Отправка видео"""
 
-        ad_response = await client.create_or_update_ad(ad_request)
-        print(f"Created ad: {ad_response.data}")
+    videoUrl: str
+    imageThumbUrl: str  # превью видео
+    conversationId: int
+    type: int = ChatMessageType.VIDEO
 
-        # Получение рыночных объявлений
-        market_ads = await client.get_market_ads(
-            fiat_unit="USD", coin_id="5989b56ba96a43599dbeeca5bb053f43", side=Side.SELL, page=1
-        )
 
-        print(f"Found {len(market_ads.data)} ads")
+class SendFileMessage(BaseModel):
+    """Отправка файла"""
 
-        # Создание ордера
-        if market_ads.data:
-            first_ad = market_ads.data[0]
-            order_request = CreateOrderRequest(advNo=first_ad.advNo, amount=Decimal("100"), userConfirmPaymentId=123)
+    fileUrl: str
+    conversationId: int
+    type: int = ChatMessageType.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}")
+class WSRequest(BaseModel):
+    """Базовая структура WebSocket запроса"""
 
-        # Генерация listenKey для WebSocket
-        listen_key = await client.generate_listen_key()
-        print(f"ListenKey: {listen_key.listenKey}")
+    method: str
+    params: dict | list[str] | None = None
+    id: int = None
 
 
-if __name__ == "__main__":
-    import asyncio
+class WSBaseResponse(BaseModel):
+    """Базовый ответ WebSocket"""
 
-    asyncio.run(main())
+    success: bool
+    method: str
+    msg: str
+    data: Optional[str] = None
+
+
+class ReceivedChatMessage(BaseModel):
+    """Полученное сообщение из чата"""
+
+    id: int
+    content: Optional[str] = None
+    conversationId: int
+    type: int
+    imageUrl: Optional[str] = None
+    imageThumbUrl: Optional[str] = None
+    videoUrl: Optional[str] = None
+    fileUrl: Optional[str] = None
+    createTime: str
+    self_: bool = Field(alias="self")
+    fromUserId: str
+    fromNickName: str