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

xync_client/Bybit/agent.py

@@ -1,4 +1,5 @@
 import asyncio
+import json
 import logging
 import re
 from asyncio import sleep, gather
@@ -10,13 +11,15 @@ from hashlib import sha256
 from http.client import HTTPException
 from math import floor
 from typing import Literal
+from uuid import uuid4
 
 import pyotp
+import websockets
 from aiohttp.http_exceptions import HttpProcessingError
-from asyncpg import ConnectionDoesNotExistError
 from bybit_p2p import P2P
 from bybit_p2p._exceptions import FailedRequestError
 from payeer_api import PayeerAPI
+from pydantic import ValidationError
 from pyro_client.client.file import FileClient
 from tortoise import BaseDBAsyncClient
 from tortoise.exceptions import IntegrityError
@@ -24,12 +27,11 @@ from tortoise.expressions import Q
 from tortoise.functions import Count
 from tortoise.signals import post_save
 from tortoise.timezone import now
-from urllib3.exceptions import ReadTimeoutError
+from 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.InAgent import InAgentClient
 
 from xync_client.Bybit.ex import ExClient
 from xync_schema import models
@@ -38,7 +40,7 @@ from xync_schema.enums import OrderStatus, AgentStatus
 from xync_schema.models import Actor, PmCur, Agent
 
 from xync_client.Abc.Agent import BaseAgentClient
-from xync_client.Abc.xtype import FlatDict, BaseOrderReq
+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 (
@@ -52,15 +54,25 @@ from xync_client.Bybit.etype.order import (
     Status,
     OrderSellRequest,
     TakeAdReq,
+    StatusChange,
+    CountDown,
+    Receive,
+    Read,
+    SellerCancelChange,
 )
-from xync_client.loader import TORM, NET_TOKEN, PAY_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 AgentClient(BaseAgentClient, InAgentClient):  # Bybit client
+class ShareException(Exception):
+    pass
+
+
+class AgentClient(BaseAgentClient):  # Bybit client
     headers = df_hdrs | {"accept-language": "ru-RU"}
     sec_hdrs: dict[str, str]
     # rewrite token for public methods
@@ -94,8 +106,16 @@ class AgentClient(BaseAgentClient, InAgentClient):  # Bybit client
         "securityRiskToken": "",
     }
 
-    def __init__(self, agent: Agent, ex_client: ExClient, fbot: FileClient, bbot: XyncBot, **kwargs):
-        super().__init__(agent, ex_client, fbot, bbot, **kwargs)
+    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"],
@@ -169,17 +189,23 @@ class AgentClient(BaseAgentClient, InAgentClient):  # Bybit client
             xtr += (" | " if xtr else "") + ecdx.qrcode
         elif ecdx.paymentExt1:
             xtr += (" | " if xtr else "") + ecdx.paymentExt1
-        cred_db, _ = await models.Cred.update_or_create(
-            {
-                "name": ecdx.realName,
-                "extra": xtr,
-            },
-            pmcur=pmcur,
-            person_id=pers_id or self.actor.person_id,
-            detail=ecdx.accountNo or ecdx.payMessage,
-        )
-        credex_in = models.CredEx.validate({"exid": ecdx.id, "cred_id": cred_db.id, "ex_id": self.actor.ex.id})
-        credex_db, _ = await models.CredEx.update_or_create(**credex_in.df_unq())
+        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, curs: list[models.Cur]):
@@ -245,33 +271,6 @@ class AgentClient(BaseAgentClient, InAgentClient):  # Bybit client
         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,
-        pmexs: list[models.PmEx],
-        amount: int = None,
-        lim: int = 50,
-        vm_filter: bool = False,
-        post_pmexs: set[models.PmEx] = None,
-    ) -> list[Ad]:
-        if post_pmexs:
-            pm_exids = None
-            lim = min(1000, lim * 25)
-            post_pmexids = {p.exid for p in post_pmexs}
-        else:
-            pm_exids = [px.exid for px in pmexs]
-            post_pmexids = set()
-        ads: list[Ad] = await self.ex_client.ads(cnx.exid, crx.exid, is_sell, pm_exids, amount, lim, vm_filter)
-        if post_pmexs:
-            ads = [
-                ad
-                for ad in ads
-                if (set(ad.payments) & post_pmexids or [True for px in post_pmexs if px.pm.norm in ad.remark.lower()])
-            ]
-        return ads
-
     @staticmethod
     def get_rate(list_ads: list) -> float:
         ads = [ad for ad in list_ads if set(ad["payments"]) - {"5", "51"}]
