xync-client 0.0.141__py3-none-any.whl → 0.0.156.dev18__py3-none-any.whl

xync_client/Htx/etype/ad.py

@@ -1,48 +1,72 @@
 from typing import Literal
 
-from pydantic import BaseModel
+from pydantic import BaseModel, RootModel
 from xync_schema.xtype import BaseAd
 
+from xync_client.Abc.xtype import BaseAdUpdate
+
 
 class TradeRule(BaseModel):
     title: str
-    titleValue: str
+    titleValue: str | None = None
     content: str
     inputType: int
     inputValue: str
     hint: str
-    contentCode: str
+    contentCode: Literal["PAY", "MERCHANT"]
+    contentType: int | None = None
     sort: int
 
 
-class Req(BaseModel):
+TradeRulesV2 = RootModel[list[TradeRule]]
+
+
+class AdsUpd(BaseAdUpdate):
     tradeType: int
     coinId: int
     currency: int
     minTradeLimit: float
     maxTradeLimit: float
     tradeCount: float
-    password: str
+    password: str = ""
     payTerm: int
     isFixed: Literal["off", "on"]
-    premium: int
+    premium: float
     isAutoReply: Literal["off", "on"]
     takerAcceptOrder: int
     isPayCode: Literal["off", "on"]
-    isVerifyCapital: bool
-    receiveAccounts: int
+    verifyCapitalStatus: str = None  # todo: check if int
+    receiveAccounts: str
     deviation: int
     isTakerLimit: Literal["off", "on"]
+    takerRealLevel: Literal["off", "on"]
+    takerIsPhoneBind: Literal["off", "on"]
+    takerIsMerchant: Literal["off", "on"]
+    takerIsPayment: Literal["off", "on"]
     blockType: int
     session: int
     chargeType: bool
     apiVersion: int
     channel: str
-    tradeRulesV2: list[TradeRule]
+    tradeRulesV2: str  # TradeRulesV2
     securityToken: str | None = ""
-    fixedPrice: str | None = ""
+    fixedPrice: float | None = None
     autoReplyContent: str | None = ""
-    tradeRule: str | None = ""
+
+
+class AdsReq(BaseModel):
+    coinId: int
+    currency: int
+    tradeType: Literal["sell", "buy"]
+    payMethod: str
+    currPage: int = 1
+    acceptOrder: int = 0
+    blockType: Literal["general"] = "general"
+    online: int = 1
+    range: int = 0
+    amount: str = ""  # float
+    onlyTradable: str = "false"  # bool
+    isFollowed: str = "false"  # bool
 
 
 class PayMethod(BaseModel):
@@ -69,21 +93,21 @@ class Resp(BaseAd):
     isOnline: bool
     isTrade: bool
     isVerifyCapital: bool
-    maxTradeLimit: str
+    maxTradeLimit: float
     merchantLevel: int
-    minTradeLimit: str
+    minTradeLimit: float
     orderCompleteRate: str
     payMethod: str
     payMethods: list[PayMethod]
-    payName: str  # list[PayName]  # приходит массив объектов внутри строки
+    payName: str  # list[PayName] # приходит массив объектов внутри строки
     payTerm: int
-    price: str
+    price: float
     takerAcceptAmount: str
     takerAcceptOrder: int
     takerLimit: int
     thumbUp: int
     totalTradeOrderCount: int
-    tradeCount: str
+    tradeCount: float
     tradeMonthTimes: int
     tradeType: int
     uid: int

xync_client/Htx/etype/order.py

