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

xync_client/Bybit/agent.py

@@ -1,37 +1,47 @@
 import asyncio
+import json
 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
+from uuid import uuid4
 
 import pyotp
-from asyncpg import ConnectionDoesNotExistError
+import websockets
+from aiohttp.http_exceptions import HttpProcessingError
 from bybit_p2p import P2P
 from bybit_p2p._exceptions import FailedRequestError
 from payeer_api import PayeerAPI
+from pydantic import ValidationError
 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 urllib3.exceptions import ReadTimeoutError
+from tortoise.timezone import now
+from tortoise.transactions import in_transaction
+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.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, AdUpd, GetAds
+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,
@@ -42,17 +52,30 @@ from xync_client.Bybit.etype.order import (
     OrderFull,
     Message,
     Status,
+    OrderSellRequest,
+    TakeAdReq,
+    StatusChange,
+    CountDown,
+    Receive,
+    Read,
+    SellerCancelChange,
 )
-from xync_client.loader import TORM, NET_TOKEN
+from xync_client.Pms.Payeer.agent import PmAgentClient
+from xync_client.loader import TORM, NET_TOKEN, PAY_TOKEN, PRX
 
 
 class NoMakerException(Exception):
     pass
 
 
+class ShareException(Exception):
+    pass
+
+
 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 = {
@@ -82,28 +105,37 @@ 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"])
-        self.hist: dict = None
-        self.completed_orders: list[int] = None
+    def __init__(
+        self,
+        agent: Agent,
+        ex_client: ExClient,
+        fbot: FileClient,
+        bbot: XyncBot,
+        pm_clients: dict[int, PmAgentClient] = None,
+        **kwargs,
+    ):
+        super().__init__(agent, ex_client, fbot, bbot, pm_clients, **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,
@@ -115,12 +147,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()
@@ -144,29 +172,43 @@ 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())
-        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())
+            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
+        try:
+            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,
+            )
+            if cred_db.ovr_pm_id is None and (cred_db.detail.startswith("XyncPay") or xtr.startswith("XyncPay")):
+                cred_db.ovr_pm_id = 0
+                await cred_db.save()
+            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())
+        except IntegrityError as e:
+            raise e
         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}
@@ -178,7 +220,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
@@ -188,6 +230,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: Список реквизитов моих платежных методов
@@ -197,62 +241,44 @@ 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(
-        self,
-        cnx: models.CoinEx,
-        crx: models.CurEx,
-        is_sell: bool,
-        pmxs: list[models.PmEx],
-        amount: int = None,
-        lim: int = 50,
-        vm_filter: bool = False,
-    ) -> 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"]
-
     @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
@@ -261,35 +287,95 @@ 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).prefetch_related("cred")
+            await mad_db.credexs.add(*credexs)
+            # share
+            if [cx for cx in credexs if cx.cred.ovr_pm_id == 0]:
+                try:
+                    await self.ad_share(mad_db.id)
+                except ShareException as e:
+                    logging.warning(e.args[0])
+                await sleep(1)
+
+        return len(ads)
+
+    async def ad_share(self, maid: int):
+        myad = await models.MyAd.get(id=maid).prefetch_related("ad")
+        if myad.hex and myad.shared_at + timedelta(minutes=55) > now():  # check expired
+            # check validity
+            data = await self._post("/x-api/fiat/otc/item/shareItem/info", {"shareCode": myad.hex.hex()})
+            if data["ret_code"] == 0:
+                return myad.get_url()
+        data = await self._post("/x-api/fiat/otc/item/share", {"itemId": str(myad.ad.exid)})
+        if data["ret_code"] == 912300058:
+            raise ShareException(f"Объява {myad.id}:{myad.ad.id}:{myad.ad.exid} выключена")
+        if data["ret_code"] == 912300059:
+            raise ShareException("Торговля выключена")
+        if data["ret_code"] != 0:  # Новая ошибка
+            raise ShareException(data)
+        url = data["result"]["shareLink"]
+        resp = await self.session.get(url)
+        hx = resp.url.query["by_web_link"].replace(models.MyAd.WEB, "")
+        await models.MyAd.filter(id=maid).update(hex=bytes.fromhex(hx), shared_at=now())
+        await myad.refresh_from_db()
+        return myad.get_url()
 
     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 get_ad(self, aid: int) -> Ad:
+        return Ad(**self.api.get_ad_details(itemId=aid)["result"])
 
     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
 
     # создание объявлений
@@ -308,14 +394,15 @@ class AgentClient(BaseAgentClient):  # Bybit client
         data = self.api.post_new_ad(**ad.model_dump())
         return data["result"]["itemId"] if data["ret_code"] == 0 else data
 
-    def ad_upd(self, upd: AdUpdateRequest):
+    async def _ad_upd(self, req: AdUpd):
+        upd = AdUpdateRequest({})
         params = upd.model_dump()
         data = self.api.update_ad(**params)
         return data["result"] if data["ret_code"] == 0 else data
 
     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
 
