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

xync_client/Bybit/agent.py

@@ -2,34 +2,44 @@ import asyncio
 import logging
 import re
 from asyncio import sleep, gather
-from collections import defaultdict
+from asyncio.tasks import create_task
 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
 
 import pyotp
+from aiohttp.http_exceptions import HttpProcessingError
 from asyncpg import ConnectionDoesNotExistError
 from bybit_p2p import P2P
 from bybit_p2p._exceptions import FailedRequestError
+from payeer_api import PayeerAPI
 from pyro_client.client.file import FileClient
 from tortoise import BaseDBAsyncClient
 from tortoise.exceptions import IntegrityError
-from tortoise.expressions import F, Q
+from tortoise.expressions import Q
 from tortoise.functions import Count
 from tortoise.signals import post_save
+from tortoise.timezone import now
 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
+from xync_client.Bybit.InAgent import InAgentClient
+
+from xync_client.Bybit.ex import ExClient
 from xync_schema import models
-from xync_schema.enums import OrderStatus
+from xync_schema.enums import OrderStatus, AgentStatus
 
-from xync_schema.models import Actor, Cond, CondSim, PmCur, PairSide
+from xync_schema.models import Actor, PmCur, Agent
 
 from xync_client.Abc.Agent import BaseAgentClient
-from xync_client.Abc.xtype import BaseOrderReq, FlatDict
-from xync_client.Bybit.etype.ad import AdPostRequest, AdUpdateRequest, Ad, AdStatus
+from xync_client.Abc.xtype import FlatDict, BaseOrderReq
+from xync_client.Bybit.etype.ad import AdPostRequest, AdUpdateRequest, Ad, AdStatus, MyAd
 from xync_client.Bybit.etype.cred import CredEpyd
 from xync_client.Bybit.etype.order import (
     OrderRequest,
@@ -40,17 +50,20 @@ from xync_client.Bybit.etype.order import (
     OrderFull,
     Message,
     Status,
+    OrderSellRequest,
+    TakeAdReq,
 )
-from xync_client.loader import TORM, TOKEN
+from xync_client.loader import TORM, NET_TOKEN, PAY_TOKEN
 
 
 class NoMakerException(Exception):
     pass
 
 
-class AgentClient(BaseAgentClient):  # Bybit client
-    host = "api2.bybit.com"
-    headers = {"cookie": ";"}  # rewrite token for public methods
+class AgentClient(BaseAgentClient, InAgentClient):  # Bybit client
+    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 = {
@@ -80,26 +93,29 @@ class AgentClient(BaseAgentClient):  # Bybit client
         "actionType": "MODIFY",
         "securityRiskToken": "",
     }
-    all_conds: dict[int, tuple[str, set[int]]] = {}
-    cond_sims: dict[int, int] = defaultdict(set)
-    rcond_sims: dict[int, set[int]] = defaultdict(set)  # backward
-    tree: dict = {}
 
-    def __init__(self, actor: Actor, bot: FileClient, **kwargs):
-        super().__init__(actor, bot, **kwargs)
-        self.api = P2P(testnet=False, api_key=actor.agent.auth["key"], api_secret=actor.agent.auth["sec"])
+    def __init__(self, agent: Agent, ex_client: ExClient, fbot: FileClient, bbot: XyncBot, **kwargs):
+        super().__init__(agent, ex_client, fbot, bbot, **kwargs)
+        self.sec_hdrs = {
+            "accept-language": "ru,en;q=0.9",
+            "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
 
     """ Private METHs"""
 
     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,
@@ -111,12 +127,8 @@ class AgentClient(BaseAgentClient):  # Bybit client
         else:
             return logging.exception(method1)
 
-    async def get_payment_method(self, fiat_id: int = None) -> dict:
-        list_methods = self.creds()
-        if fiat_id:
-            fiat = [m for m in list_methods if m["id"] == fiat_id][0]
-            return fiat
-        return list_methods[1]
+    def get_payment_method(self, fiat_id: int) -> CredEpyd:
+        return self.creds()[fiat_id]
 
     def creds(self) -> dict[int, CredEpyd]:
         data = self.api.get_user_payment_types()
@@ -140,29 +152,37 @@ class AgentClient(BaseAgentClient):  # Bybit client
         elif not cur_id:  # is new Cred
             cur_id = (
                 pmex.pm.df_cur_id
+                or await self.guess_cur(ecdx, len(pmex.pm.curs) > 1 and pmex.pm.curs)
                 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 (ecdx.currencyBalance and await models.Cur.get_or_none(ticker=ecdx.currencyBalance[0]))  # это че еще за хуйня?
             )
         if not cur_id:
             raise Exception(f"Set default cur for {pmex.name}")
         if not (pmcur := await models.PmCur.get_or_none(cur_id=cur_id, pm_id=pmex.pm_id)):
-            raise HTTPException(f"No PmCur with cur#{ecdx.currencyBalance} and pm#{ecdx.paymentType}", 404)
-        dct = {
-            "pmcur_id": pmcur.id,
-            "name": ecdx.realName,
-            "person_id": pers_id or self.actor.person_id,
-            "detail": ecdx.accountNo,
-            "extra": ecdx.branchName or ecdx.bankName or ecdx.qrcode or ecdx.payMessage or ecdx.paymentExt1,
-        }  # todo: WTD with multicur pms?
-        cred_in = models.Cred.validate(dct, False)
-        cred_db, _ = await models.Cred.update_or_create(**cred_in.df_unq())
+            raise HTTPException(f"No PmCur with cur#{cur_id} and pm#{ecdx.paymentType}", 404)
+        xtr = ecdx.branchName
+        if ecdx.bankName:
+            xtr += (" | " if xtr else "") + ecdx.bankName
+        elif ecdx.payMessage:
+            xtr += (" | " if xtr else "") + ecdx.payMessage
+        elif ecdx.qrcode:
+            xtr += (" | " if xtr else "") + ecdx.qrcode
+        elif ecdx.paymentExt1:
+            xtr += (" | " if xtr else "") + ecdx.paymentExt1
+        cred_db, _ = await models.Cred.update_or_create(
+            {
+                "name": ecdx.realName,
+                "extra": xtr,
+            },
+            pmcur=pmcur,
+            person_id=pers_id or self.actor.person_id,
+            detail=ecdx.accountNo or ecdx.payMessage,
+        )
         credex_in = models.CredEx.validate({"exid": ecdx.id, "cred_id": cred_db.id, "ex_id": self.actor.ex.id})
         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}
@@ -174,7 +194,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
@@ -184,6 +204,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: Список реквизитов моих платежных методов
@@ -193,34 +215,34 @@ class AgentClient(BaseAgentClient):  # Bybit client
         return credexs
 
     async def ott(self):
-        t = await self._post("/user/private/ott")
+        t = await self._post("/x-api/user/private/ott")
         return t
 
     # 27
     async def fiat_upd(self, fiat_id: int, detail: str, name: str = None) -> dict:
         fiat = self.get_payment_method(fiat_id)
-        fiat["realName"] = name
-        fiat["accountNo"] = detail
-        result = await self._post("/fiat/otc/user/payment/new_update", fiat)
+        fiat.realName = name
+        fiat.accountNo = detail
+        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
-        result2 = await self._post("/fiat/otc/user/payment/new_update", fiat)
+        fiat.securityRiskToken = srt
+        result2 = await self._post("/fiat/otc/user/payment/new_update", fiat.model_dump(exclude_none=True))
         return result2
 
     # 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(
@@ -228,27 +250,36 @@ class AgentClient(BaseAgentClient):  # Bybit client
         cnx: models.CoinEx,
         crx: models.CurEx,
         is_sell: bool,
-        pmxs: list[models.PmEx],
+        pmexs: list[models.PmEx],
         amount: int = None,
         lim: int = 50,
         vm_filter: bool = False,
+        post_pmexs: set[models.PmEx] = None,
     ) -> list[Ad]:
-        return await self.ex_client.ads(
-            cnx.exid, crx.exid, is_sell, [pmex.exid for pmex in pmxs or []], amount, lim, vm_filter
-        )
-
-    def online_ads(self) -> str:
-        online = self._get("/fiat/otc/maker/work-config/get")
-        return online["result"]["workStatus"]
+        if post_pmexs:
+            pm_exids = None
+            lim = min(1000, lim * 25)
+            post_pmexids = {p.exid for p in post_pmexs}
+        else:
+            pm_exids = [px.exid for px in pmexs]
+            post_pmexids = set()
+        ads: list[Ad] = await self.ex_client.ads(cnx.exid, crx.exid, is_sell, pm_exids, amount, lim, vm_filter)
+        if post_pmexs:
+            ads = [
+                ad
+                for ad in ads
+                if (set(ad.payments) & post_pmexids or [True for px in post_pmexs if px.pm.norm in ad.remark.lower()])
+            ]
+        return ads
 
     @staticmethod
     def get_rate(list_ads: list) -> float:
         ads = [ad for ad in list_ads if set(ad["payments"]) - {"5", "51"}]
         return float(ads[0]["price"])
 
-    def my_ads(self, active: bool = True, page: int = 1) -> list[Ad]:
+    def my_ads(self, active: bool = True, page: int = 1) -> list[MyAd]:
         resp = self.api.get_ads_list(size="30", page=str(page), status=AdStatus.active if active else AdStatus.sold_out)
-        ads = [Ad.model_validate(ad) for ad in resp["result"]["items"]]
+        ads = [MyAd.model_validate(ad) for ad in resp["result"]["items"]]
         if resp["result"]["count"] > 30 * page:
             ads.extend(self.my_ads(active, page + 1))
         return ads
@@ -257,35 +288,63 @@ class AgentClient(BaseAgentClient):  # Bybit client
         ads = self.my_ads(True)
         if not active:
             ads += self.my_ads(False)
-        res = [await self.ad_create(ad, actor=self.actor) for ad in ads]
-        res = [await models.MyAd.update_or_create(ad=ad) for ad in res]
-        return len(res)
+        for ad in ads:
+            ad_db = await self.ex_client.ad_load(ad, maker=self.actor)
+            mad_db, _ = await models.MyAd.update_or_create(ad=ad_db)
+            exids = [pt.id for pt in ad.paymentTerms]
+            credexs = await models.CredEx.filter(ex_id=self.actor.ex_id, exid__in=exids)
+            await mad_db.credexs.add(*credexs)
+        return len(ads)
 
     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
 
-    def _check_2fa(self, risk_token):
-        # 2fa code
-        bybit_secret = self.agent.auth["2fa"]
-        totp = pyotp.TOTP(bybit_secret)
-        totp_code = totp.now()
-
-        res = self._post(
-            "/user/public/risk/verify", {"risk_token": risk_token, "component_list": {"google2fa": totp_code}}
-        )
+    async def _check_2fa(self, risk_token) -> int:
+        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":
-            print("Wrong 2fa, wait 5 secs and retry..")
-            sleep(5)
-            self._check_2fa(risk_token)
-        return res
+            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)
+            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":
+                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
 
     # создание объявлений
@@ -311,7 +370,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
 
@@ -328,46 +387,75 @@ 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):
         data = self.api.remove_ad(itemId=ad_id)
         return data
 
-    async def order_request(self, br: BaseOrderReq) -> OrderResp:
-        res0 = await self._post("/fiat/otc/item/simple", data={"item_id": str(br.ad_id)})
-        if res0["ret_code"] == 0:
-            res0 = res0["result"]
-        res0 = PreOrderResp.model_validate(res0)
+    async def __preorder_request(self, ad_id: int) -> PreOrderResp:
+        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(self, bor: BaseOrderReq) -> OrderResp:
+        por: PreOrderResp = await self.__preorder_request(bor.ad_id)
         req = OrderRequest(
-            itemId=br.ad_id,
-            tokenId=br.coin_exid,
-            currencyId=br.cur_exid,
-            side=str(OrderRequest.Side(int(br.is_sell))),
-            amount=str(br.fiat_amount or br.asset_amount * float(res0.price)),
-            curPrice=res0.curPrice,
-            quantity=str(br.asset_amount or round(br.fiat_amount / float(res0.price), br.coin_scale)),
-            flag="amount" if br.amount_is_fiat else "quantity",
+            itemId=por.id,
+            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(bor.fiat_amount / float(por.price), bor.coin_scale)),
+            flag="amount",
+            # online="0"
         )
+        if bor.is_sell:
+            credex = await models.CredEx.get(
+                cred__person_id=self.actor.person_id,
+                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=bor.pmex_exid, paymentId=str(credex.exid))
         # вот непосредственно сам запрос на ордер
-        res = await self._post("/fiat/otc/order/create", data=req.model_dump())
+        return await self.__order_create(req, bor)
+
+    async def __order_create(self, req: OrderRequest | OrderSellRequest, bor: BaseOrderReq) -> OrderResp:
+        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:
-            return OrderResp.model_validate(res["result"])
+            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.":
-            return await self.order_request(br)
+            resp = await self._order_request(bor)
+        else:
+            logging.exception(res)
+        if not resp.orderId and resp.needSecurityRisk:
+            if rc := await self._check_2fa(resp.securityRiskToken):
+                await self.bbot.send(self.actor.person.user.username_id, f"Bybit 2fa: {rc}")
+                raise Exception(f"Bybit 2fa: {rc}")
+            # еще раз уже с токеном
+            req.securityRiskToken = resp.securityRiskToken
+            resp = await self.__order_create(req, bor)
+        return resp
 
     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})
-        return data["result"]
+    async def get_order_info(self, order_id: str) -> OrderFull:
+        data = await self._post("/x-api/fiat/otc/order/info", json={"orderId": order_id})
+        return OrderFull.model_validate(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"]
@@ -376,14 +464,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",
@@ -393,9 +481,17 @@ class AgentClient(BaseAgentClient):  # Bybit client
             },
         )
 
-    def get_orders_active(self, begin_time: int, end_time: int, status: int, side: int, token_id: str):
+    def my_reviews(self):
         return self._post(
-            "/fiat/otc/order/pending/simplifyList",
+            "/x-api/fiat/otc/order/appraiseList",
+            {"makerUserId": self.actor.exid, "page": "1", "size": "10", "appraiseType": "1"},  # "0" - bad
+        )
+
+    async def get_orders_active(
+        self, side: int = None, status: int = None, begin_time: int = None, end_time: int = None, token_id: str = None
+    ):
+        return await self._post(
+            "/x-api/fiat/otc/order/pending/simplifyList",
             {
                 "status": status,
                 "tokenId": token_id,
@@ -409,7 +505,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,
@@ -422,27 +518,49 @@ class AgentClient(BaseAgentClient):  # Bybit client
         )
 
     async def create_order(self, order: OrderFull) -> models.Order:
-        ad = Ad(**self.api.get_ad_details(itemId=order.itemId)["result"])
+        # ad = Ad(**self.api.get_ad_details(itemId=order.itemId)["result"])
         await sleep(1)
         curex = await models.CurEx.get_or_none(ex=self.ex_client.ex, exid=order.currencyId).prefetch_related("cur")
         cur_scale = (curex.scale if curex.scale is not None else curex.cur.scale) if curex else 2
         coinex = await models.CoinEx.get(ex=self.ex_client.ex, exid=order.tokenId).prefetch_related("coin")
         coin_scale = coinex.scale if coinex.scale is not None else coinex.cur.scale
-        maker_name = order.buyerRealName, order.sellerRealName
+        maker_name = order.sellerRealName, order.buyerRealName
         im_maker = int(order.makerUserId == order.userId)
         taker_id = (order.userId, order.targetUserId)[im_maker]
-        taker_person = await self.person_upsert(maker_name[::-1][ad.side], taker_id)
+        taker_person = await self.ex_client.person_name_update(maker_name[::-1][order.side], taker_id)
         seller_person = (
-            self.actor.person if order.side else await self.person_upsert(order.sellerRealName, int(order.targetUserId))
+            self.actor.person
+            if order.side
+            else await self.ex_client.person_name_update(order.sellerRealName, int(order.targetUserId))
         )
         taker_nick = (self.actor.name, order.targetNickName)[im_maker]  # todo: check
-        ad_db, cond_isnew = await self.cond_upsert(ad, maker_name[ad.side], force=True)
+        # ad_db, cond_isnew = await self.ex_client.cond_load(ad, force=True, rname=maker_name[order.side])
+        ad_db = await models.Ad.get(exid=order.itemId)
         if not ad_db:
             ...
         ecredex: CredEpyd = order.confirmedPayTerm
+
         if ecredex.paymentType == 0 and im_maker and order.side:
             ecredex = order.paymentTermList[0]
         if ecredex.paymentType:
+            if ecredex.paymentType == 51:
+                ecredex.accountNo = ecredex.accountNo.replace("p", "P").replace("р", "P").replace("Р", "P")
+                # if not re.match(r"^([Pp])\d{7,10}$", ecredex.accountNo):
+                #     msgs = self.api.get_chat_messages(orderId=order.id, size=100)["result"]["result"]
+                #     msgs = [m["message"] for m in msgs if m["roleType"] == "user" and m["userId"] == order.targetUserId]
+                #     msgs = [g.group() for m in msgs if (g := re.match(r"([PpРр])\d{7,10}\b", m))]
+                #     crd = await models.Cred.get_or_none(
+                #         detail=ecredex.accountNo, credexs__exid=ecredex.id, credexs__ex=self.ex_client.ex
+                #     )
+                #     if not msgs and re.match(r"^\d{7,10}$", ecredex.accountNo):
+                #         ecredex.accountNo = "P" + ecredex.accountNo
+                #     elif msgs:
+                #         ecredex.accountNo = msgs[-1]
+                #     else:
+                #         ...
+                #     if crd:
+                #         crd.detail = ecredex.accountNo
+                #         await crd.save(update_fields=["detail"])
             if not (credex := await models.CredEx.get_or_none(exid=ecredex.id, ex=self.ex_client.ex)):
                 # cur_id = await Cur.get(ticker=ad.currencyId).values_list('id', flat=True)
                 # await self.cred_epyd2db(ecredex, ad_db.maker.person_id, cur_id)
@@ -450,7 +568,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
                     await PmCur.filter(
                         pm__pmexs__ex=self.ex_client.ex,
                         pm__pmexs__exid=ecredex.paymentType,
-                        cur__ticker=ad.currencyId,
+                        cur__ticker=order.currencyId,
                     ).count()
                     != 1
                 ):