@@ -0,0 +1,194 @@
+from decimal import Decimal
+from typing import Literal
+
+from pydantic import BaseModel, NonNegativeInt, Field, PositiveInt
+
+
+class C2COrder(BaseModel):
+    cancelCountDown: NonNegativeInt
+    consultCancelCountDown: NonNegativeInt
+
+
+class OrderItem(BaseModel):
+    orderId: int
+    counterpartUid: PositiveInt
+    counterpartNickName: str
+    counterpartIsOnline: bool
+    counterpartOrderCount: NonNegativeInt
+    counterpartLastTradeTime: NonNegativeInt  # timestamp in ms
+    counterpartMerchantLevel: NonNegativeInt
+    counterpartThumbUp: NonNegativeInt
+    counterpartRocketAmount: NonNegativeInt | None
+    counterpartPrimeLevel: str = Field(pattern=r"^Prime\d+$")
+    counterpartRecentWithdrawTime: PositiveInt | None  # timestamp in ms
+    side: Literal[0, 1]  # 0=buy, 1=sell
+    tradeMode: Literal[1, 2]  # предполагаемые значения
+    runMode: Literal[1, 2]  # предполагаемые значения
+    quoteAssetName: str = Field(min_length=1, max_length=10)
+    cryptoAssetName: str = Field(min_length=1, max_length=10)
+    amount: Decimal = Field(gt=0, decimal_places=2)
+    quantity: Decimal = Field(gt=0)
+    quote: Decimal = Field(gt=0, decimal_places=2)
+    orderStatus: NonNegativeInt
+    c2cOrder: C2COrder = None
+    inNegotiation: bool
+
+
+class ModelField(BaseModel):
+    fieldId: str
+    name: str
+    fieldType: Literal["payee", "pay_account", "bank", "sub_bank", "qr_code"]
+    index: PositiveInt
+    maxLength: int | None = None
+    required: bool | None = None
+    copyable: bool
+    remindWord: str | None = None
+    valueType: str | None = None
+    value: str
+    nameList: list | None = None
+    remindWordList: list | None = None
+
+
+class PaymentMethod(BaseModel):
+    id: PositiveInt
+    userName: str = Field(min_length=1)
+    bankType: PositiveInt
+    bankNumber: str
+    bankName: str | None = None
+    bankAddress: str | None = None
+    qrCode: str | None = None
+    color: str = Field(pattern=r"^#[0-9A-F]{6}$")
+    payMethodName: str = Field(min_length=1)
+    paymentStatus: Literal[1]
+    modelFieldsList: list[ModelField]
+
+
+class OrderInfo(BaseModel):
+    orderId: PositiveInt
+    orderNo: PositiveInt
+    uid: PositiveInt
+    nickName: str = Field(min_length=1)
+    realName: str | None = None
+    roleName: Literal["maker", "taker"]
+    side: Literal[0, 1]
+    runMode: Literal[1]
+    tradeMode: Literal[1]
+    liquidDivision: Literal[3]
+    sideName: Literal["buy", "sell"]
+    quoteAssetId: PositiveInt
+    quoteAssetType: Literal[1]
+    quoteAssetName: str = Field(min_length=1, max_length=10)
+    quoteAssetSymbol: str
+    cryptoAssetId: PositiveInt
+    cryptoAssetType: Literal[2]
+    cryptoAssetName: str = Field(min_length=1, max_length=10)
+    cryptoAssetSymbol: str
+    amount: Decimal = Field(gt=0, decimal_places=2)
+    quantity: Decimal = Field(gt=0)
+    quote: Decimal = Field(gt=0, decimal_places=2)
+    orderStatus: NonNegativeInt
+    gmtCreate: PositiveInt
+    gmtModified: PositiveInt
+    areaType: Literal[1]
+    appealCountDown: NonNegativeInt
+
+
+class OtherInfo(BaseModel):
+    uid: PositiveInt
+    nickName: str = Field(min_length=1)
+    realName: str | None = None
+    gmtCreate: PositiveInt
+    merchantLevel: NonNegativeInt
+    realTradeCountBuy: NonNegativeInt
+    realTradeCountSell: NonNegativeInt
+    registerTime: PositiveInt
+    isPhoneBind: bool
+    marginAssetId: NonNegativeInt
+    marginAssetName: str | None = None
+    marginAmount: NonNegativeInt
+    appealMonthTimes: NonNegativeInt
+    appealMonthWinTimes: NonNegativeInt
+    isOnline: bool
+    isSeniorAuth: bool
+    orderCompleteRate: Decimal = Field(ge=0, le=100, decimal_places=2)
+    tradeMonthCount: NonNegativeInt
+    tradeCount: NonNegativeInt
+    releaseTime: NonNegativeInt
+    buyCompleteRate: Decimal = Field(ge=0, le=100, decimal_places=2)
+    buyCancelTimeAvg: Decimal = Field(ge=0, decimal_places=2)
+    thumbUp: NonNegativeInt
+    merchantTags: str | None = None
+    totalUserTradeCount: NonNegativeInt
+    totalTradeOrderCount: NonNegativeInt
+    totalTradeOrderCancelCount: NonNegativeInt
+    orderBuyCompleteRate: Decimal = Field(ge=0, le=100, decimal_places=2)
+    orderSellCompleteRate: Decimal = Field(ge=0, le=100, decimal_places=2)
+    totalOrderCompleteRate: Decimal = Field(ge=0, le=100, decimal_places=2)
+    counterpartRocketAmount: int | None = None
+    counterpartPrimeLevel: str = Field(pattern=r"^Prime\d+$")
+    counterpartRecentWithdrawTime: PositiveInt | None = None
+    counterpartOrderCount: NonNegativeInt
+    counterpartLastTradeTime: NonNegativeInt
+
+
+class Fee(BaseModel):
+    feeType: Literal[1]
+    feeStatus: Literal[1, 2]
+    fee: Decimal = Field(ge=0)
+    feeName: str = Field(min_length=1)
+
+
+class FeeInfo(BaseModel):
+    totalFee: Decimal = Field(ge=0)
+    feeList: list[Fee]
+
+
+class OrderTag(BaseModel):
+    isSoonLock: Literal[1, 2]
+    isPremature: Literal[1, 2]
+    isAppeal: Literal[1, 2]
+    specialCancelFlag: Literal[1, 2]
+    isPhone: Literal[1, 2]
+    now: PositiveInt
+    isAppealPremature: Literal[1, 2]
+    isFollowed: bool
+    isShield: bool
+    negotiationStatus: int | None = None
+
+
+class C2COrderDetail(BaseModel):
+    matchPayId: int | None = None
+    payTerm: PositiveInt
+    payCode: str | None = None
+    quote: Decimal = Field(gt=0, decimal_places=2)
+    amount: Decimal = Field(gt=0, decimal_places=2)
+    quantity: Decimal = Field(gt=0)
+    quoteAssetName: str = Field(min_length=1)
+    cryptoAssetName: str = Field(min_length=1)
+    buyPayAccount: PositiveInt | None
+    gmtPay: PositiveInt | None
+    gmtResetCancel: PositiveInt | None = None
+    orderStatus: NonNegativeInt
+    cancelCountDown: NonNegativeInt
+    consultCancelCountDown: NonNegativeInt
+    waitCompletedCountDown: NonNegativeInt
+    areaType: Literal[1]
+    acceptStatus: Literal[0, 1]
+    appCountDown: NonNegativeInt
+    appMaxCountDown: NonNegativeInt
+
+
+class OrderSnapshot(BaseModel):
+    tradeInstructionStatus: Literal["INIT", "COMPLETED"]  # добавь другие статусы
+
+
+class OrderFull(BaseModel):
+    orderInfo: OrderInfo
+    otherInfo: OtherInfo
+    paymentMethod: list[PaymentMethod]
+    feeInfo: FeeInfo
+    orderTag: OrderTag
+    c2cOrder: C2COrderDetail
+    inNegotiation: bool
+    takerEvaluateStatus: Literal[0, 1]
+    orderSnapshot: OrderSnapshot