@@ -332,46 +419,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"]
@@ -380,14 +496,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",
@@ -403,11 +519,11 @@ class AgentClient(BaseAgentClient):  # Bybit client
             {"makerUserId": self.actor.exid, "page": "1", "size": "10", "appraiseType": "1"},  # "0" - bad
         )
 
-    async def get_orders_active(
+    async def get_pending_orders(
         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",
+        res = await self._post(
+            "/x-api/fiat/otc/order/pending/simplifyList",
             {
                 "status": status,
                 "tokenId": token_id,
@@ -415,13 +531,16 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 "endTime": end_time,
                 "side": side,  # 1 - продажа, 0 - покупка
                 "page": 1,
-                "size": 10,
+                "size": 20,
             },
         )
+        if res["ret_code"] == 0:
+            return {o.id: OrderItem(**o) for o in res["result"]["items"]}
+        return res["ret_code"]
 
     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,
@@ -433,24 +552,27 @@ 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"])
-        await sleep(1)
+    async def create_order_db(self, order: OrderFull) -> models.Order:
         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
-        im_maker = int(order.makerUserId == order.userId)
+        sb_names = order.sellerRealName, order.buyerRealName
+        im_maker = int(int(order.makerUserId) == self.actor.exid)
         taker_id = (order.userId, order.targetUserId)[im_maker]
-        taker_person = await self.person_upsert(maker_name[::-1][ad.side], taker_id)
+        taker_name = sb_names[order.side]  # todo: double check
+        taker_person = await self.ex_client.person_name_update(taker_name, 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 = await models.Ad.get(exid=order.itemId)
         if not ad_db:
-            ...
+            ad = self.get_ad(order.itemId)
+            # ad_db, cond_isnew = await self.ex_client.cond_load(ad, force=True, rname=maker_name[order.side])
+            ad_db = await self.ex_client.ad_load(ad, maker=self.actor)
         ecredex: CredEpyd = order.confirmedPayTerm
 
         if ecredex.paymentType == 0 and im_maker and order.side:
@@ -458,22 +580,22 @@ class AgentClient(BaseAgentClient):  # Bybit client
         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 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)
@@ -481,7 +603,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
                 ):
@@ -490,7 +612,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,
                     )
                 ):
                     ...
@@ -545,13 +667,13 @@ class AgentClient(BaseAgentClient):  # Bybit client
             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()
+                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.person_upsert(order.buyerRealName, int(order.targetUserId))
+                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:
@@ -608,7 +730,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 continue
             fo = self.api.get_order_details(orderId=o.id)
             order = OrderFull.model_validate(fo["result"])
-            order_db = await self.create_order(order)
+            order_db = await self.create_order_db(order)
             await sleep(1)
             dmsgs = self.api.get_chat_messages(orderId=oid, size=200)["result"]["result"][::-1]
             msgs = [Message.model_validate(m) for m in dmsgs if m["msgType"] in (1, 2, 7, 8)]
@@ -633,53 +755,6 @@ class AgentClient(BaseAgentClient):  # Bybit client
     #     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)
-            return await sleep(5)
-        req = AdUpdateRequest.model_validate({**mad.model_dump(), "paymentIds": cxids})
-        try:
-            return self.ad_upd(req)
-        except FailedRequestError as e:
-            if ExcCode(e.status_code) == ExcCode.FixPriceLimit:
-                if limits := re.search(
-                    r"The fixed price set is lower than ([0-9]+\.?[0-9]{0,2}) or higher than ([0-9]+\.?[0-9]{0,2})",
-                    e.message,
-                ):
-                    return await self.mad_upd(mad, {"price": limits.group(1 if mad.side else 2)}, cxids)
-            elif ExcCode(e.status_code) == ExcCode.RareLimit:
-                await sleep(180)
-            else:
-                raise e
-        except (ReadTimeoutError, ConnectionDoesNotExistError):
-            logging.warning("Connection failed. Restarting..")
-        print("-" if mad.side else "+", end=req.price, flush=True)
-        await sleep(60)
-
-    def overprice_filter(self, ads: list[Ad], ceil: float, k: Literal[-1, 1]):
-        # вырезаем ads с ценами выше потолка
-        if ads and (ceil - float(ads[0].price)) * k > 0:
-            if int(ads[0].userId) != self.actor.exid:
-                ads.pop(0)
-                self.overprice_filter(ads, ceil, k)
-
-    def get_cad(self, ads: list[Ad], ceil: float, k: Literal[-1, 1], target_place: int, cur_plc: int) -> Ad:
-        if not ads:
-            return None
-        # чью цену будем обгонять, предыдущей или слещующей объявы?
-        # 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}")
-        cad: Ad = ads[target_place]
-        # а цена обгоняемой объявы не выше нашего потолка?
-        if (float(cad.price) - ceil) * k <= 0:
-            # тогда берем следующую
-            ads.pop(target_place)
-            cad = self.get_cad(ads, ceil, k, target_place, cur_plc)
-        # todo: добавить фильтр по лимитам min-max
-        return cad
-
     # @staticmethod
     # def premium_up(mad: Ad, cad: Ad, k: Literal[-1, 1]):
     #     mpc, mpm, cpc, cpm = Decimal(mad.price), Decimal(mad.premium), Decimal(cad.price), Decimal(cad.premium)