@@ -459,7 +577,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
                     pmcur := await PmCur.get_or_none(
                         pm__pmexs__ex=self.ex_client.ex,
                         pm__pmexs__exid=ecredex.paymentType,
-                        cur__ticker=ad.currencyId,
+                        cur__ticker=order.currencyId,
                     )
                 ):
                     ...
@@ -496,16 +614,55 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 "amount": float(order.amount) * 10**cur_scale,
                 "quantity": float(order.quantity) * 10**coin_scale,
                 "status": OrderStatus[Status(order.status).name],
-                "created_at": int(order.createDate[:-3]),
-                "payed_at": order.transferDate != "0" and int(order.transferDate[:-3]) or None,
-                "confirmed_at": Status(order.status) == Status.completed and int(order.updateDate[:-3]) or None,
-                "appealed_at": order.status == 30 and int(order.updateDate[:-3]) or None,
+                "created_at": ms2utc(order.createDate),
+                "payed_at": order.transferDate != "0" and ms2utc(order.transferDate) or None,
+                "confirmed_at": Status(order.status) == Status.completed and ms2utc(order.transferDate) or None,
+                "appealed_at": order.status == 30 and ms2utc(order.transferDate) or None,
                 "cred_id": ecredex.paymentType and credex.cred_id or None,
                 "taker": taker,
                 "ad": ad_db,
             },
             exid=order.id,
         )
+        if order.status == Status.completed and ecredex.paymentType == 51:
+            await odb.fetch_related("cred", "transfer")
+            if odb.cred.detail != ecredex.accountNo:
+                ...
+            frm = (odb.created_at + timedelta(minutes=180 - 1)).isoformat(sep=" ").split("+")[0]
+            to = ((odb.payed_at or odb.created_at) + timedelta(minutes=180 + 30)).isoformat(sep=" ").split("+")[0]
+            tsa = [
+                t
+                for tid, t in (self.hist.items() if self.hist else [])
+                if (ecredex.accountNo == t["to"] and t["from"] != "@merchant" and frm < t["date"] < to)
+            ]
+            buyer_person = (
+                self.actor.person
+                if not order.side
+                else await self.ex_client.person_name_update(order.buyerRealName, int(order.targetUserId))
+            )
+            ts = [t for t in tsa if floor(fa := float(order.amount)) <= float(t["creditedAmount"]) <= round(fa)]
+            if len(ts) != 1:
+                if len(tsa) > 1:
+                    summ = sum(float(t["creditedAmount"]) for t in tsa)
+                    if floor(fa) <= summ <= round(fa):
+                        for tr in tsa:
+                            am = int(float(tr["creditedAmount"]) * 100)
+                            await models.Transfer.create(
+                                pmid=tr["id"], order=odb, amount=am, sender_acc=tr["from"], created_at=tr["date"]
+                            )
+            else:
+                bcred, _ = await models.Cred.get_or_create(
+                    {"detail": ts[0]["from"]}, person=buyer_person, pmcur_id=odb.cred.pmcur_id
+                )
+                am = int(float(ts[0]["creditedAmount"]) * 100)
+                try:
+                    await models.Transfer.create(
+                        pmid=ts[0]["id"], order=odb, amount=am, sender_acc=ts[0]["from"], created_at=ts[0]["date"]
+                    )
+                except IntegrityError as e:
+                    logging.error(e)
+            ...
+
         await odb.fetch_related("ad")
         return odb
 
@@ -523,8 +680,8 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 page=page,
                 # status=status,  # 50 - завершено
                 # tokenId=token_id,
-                beginTime=begin_time,
-                endTime=end_time,
+                # beginTime=begin_time,
+                # endTime=end_time,
                 # side=side, # 1 - продажа, 0 - покупка
                 size=30,
             )
@@ -534,6 +691,8 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 await self.get_api_orders(page, begin_time, end_time)  # , status, side, token_id)
         ords = {int(o["id"]): OrderItem.model_validate(o) for o in lst["result"]["items"]}
         for oid, o in ords.items():
+            if o.status != Status.completed.value or oid in self.completed_orders:
+                continue
             fo = self.api.get_order_details(orderId=o.id)
             order = OrderFull.model_validate(fo["result"])
             order_db = await self.create_order(order)
@@ -557,6 +716,10 @@ class AgentClient(BaseAgentClient):  # Bybit client
         if len(ords) == 30:
             await self.get_api_orders(page + 1, begin_time, end_time, status, side, token_id)
 
+    # async def order_stat(self, papi: PayeerAPI):
+    #     for t in papi.history():
+    #         os = self.api.get_orders(page=1, size=30)
+
     async def mad_upd(self, mad: Ad, attrs: dict, cxids: list[str]):
         if not [setattr(mad, k, v) for k, v in attrs.items() if getattr(mad, k) != v]:
             print(end="v" if mad.side else "^", flush=True)
@@ -594,7 +757,8 @@ class AgentClient(BaseAgentClient):  # Bybit client
         # cad: Ad = ads[place] if cur_plc > place else ads[cur_plc]
         # переделал пока на жесткую установку целевого места, даже если текущее выше:
         if len(ads) <= target_place:
-            logging.error(f"target place {target_place} not found in ads list {ads}")
+            logging.error(f"target place {target_place} not found in ads {len(ads)}-lenght list")
+            target_place = len(ads) - 1
         cad: Ad = ads[target_place]
         # а цена обгоняемой объявы не выше нашего потолка?
         if (float(cad.price) - ceil) * k <= 0:
@@ -613,10 +777,14 @@ class AgentClient(BaseAgentClient):  # Bybit client
     #     if round(cpc * new_premium / cpm, 2) == m
     #     mad.premium = new_premium.to_eng_string()
 
-    async def racing(
-        self,
-        race: models.Race,
-    ):
+    async def start_race(self):
+        races = await models.Race.filter(started=True, road__ad__maker_id=self.actor.id).prefetch_related(
+            "road__ad__pair_side__pair__cur", "road__credexs__cred", "road__ad__pms__pmexs__pm"
+        )
+        tasks = [create_task(self.racing(race), name=f"Rc{race.id}") for race in races]
+        return await gather(*tasks)
+
+    async def racing(self, race: models.Race):
         coinex: models.CoinEx = await models.CoinEx.get(
             coin_id=race.road.ad.pair_side.pair.coin_id, ex=self.actor.ex
         ).prefetch_related("coin")