@@ -292,10 +291,39 @@ class AgentClient(BaseAgentClient, InAgentClient):  # Bybit client
             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)
+            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("/x-api/fiat/otc/item/create", self.create_ad_body)
         if data["ret_code"] == 912120019:  # Current user can not to create add as maker
@@ -342,6 +370,9 @@ class AgentClient(BaseAgentClient, InAgentClient):  # Bybit client
             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("/x-api/fiat/otc/item/create", self.create_ad_body)
@@ -363,7 +394,8 @@ class AgentClient(BaseAgentClient, InAgentClient):  # 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
@@ -487,10 +519,10 @@ class AgentClient(BaseAgentClient, InAgentClient):  # 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(
+        res = await self._post(
             "/x-api/fiat/otc/order/pending/simplifyList",
             {
                 "status": status,
@@ -499,9 +531,12 @@ class AgentClient(BaseAgentClient, InAgentClient):  # 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(
@@ -517,27 +552,27 @@ class AgentClient(BaseAgentClient, InAgentClient):  # 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.sellerRealName, order.buyerRealName
-        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.ex_client.person_name_update(maker_name[::-1][order.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.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.ex_client.cond_load(ad, force=True, rname=maker_name[order.side])
         ad_db = await models.Ad.get(exid=order.itemId)
         if not ad_db:
-            ...
+            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:
@@ -695,7 +730,7 @@ class AgentClient(BaseAgentClient, InAgentClient):  # 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)]
@@ -720,54 +755,6 @@ class AgentClient(BaseAgentClient, InAgentClient):  # 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 {len(ads)}-lenght list")
-            target_place = len(ads) - 1
-        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)
@@ -777,235 +764,6 @@ class AgentClient(BaseAgentClient, InAgentClient):  # Bybit client
     #     if round(cpc * new_premium / cpm, 2) == m
     #     mad.premium = new_premium.to_eng_string()
 
-    async def start_race(self):
-        races = await models.Race.filter(started=True, road__ad__maker_id=self.actor.id).prefetch_related(
-            "road__ad__pair_side__pair__cur", "road__credexs__cred", "road__ad__pms__pmexs__pm"
-        )
-        tasks = [create_task(self.racing(race), name=f"Rc{race.id}") for race in races]
-        return await gather(*tasks)
-
-    async def racing(self, race: models.Race):
-        coinex: models.CoinEx = await models.CoinEx.get(
-            coin_id=race.road.ad.pair_side.pair.coin_id, ex=self.actor.ex
-        ).prefetch_related("coin")
-        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
-        creds = [c.cred for c in race.road.credexs]
-        pmexs: list[models.PmEx] = [pmex for pm in race.road.ad.pms for pmex in pm.pmexs if pmex.ex_id == 4]
-        post_pm_ids = {c.cred.ovr_pm_id for c in race.road.credexs if c.cred.ovr_pm_id}
-        post_pmexs = set(await models.PmEx.filter(pm_id__in=post_pm_ids, ex=self.actor.ex).prefetch_related("pm"))
-
-        k = (-1) ** int(taker_side)  # on_buy=1, on_sell=-1
-        sleep_sec = 3  # 1 if set(pms) & {"volet"} and coinex.coin_id == 1 else 5
-        _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)
-            amt = race.filter_amount * 10**-curex.cur.scale if race.filter_amount else None
-            if race.updated_at < expiration:
-                ceils, hp, vmf, zplace = await self.get_ceils(coinex, curex, pmexs, 0.003, False, 0, amt, post_pmexs)
-                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__credexs__id__in=[c.id for c in race.road.credexs],
-                    pms_count=len(pmexs),
-                ):
-                    prace.ceil = int(ceils[int(not taker_side)] * 10**curex.scale)
-                    await prace.save()
-
-            last_vol = volume
-            if taker_side:  # гонка в стакане продажи - мы покупаем монету за ФИАТ
-                fiat = max(await models.Fiat.filter(cred_id__in=[c.id for c in creds]), key=lambda x: x.amount)
-                volume = (fiat.amount * 10**-curex.cur.scale) / (race.road.ad.price * 10**-curex.scale)
-            else:  # гонка в стакане покупки - мы продаем МОНЕТУ за фиат
-                asset = await models.Asset.get(addr__actor=self.actor, addr__coin_id=coinex.coin_id)
-                volume = asset.free * 10**-coinex.scale
-            volume = str(round(volume, coinex.scale))
-            try:
-                ads: list[Ad] = await self.ads(coinex, curex, taker_side, pmexs, amt, 50, race.vm_filter, post_pmexs)
-            except Exception:
-                await sleep(1)
-                ads: list[Ad] = await self.ads(coinex, curex, taker_side, pmexs, amt, 50, race.vm_filter, post_pmexs)
-
-            self.overprice_filter(ads, race.ceil * 10**-curex.scale, k)  # обрезаем сверху все ads дороже нашего потолка
-
-            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.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
-            #     ]
-            #     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.scale), curex.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(mad.premium) or float(cad.premium)) - k * step(mad, cad, 2)
-                # if float(mad.premium) == new_premium:  # Если нужный % и так уже стоит
-                #     if mad.priceType and cur_plc != race.target_place:
-                #         new_premium -= k * step(mad, cad, 2)
-                #     elif volume == last_vol:
-                #         print(end="v" if taker_side else "^", flush=True)
-                #         await sleep(sleep_sec)
-                #         continue
-                mad.premium = str(round(new_premium, 2))
-            mad.priceType = cad.priceType
-            mad.quantity = volume
-            mad.maxAmount = str(2_000_000 if curex.cur_id == 1 else 40_000)
-            req = AdUpdateRequest.model_validate(
-                {
-                    **mad.model_dump(),
-                    "price": str(round(new_price, curex.scale)),
-                    "paymentIds": [str(cx.exid) for cx in race.road.credexs],
-                }
-            )
-            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:
-                    if not (
-                        sads := [
-                            ma
-                            for ma in self.my_ads(False)
-                            if (
-                                ma.currencyId == curex.exid
-                                and ma.tokenId == coinex.exid
-                                and taker_side != ma.side
-                                and set(ma.payments) == set([pe.exid for pe in pmexs])
-                            )
-                        ]
-                    ):
-                        logging.error(f"Need reserve Ad {'sell' if taker_side else 'buy'} {coinex.exid}/{curex.exid}")
-                        await sleep(90)
-                        continue
-                    self.ad_del(ad_id=int(mad.id))
-                    req.id = sads[0].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],
-        amount: int,
-        post_pmexs: list[models.PmEx] = None,
-    ) -> tuple[list[Ad], list[Ad]]:
-        buy: list[Ad] = await self.ads(coinex, curex, False, pmexs, amount, 40, False, post_pmexs)
-        sell: list[Ad] = await self.ads(coinex, curex, True, pmexs, amount, 30, False, post_pmexs)
-        return buy, sell
-
-    async def get_spread(
-        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:  # todo: aA???
-        #     if not exact:
-        #         if vmf is None:  # сначала фильтруем только VA
-        #             return await self.get_spread(bb, sb, perc, True, place)
-        #         # если даже по VA не хватает спреда - увеличиваем место
-        #         return await self.get_spread(bb, sb, perc, vmf, place + 1)
-
-        return (buy_price, sell_price), half_spread, vmf, place
-
-    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,
-        amount: int = None,
-        post_pmexs: set[models.PmEx] = None,
-    ) -> tuple[tuple[float, float], float, bool, int]:  # todo: refact to Pairex
-        bb, sb = await self.get_books(coinex, curex, pmexs, amount, post_pmexs)
-        if vmf:
-            # ориентируемся на цены объявлений только проверенных мерчантов
-            bb = [b for b in bb if "VA" in b.authTag]
-            sb = [s for s in sb if "VA" in s.authTag]
-        perc = list(post_pmexs or pmexs)[0].pm.fee * 0.0001 + min_prof
-        (bf, sf), hp, vmf, zplace = await self.get_spread(bb, sb, perc, vmf, place)
-        mdl = (bf + sf) / 2
-        bc, sc = mdl + mdl * (perc / 2), mdl - mdl * (perc / 2)
-        return (bc, sc), hp, vmf, zplace
-
     async def 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