@@ -689,511 +764,531 @@ 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,
-    ):
-        coinex: models.CoinEx = await models.CoinEx.get(
-            coin_id=race.road.ad.pair_side.pair.coin_id, ex=self.actor.ex
-        ).prefetch_related("coin")
-        curex: models.CurEx = await models.CurEx.get(
-            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")
-        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:
-            # обновляем все обновления по текущей гонке из бд
-            await race.refresh_from_db()
-            if not race.started:
-                await sleep(5)
-                continue
-            # если гонка дольше Х минут не обновлялась, обновляем ее (и ее пары) потолок
-            expiration = datetime.now(timezone.utc) - timedelta(minutes=15)
-            if race.updated_at < expiration:
-                ceils, hp, vmf, zplace = await self.get_ceils(coinex, curex, pmexs, 0.001, True)
-                race.ceil = int(ceils[int(taker_side)] * 10**curex.scale)
-                await race.save()
-                # upd pair race
-                if prace := await models.Race.annotate(pms_count=Count("road__ad__pms")).get_or_none(
-                    road__ad__pair_side__pair_id=race.road.ad.pair_side.pair_id,
-                    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),
-                ):
-                    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
-            else:  # гонка в стакане покупки - мы продаем МОНЕТУ за фиат
-                asset = await models.Asset.get(addr__actor=self.actor, addr__coin_id=coinex.coin_id)
-                volume = asset.free * 10**-coinex.scale
-            volume = str(round(volume, coinex.scale))
-
+    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,
+        )
+        resp: OrderResp = await self._order_request(bor)
+        return resp
+
+    async def watch_payeer(self, mcs: dict[int, "AgentClient"]):
+        await models.CoinEx.get(coin_id=1, ex=self.actor.ex).prefetch_related("coin")
+        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:
-                ads: list[Ad] = await self.ads(coinex, curex, taker_side, pmexs)
-            except Exception:
-                await sleep(1)
-                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 дороже нашего потолка
+                breq = GetAds(coin_id=1, cur_id=1, is_sell=False, limit=50)
+                bs = await self.ex_client.ads(breq, post_pmexs=post_pmexs)
+                bs = [b for b in bs if float(b.price) < 100 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(8000 + 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_db(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)
+                    await sleep(2)
+                    self.api.mark_as_paid(
+                        orderId=str(odb.exid),
+                        paymentType=str(order.paymentTermList[0].paymentType),  # pmex.exid
+                        paymentId=order.paymentTermList[0].id,  # credex.exid
+                    )
+                    await sleep(3)
+                    if int(ad.userId) in mcs:
+                        mcs[int(ad.userId)].api.release_assets(orderId=order.id)
 
-            if 571 in pm_ids and coinex.coin.ticker == "USDT" and not taker_side:
-                ...
+                await sleep(5)
 
-            if not ads:
-                print(coinex.exid, curex.exid, taker_side, "no ads!")
-                await sleep(15)
-                continue
-            # определяем наше текущее место в уже обрезанном списке ads
-            if not (cur_plc := [i for i, ad in enumerate(ads) if int(ad.userId) == self.actor.exid]):
-                logging.warning(f"No racing in {pmexs[0].name} {'-' if taker_side else '+'}{coinex.exid}/{curex.exid}")
-                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]]
-            # rivals = [
-            #     (await models.RaceStat.update_or_create({"place": plc, "price": ad.price, "premium": ad.premium}, ad=ad))[
-            #         0
-            #     ]
-            #     for plc, ad in enumerate(rads)
-            # ]
-            mad: Ad = ads.pop(cur_plc)
-            # if (
-            #     not (lstat := lstat or await race.stats.order_by("-created_at").first())
-            #     or lstat.place != cur_plc
-            #     or lstat.price != float(mad.price)
-            #     or set(rivals) != set(await lstat.rivals)
-            # ):
-            #     lstat = await models.RaceStat.create(race=race, place=cur_plc, price=mad.price, premium=mad.premium)
-            #     await lstat.rivals.add(*rivals)
-            if not ads:
-                await sleep(60)
-                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)
-            if (
-                float(mad.price) == new_price and volume == last_vol
-            ):  # Если место уже нужное или нужная цена и так уже стоит
-                print(
-                    f"{'v' if taker_side else '^'}{mad.price}",
-                    end=f"[{race.ceil * 10**-curex.scale}+{cur_plc}] ",
-                    flush=True,
-                )
-                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
-                mad.premium = str(round(new_premium, 2))
-            mad.priceType = cad.priceType
-            mad.quantity = volume
-            mad.maxAmount = str(2_000_000)
-            req = AdUpdateRequest.model_validate(
-                {
-                    **mad.model_dump(),
-                    "price": str(round(new_price, curex.scale)),
-                    "paymentIds": [str(p.exid) for p in creds],
-                }
-            )
-            try:
-                print(
-                    f"c{race.ceil * 10**-curex.scale}+{cur_plc} {coinex.coin.ticker}{'-' if taker_side else '+'}{req.price}{curex.cur.ticker}"
-                    f"{[pm.norm for pm in race.road.ad.pms]}{f'({req.premium}%)' if req.premium != '0' else ''} "
-                    f"t{race.target_place} ;",
-                    flush=True,
-                )
-                _res = self.ad_upd(req)
-            except FailedRequestError as e:
-                if ExcCode(e.status_code) == ExcCode.FixPriceLimit:
-                    if limits := re.search(
-                        r"The fixed price set is lower than ([0-9]+\.?[0-9]{0,2}) or higher than ([0-9]+\.?[0-9]{0,2})",
-                        e.message,
-                    ):
-                        req.price = limits.group(1 if taker_side else 2)
-                        if req.price != mad.price:
-                            _res = self.ad_upd(req)
-                    else:
-                        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 * 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]
+                sreq = GetAds(coin_id=1, cur_id=1, is_sell=True, limit=50, kwargs={"post_pmexs": post_pmexs})
+                ss = await self.ex_client.ads(sreq, post_pmexs=post_pmexs)
+                ss = [s for s in ss if float(s.price) > 92 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(10000 + 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_db(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)
+                    await sleep(2)
+                    if int(ad.userId) in mcs:
+                        mcs[int(ad.userId)].api.mark_as_paid(
+                            orderId=str(odb.exid),
+                            paymentType=str(order.paymentTermList[0].paymentType),  # pmex.exid
+                            paymentId=order.paymentTermList[0].id,  # credex.exid
                         )
-                    ][0]
-                    self.ad_del(ad_id=int(mad.id))
-                    req.id = sad.id
-                    req.actionType = "ACTIVE"
-                    self.api.update_ad(**req.model_dump())
-                    logging.warning(f"Ad#{mad.id} recreated")
-                elif ExcCode(e.status_code) == ExcCode.Timestamp:
                     await sleep(3)
-                else:
-                    raise e
-            except (ReadTimeoutError, ConnectionDoesNotExistError):
-                logging.warning("Connection failed. Restarting..")
-            await sleep(6)
-
-    async def get_books(
-        self, coinex: models.CoinEx, curex: models.CurEx, pmexs: list[models.PmEx]
-    ) -> 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)
-        return buy, sell
-
-    async def get_spread(
-        self, bb: list[Ad], sb: list[Ad], perc: float, vmf: bool = None, place: int = 0, exact: bool = False
-    ) -> tuple[tuple[float, float], float, bool, int]:
-        if len(bb) <= place or len(sb) <= place:
-            ...
-        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)
-
-        return (buy_price, sell_price), half_spread, vmf, place
-
-    async def get_ceils(
-        self,
-        coinex: models.CoinEx,
-        curex: models.CurEx,
-        pmexs: list[models.PmEx],
-        min_prof=0.02,
-        vmf: bool = False,
-        place: int = 0,
-    ) -> tuple[tuple[float, float], float, bool, int]:  # todo: refact to Pairex
-        bb, sb = await self.get_books(coinex, curex, 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
-        (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)
-        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,
-        )
-        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
+                    self.api.release_assets(orderId=order.id)
+                await sleep(5)
 
