xync-client 0.0.147__py3-none-any.whl → 0.0.150__py3-none-any.whl

xync_client/Bybit/agent.py

@@ -2,10 +2,10 @@ import asyncio
 import logging
 import re
 from asyncio import sleep, gather
-from collections import defaultdict
 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
@@ -18,7 +18,7 @@ from payeer_api import PayeerAPI
 from pyro_client.client.file import FileClient
 from tortoise import BaseDBAsyncClient
 from tortoise.exceptions import IntegrityError
-from tortoise.expressions import F, Q
+from tortoise.expressions import Q
 from tortoise.functions import Count
 from tortoise.signals import post_save
 from urllib3.exceptions import ReadTimeoutError
@@ -28,7 +28,7 @@ from xync_bot import XyncBot
 from xync_schema import models
 from xync_schema.enums import OrderStatus
 
-from xync_schema.models import Actor, Cond, CondSim, PmCur, PairSide, Agent
+from xync_schema.models import Actor, PmCur, Agent
 
 from xync_client.Abc.Agent import BaseAgentClient
 from xync_client.Abc.xtype import FlatDict, BaseOrderReq
@@ -54,8 +54,11 @@ class NoMakerException(Exception):
 
 
 class AgentClient(BaseAgentClient):  # Bybit client
-    host = "api2.bybit.com"
-    headers = {"cookie": ";"}  # rewrite token for public methods
+    headers = {
+        # "accept": "application/json",
+        "Cookie": ";",
+    }
+    # rewrite token for public methods
     api: P2P
     last_ad_id: list[str] = []
     update_ad_body = {
@@ -85,28 +88,24 @@ 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, agent: Agent, fbot: FileClient, bbot: XyncBot, **kwargs):
         super().__init__(agent, fbot, bbot, **kwargs)
         self.api = P2P(testnet=False, api_key=agent.auth["key"], api_secret=agent.auth["sec"])
-        self.hist: dict = None
-        self.completed_orders: list[int] = None
+        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,
@@ -118,12 +117,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()
@@ -149,8 +144,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 pmex.pm.df_cur_id
                 or (pmex.pm.country_id and (await pmex.pm.country).cur_id)
                 # or (ecdx.currencyBalance and await models.Cur.get_or_none(ticker=ecdx.currencyBalance[0]))
-                or (0 < len(pmex.pm.curs) < 30 and pmex.pm.curs[-1].id)
-                or await self.guess_cur(ecdx)
+                or await self.guess_cur(ecdx, len(pmex.pm.curs) > 1 and pmex.pm.curs)
             )
         if not cur_id:
             raise Exception(f"Set default cur for {pmex.name}")
@@ -169,7 +163,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
         credex_db, _ = await models.CredEx.update_or_create(**credex_in.df_unq())
         return credex_db
 
-    async def guess_cur(self, ecdx: CredEpyd):
+    async def guess_cur(self, ecdx: CredEpyd, curs: list[models.Cur]):
         mbs = ecdx.bankName.split(", ")
         mbs += ecdx.branchName.split(" / ")
         mbs = {mb.lower(): mb for mb in mbs}
@@ -181,7 +175,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
@@ -191,6 +185,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: Список реквизитов моих платежных методов
@@ -206,28 +202,28 @@ class AgentClient(BaseAgentClient):  # Bybit client
     # 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(
@@ -244,10 +240,6 @@ class AgentClient(BaseAgentClient):  # Bybit client
             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"}]
@@ -264,27 +256,42 @@ 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 self.ex_client.ad_load(ad, maker=self.actor) for ad in ads]
         res = [await models.MyAd.update_or_create(ad=ad) for ad in res]
         return len(res)
 
     def get_security_token_create(self):
-        data = self._post("/fiat/otc/item/create", self.create_ad_body)
+        data = self._post("/x-api/fiat/otc/item/create", self.create_ad_body)
         if data["ret_code"] == 912120019:  # Current user can not to create add as maker
             raise NoMakerException(data)
         security_risk_token = data["result"]["securityRiskToken"]
         return security_risk_token
 
     async def _check_2fa(self, risk_token) -> int:
-        cres = await self._post("/user/public/risk/components", {"risk_token": risk_token})
-        if cres["ret_msg"] != "success":
+        res = await self._post(
+            "/x-api/user/public/risk/components",
+            {"risk_token": risk_token},
+            hdrs={
+                # "Accept-Language": "ru,en;q=0.9",
+            },
+        )
+        if res["ret_msg"] != "success":
             raise HTTPException("get")
-        cres = cres["result"]["component_list"]
+        cres = sorted(res["result"]["component_list"], key=lambda c: c["component_id"], reverse=True)
+        # cres = [{"component_id": "payment_password_verify"}]
+        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(
-            "/user/public/risk/verify",
-            {
-                "risk_token": risk_token,
-                "component_list": {c["component_id"]: self.__get_2fa(c["component_id"]) for c in cres},
+            "/x-api/user/public/risk/verify",
+            vdata,
+            hdrs={
+                "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+                "accept-language": "ru,en;q=0.9",
+                # "accept-language": "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7",
+                "accept-encoding": "gzip, deflate, br, zstd",
+                "accept": "application/json",
             },
         )
         if res["ret_msg"] != "success":
@@ -293,25 +300,32 @@ class AgentClient(BaseAgentClient):  # Bybit client
             await self._check_2fa(risk_token)
         return res["ret_code"]
 
-    async def __get_2fa(self, typ: Literal["google2fa", "email_verify", "payment_password_verify"], rt: str = None):
-        if typ == "google2fa":
-            bybit_secret = self.agent.auth["2fa"]
-            totp = pyotp.TOTP(bybit_secret)
-            return totp.now()
-        elif typ == "email_verify":
-            res = await self._post("/user/public/risk/send/code", {"risk_token": rt, "component_id": "email_verify"})
-            if res["ret_msg"] != "success":
-                return self.gmail.bybit_code()
-            elif cool_down := int(res["result"]["cool_down"]):
-                await sleep(cool_down)
+    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":
+            #     "accept-language": "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7",
+            #     "accept": "application/json"
+            res = await self._post("/x-api/user/public/risk/send/code", {"risk_token": rt, "component_id": typ})
+        if res["ret_msg"] == "success":
+            if typ == "google2fa":
+                bybit_secret = self.agent.auth["2fa"]
+                totp = pyotp.TOTP(bybit_secret)
+                return totp.now()
+            elif typ == "email_verify":
                 return self.gmail.bybit_code()
-        elif typ == "payment_password_verify":
-            return self.agent.auth["pass"]
+            elif typ == "payment_password_verify":
+                hp = sha256(self.agent.auth["pass"].encode()).hexdigest()
+                return hp
+        elif cool_down := int(res["result"]["cool_down"]):
+            await sleep(cool_down)
+            return self.__get_2fa(typ, rt)
         raise Exception("2fa fail")
 
     def _post_ad(self, risk_token: str):
         self.create_ad_body.update({"securityRiskToken": risk_token})
-        data = self._post("/fiat/otc/item/create", self.create_ad_body)
+        data = self._post("/x-api/fiat/otc/item/create", self.create_ad_body)
         return data
 
     # создание объявлений
@@ -337,7 +351,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
     def get_security_token_update(self) -> str:
         self.update_ad_body["id"] = self.last_ad_id
-        data = self._post("/fiat/otc/item/update", self.update_ad_body)
+        data = self._post("/x-api/fiat/otc/item/update", self.update_ad_body)
         security_risk_token = data["result"]["securityRiskToken"]
         return security_risk_token
 
@@ -354,7 +368,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
     def update_ad(self, risk_token: str):
         self.update_ad_body.update({"securityRiskToken": risk_token})
-        data = self._post("/fiat/otc/item/update", self.update_ad_body)
+        data = self._post("/x-api/fiat/otc/item/update", self.update_ad_body)
         return data
 
     def ad_del(self, ad_id: int):
@@ -362,7 +376,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
         return data
 
     async def __preorder_request(self, ad_id: int) -> PreOrderResp:
-        res = await self._post("/fiat/otc/item/simple", data={"item_id": str(ad_id)})
+        res = await self._post("/x-api/fiat/otc/item/simple", json={"item_id": str(ad_id)})
         if res["ret_code"] == 0:
             res = res["result"]
         return PreOrderResp.model_validate(res)
@@ -373,20 +387,18 @@ class AgentClient(BaseAgentClient):  # Bybit client
             tokenId=br.coin_exid,
             currencyId=br.cur_exid,
             side="1" if br.is_sell else "0",
-            amount=str(br.fiat_amount),
+            amount=f"{br.fiat_amount:.2f}".rstrip("0").rstrip("."),
             curPrice=por.curPrice,
             quantity=str(round(br.fiat_amount / float(por.price), br.coin_scale)),
             flag="amount",
-            # paymentType="51",
-            # paymentId="20399134",
             # online="0"
         )
         if br.is_sell:
             credex = await models.CredEx.get(
                 cred__person_id=self.actor.person_id,
-                pmcur__pm__pmexs__exid=por.payments[0],
-                pmcur__pm__pmexs__ex_id=self.ex_client.ex.id,
-                pmcur__cur_id=br.cur_exid,
+                cred__pmcur__pm__pmexs__exid=por.payments[0],
+                cred__pmcur__pm__pmexs__ex_id=self.ex_client.ex.id,
+                cred__pmcur__cur__ticker=br.cur_exid,
             )
             req = OrderSellRequest(**req.model_dump(), paymentType=por.payments[0], paymentId=str(credex.exid))
         return req