xync_client/Htx/ex.py

@@ -9,7 +9,7 @@ from xync_schema.models import Ex, Cur
 from xync_schema.enums import PmType
 
 from xync_client.Abc.Ex import BaseExClient
-from xync_client.Abc.xtype import PmEx, MapOfIdsList
+from xync_client.Abc.xtype import PmEx, MapOfIdsList, GetAds
 from xync_client.Htx.etype import pm, Country, ad
 from xync_client.loader import NET_TOKEN
 from xync_client.loader import TORM
@@ -42,24 +42,22 @@ class ExClient(BaseExClient):
                         pair[rcurs[cur["name"]]] += [coen]
         return tuple(pairs.values())
 
-    async def ads(
-        self, coin_exid: int, cur_exid: int, is_sell: bool, pm_exids: list[str] = None, amount: int = None
-    ) -> list[xtype.BaseAd]:
-        params = {
-            "coinId": coin_exid,
-            "currency": cur_exid,
-            "tradeType": "sell" if is_sell else "buy",
-            "currPage": 1,
-            "payMethod": ",".join(pm_exids) if pm_exids else 0,
-            "acceptOrder": 0,
-            "blockType": "general",
-            "online": 1,
-            "range": 0,
-            "amount": amount or "",
-            "onlyTradable": "false",
-            "isFollowed": "false",
-        }
-        res = (await self._get("/-/x/otc/v1/data/trade-market", params))["data"]
+    async def x2e_req_ads(self, xreq: GetAds) -> ad.AdsReq:
+        coin_id, _ = await self.x2e_coin(xreq.coin_id)
+        cur_id, _, __ = await self.x2e_cur(xreq.cur_id)
+        ereq = ad.AdsReq(
+            coinId=int(coin_id),
+            currency=int(cur_id),
+            tradeType="sell" if xreq.is_sell else "buy",
+            payMethod=",".join([await self.x2e_pm(pm_id) for pm_id in xreq.pm_ids]),
+        )
+        if xreq.amount:
+            ereq.amount = str(xreq.amount)
+        # todo: all kwargs
+        return ereq
+
+    async def _ads(self, req: ad.AdsReq, lim: int = None, vm_filter: bool = False, **kwargs) -> list[ad.Resp]:
+        res = (await self._get("/-/x/otc/v1/data/trade-market", req.model_dump()))["data"]
         ads = [ad.Resp(**a) for a in res]
         return ads
 