-            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 Exception as e:
+                logging.exception(e)
+                await sleep(30)
+            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_db(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)
+        ...
+
+    pm_clients: dict[int, PmAgentClient]
+
+    async def start_listen(self):
+        t = await self.ott()
+        ts = int(float(t["time_now"]) * 1000)
+        await self.ws_prv(self.agent.auth["cookies"]["deviceId"], t["result"], ts)
+
+    # 3N: [T] - Уведомление об одобрении запроса на сделку
+    async def request_accepted_notify(self) -> int: ...  # id
+
+    async def ws_prv(self, did: str, tok: str, ts: int):
+        u = f"wss://ws2.bybit.com/private?appid=bybit&os=web&deviceid={did}&timestamp={ts}"
+        async with websockets.connect(u) as websocket:
+            auth_msg = json.dumps({"req_id": did, "op": "login", "args": [tok]})
+            await websocket.send(auth_msg)
+
+            sub_msg = json.dumps({"op": "subscribe", "args": ["FIAT_OTC_TOPIC", "FIAT_OTC_ONLINE_TOPIC"]})
+            await websocket.send(sub_msg)
+            sub_msg = json.dumps({"op": "input", "args": ["FIAT_OTC_TOPIC", '{"topic":"SUPER_DEAL"}']})
+            await websocket.send(sub_msg)
+            sub_msg = json.dumps({"op": "input", "args": ["FIAT_OTC_TOPIC", '{"topic":"OTC_ORDER_STATUS"}']})
+            await websocket.send(sub_msg)
+            sub_msg = json.dumps({"op": "input", "args": ["FIAT_OTC_TOPIC", '{"topic":"WEB_THREE_SELL"}']})
+            await websocket.send(sub_msg)
+            sub_msg = json.dumps({"op": "input", "args": ["FIAT_OTC_TOPIC", '{"topic":"APPEALED_CHANGE"}']})
+            await websocket.send(sub_msg)
+
+            sub_msg = json.dumps({"op": "subscribe", "args": ["fiat.cashier.order"]})
+            await websocket.send(sub_msg)
+            sub_msg = json.dumps({"op": "subscribe", "args": ["fiat.cashier.order-eftd-complete-privilege-event"]})
+            await websocket.send(sub_msg)
+            sub_msg = json.dumps({"op": "subscribe", "args": ["fiat.cashier.order-savings-product-event"]})
+            await websocket.send(sub_msg)
+            sub_msg = json.dumps({"op": "subscribe", "args": ["fiat.deal-core.order-savings-complete-event"]})
+            await websocket.send(sub_msg)
+
+            sub_msg = json.dumps({"op": "subscribe", "args": ["FIAT_OTC_TOPIC", "FIAT_OTC_ONLINE_TOPIC"]})
+            await websocket.send(sub_msg)
+            while resp := await websocket.recv():
+                if data := json.loads(resp):
+                    upd, order_db = None, None
+                    logging.info(f" {now().strftime('%H:%M:%S')} upd: {data.get('topic')}:{data.get('type')}")
+                    match data.get("topic"):
+                        case "OTC_ORDER_STATUS":
+                            match data["type"]:
+                                case "STATUS_CHANGE":
+                                    try:
+                                        upd = StatusChange.model_validate(data["data"])
+                                    except ValidationError as e:
+                                        logging.error(e)
+                                        logging.error(data["data"])
+                                    order = self.api.get_order_details(orderId=upd.id)
+                                    order = OrderFull.model_validate(order["result"])
+                                    order_db = await models.Order.get_or_none(
+                                        exid=order.id, ad__exid=order.itemId
+                                    ) or await self.create_order_db(order)
+                                    match upd.status:
+                                        case Status.created:
+                                            logging.info(f"Order {order.id} created at {order.createDate}")
+                                            # сразу уменьшаем доступный остаток монеты/валюты
+                                            await self.money_upd(order_db)
+                                            if upd.side:  # я покупатель - ждем мою оплату
+                                                _dest = order.paymentTermList[0].accountNo
+                                                if not re.match(r"^([PpРр])\d{7,10}\b", _dest):
+                                                    continue
+                                                await order_db.fetch_related("ad__pair_side__pair", "cred__pmcur__cur")
+                                                await self.send_payment(order_db)
+                                        case Status.wait_for_buyer:
+                                            if upd.side == 0:  # ждем когда покупатель оплатит
+                                                if not (pmacdx := await self.get_pma_by_cdex(order)):
+                                                    continue
+                                                pma, cdx = pmacdx
+                                                am, tid = await pma.check_in(
+                                                    float(order.amount),
+                                                    cdx.cred.pmcur.cur.ticker,
+                                                    # todo: почему в московском час.поясе?
+                                                    datetime.fromtimestamp(float(order.transferDate) / 1000),
+                                                )
+                                                if not tid:
+                                                    logging.info(
+                                                        f"Order {order.id} created at {order.createDate}, not paid yet"
+                                                    )
+                                                    continue
+                                                try:
+                                                    t, is_new = await models.Transfer.update_or_create(
+                                                        dict(
+                                                            amount=int(float(order.amount) * 100),
+                                                            order=order_db,
+                                                        ),
+                                                        pmid=tid,
+                                                    )
+                                                except IntegrityError as e:
+                                                    logging.error(tid)
+                                                    logging.error(order)
+                                                    logging.exception(e)
+
+                                                if not is_new:  # если по этому платежу уже отпущен другая продажа
+                                                    continue
+
+                                                # если висят незавершенные продажи с такой же суммой
+                                                pos = (await self.get_pending_orders(1))["result"]
+                                                pos = [
+                                                    o
+                                                    for o in pos.get("items", [])
+                                                    if (
+                                                        o["amount"] == order.amount
+                                                        and o["id"] != upd.id
+                                                        and int(order.createDate)
+                                                        < int(o["createDate"]) + 15 * 60 * 1000
+                                                        # get full_order from o, and cred or pm from full_order:
+                                                        and self.api.get_order_details(orderId=o["id"])["result"][
+                                                            "paymentTermList"
+                                                        ][0]["accountNo"]
+                                                        == order.paymentTermList[0].accountNo
+                                                    )
+                                                ]
+                                                curex = await models.CurEx.get(
+                                                    cur__ticker=order.currencyId, ex=self.ex_client.ex
+                                                )
+                                                pos_db = await models.Order.filter(
+                                                    exid__not=order.id,
+                                                    cred_id=order_db.cred_id,
+                                                    amount=int(float(order.amount) * 10**curex.scale),
+                                                    status__not_in=[OrderStatus.completed, OrderStatus.canceled],
+                                                    created_at__gt=now() - timedelta(minutes=15),
+                                                )
+                                                if pos or pos_db:
+                                                    await self.ex_client.bot.send(
+                                                        f"[Duplicate amount!]"
+                                                        f"(https://www.bybit.com/ru-RU/p2p/orderList/{order.id})",
+                                                        self.actor.person.user.username_id,
+                                                    )
+                                                    logging.warning("Duplicate amount!")
+                                                    continue
+
+                                                # !!! ОТПРАВЛЯЕМ ДЕНЬГИ !!!
+                                                self.api.release_assets(orderId=upd.id)
+                                                logging.info(
+                                                    f"Order {order.id} created, paid before #{tid}:{am} at {order.createDate}, and RELEASED at {now()}"
+                                                )
+                                            elif upd.side == 1:  # я покупатель - ждем мою оплату
+                                                continue  # logging.warning(f"Order {order.id} PAID at {now()}: {int_am}")
+                                            else:
+                                                ...
+                                            # todo: check is always canceling
+                                            # await order_db.update_from_dict({"status": OrderStatus.canceled}).save()
+                                            # logging.info(f"Order {order.id} canceled at {datetime.now()}")
+
+                                        case Status.wait_for_seller:
+                                            if order_db.status == OrderStatus.paid:
+                                                continue
+                                            await order_db.update_from_dict(
+                                                {
+                                                    "status": OrderStatus.paid,
+                                                    "payed_at": datetime.fromtimestamp(
+                                                        float(order.transferDate) / 1000
+                                                    ),
+                                                }
+                                            ).save()
+                                            logging.info(f"Order {order.id} payed at {order_db.payed_at}")
+
+                                        case Status.appealed:
+                                            # todo: appealed by WHO? щас наугад стоит by_seller
+                                            await order_db.update_from_dict(
+                                                {
+                                                    "status": OrderStatus.appealed_by_seller,
+                                                    "appealed_at": datetime.fromtimestamp(
+                                                        float(order.updateDate) / 1000
+                                                    ),
+                                                }
+                                            ).save()
+                                            logging.info(f"Order {order.id} appealed at {order_db.appealed_at}")
+
+                                        case Status.canceled:
+                                            await order_db.update_from_dict({"status": OrderStatus.canceled}).save()
+                                            logging.info(f"Order {order.id} canceled at {datetime.now()}")
+                                            await self.money_upd(order_db)
+
+                                        case Status.completed:
+                                            await order_db.update_from_dict(
+                                                {
+                                                    "status": OrderStatus.completed,
+                                                    "confirmed_at": datetime.fromtimestamp(
+                                                        float(order.updateDate) / 1000
+                                                    ),
+                                                }
+                                            ).save()
+                                            await self.money_upd(order_db)
+
+                                        case _:
+                                            logging.warning(f"Order {order.id} UNKNOWN STATUS {datetime.now()}")
+                                case "COUNT_DOWN":
+                                    upd = CountDown.model_validate(data["data"])
+                                case _:
+                                    self.listen(data)
+                        case "OTC_USER_CHAT_MSG":
+                            match data["type"]:
+                                case "RECEIVE":
+                                    upd = Receive.model_validate(data["data"])
+                                    if order_db := await models.Order.get_or_none(
+                                        exid=upd.orderId, ad__maker__ex=self.actor.ex
+                                    ).prefetch_related("ad__pair_side__pair", "cred__pmcur__cur"):
+                                        im_taker = order_db.taker_id == self.actor.id
+                                        im_buyer = order_db.ad.pair_side.is_sell == im_taker
+                                        if order_db.ad.auto_msg != upd.message and upd.roleType == "user":
+                                            msg, _ = await models.Msg.update_or_create(
+                                                {
+                                                    "to_maker": upd.userId == self.actor.exid and im_taker,
+                                                    "sent_at": datetime.fromtimestamp(float(upd.createDate) / 1000),
+                                                },
+                                                txt=upd.message,
+                                                order=order_db,
+                                            )
+                                            if not upd.message:
+                                                ...
+                                            if im_buyer and (g := re.match(r"^[PpРр]\d{7,10}\b", upd.message)):
+                                                if not order_db.cred.detail.startswith(dest := g.group()):
+                                                    order_db.cred.detail = dest
+                                                    await order_db.save()
+                                                await self.send_payment(order_db)
+                                case "READ":
+                                    upd = Read.model_validate(data["data"])
+                                    # if upd.status not in (StatusWs.created, StatusWs.canceled, 10, StatusWs.completed):
+                                    if upd.orderStatus in (
+                                        Status.wait_for_buyer,
+                                    ):  # todo: тут приходит ордер.статус=10, хотя покупатель еще не нажал оплачено
+                                        order = self.api.get_order_details(orderId=upd.orderId)["result"]
+                                        order = OrderFull.model_validate(order)
+
+                                case "CLEAR":
+                                    continue
+                                case _:
+                                    self.listen(data)
+                        case "OTC_USER_CHAT_MSG_V2":
+                            # match data["type"]:
+                            #     case "RECEIVE":
+                            #         upd = Receive.model_validate(data["data"])
+                            #     case "READ":
+                            #         upd = Read.model_validate(data["data"])
+                            #     case "CLEAR":
+                            #         pass
+                            #     case _:
+                            #         self.listen(data)
+                            continue
+                        case "SELLER_CANCEL_CHANGE":
+                            upd = SellerCancelChange.model_validate(data["data"])
+                        case None:
+                            if not data.get("success"):
+                                logging.error(data, "NOT SUCCESS!")
+                            else:
+                                continue  # success login, subscribes, input
+                        case _:
+                            logging.warning(data, "UNKNOWN TOPIC")
                     ...