@@ -624,11 +792,13 @@ class AgentClient(BaseAgentClient):  # Bybit client
             cur_id=race.road.ad.pair_side.pair.cur_id, ex=self.actor.ex
         ).prefetch_related("cur")
         taker_side: bool = not race.road.ad.pair_side.is_sell
-        pm_ids = [pm.id for pm in race.road.ad.pms]
-        pmexs: list[models.PmEx] = await models.PmEx.filter(pm_id__in=pm_ids, ex=self.actor.ex).prefetch_related("pm")
+        creds = [c.cred for c in race.road.credexs]
+        pmexs: list[models.PmEx] = [pmex for pm in race.road.ad.pms for pmex in pm.pmexs if pmex.ex_id == 4]
+        post_pm_ids = {c.cred.ovr_pm_id for c in race.road.credexs if c.cred.ovr_pm_id}
+        post_pmexs = set(await models.PmEx.filter(pm_id__in=post_pm_ids, ex=self.actor.ex).prefetch_related("pm"))
+
         k = (-1) ** int(taker_side)  # on_buy=1, on_sell=-1
         sleep_sec = 3  # 1 if set(pms) & {"volet"} and coinex.coin_id == 1 else 5
-        creds: list[models.CredEx] = await self.get_credexs_by_pms(race.road.ad.pms, curex.cur_id)
         _lstat, volume = None, 0
 
         while self.actor.person.user.status > 0:
@@ -639,8 +809,9 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 continue
             # если гонка дольше Х минут не обновлялась, обновляем ее (и ее пары) потолок
             expiration = datetime.now(timezone.utc) - timedelta(minutes=15)
+            amt = race.filter_amount * 10**-curex.cur.scale if race.filter_amount else None
             if race.updated_at < expiration:
-                ceils, hp, vmf, zplace = await self.get_ceils(coinex, curex, pmexs, 0.001, True)
+                ceils, hp, vmf, zplace = await self.get_ceils(coinex, curex, pmexs, 0.003, False, 0, amt, post_pmexs)
                 race.ceil = int(ceils[int(taker_side)] * 10**curex.scale)
                 await race.save()
                 # upd pair race
@@ -649,29 +820,28 @@ class AgentClient(BaseAgentClient):  # Bybit client
                     road__ad__pair_side__is_sell=taker_side,
                     road__ad__maker=self.actor,
                     updated_at__lt=expiration,
-                    road__ad__pms__id__in=pm_ids,
-                    pms_count=len(pm_ids),
+                    road__credexs__id__in=[c.id for c in race.road.credexs],
+                    pms_count=len(pmexs),
                 ):
                     prace.ceil = int(ceils[int(not taker_side)] * 10**curex.scale)
                     await prace.save()
 
             last_vol = volume
             if taker_side:  # гонка в стакане продажи - мы покупаем монету за ФИАТ
-                fiat = max(await models.Fiat.filter(cred_id__in=[c.cred_id for c in creds]), key=lambda x: x.amount)
-                volume = fiat.amount / race.road.ad.price
+                fiat = max(await models.Fiat.filter(cred_id__in=[c.id for c in creds]), key=lambda x: x.amount)
+                volume = (fiat.amount * 10**-curex.cur.scale) / (race.road.ad.price * 10**-curex.scale)
             else:  # гонка в стакане покупки - мы продаем МОНЕТУ за фиат
                 asset = await models.Asset.get(addr__actor=self.actor, addr__coin_id=coinex.coin_id)
-                volume = (asset.free - (asset.freeze or 0) - (asset.lock or 0)) * 10**-coinex.scale
+                volume = asset.free * 10**-coinex.scale
             volume = str(round(volume, coinex.scale))
+            try:
+                ads: list[Ad] = await self.ads(coinex, curex, taker_side, pmexs, amt, 50, race.vm_filter, post_pmexs)
+            except Exception:
+                await sleep(1)
+                ads: list[Ad] = await self.ads(coinex, curex, taker_side, pmexs, amt, 50, race.vm_filter, post_pmexs)
 
-            ads: list[Ad] = await self.ads(coinex, curex, taker_side, pmexs)
-            if race.vm_filter:
-                ads = [ad for ad in ads if "VA" in ad.authTag]
             self.overprice_filter(ads, race.ceil * 10**-curex.scale, k)  # обрезаем сверху все ads дороже нашего потолка
 
-            if 571 in pm_ids and coinex.coin.ticker == "USDT" and not taker_side:
-                ...
-
             if not ads:
                 print(coinex.exid, curex.exid, taker_side, "no ads!")
                 await sleep(15)
@@ -682,7 +852,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 await sleep(15)
                 continue
             (cur_plc,) = cur_plc  # может упасть если в списке > 1 наш ad
-            [(await self.cond_upsert(ad, ps=race.road.ad.pair_side, force=True))[0] for ad in ads[:cur_plc]]
+            [(await self.ex_client.cond_load(ad, race.road.ad.pair_side, True))[0] for ad in ads[:cur_plc]]
             # rivals = [
             #     (await models.RaceStat.update_or_create({"place": plc, "price": ad.price, "premium": ad.premium}, ad=ad))[
             #         0
@@ -703,7 +873,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 continue
             if not (cad := self.get_cad(ads, race.ceil * 10**-curex.scale, k, race.target_place, cur_plc)):
                 continue
-            new_price = round(float(cad.price) - k * step(mad, cad, curex.cur.scale), curex.cur.scale)
+            new_price = round(float(cad.price) - k * step(mad, cad, curex.scale), curex.scale)
             if (
                 float(mad.price) == new_price and volume == last_vol
             ):  # Если место уже нужное или нужная цена и так уже стоит
@@ -715,23 +885,23 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 await sleep(sleep_sec)
                 continue
             if cad.priceType:  # Если цена конкурента плавающая, то повышаем себе не цену, а %
-                new_premium = float(cad.premium) - k * step(mad, cad, 2)
-                if float(mad.premium) == new_premium:  # Если нужный % и так уже стоит
-                    if mad.priceType and cur_plc != race.target_place:
-                        new_premium -= k * step(mad, cad, 2)
-                    elif volume == last_vol:
-                        print(end="v" if taker_side else "^", flush=True)
-                        await sleep(sleep_sec)
-                        continue
+                new_premium = (float(mad.premium) or float(cad.premium)) - k * step(mad, cad, 2)
+                # if float(mad.premium) == new_premium:  # Если нужный % и так уже стоит
+                #     if mad.priceType and cur_plc != race.target_place:
+                #         new_premium -= k * step(mad, cad, 2)
+                #     elif volume == last_vol:
+                #         print(end="v" if taker_side else "^", flush=True)
+                #         await sleep(sleep_sec)
+                #         continue
                 mad.premium = str(round(new_premium, 2))
             mad.priceType = cad.priceType
             mad.quantity = volume
-            mad.maxAmount = str(2_000_000)
+            mad.maxAmount = str(2_000_000 if curex.cur_id == 1 else 40_000)
             req = AdUpdateRequest.model_validate(
                 {
                     **mad.model_dump(),
                     "price": str(round(new_price, curex.scale)),
-                    "paymentIds": [str(p.exid) for p in creds],
+                    "paymentIds": [str(cx.exid) for cx in race.road.credexs],
                 }
             )
             try:
@@ -755,26 +925,26 @@ class AgentClient(BaseAgentClient):  # Bybit client
                         raise e
                 elif ExcCode(e.status_code) == ExcCode.InsufficientBalance:
                     asset = await models.Asset.get(addr__actor=self.actor, addr__coin_id=coinex.coin_id)
-                    req.quantity = str(
-                        round(
-                            (asset.free - (asset.freeze or 0) - (asset.lock or 0)) * 10**-coinex.scale,
-                            coinex.coin.scale or coinex.scale,
-                        )
-                    )
+                    req.quantity = str(round(asset.free * 10**-coinex.scale, coinex.scale))
                     _res = self.ad_upd(req)
                 elif ExcCode(e.status_code) == ExcCode.RareLimit:
-                    sad = [
-                        ma
-                        for ma in self.my_ads(False)
-                        if (
-                            ma.currencyId == curex.exid
-                            and ma.tokenId == coinex.exid
-                            and taker_side == (not ma.side)
-                            and ma.payments == [pe.exid for pe in pmexs]
-                        )
-                    ][0]
+                    if not (
+                        sads := [
+                            ma
+                            for ma in self.my_ads(False)
+                            if (
+                                ma.currencyId == curex.exid
+                                and ma.tokenId == coinex.exid
+                                and taker_side != ma.side
+                                and set(ma.payments) == set([pe.exid for pe in pmexs])
+                            )
+                        ]
+                    ):
+                        logging.error(f"Need reserve Ad {'sell' if taker_side else 'buy'} {coinex.exid}/{curex.exid}")
+                        await sleep(90)
+                        continue
                     self.ad_del(ad_id=int(mad.id))
-                    req.id = sad.id
+                    req.id = sads[0].id
                     req.actionType = "ACTIVE"
                     self.api.update_ad(**req.model_dump())
                     logging.warning(f"Ad#{mad.id} recreated")
@@ -787,10 +957,15 @@ class AgentClient(BaseAgentClient):  # Bybit client
             await sleep(6)
 
     async def get_books(
-        self, coinex: models.CoinEx, curex: models.CurEx, pmexs: list[models.PmEx]
+        self,
+        coinex: models.CoinEx,
+        curex: models.CurEx,
+        pmexs: list[models.PmEx],
+        amount: int,
+        post_pmexs: list[models.PmEx] = None,
     ) -> tuple[list[Ad], list[Ad]]:
-        buy: list[Ad] = await self.ads(coinex, curex, False, pmexs, None, 30)
-        sell: list[Ad] = await self.ads(coinex, curex, True, pmexs, None, 30)
+        buy: list[Ad] = await self.ads(coinex, curex, False, pmexs, amount, 40, False, post_pmexs)
+        sell: list[Ad] = await self.ads(coinex, curex, True, pmexs, amount, 30, False, post_pmexs)
         return buy, sell
 
     async def get_spread(
@@ -800,12 +975,12 @@ class AgentClient(BaseAgentClient):  # Bybit client
             ...
         buy_price, sell_price = float(bb[place].price), float(sb[place].price)
         half_spread = (buy_price - sell_price) / (buy_price + sell_price)
-        if half_spread * 2 < perc:
-            if not exact:
-                if vmf is None:  # сначала фильтруем только VA
-                    return await self.get_spread(bb, sb, perc, True, place)
-                # если даже по VA не хватает спреда - увеличиваем место
-                return await self.get_spread(bb, sb, perc, vmf, place + 1)
+        # if half_spread * 2 < perc:  # todo: aA???
+        #     if not exact:
+        #         if vmf is None:  # сначала фильтруем только VA
+        #             return await self.get_spread(bb, sb, perc, True, place)
+        #         # если даже по VA не хватает спреда - увеличиваем место
+        #         return await self.get_spread(bb, sb, perc, vmf, place + 1)
 
         return (buy_price, sell_price), half_spread, vmf, place
 
@@ -817,301 +992,159 @@ class AgentClient(BaseAgentClient):  # Bybit client
         min_prof=0.02,
         vmf: bool = False,
         place: int = 0,
+        amount: int = None,
+        post_pmexs: set[models.PmEx] = None,
     ) -> tuple[tuple[float, float], float, bool, int]:  # todo: refact to Pairex
-        bb, sb = await self.get_books(coinex, curex, pmexs)
+        bb, sb = await self.get_books(coinex, curex, pmexs, amount, post_pmexs)
         if vmf:
+            # ориентируемся на цены объявлений только проверенных мерчантов
             bb = [b for b in bb if "VA" in b.authTag]
             sb = [s for s in sb if "VA" in s.authTag]
-        perc = pmexs[0].pm.fee * 0.0001 + min_prof
+        perc = list(post_pmexs or pmexs)[0].pm.fee * 0.0001 + min_prof
         (bf, sf), hp, vmf, zplace = await self.get_spread(bb, sb, perc, vmf, place)
         mdl = (bf + sf) / 2
         bc, sc = mdl + mdl * (perc / 2), mdl - mdl * (perc / 2)
         return (bc, sc), hp, vmf, zplace
 
-    async def parse_ads(
-        self,
-        coinex: models.CoinEx,
-        curex: models.CurEx,
-        taker_side: bool,
-        pms: list[str] = None,
-        ceil: float = None,
-        volume: float = 9000,
-        min_fiat: int = None,
-        max_fiat: int = None,
-    ):
-        k = (-1) ** int(taker_side)  # on_buy=1, on_sell=-1
-
-        if pms:
-            creds: dict[models.PmEx, models.CredEx] = await self.get_credexs_by_norms(pms, curex.cur_id)
-            [str(p.exid) for p in creds.values()]
-
-            if taker_side:  # гонка в стакане продажи - мы покупаем монету за ФИАТ
-                fiats = await models.Fiat.filter(
-                    cred_id__in=[cx.cred_id for cx in creds.values()], amount__not=F("target")
-                )
-                volume = min(volume, max(fiats, key=lambda f: f.target - f.amount).amount / ceil)
-            else:  # гонка в стакане покупки - мы продаем МОНЕТУ за фиат
-                asset = await models.Asset.get(addr__actor=self.actor, addr__coin_id=coinex.coin_id)
-                volume = min(volume, asset.free - (asset.freeze or 0) - (asset.lock or 0))
-        volume = str(round(volume, coinex.coin.scale))
-        ps = await PairSide.get(
-            is_sell=taker_side,
-            pair__coin_id=coinex.coin_id,
-            pair__cur_id=curex.cur_id,
+    async def take_ad(self, req: TakeAdReq):
+        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]
+        #
+        # # todo: map pm->cred_pattern
+        # pmexid = exids.pop() if (exids := set(ad.payments) & set(px.exid for px in pmexs)) else "40"
+        pmexid = str(req.pm_id)
+        coinex = await models.CoinEx.get(coin_id=req.coin_id, ex=self.ex_client.ex)
+        curex = await models.CurEx.get(cur_id=req.cur_id, ex=self.ex_client.ex)
+
+        # 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(req.ad_id),
+            fiat_amount=req.amount,
+            is_sell=req.is_sell,
+            cur_exid=curex.exid,
+            coin_exid=coinex.exid,
+            coin_scale=coinex.scale,
+            pmex_exid=pmexid,
         )