@@ -398,9 +410,12 @@ class AgentClient(BaseAgentClient):  # Bybit client
         return await self.__order_create(req, bor)
 
     async def __order_create(self, req: OrderRequest | OrderSellRequest, bor: BaseOrderReq) -> OrderResp:
-        res: dict = await self._post("/fiat/otc/order/create", data=req.model_dump())
+        res: dict = await self._post("/x-api/fiat/otc/order/create", json=req.model_dump())
         if res["ret_code"] == 0:
             resp = OrderResp.model_validate(res["result"])
+        elif res["ret_code"] == 10001:
+            logging.error(req.model_dump(), "POST", self.session._base_url)
+            raise HTTPException()
         elif res["ret_code"] == 912120030 or res["ret_msg"] == "The price has changed, please try again later.":
             resp = await self._order_request(bor)
         if not resp.orderId and resp.needSecurityRisk:
@@ -414,15 +429,15 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
     async def cancel_order(self, order_id: str) -> bool:
         cr = CancelOrderReq(orderId=order_id)
-        res = await self._post("/fiat/otc/order/cancel", cr.model_dump())
+        res = await self._post("/x-api/fiat/otc/order/cancel", cr.model_dump())
         return res["ret_code"] == 0
 
     def get_order_info(self, order_id: str) -> dict:
-        data = self._post("/fiat/otc/order/info", json={"orderId": order_id})
+        data = self._post("/x-api/fiat/otc/order/info", json={"orderId": order_id})
         return data["result"]
 
     def get_chat_msg(self, order_id):