-                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()
+                    if not upd:
+                        logging.warning(data, "NOT PROCESSED UPDATE")
+
+    async def money_upd(self, odb: models.Order):
+        # обновляем остаток монеты
+        await odb.fetch_related("ad__pair_side__pair", "ad__my_ad__credexs__cred__fiat", "cred__pmcur", "transfer")
+        ass = await models.Asset.get(addr__coin_id=odb.ad.pair_side.pair.coin_id, addr__actor=self.actor)
+        # обновляем остаток валюты
+        im_maker = odb.ad.maker_id == self.actor.id
+        im_seller = odb.ad.pair_side.is_sell == im_maker
+        if im_maker:
+            if _fiats := [cx.cred.fiat for cx in odb.ad.my_ad.credexs if cx.cred.fiat]:
+                fiat = _fiats[0]
+                await fiat.fetch_related("cred__pmcur__pm")
             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()
+                raise ValueError(odb, "No Fiat")
+        elif im_seller:  # im taker
+            fltr = dict(cred__person_id=self.actor.person_id)
+            fltr |= (
+                {"cred__ovr_pm_id": odb.cred.ovr_pm_id, "cred__pmcur__cur_id": odb.cred.pmcur.cur_id}
+                if odb.cred.ovr_pm_id
+                else {"cred__pmcur_id": odb.cred.pmcur_id}
+            )
+            if not (fiat := await models.Fiat.get_or_none(**fltr).prefetch_related("cred__pmcur__pm")):
+                raise ValueError(odb, "No Fiat")
+        fee = round(odb.amount * (fiat.cred.pmcur.pm.fee or 0) * 0.0001)
+        # k = int(im_seller) * 2 - 1  # im_seller: 1, im_buyer: -1
+        if odb.status == OrderStatus.created:
+            if im_seller:
+                ass.free -= odb.quantity
+                ass.freeze += odb.quantity
+            else:  # я покупатель
+                fiat.amount -= odb.amount + fee
+        elif odb.status == OrderStatus.completed:
+            if im_seller:
+                fiat.amount += odb.amount
+            else:  # я покупатель
+                ass.free += odb.quantity
+        elif odb.status == OrderStatus.canceled:
+            if im_seller:
+                ass.free += odb.quantity
+                ass.freeze -= odb.quantity
+            else:  # я покупатель
+                fiat.amount += odb.amount + fee
         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,