-        while self.actor.person.user.status > 0:  # todo: depends on rest asset/fiat
-            ads: list[Ad] = await self.ads(coinex, curex, taker_side, pms and list(creds.keys()))
-
-            if not ads:
-                print(coinex.exid, curex.exid, taker_side, "no ads!")
-                await sleep(300)
-                continue
-
-            for i, ad in enumerate(ads):
-                if (ceil - float(ad.price)) * k < 0:
-                    break
-                if int(ad.userId) == self.actor.exid:
-                    logging.info(f"My ad {'-' if taker_side else '+'}{coinex.exid}/{curex.exid} on place#{i}")
-                    continue
-                ad_db, isnew = await self.cond_upsert(ad, ps=ps)
-                if isnew:
-                    s = f"{'-' if taker_side else '+'}{ad.price}[{ad.minAmount}-{ad.maxAmount}]{coinex.exid}/{curex.exid}"
-                    print(s, end=" | ", flush=True)
-                try:
-                    # take
-                    ...
-                except FailedRequestError as e:
-                    if ExcCode(e.status_code) == ExcCode.RareLimit:
-                        await sleep(195)
-                    elif ExcCode(e.status_code) == ExcCode.Timestamp:
-                        await sleep(2)
-                    else:
-                        raise e
-                except (ReadTimeoutError, ConnectionDoesNotExistError):
-                    logging.warning("Connection failed. Restarting..")
-            await sleep(3)
-
-    async def cond_upsert(
-        self, ad: Ad, rname: str = None, ps: PairSide = None, force: bool = False
-    ) -> tuple[models.Ad, bool]:
-        _sim, cid = None, None
-        ad_db = await models.Ad.get_or_none(exid=ad.id, maker__ex=self.ex_client.ex).prefetch_related("cond")
-        # если точно такое условие уже есть в бд
-        if not (cleaned := clean(ad.remark)) or (cid := {oc[0]: ci for ci, oc in self.all_conds.items()}.get(cleaned)):
-            # и объява с таким ид уже есть, но у нее другое условие
-            if ad_db and ad_db.cond_id != cid:
-                # то обновляем ид ее условия
-                ad_db.cond_id = cid
-                await ad_db.save()
-                logging.info(f"{ad.nickName} upd cond#{ad_db.cond_id}->{cid}")
-                # old_cid = ad_db.cond_id # todo: solve race-condition, а пока что очищаем при каждом запуске
-                # if not len((old_cond := await Cond.get(id=old_cid).prefetch_related('ads')).ads):
-                #     await old_cond.delete()
-                #     logging.warning(f"Cond#{old_cid} deleted!")
-            return (ad_db or force and await self.ad_create(ad, cid, rname, ps)), False
-        # если эта объява в таким ид уже есть в бд, но с другим условием (или без), а текущего условия еще нет в бд
-        if ad_db:
-            await ad_db.fetch_related("cond__ads", "maker")
-            if not ad_db.cond_id or (
-                # у измененного условия этой объявы есть другие объявы?
-                (rest_ads := set(ad_db.cond.ads) - {ad_db})
-                and
-                # другие объявы этого условия принадлежат другим юзерам
-                {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
-                await ad_db.save()
-
-                return ad_db, True
-            # а если других объяв со старым условием этой обявы нет, либо они все этого же юзера
-            # обновляем условие (в тч во всех ЕГО объявах)
-            ad_db.cond.last_ver = ad_db.cond.raw_txt
-            ad_db.cond.raw_txt = cleaned
-            await ad_db.cond.save()
-            await self.cond_upd(ad_db.cond, {ad_db.maker.exid})
-            # и подправим коэфициенты похожести нового текста
-            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_create(ad, cid, rname, ps), True
-
-    async def cond_new(self, txt: str, uids: set[int]) -> int:
-        new_cond, _ = await Cond.update_or_create(raw_txt=txt)
-        # и максимально похожую связь для нового условия (если есть >= 60%)
-        await self.cond_upd(new_cond, uids)
-        return new_cond.id
-
-    async def cond_upd(self, cond: Cond, uids: set[int]):
-        self.all_conds[cond.id] = cond.raw_txt, uids
-        # и максимально похожую связь для нового условия (если есть >= 60%)
-        old_cid, sim = await self.cond_get_max_sim(cond.id, cond.raw_txt, uids)
-        await self.actual_sim(cond.id, old_cid, sim)
-
-    def find_in_tree(self, cid: int, old_cid: int) -> bool:
-        if p := self.cond_sims.get(old_cid):
-            if p == cid:
-                return True
-            return self.find_in_tree(cid, p)
-        return False
-
-    async def cond_get_max_sim(self, cid: int, txt: str, uids: set[int]) -> tuple[int | None, int | None]:
-        # находим все старые тексты похожие на 90% и более
-        if len(txt) < 15:
-            return None, None
-        sims: dict[int, int] = {}
-        for old_cid, (old_txt, old_uids) in self.all_conds.items():
-            if len(old_txt) < 15 or uids == old_uids:
-                continue
-            elif not self.can_add_sim(cid, old_cid):
-                continue
-            if sim := get_sim(txt, old_txt):
-                sims[old_cid] = sim
-        # если есть, берем самый похожий из них
-        if sims:
-            old_cid, sim = max(sims.items(), key=lambda x: x[1])
-            await sleep(0.3)
-            return old_cid, sim
-        return None, None
-
-    def can_add_sim(self, cid: int, old_cid: int) -> bool:
-        if cid == old_cid:
-            return False
-        elif self.cond_sims.get(cid) == old_cid:
-            return False
-        elif self.find_in_tree(cid, old_cid):
-            return False
-        elif self.cond_sims.get(old_cid) == cid:
-            return False
-        elif cid in self.rcond_sims.get(old_cid, {}):
-            return False
-        elif old_cid in self.rcond_sims.get(cid, {}):
-            return False
-        return True
-
-    async def person_upsert(self, name: str, exid: int) -> models.Person:
-        if actor := await models.Actor.get_or_none(exid=exid, ex=self.ex_client.ex).prefetch_related("person"):
-            if not actor.person:
-                actor.person = await models.Person.create(name=name)
-                await actor.save()
-            return actor.person
-        return await models.Person.create(name=name)
-
-    async def ad_create(
-        self, ad: Ad, cid: int = None, rname: str = None, ps: PairSide = None, actor: Actor = None
-    ) -> models.Ad:
-        act_df = {}
-        if int(ad.userId) != self.actor.exid:
-            act_df |= {"name": ad.nickName}
-        if rname:
-            act_df |= {"person": await self.person_upsert(rname, int(ad.userId))}
-        if not actor:
-            act_df |= {"person": await self.person_upsert(ad.nickName, int(ad.userId))}
-            actor, _ = await Actor.update_or_create(act_df, exid=ad.userId, ex=self.ex_client.ex)
-        ps = ps or await PairSide.get_or_none(
-            is_sell=ad.side,
-            pair__coin__ticker=ad.tokenId,
-            pair__cur__ticker=ad.currencyId,
-        ).prefetch_related("pair__cur", "pair__coin")
-        if not ps or not ps.pair:
-            ...  # THB/USDC
-        ad_upd = models.Ad.validate(ad.model_dump(by_alias=True))
-        cur_scale = 10**ps.pair.cur.scale
-        coinex = await models.CoinEx.get(coin_id=ps.pair.coin_id, ex=self.ex_client.ex)
-        df_unq = ad_upd.df_unq(
-            maker_id=actor.id,
-            pair_side_id=ps.id,
-            amount=int(float(ad.quantity) * float(ad.price) * cur_scale),
-            quantity=int(float(ad.quantity) * 10**coinex.scale),
-            min_fiat=int(float(ad.minAmount) * cur_scale),
-            max_fiat=ad.maxAmount and int(float(ad.maxAmount) * cur_scale),
-            price=int(float(ad.price) * cur_scale),
-            premium=int(float(ad.premium) * cur_scale),
-        )
-        ad_db, _ = await models.Ad.update_or_create(**df_unq)
-        await ad_db.pms.add(*(await models.Pm.filter(pmexs__ex=self.ex_client.ex, pmexs__exid__in=ad.payments)))
-        return ad_db
-
-    async def fix_rel_sims(self, cid: int, new_txt: str):
-        for rel_sim in await CondSim.filter(cond_rel_id=cid).prefetch_related("cond"):
-            if sim := get_sim(new_txt, rel_sim.cond.raw_txt):
-                rel_sim.similarity = sim
-                await rel_sim.save()
-            else:
-                await rel_sim.delete()
-
-    async def actual_cond(self):
-        for curr, old in await CondSim.all().values_list("cond_id", "cond_rel_id"):
-            self.cond_sims[curr] = old
-            self.rcond_sims[old] |= {curr}
-        for cid, (txt, uids) in self.all_conds.items():
-            old_cid, sim = await self.cond_get_max_sim(cid, txt, uids)
-            await self.actual_sim(cid, old_cid, sim)
-            # хз бля чо это ваще
-            # for ad_db in await models.Ad.filter(direction__pairex__ex=self.ex_client.ex).prefetch_related("cond", "maker"):
-            #     ad = Ad(id=str(ad_db.exid), userId=str(ad_db.maker.exid), remark=ad_db.cond.raw_txt)
-            #     await self.cond_upsert(ad, force=True)
-
-    async def actual_sim(self, cid: int, old_cid: int, sim: int):
-        if not sim:
-            return
-        if old_sim := await CondSim.get_or_none(cond_id=cid):
-            if old_sim.cond_rel_id != old_cid:
-                if sim > old_sim.similarity:
-                    logging.warning(f"R {cid}: {old_sim.similarity}->{sim} ({old_sim.cond_rel_id}->{old_cid})")
-                    await old_sim.update_from_dict({"similarity": sim, "old_rel_id": old_cid}).save()
-                    self._cond_sim_upd(cid, old_cid)
-            elif sim != old_sim.similarity:
-                logging.info(f"{cid}: {old_sim.similarity}->{sim}")
-                await old_sim.update_from_dict({"similarity": sim}).save()
-        else:
-            await CondSim.create(cond_id=cid, cond_rel_id=old_cid, similarity=sim)
-            self._cond_sim_upd(cid, old_cid)
-
-    def _cond_sim_upd(self, cid: int, old_cid: int):
-        if old_old_cid := self.cond_sims.get(cid):  # если старый cid уже был в дереве:
-            self.rcond_sims[old_old_cid].remove(cid)  # удаляем из обратного
-        self.cond_sims[cid] = old_cid  # а в прямом он автоматом переопределится, даже если и был
-        self.rcond_sims[old_cid] |= {cid}  # ну и в обратное добавим новый
-
-    async def get_credexs_by_pms(self, pms: list[models.Pm], cur_id: int) -> list[models.CredEx]:
-        return await models.CredEx.filter(
-            ex_id=self.actor.ex_id,
-            cred__pmcur__pm_id__in=[pm.id for pm in pms],
-            cred__person_id=self.actor.person_id,
-            cred__pmcur__cur_id=cur_id,
-        )
-
-    def build_tree(self):
-        set(self.cond_sims.keys()) | set(self.cond_sims.values())
-        tree = defaultdict(dict)
-        # Группируем родителей по детям
-        for child, par in self.cond_sims.items():
-            tree[par] |= {child: {}}  # todo: make from self.rcond_sim
-
-        # Строим дерево снизу вверх
-        def subtree(node):
-            if not node:
-                return node
-            for key in node:
-                subnode = tree.pop(key, {})
-                d = subtree(subnode)
-                node[key] |= d  # actual tree rebuilding here!
-            return node  # todo: refact?
-
-        # Находим корни / без родителей
-        roots = set(self.cond_sims.values()) - set(self.cond_sims.keys())
-        for root in roots:
-            _ = subtree(tree[root])
-
-        self.tree = tree
-
+        resp: OrderResp = await self._order_request(bor)
+        return resp
+
+    async def watch_payeer(self, mcs: dict[int, "AgentClient"]):
+        coinex: models.CoinEx = await models.CoinEx.get(coin_id=1, ex=self.actor.ex).prefetch_related("coin")
+        curex: models.CurEx = await models.CurEx.get(cur_id=1, ex=self.actor.ex).prefetch_related("cur")
+        post_pmexs = set(await models.PmEx.filter(pm_id=366, ex=self.actor.ex).prefetch_related("pm"))
+        i = 0
+        while True:
+            try:
+                ss = await self.ads(coinex, curex, True, None, None, 1000, False, post_pmexs)
+                ss = [s for s in ss if float(s.price) > 90.42 or int(s.userId) in mcs.keys()]
+                if ss:
+                    ad: Ad = ss[0]
+                    await self.bbot.send(
+                        193017646,
+                        f"price: {ad.price}\nnick: {ad.nickName}\nprice: {ad.price}"
+                        f"\nqty: {ad.quantity} [{ad.minAmount}-{ad.maxAmount}]",
+                    )
+                    am = min(float(ad.maxAmount), max(1000 + i, float(ad.minAmount)))
+                    req = TakeAdReq(
+                        ad_id=ad.id,
+                        amount=am,
+                        pm_id=14,
+                        is_sell=True,
+                        coin_id=1,
+                        cur_id=1,
+                    )
+                    ord_resp: OrderResp = await self.take_ad(req)
+                    # order: OrderFull = OrderFull(**self.api.get_order_details(orderId=ord_resp.orderId)["result"])
+                    order: OrderFull = await self.get_order_info(ord_resp.orderId)
+                    odb = await self.create_order(order)
+                    # t = await models.Transfer(order=odb, amount=odb.amount, updated_at=now())
+                    # await t.fetch_related("order__cred__pmcur__cur")
+                    # res = await self.pm_clients[366].check_in(t)
+                    if int(ad.userId) in mcs:
+                        mcs[int(ad.userId)].api.mark_as_paid(
+                            orderId=str(odb.exid),
+                            paymentType=ad.payments[0],  # pmex.exid
+                            paymentId=order.paymentTermList[0].id,  # credex.exid
+                        )
+                    self.api.release_assets(orderId=order.id)
+                ...
 
-def get_sim(s1, s2) -> int:
-    sim = int((SequenceMatcher(None, s1, s2).ratio() - 0.6) * 10_000)
-    return sim if sim > 0 else 0
+                bs = await self.ads(coinex, curex, False, None, None, 1000, False, post_pmexs)
+                bs = [b for b in bs if float(b.price) < 89.56 or int(b.userId) in mcs.keys()]
+                if bs:
+                    ad: Ad = bs[0]
+                    await self.bbot.send(
+                        193017646,
+                        f"price: {ad.price}\nnick: {ad.nickName}\nprice: {ad.price}"
+                        f"\nqty: {ad.quantity} [{ad.minAmount}-{ad.maxAmount}]",
+                    )
+                    am = min(float(ad.maxAmount), max(600 + i, float(ad.minAmount)))
+                    req = TakeAdReq(
+                        ad_id=ad.id,
+                        amount=am,
+                        pm_id=14,
+                        is_sell=False,
+                        coin_id=1,
+                        cur_id=1,
+                    )
+                    ord_resp: OrderResp = await self.take_ad(req)
+                    # order: OrderFull = OrderFull(**self.api.get_order_details(orderId=ord_resp.orderId)["result"])
+                    order: OrderFull = await self.get_order_info(ord_resp.orderId)
+                    odb = await self.create_order(order)
+                    t = await models.Transfer(order=odb, amount=odb.amount, updated_at=now())
+                    await t.fetch_related("order__cred__pmcur__cur")
+                    # res = await self.pm_clients[366].send(t)
+                    self.api.mark_as_paid(
+                        orderId=str(odb.exid),
+                        paymentType=ad.payments[0],  # pmex.exid
+                        paymentId=order.paymentTermList[0].id,  # credex.exid
+                    )
+                    if int(ad.userId) in mcs:
+                        mcs[int(ad.userId)].api.release_assets(orderId=order.id)
+                    await sleep(1)
+                ...
+            except Exception as e:
+                logging.exception(e)
+                await sleep(90)
+            except HttpProcessingError as e:
+                logging.error(e)
+            print(end=".", flush=True)
+            i += 1
+            await sleep(5)
+
+    async def boost_acc(self):
+        await sleep(45)
+        for i in range(10):
+            am = 500 + i
+            req = TakeAdReq(ad_id="1856989782009487360", amount=am, pm_id=366)
+            ord_resp: OrderResp = await self.take_ad(req)
+            order: OrderFull = OrderFull(**self.api.get_order_details(orderId=ord_resp.orderId)["result"])
+            odb = await self.create_order(order)
+            t = await models.Transfer(order=odb, amount=odb.amount, updated_at=now())
+            await t.fetch_related("order__cred__pmcur__cur")
+            await self.pm_clients[366].send(t)
+        ...
+
+
+def ms2utc(msk_ts_str: str):
+    return datetime.fromtimestamp(int(msk_ts_str) / 1000, timezone(timedelta(hours=3), name="MSK"))
 
 
 def detailed_diff(str1, str2):
@@ -1131,17 +1164,9 @@ def detailed_diff(str1, str2):
     return "".join(result)
 
 
-def clean(s) -> str:
-    clear = r"[^\w\s.,!?;:()\-]"
-    repeat = r"(.)\1{2,}"
-    s = re.sub(clear, "", s).lower()
-    s = re.sub(repeat, r"\1", s)
-    return s.replace("\n\n", "\n").replace("  ", " ").strip(" \n/.,!?-")
-
-
 def step_is_need(mad, cad) -> bool:
     # todo: пока не решен непонятный кейс, почему то конкурент по всем параметрам слабже, но в списке ранжируется выше.
-    #  текущая версия: recentExecuteRate округляется до целого, но на бэке его дробная часть больше
+    #  текущая версия: recentExecuteRate округляется до целого, но на бэке байбита его дробная часть больше
     return (
         bool(set(cad.authTag) & {"VA2", "BA"})
         or cad.recentExecuteRate > mad.recentExecuteRate
@@ -1163,115 +1188,102 @@ class ExcCode(IntEnum):
     Timestamp = 10002
     IP = 10010
     Quantity = 912300019
+    PayMethod = 912300013
     Unknown = 912300014
 
 
-async def main():
-    logging.basicConfig(level=logging.INFO)
-    _ = await init_db(TORM)
+@post_save(models.Race)
+async def race_upserted(
+    _cls: type[models.Race], race: models.Race, created: bool, _db: BaseDBAsyncClient, _updated: list[str]
+):
+    logging.warning(f"Race {race.id} is now upserted")
+    asyncio.all_tasks()
+    if created:
+        ...
+    else:  # параметры гонки изменены
+        ...
 
-    @post_save(models.Race)
-    async def race_upserted(
-        _cls: type[models.Race], race: models.Race, created: bool, _db: BaseDBAsyncClient, _updated: list[str]
-    ):
-        logging.warning(f"Race {race.id} is now upserted")
-        asyncio.all_tasks()
-        if created:
-            ...
-        else:  # параметры гонки изменены
-            ...
-
-    actor = (
-        await models.Actor.filter(ex_id=4, agent__isnull=False).prefetch_related("ex", "agent", "person__user").first()
-    )
-    async with FileClient(TOKEN) as b:
-        b: FileClient
-        # b.add_handler(MessageHandler(cond_start_handler, command("cond")))
-        cl: AgentClient = actor.client(b)
-
-        # await cl.ex_client.set_pairs()
-        # await cl.ex_client.set_pms()
-        # await cl.set_creds()
-        # await cl.export_my_ads()
-
-        # создание гонок по мои активным объявам:
-        # for ma in cl.my_ads():
-        #     my_ad = await models.MyAd.get(ad__exid=ma.id).prefetch_related('ad__pms', 'ad__pair_side__pair')
-        #     race, _ = await models.Race.update_or_create(
-        #         {"started": True, "vm_filter": True, "target_place": 5},
-        #         road=my_ad
-        #     )
-
-        # for name in names:
-        #     s, _ = await models.Synonym.update_or_create(typ=SynonymType.name, txt=name)
-        #     await s.curs.add(rub.cur)
-
-        # пока порешали рейс-кондишн, очищаем сиротские условия при каждом запуске
-        # [await c.delete() for c in await Cond.filter(ads__isnull=True)]
-        cl.all_conds = {
-            c.id: (c.raw_txt, {a.maker.exid for a in c.ads}) for c in await Cond.all().prefetch_related("ads__maker")
-        }
-        for curr, old in await CondSim.filter().values_list("cond_id", "cond_rel_id"):
-            cl.cond_sims[curr] = old
-            cl.rcond_sims[old] |= {curr}
-
-        cl.build_tree()
-        a = set()
-
-        def check_tree(tre):
-            for p, c in tre.items():
-                a.add(p)
-                check_tree(c)
-
-        for pr, ch in cl.tree.items():
-            check_tree(ch)
-        if ct := set(cl.tree.keys()) & a:
-            logging.exception(f"cycle cids: {ct}")
 
-        # await cl.get_api_orders(43, 1741294800000, 1749157199999)
-
-        races = await models.Race.filter(started=True).prefetch_related(
-            "road__ad__pair_side__pair__cur",
-            "road__ad__pms",
-        )
-        tasks = [asyncio.create_task(cl.racing(race), name=f"Rc{race.id}") for race in races]
-        # await cl.actual_cond()
-        await gather(
-            *tasks
-            # cl.get_api_orders(),  # 10, 1738357200000, 1742504399999
-            # cl.racing(usdt, rub, False, ["volet"], 83.88),  # гонка в стакане покупки - мы продаем
-            # cl.racing(usdt, rub, True, ["volet"], 81.51),  # гонка в стакане продажи - мы покупаем
-            # cl.racing(usdt, rub, False, ["payeer"], 81.49),  # гонка в стакане покупки - мы продаем
-            # cl.racing(usdt, rub, True, ["payeer"], 80.7),  # гонка в стакане продажи - мы покупаем
-            # cl.racing(eth, rub, False, ["volet"], 300_000),
-            # cl.racing(eth, rub, True, ["volet"], 296_000),
-            # cl.racing(eth, rub, False, ["payeer"], 300_000),
-            # cl.racing(eth, rub, True, ["payeer"], 296_000),
-            # cl.racing(btc, rub, False, ["volet"], 9_800_000),
-            # cl.racing(btc, rub, True, ["volet"], 9_700_000),
-            # cl.racing(btc, rub, False, ["payeer"], 9_800_000),
-            # cl.racing(btc, rub, True, ["payeer"], 9_700_000),
-            # cl.racing(usdc, rub, False, ["volet"], 80.98),
-            # cl.racing(usdc, rub, True, ["volet"], 80.01),
-            # cl.racing(usdc, rub, False, ["payeer"], 80.98),
-            # cl.racing(usdc, rub, True, ["payeer"], 80.01),
-            # cl.parse_ads(usdt, rub, False, ceil=81, volume=360),
-            # cl.parse_ads(usdt, rub, True, ceil=80, volume=360),
+async def main():
+    logging.basicConfig(level=logging.INFO)
+    cn = await init_db(TORM)
+
+    agent = (
+        await models.Agent.filter(actor__ex_id=4, auth__isnull=False, status__gt=AgentStatus.off, id=8)
+        .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()
+    # b.add_handler(MessageHandler(cond_start_handler, command("cond")))
+    ex = await models.Ex.get(name="Bybit")
+    ecl: ExClient = ex.client(filebot)
+    abot = XyncBot(PAY_TOKEN, cn)
+    cl: AgentClient = agent.client(ecl, filebot, abot)
+
+    # req = TakeAdReq(ad_id=1955696985964089344, amount=504, pm_id=128)
+    # await cl.take_ad(req)
+
+    # await cl.actual_cond()
+    # cl.get_api_orders(),  # 10, 1738357200000, 1742504399999
+
+    # await cl.ex_client.set_pairs()
+    # await cl.ex_client.set_pms()
+
+    # await cl.set_creds()
+    # await cl.export_my_ads()
+
+    ms = await models.Agent.filter(
+        actor__ex_id=4, auth__isnull=False, status__gt=AgentStatus.off, actor__person__user__id__in=[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",
+    )
+    mcs = {m.actor.exid: m.client(ecl, filebot, abot) for m in ms}
 
-        # bor = BaseOrderReq(
-        #     ad_id="1861440060199632896",
-        #     # asset_amount=40,
-        #     fiat_amount=3000,
-        #     amount_is_fiat=True,
-        #     is_sell=False,
-        #     cur_exid=rub.exid,
-        #     coin_exid=usdt.exid,
-        #     coin_scale=usdt.coin.scale,
-        # )
-        # res: OrderResp = await cl.order_request(bor)
-        # await cl.cancel_order(res.orderId)
-        await cl.close()
+    await gather(
+        create_task(cl.start(True)),
+        create_task(cl.watch_payeer(mcs)),
+    )
+    # ensure_future(cl.start(True))
+    # await cl.boost_acc()
+
+    # создание гонок по мои активным объявам:
+    # for ma in cl.my_ads():
+    #     my_ad = await models.MyAd.get(ad__exid=ma.id).prefetch_related('ad__pms', 'ad__pair_side__pair')
+    #     race, _ = await models.Race.update_or_create(
+    #         {"started": True, "vm_filter": True, "target_place": 5},
+    #         road=my_ad
+    #     )
+
+    # for name in names:
+    #     s, _ = await models.Synonym.update_or_create(typ=SynonymType.name, txt=name)
+    #     await s.curs.add(rub.cur)
+
+    pauth = (await models.PmAgent[1]).auth
+    papi = PayeerAPI(pauth["email"], pauth["api_id"], pauth["api_sec"])
+    hist: dict = papi.history(count=1000)
+    hist |= papi.history(count=1000, append=list(hist.keys())[-1])
+    hist |= papi.history(count=1000, append=list(hist.keys())[-1])
+    cl.hist = hist
+
+    # cl.completed_orders = await models.Order.filter(status=OrderStatus.completed, transfer__isnull=False).values_list(
+    #     "exid", flat=True
+    # )
+    # await cl.get_api_orders()  # 43, 1741294800000, 1749157199999)
+
+    # await cl.cancel_order(res.orderId)
+    await filebot.stop()
+    await cl.close()
 
 
 if __name__ == "__main__":