-        data = self._post("/fiat/otc/order/message/listpage", json={"orderId": order_id, "size": 100})
+        data = self._post("/x-api/fiat/otc/order/message/listpage", json={"orderId": order_id, "size": 100})
         msgs = [
             {"text": msg["message"], "type": msg["contentType"], "role": msg["roleType"], "user_id": msg["userId"]}
             for msg in data["result"]["result"]
@@ -431,14 +446,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",
@@ -458,7 +473,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
         self, side: int = None, status: int = None, begin_time: int = None, end_time: int = None, token_id: str = None
     ):
         return await self._post(
-            "/fiat/otc/order/pending/simplifyList",
+            "/x-api/fiat/otc/order/pending/simplifyList",
             {
                 "status": status,
                 "tokenId": token_id,
@@ -472,7 +487,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
     def get_orders_done(self, begin_time: int, end_time: int, status: int, side: int, token_id: str):
         return self._post(
-            "/fiat/otc/order/simplifyList",
+            "/x-api/fiat/otc/order/simplifyList",
             {
                 "status": status,  # 50 - завершено
                 "tokenId": token_id,
@@ -494,12 +509,14 @@ class AgentClient(BaseAgentClient):  # Bybit client
         maker_name = order.buyerRealName, order.sellerRealName
         im_maker = int(order.makerUserId == order.userId)
         taker_id = (order.userId, order.targetUserId)[im_maker]
-        taker_person = await self.person_upsert(maker_name[::-1][ad.side], taker_id)
+        taker_person = await self.ex_client.person_name_update(maker_name[::-1][ad.side], taker_id)
         seller_person = (
-            self.actor.person if order.side else await self.person_upsert(order.sellerRealName, int(order.targetUserId))
+            self.actor.person
+            if order.side
+            else await self.ex_client.person_name_update(order.sellerRealName, int(order.targetUserId))
         )
         taker_nick = (self.actor.name, order.targetNickName)[im_maker]  # todo: check
-        ad_db, cond_isnew = await self.cond_upsert(ad, maker_name[ad.side], force=True)
+        ad_db, cond_isnew = await self.ex_client.cond_load(ad, force=True, rname=maker_name[ad.side])
         if not ad_db:
             ...
         ecredex: CredEpyd = order.confirmedPayTerm
@@ -602,7 +619,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
             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:
@@ -755,7 +772,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
         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)
+        creds: list[models.CredEx] = await self.actor.get_credexs_by(pm_ids, curex.cur_id)
         _lstat, volume = None, 0
 
         while self.actor.person.user.status > 0:
@@ -814,7 +831,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 await sleep(15)
                 continue
             (cur_plc,) = cur_plc  # может упасть если в списке > 1 наш ad
-            [(await self.cond_upsert(ad, ps=race.road.ad.pair_side, force=True))[0] for ad in ads[:cur_plc]]
+            [(await self.ex_client.cond_load(ad, race.road.ad.pair_side, True))[0] for ad in ads[:cur_plc]]
             # rivals = [
             #     (await models.RaceStat.update_or_create({"place": plc, "price": ad.price, "premium": ad.premium}, ad=ad))[
             #         0
@@ -955,310 +972,89 @@ class AgentClient(BaseAgentClient):  # Bybit client
         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
+    async def _take_ad(self, req: TakeAdReq):
+        res = self.api.get_ad_details(itemId=req.ad_id)["result"]
+        ad: Ad = Ad.model_validate(res)
 
-        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
-
-            for i, ad in enumerate(ads):
-                if (ceil - float(ad.price)) * k < 0:
-                    break
-                if int(ad.userId) == self.actor.exid:
-                    logging.info(f"My ad {'-' if taker_side else '+'}{coinex.exid}/{curex.exid} on place#{i}")
-                    continue
-                ad_db, isnew = await self.cond_upsert(ad, ps=ps)
-                if isnew:
-                    s = f"{'-' if taker_side else '+'}{ad.price}[{ad.minAmount}-{ad.maxAmount}]{coinex.exid}/{curex.exid}"
-                    print(s, end=" | ", flush=True)
-                try:
-                    # take
-                    ...
-                except FailedRequestError as e:
-                    if ExcCode(e.status_code) == ExcCode.RareLimit:
-                        await sleep(195)
-                    elif ExcCode(e.status_code) == ExcCode.Timestamp:
-                        await sleep(2)
-                    else:
-                        raise e
-                except (ReadTimeoutError, ConnectionDoesNotExistError):
-                    logging.warning("Connection failed. Restarting..")
-            await sleep(3)
-
-    async def cond_upsert(
-        self, ad: Ad, rname: str = None, ps: PairSide = None, force: bool = False
-    ) -> tuple[models.Ad, bool]:
-        _sim, cid = None, None
-        ad_db = await models.Ad.get_or_none(exid=ad.id, maker__ex=self.ex_client.ex).prefetch_related("cond")
-        # если точно такое условие уже есть в бд
-        if not (cleaned := clean(ad.remark)) or (cid := {oc[0]: ci for ci, oc in self.all_conds.items()}.get(cleaned)):
-            # и объява с таким ид уже есть, но у нее другое условие
-            if ad_db and ad_db.cond_id != cid:
-                # то обновляем ид ее условия
-                ad_db.cond_id = cid
-                await ad_db.save()
-                logging.info(f"{ad.nickName} upd cond#{ad_db.cond_id}->{cid}")
-                # old_cid = ad_db.cond_id # todo: solve race-condition, а пока что очищаем при каждом запуске
-                # if not len((old_cond := await Cond.get(id=old_cid).prefetch_related('ads')).ads):
-                #     await old_cond.delete()
-                #     logging.warning(f"Cond#{old_cid} deleted!")
-            return (ad_db or force and await self.ad_create(ad, cid, rname, ps)), False
-        # если эта объява в таким ид уже есть в бд, но с другим условием (или без), а текущего условия еще нет в бд
-        if ad_db:
-            await ad_db.fetch_related("cond__ads", "maker")
-            if not ad_db.cond_id or (
-                # у измененного условия этой объявы есть другие объявы?
-                (rest_ads := set(ad_db.cond.ads) - {ad_db})
-                and
-                # другие объявы этого условия принадлежат другим юзерам
-                {ra.maker_id for ra in rest_ads} - {ad_db.maker_id}
-            ):
-                # создадим новое условие и присвоим его только текущей объяве
-                cid = await self.cond_new(cleaned, {int(ad.userId)})
-                ad_db.cond_id = cid
-                await ad_db.save()
-
-                return ad_db, True
-            # а если других объяв со старым условием этой обявы нет, либо они все этого же юзера
-            # обновляем условие (в тч во всех ЕГО объявах)
-            ad_db.cond.last_ver = ad_db.cond.raw_txt
-            ad_db.cond.raw_txt = cleaned
-            await ad_db.cond.save()
-            await self.cond_upd(ad_db.cond, {ad_db.maker.exid})
-            # и подправим коэфициенты похожести нового текста
-            await self.fix_rel_sims(ad_db.cond_id, cleaned)
-            return ad_db, False
-
-        cid = await self.cond_new(cleaned, {int(ad.userId)})
-        return await self.ad_create(ad, cid, rname, ps), True
-
-    async def cond_new(self, txt: str, uids: set[int]) -> int:
-        new_cond, _ = await Cond.update_or_create(raw_txt=txt)
-        # и максимально похожую связь для нового условия (если есть >= 60%)
-        await self.cond_upd(new_cond, uids)
-        return new_cond.id
-
-    async def cond_upd(self, cond: Cond, uids: set[int]):
-        self.all_conds[cond.id] = cond.raw_txt, uids
-        # и максимально похожую связь для нового условия (если есть >= 60%)
-        old_cid, sim = await self.cond_get_max_sim(cond.id, cond.raw_txt, uids)
-        await self.actual_sim(cond.id, old_cid, sim)
-
-    def find_in_tree(self, cid: int, old_cid: int) -> bool:
-        if p := self.cond_sims.get(old_cid):
-            if p == cid:
-                return True
-            return self.find_in_tree(cid, p)
-        return False
-
-    async def cond_get_max_sim(self, cid: int, txt: str, uids: set[int]) -> tuple[int | None, int | None]:
-        # находим все старые тексты похожие на 90% и более
-        if len(txt) < 15:
-            return None, None
-        sims: dict[int, int] = {}
-        for old_cid, (old_txt, old_uids) in self.all_conds.items():
-            if len(old_txt) < 15 or uids == old_uids:
-                continue
-            elif not self.can_add_sim(cid, old_cid):
-                continue
-            if sim := get_sim(txt, old_txt):
-                sims[old_cid] = sim
-        # если есть, берем самый похожий из них
-        if sims:
-            old_cid, sim = max(sims.items(), key=lambda x: x[1])
-            await sleep(0.3)
-            return old_cid, sim
-        return None, None
-
-    def can_add_sim(self, cid: int, old_cid: int) -> bool:
-        if cid == old_cid:
-            return False
-        elif self.cond_sims.get(cid) == old_cid:
-            return False
-        elif self.find_in_tree(cid, old_cid):
-            return False
-        elif self.cond_sims.get(old_cid) == cid:
-            return False
-        elif cid in self.rcond_sims.get(old_cid, {}):
-            return False
-        elif old_cid in self.rcond_sims.get(cid, {}):
-            return False
-        return True
-
-    async def person_upsert(self, name: str, exid: int) -> models.Person:
-        if actor := await models.Actor.get_or_none(exid=exid, ex=self.ex_client.ex).prefetch_related("person"):
-            if not actor.person:
-                actor.person = await models.Person.create(name=name)
-                await actor.save()
-            return actor.person
-        return await models.Person.create(name=name)
-
-    async def ad_create(
-        self, ad: Ad, cid: int = None, rname: str = None, ps: PairSide = None, actor: Actor = None
-    ) -> models.Ad:
-        act_df = {}
-        if int(ad.userId) != self.actor.exid:
-            act_df |= {"name": ad.nickName}
-        if rname:
-            act_df |= {"person": await self.person_upsert(rname, int(ad.userId))}
-        if not actor:
-            act_df |= {"person": await self.person_upsert(ad.nickName, int(ad.userId))}
-            actor, _ = await Actor.update_or_create(act_df, exid=ad.userId, ex=self.ex_client.ex)
-        ps = ps or await PairSide.get_or_none(
-            is_sell=ad.side,
-            pair__coin__ticker=ad.tokenId,
-            pair__cur__ticker=ad.currencyId,
-        ).prefetch_related("pair__cur", "pair__coin")
-        if not ps or not ps.pair:
-            ...  # THB/USDC
-        ad_upd = models.Ad.validate(ad.model_dump(by_alias=True))
-        cur_scale = 10**ps.pair.cur.scale
-        coinex = await models.CoinEx.get(coin_id=ps.pair.coin_id, ex=self.ex_client.ex)
-        df_unq = ad_upd.df_unq(
-            maker_id=actor.id,
-            pair_side_id=ps.id,
-            amount=int(float(ad.quantity) * float(ad.price) * cur_scale),
-            quantity=int(float(ad.quantity) * 10**coinex.scale),
-            min_fiat=int(float(ad.minAmount) * cur_scale),
-            max_fiat=ad.maxAmount and int(float(ad.maxAmount) * cur_scale),
-            price=int(float(ad.price) * cur_scale),
-            premium=int(float(ad.premium) * cur_scale),
-        )
-        ad_db, _ = await models.Ad.update_or_create(**df_unq)
-        await ad_db.pms.add(*(await models.Pm.filter(pmexs__ex=self.ex_client.ex, pmexs__exid__in=ad.payments)))
-        return ad_db
-
-    async def fix_rel_sims(self, cid: int, new_txt: str):
-        for rel_sim in await CondSim.filter(cond_rel_id=cid).prefetch_related("cond"):
-            if sim := get_sim(new_txt, rel_sim.cond.raw_txt):
-                rel_sim.similarity = sim
-                await rel_sim.save()
-            else:
-                await rel_sim.delete()
-
-    async def actual_cond(self):
-        for curr, old in await CondSim.all().values_list("cond_id", "cond_rel_id"):
-            self.cond_sims[curr] = old
-            self.rcond_sims[old] |= {curr}
-        for cid, (txt, uids) in self.all_conds.items():
-            old_cid, sim = await self.cond_get_max_sim(cid, txt, uids)
-            await self.actual_sim(cid, old_cid, sim)
-            # хз бля чо это ваще
-            # for ad_db in await models.Ad.filter(direction__pairex__ex=self.ex_client.ex).prefetch_related("cond", "maker"):
-            #     ad = Ad(id=str(ad_db.exid), userId=str(ad_db.maker.exid), remark=ad_db.cond.raw_txt)
-            #     await self.cond_upsert(ad, force=True)
-
-    async def actual_sim(self, cid: int, old_cid: int, sim: int):
-        if not sim:
-            return
-        if old_sim := await CondSim.get_or_none(cond_id=cid):
-            if old_sim.cond_rel_id != old_cid:
-                if sim > old_sim.similarity:
-                    logging.warning(f"R {cid}: {old_sim.similarity}->{sim} ({old_sim.cond_rel_id}->{old_cid})")
-                    await old_sim.update_from_dict({"similarity": sim, "old_rel_id": old_cid}).save()
-                    self._cond_sim_upd(cid, old_cid)
-            elif sim != old_sim.similarity:
-                logging.info(f"{cid}: {old_sim.similarity}->{sim}")
-                await old_sim.update_from_dict({"similarity": sim}).save()
-        else:
-            await CondSim.create(cond_id=cid, cond_rel_id=old_cid, similarity=sim)
-            self._cond_sim_upd(cid, old_cid)
-
-    def _cond_sim_upd(self, cid: int, old_cid: int):
-        if old_old_cid := self.cond_sims.get(cid):  # если старый cid уже был в дереве:
-            self.rcond_sims[old_old_cid].remove(cid)  # удаляем из обратного
-        self.cond_sims[cid] = old_cid  # а в прямом он автоматом переопределится, даже если и был
-        self.rcond_sims[old_cid] |= {cid}  # ну и в обратное добавим новый
-
-    async def get_credexs_by_pms(self, pms: list[models.Pm], cur_id: int) -> list[models.CredEx]:
-        return await models.CredEx.filter(
-            ex_id=self.actor.ex_id,
-            cred__pmcur__pm_id__in=[pm.id for pm in pms],
-            cred__person_id=self.actor.person_id,
-            cred__pmcur__cur_id=cur_id,
-        )
-
-    def build_tree(self):
-        set(self.cond_sims.keys()) | set(self.cond_sims.values())
-        tree = defaultdict(dict)
-        # Группируем родителей по детям
-        for child, par in self.cond_sims.items():
-            tree[par] |= {child: {}}  # todo: make from self.rcond_sim
-
-        # Строим дерево снизу вверх
-        def subtree(node):
-            if not node:
-                return node
-            for key in node:
-                subnode = tree.pop(key, {})
-                d = subtree(subnode)
-                node[key] |= d  # actual tree rebuilding here!
-            return node  # todo: refact?
-
-        # Находим корни / без родителей
-        roots = set(self.cond_sims.values()) - set(self.cond_sims.keys())
-        for root in roots:
-            _ = subtree(tree[root])
-
-        self.tree = tree
-
-    async def take_ad(self, req: TakeAdReq):
-        ad: Ad = Ad.model_validate(self.api.get_ad_details(itemId=req.ad_id))
         bor = BaseOrderReq(
             ad_id=str(ad.id),
             fiat_amount=req.amount,
-            is_sell=bool(ad.side),
+            is_sell=not bool(ad.side),
             cur_exid=ad.currencyId,
             coin_exid=ad.tokenId,
-            coin_scale=ad.token.scale,
+            coin_scale=ad.symbolInfo.token.scale,
             pm_id=req.pm_id,
         )
         resp: OrderResp = await self._order_request(bor)
         return resp
 
+    # 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
+    #
+    #         for i, ad in enumerate(ads):
+    #             if (ceil - float(ad.price)) * k < 0:
+    #                 break
+    #             if int(ad.userId) == self.actor.exid:
+    #                 logging.info(f"My ad {'-' if taker_side else '+'}{coinex.exid}/{curex.exid} on place#{i}")
+    #                 continue
+    #             ad_db, isnew = await self.cond_upsert(ad, ps=ps)
+    #             if isnew:
+    #                 s = f"{'-' if taker_side else '+'}{ad.price}[{ad.minAmount}-{ad.maxAmount}]{coinex.exid}/{curex.exid}"
+    #                 print(s, end=" | ", flush=True)
+    #             try:
+    #                 # take
+    #                 ...
+    #             except FailedRequestError as e:
+    #                 if ExcCode(e.status_code) == ExcCode.RareLimit:
+    #                     await sleep(195)
+    #                 elif ExcCode(e.status_code) == ExcCode.Timestamp:
+    #                     await sleep(2)
+    #                 else:
+    #                     raise e
+    #             except (ReadTimeoutError, ConnectionDoesNotExistError):
+    #                 logging.warning("Connection failed. Restarting..")
+    #         await sleep(3)
+
 
 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 = []
@@ -1276,14 +1072,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 округляется до целого, но на бэке байбита его дробная часть больше
@@ -1353,28 +1141,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)