-        )
+            logging.exception(odb.id, f"STATUS: {odb.status.name}")
+        await ass.save(update_fields=["free", "freeze"])
+        await fiat.save(update_fields=["amount"])
+        logging.info(f"Order #{odb.id} {odb.status.name}. Fiat: {fiat.amount}, Asset: {ass.free}")
 
-    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
+    async def send_payment(self, order_db: models.Order):
+        if order_db.status != OrderStatus.created:
+            return
+        fmt_am = round(order_db.amount * 10**-2, 2)
+        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.actor.ex)
+            credex = await models.CredEx.get(cred=order_db.cred, ex=self.actor.ex)
+            self.api.mark_as_paid(
+                orderId=str(order_db.exid),
+                paymentType=pmex.exid,  # pmex.exid
+                paymentId=str(credex.exid),  # credex.exid
+            )
+            # проверяем не отправляли ли мы уже перевод по этому ордеру
+            if t := await models.Transfer.get_or_none(order=order_db, amount=order_db.amount):
+                await pma.bot.send(
+                    f"Order# {order_db.exid}: Double send {fmt_am}{cur} to {order_db.cred.detail} #{t.pmid}!",
+                    self.actor.person.user.username_id,
+                )
+                raise Exception(
+                    f"Order# {order_db.exid}: Double send {fmt_am}{cur} to {order_db.cred.detail} #{t.pmid}!"
+                )
 
