xync-client 0.0.145__py3-none-any.whl → 0.0.148__py3-none-any.whl

xync_client/Bybit/agent.py

@@ -2,7 +2,6 @@ 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
@@ -18,7 +17,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,10 +27,10 @@ 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 BaseOrderReq, FlatDict
+from xync_client.Abc.xtype import FlatDict, BaseOrderReq
 from xync_client.Bybit.etype.ad import AdPostRequest, AdUpdateRequest, Ad, AdStatus
 from xync_client.Bybit.etype.cred import CredEpyd
 from xync_client.Bybit.etype.order import (
@@ -43,6 +42,8 @@ from xync_client.Bybit.etype.order import (
     OrderFull,
     Message,
     Status,
+    OrderSellRequest,
+    TakeAdReq,
 )
 from xync_client.loader import TORM, NET_TOKEN, PAY_TOKEN
 
@@ -83,16 +84,12 @@ 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"""
 
@@ -116,12 +113,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()
@@ -204,13 +197,13 @@ 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("/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
@@ -242,10 +235,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"}]
@@ -262,7 +251,7 @@ 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)
 
@@ -273,20 +262,39 @@ class AgentClient(BaseAgentClient):  # Bybit client
         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:
+        cres = await self._post("/user/public/risk/components", {"risk_token": risk_token})
+        if cres["ret_msg"] != "success":
+            raise HTTPException("get")
+        cres = cres["result"]["component_list"]
+        res = await self._post(
+            "/user/public/risk/verify",
+            {
+                "risk_token": risk_token,
+                "component_list": {c["component_id"]: self.__get_2fa(c["component_id"]) for c in cres},
+            },
         )
         if res["ret_msg"] != "success":
-            print("Wrong 2fa, wait 5 secs and retry..")
-            sleep(5)
-            self._check_2fa(risk_token)
-        return res
+            logging.error("Wrong 2fa, wait 5 secs and retry..")
+            await sleep(5)
+            await self._check_2fa(risk_token)
+        return res["ret_code"]
+
+    async def __get_2fa(self, typ: Literal["google2fa", "email_verify", "payment_password_verify"], rt: str = None):
+        if typ == "google2fa":
+            bybit_secret = self.agent.auth["2fa"]
+            totp = pyotp.TOTP(bybit_secret)
+            return totp.now()
+        elif typ == "email_verify":
+            res = await self._post("/user/public/risk/send/code", {"risk_token": rt, "component_id": "email_verify"})
+            if res["ret_msg"] != "success":
+                return self.gmail.bybit_code()
+            elif cool_down := int(res["result"]["cool_down"]):
+                await sleep(cool_down)
+                return self.gmail.bybit_code()
+        elif typ == "payment_password_verify":
+            return self.agent.auth["pass"]
+        raise Exception("2fa fail")
 
     def _post_ad(self, risk_token: str):
         self.create_ad_body.update({"securityRiskToken": risk_token})
@@ -340,27 +348,56 @@ class AgentClient(BaseAgentClient):  # Bybit client
         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("/fiat/otc/item/simple", data={"item_id": str(ad_id)})
+        if res["ret_code"] == 0:
+            res = res["result"]
+        return PreOrderResp.model_validate(res)
+
+    async def __order_request_build(self, por: PreOrderResp, br: BaseOrderReq) -> OrderRequest:
         req = OrderRequest(
-            itemId=br.ad_id,
+            itemId=por.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",
+            side="1" if br.is_sell else "0",
+            amount=str(br.fiat_amount),
+            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,
+            )
+            req = OrderSellRequest(**req.model_dump(), paymentType=por.payments[0], paymentId=str(credex.exid))
+        return req
+
+    async def _order_request(self, bor: BaseOrderReq) -> OrderResp:
+        por: PreOrderResp = await self.__preorder_request(bor.ad_id)
+        req: OrderRequest | OrderSellRequest = await self.__order_request_build(por, bor)
         # вот непосредственно сам запрос на ордер
-        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:
+        res: dict = await self._post("/fiat/otc/order/create", data=req.model_dump())
         if res["ret_code"] == 0:
-            return OrderResp.model_validate(res["result"])
+            resp = OrderResp.model_validate(res["result"])
         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)
+        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)
@@ -444,12 +481,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
@@ -546,13 +585,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:
@@ -705,7 +744,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:
@@ -764,7 +803,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
@@ -905,296 +944,87 @@ 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
-
-        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),
+    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),
+            cur_exid=ad.currencyId,
+            coin_exid=ad.tokenId,
+            coin_scale=ad.token.scale,
+            pm_id=req.pm_id,
         )
-        ad_db, _ = await models.Ad.update_or_create(**df_unq)
-        await ad_db.pms.add(*(await models.Pm.filter(pmexs__ex=self.ex_client.ex, pmexs__exid__in=ad.payments)))
-        return ad_db
-
-    async def fix_rel_sims(self, cid: int, new_txt: str):
-        for rel_sim in await CondSim.filter(cond_rel_id=cid).prefetch_related("cond"):
-            if sim := get_sim(new_txt, rel_sim.cond.raw_txt):
-                rel_sim.similarity = sim
-                await rel_sim.save()
-            else:
-                await rel_sim.delete()
-
-    async def actual_cond(self):
-        for curr, old in await CondSim.all().values_list("cond_id", "cond_rel_id"):
-            self.cond_sims[curr] = old
-            self.rcond_sims[old] |= {curr}
-        for cid, (txt, uids) in self.all_conds.items():
-            old_cid, sim = await self.cond_get_max_sim(cid, txt, uids)
-            await self.actual_sim(cid, old_cid, sim)
-            # хз бля чо это ваще
-            # for ad_db in await models.Ad.filter(direction__pairex__ex=self.ex_client.ex).prefetch_related("cond", "maker"):
-            #     ad = Ad(id=str(ad_db.exid), userId=str(ad_db.maker.exid), remark=ad_db.cond.raw_txt)
-            #     await self.cond_upsert(ad, force=True)
-
-    async def actual_sim(self, cid: int, old_cid: int, sim: int):
-        if not sim:
-            return
-        if old_sim := await CondSim.get_or_none(cond_id=cid):
-            if old_sim.cond_rel_id != old_cid:
-                if sim > old_sim.similarity:
-                    logging.warning(f"R {cid}: {old_sim.similarity}->{sim} ({old_sim.cond_rel_id}->{old_cid})")
-                    await old_sim.update_from_dict({"similarity": sim, "old_rel_id": old_cid}).save()
-                    self._cond_sim_upd(cid, old_cid)
-            elif sim != old_sim.similarity:
-                logging.info(f"{cid}: {old_sim.similarity}->{sim}")
-                await old_sim.update_from_dict({"similarity": sim}).save()
-        else:
-            await CondSim.create(cond_id=cid, cond_rel_id=old_cid, similarity=sim)
-            self._cond_sim_upd(cid, old_cid)
-
-    def _cond_sim_upd(self, cid: int, old_cid: int):
-        if old_old_cid := self.cond_sims.get(cid):  # если старый cid уже был в дереве:
-            self.rcond_sims[old_old_cid].remove(cid)  # удаляем из обратного
-        self.cond_sims[cid] = old_cid  # а в прямом он автоматом переопределится, даже если и был
-        self.rcond_sims[old_cid] |= {cid}  # ну и в обратное добавим новый
-
-    async def get_credexs_by_pms(self, pms: list[models.Pm], cur_id: int) -> list[models.CredEx]:
-        return await models.CredEx.filter(
-            ex_id=self.actor.ex_id,
-            cred__pmcur__pm_id__in=[pm.id for pm in pms],
-            cred__person_id=self.actor.person_id,
-            cred__pmcur__cur_id=cur_id,
-        )
-
-    def build_tree(self):
-        set(self.cond_sims.keys()) | set(self.cond_sims.values())
-        tree = defaultdict(dict)
-        # Группируем родителей по детям
-        for child, par in self.cond_sims.items():
-            tree[par] |= {child: {}}  # todo: make from self.rcond_sim
-
-        # Строим дерево снизу вверх
-        def subtree(node):
-            if not node:
-                return node
-            for key in node:
-                subnode = tree.pop(key, {})
-                d = subtree(subnode)
-                node[key] |= d  # actual tree rebuilding here!
-            return node  # todo: refact?
-
-        # Находим корни / без родителей
-        roots = set(self.cond_sims.values()) - set(self.cond_sims.keys())
-        for root in roots:
-            _ = subtree(tree[root])
-
-        self.tree = tree
+        resp: OrderResp = await self._order_request(bor)
+        return resp
+
+    # async def 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 = []
@@ -1212,14 +1042,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 округляется до целого, но на бэке байбита его дробная часть больше
@@ -1262,20 +1084,20 @@ async def main():
         else:  # параметры гонки изменены
             ...
 
-    actor = (
+    agent = (
         await models.Agent.filter(actor__ex_id=4, auth__isnull=False, active=True)
-        .prefetch_related("actor__ex", "actor__person__user")
+        .prefetch_related("actor__ex", "actor__person__user__gmail")
         .first()
     )
     filebot = FileClient(NET_TOKEN)
     await filebot.start()
     # b.add_handler(MessageHandler(cond_start_handler, command("cond")))
-    cl: AgentClient = actor.client(filebot, XyncBot(PAY_TOKEN, cn))
+    cl: AgentClient = agent.client(filebot, XyncBot(PAY_TOKEN, cn))
 
     # await cl.ex_client.set_pairs()
     # await cl.ex_client.set_pms()
-    # await cl.set_creds()
-    # await cl.export_my_ads()
+    await cl.set_creds()
+    await cl.export_my_ads()
 
     # создание гонок по мои активным объявам:
     # for ma in cl.my_ads():
@@ -1289,28 +1111,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)
@@ -1323,7 +1123,7 @@ async def main():
     # )
     # await cl.get_api_orders()  # 43, 1741294800000, 1749157199999)
 
-    races = await models.Race.filter(started=True).prefetch_related(
+    races = await models.Race.filter(started=True, road__ad__maker_id=agent.actor_id).prefetch_related(
         "road__ad__pair_side__pair__cur",
         "road__ad__pms",
     )
@@ -1335,20 +1135,10 @@ async def main():
             # 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)
+        await filebot.send("🤬Bybit agent CRASHED!!!🤬", agent.actor.person.user.username_id)
+        await filebot.send(e.__repr__(), agent.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()