xync_client/Mexc/agent.py

@@ -0,0 +1,268 @@
+import json
+import logging
+from asyncio import run, sleep, create_task
+from hashlib import md5
+from urllib.parse import quote
+from uuid import uuid4
+
+import websockets
+from blackboxprotobuf import protobuf_to_json
+from pyro_client.client.file import FileClient
+from xync_bot import XyncBot
+
+from xync_client.Mexc.api import MEXCP2PApiClient
+from xync_client.Mexc.etype import ad
+
+from xync_client.Abc.xtype import GetAds, AdUpd
+from xync_client.Bybit.etype.order import TakeAdReq
+from xync_client.Mexc.etype.order import OrderDetail
+
+from xync_client.loader import PAY_TOKEN, NET_TOKEN
+from xync_schema import models
+from xync_schema.enums import UserStatus, AgentStatus
+
+from xync_client.Abc.Agent import BaseAgentClient
+
+
+class AgentClient(BaseAgentClient):
+    i: int = 5
+    headers = {
+        # "Accept-Encoding": "gzip, deflate, br, zstd",
+        "Accept-Language": "ru,en;q=0.9",
+        "Language:": "ru-RU",
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36",
+    }
+    api: MEXCP2PApiClient
+
+    @staticmethod
+    async def _heartbeat(ws):
+        """Фоновая задача для PING/PONG"""
+        while True:
+            await sleep(25)
+            await ws.send('{"method":"PING"}')
+
+    async def _ws_key(self):
+        self.i = 13 if self.i > 9999 else self.i + 1
+        hdrs = self.agent.auth["headers"] | {
+            "trochilus-trace-id": "c7831459-3bb2-4aa7-bf5d-9ff2adef0c08-0062",
+            "ucenter-token": self.agent.auth["cookies"]["u_id"],
+        }
+        # resp = get("https://www.mexc.com/ucenter/api/ws_token", headers=hdrs, cookies=self.agent.auth['cookies'])
+        resp = await self._get("/ucenter/api/ws_token", hdrs=hdrs)
+        self.wkk = resp["data"]["wsToken"]
+
+    async def ws_prv(self):
+        await self._ws_key()
+        url = f"wss://wbs.mexc.com/ws?wsToken={self.wkk}"
+        async with websockets.connect(url) as ws:
+            create_task(self._heartbeat(ws))
+            await ws.send('{"method":"SUBSCRIPTION","params":["otc@private.p2p.orders.pb"],"id":12}')
+            await ws.send('{"method":"SUBSCRIPTION","params":["common@private.risk.result.pb"],"id":11}')
+            while resp := await ws.recv():
+                try:
+                    data: dict = json.loads(resp)
+                except UnicodeDecodeError:
+                    msg, typedef = protobuf_to_json(resp)
+                    data = json.loads(msg)
+                    await self.recv(data)
+                if data.get("msg") == "PONG":
+                    print(end="p")
+                else:
+                    logging.warning(data)
+
+    async def recv(self, data: dict):
+        if data["1"] == "otc@private.p2p.orders.pb":
+            o = data["218"]["1"]
+            order: OrderDetail = (await self.api.get_order_detail(o["1"])).data
+            if order.side == "SELL":
+                if order.state == "NOT_PAID":
+                    ...
+            elif order.side == "BUY":
+                if order.state == "PAID":
+                    ...
+        ...
+
+    async def _take_ad(self, req: TakeAdReq):
+        self.i = 33 if self.i > 9998 else self.i + 2
+        hdrs = self.headers | {"trochilus-trace-id": f"{uuid4()}-{self.i:04d}"}
+        auth = {
+            "p0": self.actor.agent.auth["p0"],
+            "k0": self.actor.agent.auth["k0"],
+            "chash": self.actor.agent.auth["chash"],
+            "mtoken": self.actor.agent.auth["deviceId"],
+            "mhash": md5(self.actor.agent.auth["deviceId"].encode()).hexdigest(),
+        }
+        data = {
+            "scene": "TRADE_BUY",
+            "quantity": req.quantity,
+            "amount": req.amount,
+            "orderId": req.ad_id,
+            "authVersion": "v2",
+            "deviceId": auth["mtoken"],
+        }
+        res = await self._post("/api/platform/p2p/api/verify/second_auth/risk/scene", json=data, hdrs=hdrs)
+        data = {
+            "amount": req.amount,
+            "authVersion": "v2",
+            "orderId": req.ad_id,
+            "price": req.price,
+            "ts": int(1761155700.8372989 * 1000),
+            "userConfirmPaymentId" if req.is_sell else "userConfirmPayMethodId": req.pm_id,
+        }
+        self.i = 33 if self.i > 9999 else self.i + 1
+        hdrs = self.headers | {"trochilus-trace-id": f"{uuid4()}-{self.i:04d}"}
+        res = await self._post("/api/platform/p2p/api/order/deal?mhash=" + auth["mhash"], data=auth | data, hdrs=hdrs)
+        return res["data"]
+
+    async def x2e_req_ad_upd(self, xreq: AdUpd) -> ad.AdUpd:
+        coin_id, coin_scale = await self.ex_client.x2e_coin(xreq.coin_id)
+        cur_id, cur_scale, minimum = await self.ex_client.x2e_cur(xreq.cur_id)
+        ereq = ad.AdUpd(
+            id=xreq.id,
+            price=round(xreq.price, cur_scale),
+            coinId=coin_id,
+            currency=cur_id,
+            tradeType="SELL" if xreq.is_sell else "BUY",
+            deviceId=self.agent.auth["deviceId"],
+            payment=",".join([str(cdx.exid) for cdx in xreq.credexs]),
+            priceType=0,
+            minTradeLimit=minimum,
+            maxTradeLimit=round(xreq.max_amount or xreq.amount - 10**-cur_scale, cur_scale),
+            quantity=round(xreq.quantity or xreq.amount / xreq.price, coin_scale),
+        )
+        if xreq.cond:
+            ereq.autoResponse = quote(xreq.cond)
+        # todo: all kwargs
+        return ereq
+
+    async def _ad_upd(self, req: ad.AdUpd):
+        self.i = 33 if self.i > 9999 else self.i + 1
+        hdrs = self.headers | {"trochilus-trace-id": f"{uuid4()}-{self.i:04d}"}
+        res = await self._put("/api/platform/p2p/api/merchant/order", form_data=req.model_dump(), hdrs=hdrs)
+        return res["code"]
+
+
+async def main():
+    from x_model import init_db
+    from xync_client.loader import TORM
+
+    cn = 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()
+    )
+    bbot = XyncBot(PAY_TOKEN, cn)
+    fbot = FileClient(NET_TOKEN)
+    ecl = ex.client(fbot)
+    cl: AgentClient = agent.client(ecl, fbot, bbot)
+    cl.api = MEXCP2PApiClient(agent.auth["key"], agent.auth["sec"])
+    create_task(cl.ws_prv())
+
+    while True:
+        bceil = 106
+        sceil = 124.98
+        breq = GetAds(coin_id=1, cur_id=1, is_sell=False, pm_ids=[366])
+        sreq = GetAds(coin_id=1, cur_id=1, is_sell=True, pm_ids=[366])
+        breq_upd = AdUpd(
+            id="a1574183931501582340", price=87, **{**breq.model_dump(), "amount": 11000.01}, max_amount=4370
+        )  # + 1 cent
+        sreq_upd = AdUpd(id="a1594624084590445568", price=150, **{**sreq.model_dump(), "amount": 30000.01})
+
+        await sleep(5)
+        bads: list[ad.Ad] = await cl.ex_client.ads(breq)
+        if bads[0].price >= sceil:
+            bad: ad.Ad = bads.pop(0)
+            await cl.bbot.send(
+                193017646,
+                f"price: {bad.price}\nnick: {bad.merchant.nickName}\nmax:{bad.maxPayLimit}"
+                f"\nqty: {bad.availableQuantity} [{bad.minTradeLimit}-{bad.maxTradeLimit}]",
+            )
+            # am = min(bad.maxTradeLimit, max(10000.0, bad.minTradeLimit))
+            # req = TakeAdReq(
+            #     ad_id=bad.exid,
+            #     amount=am,
+            #     pm_id=366,
+            #     is_sell=False,
+            #     coin_id=1,
+            #     cur_id=1,
+            # )
+            # ord_resp: OrderResp = await cl.take_ad(req)
+
+        bads = [
+            a
+            for a in bads
+            if a.price <= bceil and a.availableQuantity > 20 and (a.maxTradeLimit - a.minTradeLimit > 1000)
+        ]
+        if len(bads) > 1:
+            if bads[0].merchant.nickName == cl.actor.name:
+                if round(bads[0].price - bads[1].price, 2) > 0.01:
+                    breq_upd.price = bads[1].price + 0.01
+                    if _ := await cl.ad_upd(breq_upd):
+                        await sleep(5, print(_, flush=True))
+                    print(end="!", flush=True)
+            elif bads[0].price != (trgt_price := bads[0].price + 0.01):
+                breq_upd.price = trgt_price
+                if _ := await cl.ad_upd(breq_upd):
+                    await sleep(5, print(_, flush=True))
+                print(end="!", flush=True)
+
+        await sleep(5)
+        sads: list[ad.Ad] = await cl.ex_client.ads(sreq)
+        if sads[0].price <= bceil:
+            sad: ad.Ad = sads.pop(0)
+            await cl.bbot.send(
+                193017646,
+                f"price: {sad.price}\nnick: {sad.merchant.nickName}\nmax:{sad.maxPayLimit}"
+                f"\nqty: {sad.availableQuantity} [{sad.minTradeLimit}-{sad.maxTradeLimit}]",
+            )
+            # am = min(sad.maxTradeLimit, max(10000.0, sad.minTradeLimit))
+            # req = TakeAdReq(
+            #     ad_id=sad.exid,
+            #     amount=am,
+            #     pm_id=366,
+            #     is_sell=False,
+            #     coin_id=1,
+            #     cur_id=1,
+            # )
+            # ord_resp: OrderResp = await cl.take_ad(req)
+
+        sads = [
+            a
+            for a in sads
+            if a.price >= sceil and a.availableQuantity > 20 and (a.maxTradeLimit - a.minTradeLimit > 1000)
+        ]
+        if len(sads) > 1:
+            if sads[0].merchant.nickName == cl.actor.name:
+                if round(sads[1].price - sads[0].price, 2) > 0.01:
+                    sreq_upd.price = sads[1].price - 0.01
+                    if _ := await cl.ad_upd(sreq_upd):
+                        await sleep(15, print(_, flush=True))
+                        continue
+                    print(end="!", flush=True)
+                    continue
+            elif sads[0].price > sceil:
+                sreq_upd.price = sads[0].price - 0.01
+                if _ := await cl.ad_upd(sreq_upd):
+                    await sleep(15, print(_, flush=True))
+                    continue
+                print(end="!", flush=True)
+                continue
+
+        print(end=".", flush=True)
+
+    req = TakeAdReq(ad_id="a1574088909645125632", amount=500, pm_id=366, cur_id=1, price=85.8, is_sell=True)
+    res = await cl.take_ad(req)
+    print(res)
+
+
+if __name__ == "__main__":
+    run(main())