-        # Строим дерево снизу вверх
-        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?
+            # ставим в бд статус "оплачен"
+            order_db.status = OrderStatus.paid
+            order_db.payed_at = datetime.now(timezone.utc)
+            await order_db.save()
+            # создаем перевод в бд
+            t = models.Transfer(order=order_db, amount=order_db.amount, updated_at=now())
+            # отправляем деньги
+            tid, img = await pma.send(t)
+            t.pmid = tid
+            await t.save()
+            await self.send_receipt(str(order_db.exid), tid)  # отправляем продавцу чек
+            logging.info(f"Order {order_db.exid} PAID at {datetime.now()}: {fmt_am}!")
+
+    async def send_receipt(self, oexid: str, tid: int) -> tuple[PmAgentClient | None, models.CredEx] | None:
+        try:
+            if res := self.api.upload_chat_file(upload_file=f"tmp/{tid}.png").get("result"):
+                await sleep(0.5)
+                self.api.send_chat_message(orderId=oexid, contentType="pic", message=res["url"], msgUuid=uuid4().hex)
+        except Exception as e:
+            logging.error(e)
+        await sleep(0.5)
+        self.api.send_chat_message(orderId=oexid, contentType="str", message=f"#{tid}", msgUuid=uuid4().hex)
+
+    async def get_pma_by_cdex(self, order: OrderFull) -> tuple[PmAgentClient | None, models.CredEx] | None:
+        cdxs = await models.CredEx.filter(
+            ex=self.ex_client.ex,
+            exid__in=[ptl.id for ptl in order.paymentTermList],
+            cred__person=self.actor.person,
+        ).prefetch_related("cred__pmcur__cur")
+        pmas = [pma for cdx in cdxs if (pma := self.pm_clients.get(cdx.cred.pmcur.pm_id))]
+        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}")
+        else:
+            return pmas[0], cdxs[0]
 