@@ -1046,83 +804,90 @@ class AgentClient(BaseAgentClient, InAgentClient):  # Bybit client
         return resp
 
     async def watch_payeer(self, mcs: dict[int, "AgentClient"]):
-        coinex: models.CoinEx = await models.CoinEx.get(coin_id=1, ex=self.actor.ex).prefetch_related("coin")
-        curex: models.CurEx = await models.CurEx.get(cur_id=1, ex=self.actor.ex).prefetch_related("cur")
+        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:
-                ss = await self.ads(coinex, curex, True, None, None, 1000, False, post_pmexs)
-                ss = [s for s in ss if float(s.price) > 90.42 or int(s.userId) in mcs.keys()]
-                if ss:
-                    ad: Ad = ss[0]
+                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(1000 + i, float(ad.minAmount)))
+                    am = min(float(ad.maxAmount), max(8000 + i, float(ad.minAmount)))
                     req = TakeAdReq(
                         ad_id=ad.id,
                         amount=am,
                         pm_id=14,
-                        is_sell=True,
+                        is_sell=False,
                         coin_id=1,
                         cur_id=1,
                     )
                     ord_resp: OrderResp = await self.take_ad(req)
                     # order: OrderFull = OrderFull(**self.api.get_order_details(orderId=ord_resp.orderId)["result"])
                     order: OrderFull = await self.get_order_info(ord_resp.orderId)
