xync-client 0.0.148__tar.gz → 0.0.151__tar.gz

{xync_client-0.0.148/xync_client.egg-info → xync_client-0.0.151}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.148
+Version: 0.0.151
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client

{xync_client-0.0.148 → xync_client-0.0.151}/xync_client/Abc/AdLoader.py

@@ -4,6 +4,7 @@ from asyncio import sleep
 from collections import defaultdict
 from difflib import SequenceMatcher
 
+from tortoise.exceptions import OperationalError
 from xync_schema import models
 from xync_schema.xtype import BaseAd
 
@@ -72,20 +73,25 @@ class AdLoader:
         # if not ps or not ps.pair:
         #     ...  # THB/USDC: just for initial filling
         ad_upd = models.Ad.validate(pad.model_dump(by_alias=True))
-        cur_scale = 10 ** (curex or await models.CurEx.get(coin_id=ps.pair.cur_id, ex=self.ex)).scale
+        cur_scale = 10 ** (curex or await models.CurEx.get(cur_id=ps.pair.cur_id, ex=self.ex)).scale
         coin_scale = 10 ** (coinex or await models.CoinEx.get(coin_id=ps.pair.coin_id, ex=self.ex)).scale
+        amt = int(float(pad.quantity) * float(pad.price) * cur_scale)
+        mxf = pad.maxAmount and int(float(pad.maxAmount) * cur_scale)
         df_unq = ad_upd.df_unq(
             maker_id=maker.id,
             pair_side_id=ps.id,
-            amount=int(float(pad.quantity) * float(pad.price) * cur_scale),
+            amount=amt if amt < 4_294_967_295 else 4_294_967_295,
             quantity=int(float(pad.quantity) * coin_scale),
             min_fiat=int(float(pad.minAmount) * cur_scale),
-            max_fiat=pad.maxAmount and int(float(pad.maxAmount) * cur_scale),
+            max_fiat=mxf if mxf < 4_294_967_295 else 4_294_967_295,
             price=int(float(pad.price) * cur_scale),
             premium=int(float(pad.premium) * 100),
             cond_id=cid,
         )
-        ad_db, _ = await models.Ad.update_or_create(**df_unq)
+        try:
+            ad_db, _ = await models.Ad.update_or_create(**df_unq)
+        except OperationalError as e:
+            raise e
         if not pms_from_cond:
             await ad_db.pms.add(*(await models.Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=pad.payments)))
         return ad_db
@@ -132,10 +138,10 @@ class AdLoader:
                 {ra.maker_id for ra in rest_ads} - {ad_db.maker_id}
             ):
                 # создадим новое условие и присвоим его только текущей объяве
-                cid = await self.cond_new(cleaned, {int(ad.userId)})
-                ad_db.cond_id = cid
+                cond = await self.cond_new(cleaned, {int(ad.userId)})
+                ad_db.cond_id = cond.id
                 await ad_db.save()
-
+                ad_db.cond = cond
                 return ad_db, True
             # а если других объяв со старым условием этой обявы нет, либо они все этого же юзера
             # обновляем условие (в тч во всех ЕГО объявах)
@@ -147,16 +153,18 @@ class AdLoader:
             await self.fix_rel_sims(ad_db.cond_id, cleaned)
             return ad_db, False
 
-        cid = await self.cond_new(cleaned, {int(ad.userId)})
-        return await self.ad_load(
-            ad, cid, ps, coinex=coinex, curex=curex, rname=rname, pms_from_cond=pms_from_cond
-        ), True
+        cond = await self.cond_new(cleaned, {int(ad.userId)})
+        ad_db = await self.ad_load(
+            ad, cond.id, ps, coinex=coinex, curex=curex, rname=rname, pms_from_cond=pms_from_cond
+        )
+        ad_db.cond = cond
+        return ad_db, True
 
-    async def cond_new(self, txt: str, uids: set[int]) -> int:
+    async def cond_new(self, txt: str, uids: set[int]) -> models.Cond:
         new_cond, _ = await models.Cond.update_or_create(raw_txt=txt)
         # и максимально похожую связь для нового условия (если есть >= 60%)
         await self.cond_upd(new_cond, uids)