-        # Находим корни / без родителей
-        roots = set(self.cond_sims.values()) - set(self.cond_sims.keys())
-        for root in roots:
-            _ = subtree(tree[root])
+    async def get_pma_by_pmex(self, order_db: models.Order) -> tuple[PmAgentClient, str]:
+        pma = self.pm_clients.get(order_db.cred.pmcur.pm_id)
+        if pma:
+            return pma, order_db.cred.pmcur.cur.ticker
+        logging.error(f"No pm_agents for {order_db.cred.pmcur.pm_id}")
 
-        self.tree = tree
+    @staticmethod
+    def listen(data: dict | None):
+        # print(data)
+        ...
 
 
 def ms2utc(msk_ts_str: str):
     return datetime.fromtimestamp(int(msk_ts_str) / 1000, timezone(timedelta(hours=3), name="MSK"))
 
 
-def get_sim(s1, s2) -> int:
-    sim = int((SequenceMatcher(None, s1, s2).ratio() - 0.6) * 10_000)
-    return sim if sim > 0 else 0
-
-
 def detailed_diff(str1, str2):
     matcher = SequenceMatcher(None, str1, str2)
     result = []
@@ -1211,31 +1306,6 @@ 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 округляется до целого, но на бэке байбита его дробная часть больше
-    return (
-        bool(set(cad.authTag) & {"VA2", "BA"})
-        or cad.recentExecuteRate > mad.recentExecuteRate
-        or (
-            cad.recentExecuteRate
-            == mad.recentExecuteRate  # and cad.finishNum > mad.finishNum # пока прибавляем для равных
-        )
-    )
-
-
-def step(mad, cad, scale: int = 2) -> float:
-    return float(int(step_is_need(mad, cad)) * 10**-scale).__round__(scale)
-
-
 class ExcCode(IntEnum):
     FixPriceLimit = 912120022
     RareLimit = 912120050
@@ -1243,37 +1313,82 @@ 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 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=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 = actor.client(filebot)
+    ex = await models.Ex.get(name="Bybit")
+    ecl: ExClient = ex.client(filebot)
+    abot = XyncBot(PAY_TOKEN, cn)
+    # pmas = await models.PmAgent.filter(active=True, user_id=1).prefetch_related("pm", "user__gmail")
+    # pm_clients = {pma.pm_id: pma.client(abot) for pma in pmas}
+    prx = PRX and "http://" + PRX
+    cl: AgentClient = agent.client(ecl, filebot, abot, proxy=prx)
+
+    # 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()
 
+    my_ad = await models.MyAd[5]
+    await cl.ad_share(my_ad.id)
+    await cl.start_listen()
+
+    ms = await models.Agent.filter(
+        actor__ex_id=4, auth__isnull=False, status__gt=AgentStatus.off, actor__person__user__id__in=[3]
+    ).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}
+
+    await gather(
+        # create_task(cl.start()),
+        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')
@@ -1286,28 +1401,6 @@ async def main():
     #     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}")
-
     pauth = (await models.PmAgent[1]).auth
     papi = PayeerAPI(pauth["email"], pauth["api_id"], pauth["api_sec"])
     hist: dict = papi.history(count=1000)
@@ -1320,32 +1413,6 @@ async def main():
     # )
     # 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()
-    try:
-        await gather(
-            *tasks
-            # cl.get_api_orders(),  # 10, 1738357200000, 1742504399999
-        )
-    except Exception as e:
-        await filebot.send("🤬Bybit agent CRASHED!!!🤬", actor.person.user.username_id)
-        await filebot.send(e.__repr__(), actor.person.user.username_id)
-        raise e
-    # 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 filebot.stop()
     await cl.close()