-                    odb = await self.create_order(order)
-                    # t = await models.Transfer(order=odb, amount=odb.amount, updated_at=now())
-                    # await t.fetch_related("order__cred__pmcur__cur")
-                    # res = await self.pm_clients[366].check_in(t)
+                    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.mark_as_paid(
-                            orderId=str(odb.exid),
-                            paymentType=ad.payments[0],  # pmex.exid
-                            paymentId=order.paymentTermList[0].id,  # credex.exid
-                        )
-                    self.api.release_assets(orderId=order.id)
-                ...
+                        mcs[int(ad.userId)].api.release_assets(orderId=order.id)
 
-                bs = await self.ads(coinex, curex, False, None, None, 1000, False, post_pmexs)
-                bs = [b for b in bs if float(b.price) < 89.56 or int(b.userId) in mcs.keys()]
-                if bs:
-                    ad: Ad = bs[0]
+                await sleep(5)
+
+                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(600 + i, float(ad.minAmount)))
+                    am = min(float(ad.maxAmount), max(10000 + i, float(ad.minAmount)))
                     req = TakeAdReq(
                         ad_id=ad.id,
                         amount=am,
                         pm_id=14,
-                        is_sell=False,
+                        is_sell=True,
                         coin_id=1,
                         cur_id=1,
                     )
                     ord_resp: OrderResp = await self.take_ad(req)
                     # order: OrderFull = OrderFull(**self.api.get_order_details(orderId=ord_resp.orderId)["result"])
                     order: OrderFull = await self.get_order_info(ord_resp.orderId)
-                    odb = await self.create_order(order)
-                    t = await models.Transfer(order=odb, amount=odb.amount, updated_at=now())
-                    await t.fetch_related("order__cred__pmcur__cur")
-                    # res = await self.pm_clients[366].send(t)
-                    self.api.mark_as_paid(
-                        orderId=str(odb.exid),
-                        paymentType=ad.payments[0],  # pmex.exid
-                        paymentId=order.paymentTermList[0].id,  # credex.exid
-                    )
+                    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.release_assets(orderId=order.id)
-                    await sleep(1)
-                ...
+                        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
+                        )
+                    await sleep(3)
+                    self.api.release_assets(orderId=order.id)
+                await sleep(5)
+
             except Exception as e:
                 logging.exception(e)
-                await sleep(90)
+                await sleep(30)
             except HttpProcessingError as e:
                 logging.error(e)
             print(end=".", flush=True)
@@ -1136,12 +901,389 @@ class AgentClient(BaseAgentClient, InAgentClient):  # Bybit client
             req = TakeAdReq(ad_id="1856989782009487360", amount=am, pm_id=366)
             ord_resp: OrderResp = await self.take_ad(req)
             order: OrderFull = OrderFull(**self.api.get_order_details(orderId=ord_resp.orderId)["result"])
-            odb = await self.create_order(order)
+            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")
+                    ...
+                    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:
+                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:
+            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}")
+
+    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}!"
+                )
+
+            # ставим в бд статус "оплачен"
+            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]
+
+    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}")
+
+    @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"))
@@ -1164,23 +1306,6 @@ def detailed_diff(str1, str2):
     return "".join(result)
 
 
-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
@@ -1209,7 +1334,7 @@ async def main():
     cn = await init_db(TORM)
 
     agent = (
-        await models.Agent.filter(actor__ex_id=4, auth__isnull=False, status__gt=AgentStatus.off, id=8)
+        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",
@@ -1225,7 +1350,10 @@ async def main():
     ex = await models.Ex.get(name="Bybit")
     ecl: ExClient = ex.client(filebot)
     abot = XyncBot(PAY_TOKEN, cn)
-    cl: AgentClient = agent.client(ecl, filebot, abot)
+    # 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)
@@ -1239,8 +1367,12 @@ async def main():
     # 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=[2]
+        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",
@@ -1251,7 +1383,7 @@ async def main():
     mcs = {m.actor.exid: m.client(ecl, filebot, abot) for m in ms}
 
     await gather(
-        create_task(cl.start(True)),
+        # create_task(cl.start()),
         create_task(cl.watch_payeer(mcs)),
     )
     # ensure_future(cl.start(True))