-        return new_cond.id
+        return new_cond
 
     async def cond_upd(self, cond: models.Cond, uids: set[int]):
         self.all_conds[cond.id] = cond.raw_txt, uids

{xync_client-0.0.148 → xync_client-0.0.151}/xync_client/Abc/Agent.py

@@ -2,8 +2,10 @@ from abc import abstractmethod
 
 from pydantic import BaseModel
 from pyro_client.client.file import FileClient
+from x_client import df_hdrs
 from x_client.aiohttp import Client as HttpClient
 from xync_bot import XyncBot
+from xync_client.Bybit.etype.order import TakeAdReq
 from xync_schema import models
 from xync_schema.models import OrderStatus, Coin, Cur, Ad, AdStatus, Actor, Agent
 from xync_schema.xtype import BaseAd
@@ -22,7 +24,7 @@ class BaseAgentClient(HttpClient):
         agent: Agent,
         fbot: FileClient,
         bbot: XyncBot,
-        headers: dict[str, str] = None,
+        headers: dict[str, str] = df_hdrs,
         cookies: dict[str, str] = None,
     ):
         self.bbot = bbot
@@ -131,6 +133,9 @@ class BaseAgentClient(HttpClient):
     @abstractmethod
     async def my_assets(self) -> dict: ...
 
+    @abstractmethod
+    async def take_ad(self, req: TakeAdReq): ...
+
     # Сохранение объявления (с Pm/Cred-ами) в бд
     # async def ad_pydin2db(self, ad_pydin: AdSaleIn | AdBuyIn) -> Ad:
     #     ad_db = await self.ex_client.ad_pydin2db(ad_pydin)

{xync_client-0.0.148 → xync_client-0.0.151}/xync_client/Abc/xtype.py

@@ -53,7 +53,7 @@ class BaseOrderReq(BaseModel):
     asset_amount: float | None = None
     fiat_amount: float | None = None
 
-    pm_id: int = (None,)
+    pmex_exid: str = None  # int
 
     # todo: mv from base to special ex class
     amount_is_fiat: bool = True

{xync_client-0.0.148 → xync_client-0.0.151}/xync_client/Bybit/InAgent.py

@@ -335,7 +335,7 @@ class InAgentClient(BaseInAgentClient):
         pma, cur = await self.get_pma_by_pmex(order_db)
         async with in_transaction():
             # отмечаем ордер на бирже "оплачен"
-            pmex = await models.PmEx.get(pm_id=order_db.cred.pmcur.pm_id, ex=self.agent_client.actor.ex)
+            pmex = await models.PmEx.get(pm_id=order_db.cred.pmcur.pmex_exid, ex=self.agent_client.actor.ex)
             credex = await models.CredEx.get(cred=order_db.cred, ex=self.agent_client.actor.ex)
             self.agent_client.api.mark_as_paid(
                 orderId=str(order_db.exid),
@@ -385,20 +385,20 @@ class InAgentClient(BaseInAgentClient):
             exid__in=[ptl.id for ptl in order.paymentTermList],
             cred__person=self.agent_client.actor.person,
         ).prefetch_related("cred__pmcur__cur")
-        pmas = [pma for cdx in cdxs if (pma := self.pmacs.get(cdx.cred.pmcur.pm_id))]
+        pmas = [pma for cdx in cdxs if (pma := self.pmacs.get(cdx.cred.pmcur.pmex_exid))]
         if not len(pmas):
             # raise ValueError(order.paymentTermList, f"No pm_agents for {order.paymentTermList[0].paymentType}")
             return None
         elif len(pmas) > 1:
-            logging.error(order.paymentTermList, f">1 pm_agents for {cdxs[0].cred.pmcur.pm_id}")
+            logging.error(order.paymentTermList, f">1 pm_agents for {cdxs[0].cred.pmcur.pmex_exid}")
         else:
             return pmas[0], cdxs[0]
 
     async def get_pma_by_pmex(self, order_db: models.Order) -> tuple[PmAgentClient, str]:
-        pma = self.pmacs.get(order_db.cred.pmcur.pm_id)
+        pma = self.pmacs.get(order_db.cred.pmcur.pmex_exid)
         if pma:
             return pma, order_db.cred.pmcur.cur.ticker
-        logging.error(f"No pm_agents for {order_db.cred.pmcur.pm_id}")
+        logging.error(f"No pm_agents for {order_db.cred.pmcur.pmex_exid}")
 
     @staticmethod
     def listen(data: dict | None):

{xync_client-0.0.148 → xync_client-0.0.151}/xync_client/Bybit/agent.py

@@ -5,6 +5,7 @@ from asyncio import sleep, gather
 from datetime import datetime, timedelta, timezone
 from difflib import SequenceMatcher
 from enum import IntEnum
+from hashlib import sha256
 from http.client import HTTPException
 from math import floor
 from typing import Literal
@@ -21,6 +22,7 @@ from tortoise.expressions import Q
 from tortoise.functions import Count
 from tortoise.signals import post_save
 from urllib3.exceptions import ReadTimeoutError
+from x_client import df_hdrs
 from x_model import init_db
 from x_model.func import ArrayAgg
 from xync_bot import XyncBot
@@ -53,8 +55,9 @@ class NoMakerException(Exception):
 
 
 class AgentClient(BaseAgentClient):  # Bybit client
-    host = "api2.bybit.com"
-    headers = {"cookie": ";"}  # rewrite token for public methods
+    headers = df_hdrs | {"accept-language": "ru-RU"}
+    sec_hdrs: dict[str, str]
+    # rewrite token for public methods
     api: P2P
     last_ad_id: list[str] = []
     update_ad_body = {
@@ -87,6 +90,11 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
     def __init__(self, agent: Agent, fbot: FileClient, bbot: XyncBot, **kwargs):
         super().__init__(agent, fbot, bbot, **kwargs)
+        self.sec_hdrs = {
+            "accept-language": "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7",
+            "gdfp": agent.auth["Risktoken"],
+            "tx-id": agent.auth["Risktoken"],
+        }
         self.api = P2P(testnet=False, api_key=agent.auth["key"], api_secret=agent.auth["sec"])
         self.hist: dict | None = None
         self.completed_orders: list[int] | None = None
@@ -95,13 +103,13 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
     async def fiat_new(self, payment_type: int, real_name: str, account_number: str) -> FlatDict | None:
         method1 = await self._post(
-            "/fiat/otc/user/payment/new_create",
+            "/x-api/fiat/otc/user/payment/new_create",
             {"paymentType": payment_type, "realName": real_name, "accountNo": account_number, "securityRiskToken": ""},
         )
         if srt := method1["result"]["securityRiskToken"]:
             await self._check_2fa(srt)
             method2 = await self._post(
-                "/fiat/otc/user/payment/new_create",
+                "/x-api/fiat/otc/user/payment/new_create",
                 {
                     "paymentType": payment_type,
                     "realName": real_name,
@@ -140,8 +148,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 pmex.pm.df_cur_id
                 or (pmex.pm.country_id and (await pmex.pm.country).cur_id)
                 # or (ecdx.currencyBalance and await models.Cur.get_or_none(ticker=ecdx.currencyBalance[0]))
-                or (0 < len(pmex.pm.curs) < 30 and pmex.pm.curs[-1].id)
-                or await self.guess_cur(ecdx)
+                or await self.guess_cur(ecdx, len(pmex.pm.curs) > 1 and pmex.pm.curs)
             )
         if not cur_id:
             raise Exception(f"Set default cur for {pmex.name}")
@@ -160,7 +167,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
         credex_db, _ = await models.CredEx.update_or_create(**credex_in.df_unq())
         return credex_db
 
-    async def guess_cur(self, ecdx: CredEpyd):
+    async def guess_cur(self, ecdx: CredEpyd, curs: list[models.Cur]):
         mbs = ecdx.bankName.split(", ")
         mbs += ecdx.branchName.split(" / ")
         mbs = {mb.lower(): mb for mb in mbs}
@@ -172,7 +179,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
             .values("pmcurs__cur_id", "names", "ccnt")
         ):
             return pms[0]["pmcurs__cur_id"]
-        curs = {c.ticker: c.id for c in await models.Cur.all()}
+        curs = {c.ticker: c.id for c in curs or await models.Cur.all()}
         for cur, cid in curs.items():
             if re.search(re.compile(rf"\({cur}\)$"), ecdx.bankName):
                 return cid
@@ -182,6 +189,8 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 return cid
             if re.search(re.compile(rf"\({cur}\)$"), ecdx.payMessage):
                 return cid
+            if re.search(re.compile(rf"\({cur}\)$"), ecdx.paymentExt1):
+                return cid
         return None
 
     # 25: Список реквизитов моих платежных методов
@@ -199,7 +208,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
         fiat = self.get_payment_method(fiat_id)
         fiat.realName = name
         fiat.accountNo = detail
-        result = await self._post("/fiat/otc/user/payment/new_update", fiat.model_dump(exclude_none=True))
+        result = await self._post("/x-api/fiat/otc/user/payment/new_update", fiat.model_dump(exclude_none=True))
         srt = result["result"]["securityRiskToken"]
         await self._check_2fa(srt)
         fiat.securityRiskToken = srt
@@ -209,16 +218,16 @@ class AgentClient(BaseAgentClient):  # Bybit client
     # 28
     async def fiat_del(self, fiat_id: int) -> dict | str:
         data = {"id": fiat_id, "securityRiskToken": ""}
-        method = await self._post("/fiat/otc/user/payment/new_delete", data)
+        method = await self._post("/x-api/fiat/otc/user/payment/new_delete", data)
         srt = method["result"]["securityRiskToken"]
         await self._check_2fa(srt)
         data["securityRiskToken"] = srt
-        delete = await self._post("/fiat/otc/user/payment/new_delete", data)
+        delete = await self._post("/x-api/fiat/otc/user/payment/new_delete", data)
         return delete
 
     async def switch_ads(self, new_status: AdStatus) -> dict:
         data = {"workStatus": new_status.name}  # todo: переделать на апи, там status 0 -> 1
-        res = await self._post("/fiat/otc/maker/work-config/switch", data)
+        res = await self._post("/x-api/fiat/otc/maker/work-config/switch", data)
         return res
 
     async def ads(
@@ -256,49 +265,54 @@ class AgentClient(BaseAgentClient):  # Bybit client
         return len(res)
 
     def get_security_token_create(self):
-        data = self._post("/fiat/otc/item/create", self.create_ad_body)
+        data = self._post("/x-api/fiat/otc/item/create", self.create_ad_body)
         if data["ret_code"] == 912120019:  # Current user can not to create add as maker
             raise NoMakerException(data)
         security_risk_token = data["result"]["securityRiskToken"]
         return security_risk_token
 
     async def _check_2fa(self, risk_token) -> int:
-        cres = await self._post("/user/public/risk/components", {"risk_token": risk_token})
-        if cres["ret_msg"] != "success":
-            raise HTTPException("get")
-        cres = cres["result"]["component_list"]
-        res = await self._post(
-            "/user/public/risk/verify",
-            {
-                "risk_token": risk_token,
-                "component_list": {c["component_id"]: self.__get_2fa(c["component_id"]) for c in cres},
-            },
-        )
+        data = {"risk_token": risk_token}
+        res = await self._post("/x-api/user/public/risk/components", data, hdrs=self.sec_hdrs)
         if res["ret_msg"] != "success":
+            raise HTTPException("get")
+        cres = sorted(res["result"]["component_list"], key=lambda c: c["component_id"], reverse=True)
+        vdata = {
+            "risk_token": risk_token,
+            "component_list": {c["component_id"]: await self.__get_2fa(c["component_id"], risk_token) for c in cres},
+        }
+        res = await self._post("/x-api/user/public/risk/verify", vdata, hdrs=self.sec_hdrs)
+        if er_code := res["ret_code"] or res["result"]["ret_code"]:  # если код не 0, значит ошибка
             logging.error("Wrong 2fa, wait 5 secs and retry..")
             await sleep(5)
-            await self._check_2fa(risk_token)
-        return res["ret_code"]
-
-    async def __get_2fa(self, typ: Literal["google2fa", "email_verify", "payment_password_verify"], rt: str = None):
-        if typ == "google2fa":
-            bybit_secret = self.agent.auth["2fa"]
-            totp = pyotp.TOTP(bybit_secret)
-            return totp.now()
-        elif typ == "email_verify":
-            res = await self._post("/user/public/risk/send/code", {"risk_token": rt, "component_id": "email_verify"})
-            if res["ret_msg"] != "success":
-                return self.gmail.bybit_code()
-            elif cool_down := int(res["result"]["cool_down"]):
-                await sleep(cool_down)
+            return await self._check_2fa(risk_token)
+        return er_code
+
+    async def __get_2fa(
+        self, typ: Literal["google2fa", "email_verify", "payment_password_verify", "phone_verify"], rt: str = None
+    ):
+        res = {"ret_msg": "success"}
+        if typ != "google2fa":
+            data = {"risk_token": rt, "component_id": typ}
+            res = await self._post("/x-api/user/public/risk/send/code", data, hdrs=self.sec_hdrs)
+        if res["ret_msg"] == "success":
+            if typ == "google2fa":
+                bybit_secret = self.agent.auth["2fa"]
+                totp = pyotp.TOTP(bybit_secret)
+                return totp.now()
+            elif typ == "email_verify":
                 return self.gmail.bybit_code()
-        elif typ == "payment_password_verify":
-            return self.agent.auth["pass"]
+            elif typ == "payment_password_verify":
+                hp = sha256(self.agent.auth["pass"].encode()).hexdigest()
+                return hp
+        elif cool_down := int(res["result"]["cool_down"]):
+            await sleep(cool_down)
+            return self.__get_2fa(typ, rt)
         raise Exception("2fa fail")
 
     def _post_ad(self, risk_token: str):
         self.create_ad_body.update({"securityRiskToken": risk_token})
-        data = self._post("/fiat/otc/item/create", self.create_ad_body)
+        data = self._post("/x-api/fiat/otc/item/create", self.create_ad_body)
         return data
 
     # создание объявлений
@@ -324,7 +338,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
     def get_security_token_update(self) -> str:
         self.update_ad_body["id"] = self.last_ad_id
-        data = self._post("/fiat/otc/item/update", self.update_ad_body)
+        data = self._post("/x-api/fiat/otc/item/update", self.update_ad_body)
         security_risk_token = data["result"]["securityRiskToken"]
         return security_risk_token
 
@@ -341,7 +355,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
     def update_ad(self, risk_token: str):
         self.update_ad_body.update({"securityRiskToken": risk_token})
-        data = self._post("/fiat/otc/item/update", self.update_ad_body)
+        data = self._post("/x-api/fiat/otc/item/update", self.update_ad_body)
         return data
 
     def ad_del(self, ad_id: int):
@@ -349,45 +363,43 @@ class AgentClient(BaseAgentClient):  # Bybit client
         return data
 
     async def __preorder_request(self, ad_id: int) -> PreOrderResp:
-        res = await self._post("/fiat/otc/item/simple", data={"item_id": str(ad_id)})
+        res = await self._post("/x-api/fiat/otc/item/simple", json={"item_id": str(ad_id)})
         if res["ret_code"] == 0:
             res = res["result"]
         return PreOrderResp.model_validate(res)
 
-    async def __order_request_build(self, por: PreOrderResp, br: BaseOrderReq) -> OrderRequest:
+    async def _order_request(self, bor: BaseOrderReq) -> OrderResp:
+        por: PreOrderResp = await self.__preorder_request(bor.ad_id)
         req = OrderRequest(
             itemId=por.id,
-            tokenId=br.coin_exid,
-            currencyId=br.cur_exid,
-            side="1" if br.is_sell else "0",
-            amount=str(br.fiat_amount),
+            tokenId=bor.coin_exid,
+            currencyId=bor.cur_exid,
+            side="1" if bor.is_sell else "0",
+            amount=f"{bor.fiat_amount:.2f}".rstrip("0").rstrip("."),
             curPrice=por.curPrice,
-            quantity=str(round(br.fiat_amount / float(por.price), br.coin_scale)),
+            quantity=str(round(bor.fiat_amount / float(por.price), bor.coin_scale)),
             flag="amount",
-            # paymentType="51",
-            # paymentId="20399134",
             # online="0"
         )
-        if br.is_sell:
+        if bor.is_sell:
             credex = await models.CredEx.get(
                 cred__person_id=self.actor.person_id,
-                pmcur__pm__pmexs__exid=por.payments[0],
-                pmcur__pm__pmexs__ex_id=self.ex_client.ex.id,
-                pmcur__cur_id=br.cur_exid,
+                cred__pmcur__pm__pmexs__exid=[pp for pp in por.payments if pp == bor.pmex_exid][0],  # bor.pmex_exid
+                cred__pmcur__pm__pmexs__ex_id=self.ex_client.ex.id,
+                cred__pmcur__cur__ticker=bor.cur_exid,
             )
-            req = OrderSellRequest(**req.model_dump(), paymentType=por.payments[0], paymentId=str(credex.exid))
-        return req
-
-    async def _order_request(self, bor: BaseOrderReq) -> OrderResp:
-        por: PreOrderResp = await self.__preorder_request(bor.ad_id)
-        req: OrderRequest | OrderSellRequest = await self.__order_request_build(por, bor)
+            req = OrderSellRequest(**req.model_dump(), paymentType=bor.pmex_exid, paymentId=str(credex.exid))
         # вот непосредственно сам запрос на ордер
         return await self.__order_create(req, bor)
 
     async def __order_create(self, req: OrderRequest | OrderSellRequest, bor: BaseOrderReq) -> OrderResp:
-        res: dict = await self._post("/fiat/otc/order/create", data=req.model_dump())
+        hdrs = {"Risktoken": self.sec_hdrs["gdfp"]}
+        res: dict = await self._post("/x-api/fiat/otc/order/create", json=req.model_dump(), hdrs=hdrs)
         if res["ret_code"] == 0:
             resp = OrderResp.model_validate(res["result"])
+        elif res["ret_code"] == 10001:
+            logging.error(req.model_dump(), "POST", self.session._base_url)
+            raise HTTPException()
         elif res["ret_code"] == 912120030 or res["ret_msg"] == "The price has changed, please try again later.":
             resp = await self._order_request(bor)
         if not resp.orderId and resp.needSecurityRisk:
@@ -401,15 +413,15 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
     async def cancel_order(self, order_id: str) -> bool:
         cr = CancelOrderReq(orderId=order_id)
-        res = await self._post("/fiat/otc/order/cancel", cr.model_dump())
+        res = await self._post("/x-api/fiat/otc/order/cancel", cr.model_dump())
         return res["ret_code"] == 0
 
     def get_order_info(self, order_id: str) -> dict:
-        data = self._post("/fiat/otc/order/info", json={"orderId": order_id})
+        data = self._post("/x-api/fiat/otc/order/info", json={"orderId": order_id})
         return data["result"]
 
     def get_chat_msg(self, order_id):
-        data = self._post("/fiat/otc/order/message/listpage", json={"orderId": order_id, "size": 100})
+        data = self._post("/x-api/fiat/otc/order/message/listpage", json={"orderId": order_id, "size": 100})
         msgs = [
             {"text": msg["message"], "type": msg["contentType"], "role": msg["roleType"], "user_id": msg["userId"]}
             for msg in data["result"]["result"]
@@ -418,14 +430,14 @@ class AgentClient(BaseAgentClient):  # Bybit client
         return msgs
 
     def block_user(self, user_id: str):
-        return self._post("/fiat/p2p/user/add_block_user", {"blockedUserId": user_id})
+        return self._post("/x-api/fiat/p2p/user/add_block_user", {"blockedUserId": user_id})
 
     def unblock_user(self, user_id: str):
-        return self._post("/fiat/p2p/user/delete_block_user", {"blockedUserId": user_id})
+        return self._post("/x-api/fiat/p2p/user/delete_block_user", {"blockedUserId": user_id})
 
     def user_review_post(self, order_id: str):
         return self._post(
-            "/fiat/otc/order/appraise/modify",
+            "/x-api/fiat/otc/order/appraise/modify",
             {
                 "orderId": order_id,
                 "anonymous": "0",
@@ -445,7 +457,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
         self, side: int = None, status: int = None, begin_time: int = None, end_time: int = None, token_id: str = None
     ):
         return await self._post(
-            "/fiat/otc/order/pending/simplifyList",
+            "/x-api/fiat/otc/order/pending/simplifyList",
             {
                 "status": status,
                 "tokenId": token_id,
@@ -459,7 +471,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
     def get_orders_done(self, begin_time: int, end_time: int, status: int, side: int, token_id: str):
         return self._post(
-            "/fiat/otc/order/simplifyList",
+            "/x-api/fiat/otc/order/simplifyList",
             {
                 "status": status,  # 50 - завершено
                 "tokenId": token_id,
@@ -945,15 +957,33 @@ class AgentClient(BaseAgentClient):  # Bybit client
         return (bc, sc), hp, vmf, zplace
 
     async def take_ad(self, req: TakeAdReq):
-        ad: Ad = Ad.model_validate(self.api.get_ad_details(itemId=req.ad_id))
+        if req.price and req.is_sell and req.cur_:
+            ...  # todo call the get_ad_details() only if lack of data
+        res = self.api.get_ad_details(itemId=req.ad_id)["result"]
+        ad: Ad = Ad.model_validate(res)
+        pmexs = await models.PmEx.filter(ex_id=self.actor.ex_id, pm_id=req.pm_id)
+        if len(pmexs) > 1:
+            pmexs = [p for p in pmexs if p.exid in ad.payments]
+        # if ad.side: # продажа, я (тейкер) покупатель
+        #     pmexs = await models.PmEx.filter(ex_id=self.actor.ex_id, pm_id=req.pm_id)
+        #     if len(pmexs) > 1:
+        #         pmexs = [p for p in pmexs if p.name.endswith(f" ({ad.currencyId})")]
+        # else:
+        #     pmexs = await models.CredEx.filter(
+        #         ex_id=self.actor.ex_id, cred__person_id=self.actor.person_id,
+        #         cred__pmcur__pm_id=req.pm_id, cred__pmcur__cur__ticker=ad.currencyId
+        #    )
+        # req.pm_id = pmexs[0].exid
+        # req.quantity = round(req.amount / float(ad.price) - 0.00005, 4)  # todo: to get the scale from coinEx
+
         bor = BaseOrderReq(
             ad_id=str(ad.id),
             fiat_amount=req.amount,
-            is_sell=bool(ad.side),
+            is_sell=not bool(ad.side),
             cur_exid=ad.currencyId,
             coin_exid=ad.tokenId,
-            coin_scale=ad.token.scale,
-            pm_id=req.pm_id,
+            coin_scale=ad.symbolInfo.token.scale,
+            pmex_exid=pmexs[0].exid,
         )
         resp: OrderResp = await self._order_request(bor)
         return resp
@@ -1085,14 +1115,22 @@ async def main():
             ...
 
     agent = (
-        await models.Agent.filter(actor__ex_id=4, auth__isnull=False, active=True)
-        .prefetch_related("actor__ex", "actor__person__user__gmail")
+        await models.Agent.filter(actor__ex_id=4, auth__isnull=False, active=True, actor__person__user__id=2)
+        .prefetch_related(
+            "actor__ex",
+            "actor__person__user__gmail",
+            "actor__my_ads__my_ad__race",
+            "actor__my_ads__pair_side__pair__cur",
+            "actor__my_ads__pms",
+        )
         .first()
     )
     filebot = FileClient(NET_TOKEN)
-    await filebot.start()
+    # await filebot.start()
     # b.add_handler(MessageHandler(cond_start_handler, command("cond")))
     cl: AgentClient = agent.client(filebot, XyncBot(PAY_TOKEN, cn))
+    req = TakeAdReq(ad_id=1955696985964089344, amount=504, pm_id=128)
+    await cl.take_ad(req)
 
     # await cl.ex_client.set_pairs()
     # await cl.ex_client.set_pms()

{xync_client-0.0.148 → xync_client-0.0.151}/xync_client/Bybit/etype/order.py

@@ -47,7 +47,11 @@ class StatusApi(IntEnum):
 class TakeAdReq(BaseModel):
     ad_id: int | str
     amount: float
-    pm_id: int = None
+    quantity: float | None = None
+    is_sell: bool | None = None
+    price: float | None = None
+    pm_id: int | str = None
+    cur_: str | None = None
 
 
 class OrderRequest(BaseModel):
@@ -82,7 +86,7 @@ class PreOrderResp(BaseModel):
     isOnline: bool
     lastLogoutTime: str  # timestamp(0)+0
     payments: list[str]  # list[int]
-    status: Literal[10, 20]
+    status: Literal[10, 15, 20]
     paymentTerms: list  # empty
     paymentPeriod: Literal[15, 30, 60]
     totalAmount: str  # float .cur.scale
@@ -102,8 +106,8 @@ class OrderResp(BaseModel):
     confirmId: str = ""
     success: bool
     securityRiskToken: str = ""
-    riskTokenType: Literal["challenge"] = None
-    riskVersion: Literal["1", "2"] = None
+    riskTokenType: Literal["challenge", ""] = ""
+    riskVersion: Literal["1", "2", ""] = ""
     needSecurityRisk: bool
     isBulkOrder: bool
     confirmed: str = None

{xync_client-0.0.148 → xync_client-0.0.151}/xync_client/Htx/agent.py

@@ -46,7 +46,7 @@ class AgentClient(BaseAgentClient):
 
     async def cred_new(self, cred: models.Cred) -> models.CredEx:
         pmcur = await cred.pmcur
-        exid = str(await models.PmEx.get(pm_id=pmcur.pm_id, ex=self.ex_client.ex).values_list("exid", flat=True))
+        exid = str(await models.PmEx.get(pm_id=pmcur.pmex_exid, ex=self.ex_client.ex).values_list("exid", flat=True))
         field_map = {
             "payee": "name",
             "bank": "extra",
@@ -71,7 +71,7 @@ class AgentClient(BaseAgentClient):
 
     async def cred_upd(self, cred: models.Cred, exid: int) -> models.CredEx:
         pmcur = await cred.pmcur
-        _exid = str(await models.PmEx.get(pm_id=pmcur.pm_id, ex=self.ex_client.ex).values_list("exid", flat=True))
+        _exid = str(await models.PmEx.get(pm_id=pmcur.pmex_exid, ex=self.ex_client.ex).values_list("exid", flat=True))
         field_map = {
             "payee": "name",
             "bank": "extra",

xync_client-0.0.151/xync_client/Mexc/agent.py

@@ -0,0 +1,85 @@
+from asyncio import run
+from hashlib import md5
+from uuid import uuid4
+
+from pyro_client.client.file import FileClient
+from xync_bot import XyncBot
+from xync_client.Bybit.etype.order import TakeAdReq
+
+from xync_client.loader import PAY_TOKEN, NET_TOKEN
+from xync_schema import models
+from xync_schema.enums import UserStatus
+
+from xync_client.Abc.Agent import BaseAgentClient
+
+
+class AgentClient(BaseAgentClient):
+    i: int = 0
+    headers = {
+        "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/125.0.0.0 Safari/537.36",
+    }
+
+    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/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/order/deal?mhash=" + auth["mhash"], data=auth | data, hdrs=hdrs)
+        return res["data"]
+
+
+async def main():
+    from x_model import init_db
+    from xync_client.loader import TORM
+
+    cn = await init_db(TORM, True)
+
+    agent = (
+        await models.Agent.filter(
+            actor__ex_id=12,
+            active=True,
+            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)
+
+    cl = agent.client(fbot, bbot)
+    req = TakeAdReq(ad_id="a1574088909645125632", amount=500, pm_id=366, cur_="RUB", price=85.8, is_sell=True)
+    res = await cl.take_ad(req)
+    print(res)
+
+
+if __name__ == "__main__":
+    run(main())

{xync_client-0.0.148 → xync_client-0.0.151}/xync_client/Pms/Volet/__init__.py

@@ -273,7 +273,7 @@ async def _test():
         pma = await models.PmAgent.get(
             active=True,
             auth__isnull=False,
-            pm_id=o.cred.pmcur.pm_id,
+            pm_id=o.cred.pmcur.pmex_exid,
             user__person__actors=o.ad.maker_id,
             user__status=UserStatus.ACTIVE,
         ).prefetch_related("pm", "user__gmail", "user__username__session")

{xync_client-0.0.148 → xync_client-0.0.151/xync_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.148
+Version: 0.0.151
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client

{xync_client-0.0.148 → xync_client-0.0.151}/xync_client.egg-info/SOURCES.txt

@@ -86,6 +86,7 @@ xync_client/KuCoin/ex.py
 xync_client/KuCoin/web.py
 xync_client/KuCoin/etype/ad.py
 xync_client/KuCoin/etype/pm.py
+xync_client/Mexc/agent.py
 xync_client/Mexc/ex.py
 xync_client/Mexc/etype/ad.py
 xync_client/Mexc/etype/pm.py