xync-client 0.0.164__py3-none-any.whl → 0.0.179.dev4__py3-none-any.whl

xync_client/Bybit/agent.py

@@ -1,7 +1,6 @@
 import asyncio
 import json
 import logging
-import re
 from asyncio import sleep, gather
 from asyncio.tasks import create_task
 from datetime import datetime, timedelta, timezone
@@ -9,7 +8,6 @@ from difflib import SequenceMatcher
 from enum import IntEnum
 from hashlib import sha256
 from http.client import HTTPException
-from math import floor
 from typing import Literal
 from uuid import uuid4
 
@@ -19,29 +17,26 @@ from aiohttp.http_exceptions import HttpProcessingError
 from bybit_p2p import P2P
 from bybit_p2p._exceptions import FailedRequestError
 from payeer_api import PayeerAPI
-from pyro_client.client.file import FileClient
+from pydantic import ValidationError
 from tortoise import BaseDBAsyncClient
-from tortoise.exceptions import IntegrityError
-from tortoise.expressions import Q
-from tortoise.functions import Count
 from tortoise.signals import post_save
 from tortoise.timezone import now
 from tortoise.transactions import in_transaction
+from websockets import ConnectionClosedError
 from x_client import df_hdrs
 from x_model import init_db
-from x_model.func import ArrayAgg
 from xync_bot import XyncBot
 
 from xync_client.Bybit.ex import ExClient
 from xync_schema import models
 from xync_schema.enums import OrderStatus, AgentStatus
 
-from xync_schema.models import Actor, PmCur, Agent
+from xync_schema.models import Agent
 
 from xync_client.Abc.Agent import BaseAgentClient
-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.Abc.xtype import FlatDict, BaseOrderReq, AdUpdReq, GetAdsReq
+from xync_client.Bybit.etype.ad import AdPostRequest, AdRequest, Ad, AdStatusReq, MyAd
+from xync_client.Bybit.etype.cred import CredEpyd, PaymentTerm, CredEx
 from xync_client.Bybit.etype.order import (
     OrderRequest,
     PreOrderResp,
@@ -60,7 +55,7 @@ from xync_client.Bybit.etype.order import (
     SellerCancelChange,
 )
 from xync_client.Pms.Payeer.agent import PmAgentClient
-from xync_client.loader import TORM, NET_TOKEN, PAY_TOKEN, PRX
+from xync_client.loader import TORM, PAY_TOKEN, PRX
 
 
 class NoMakerException(Exception):
@@ -77,23 +72,26 @@ class AgentClient(BaseAgentClient):  # Bybit client
     # rewrite token for public methods
     api: P2P
     orders: dict[int, tuple[models.Order, OrderFull]] = {}  # pending
+    cdx_cls: type[CredEx] = CredEx
 
     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)
+        super().__init__(agent, ex_client, pm_clients, **kwargs)
         self.sec_hdrs = {
             "accept-language": "ru,en;q=0.9",
             "gdfp": agent.auth["Risktoken"],
             "tx-id": agent.auth["Risktoken"],
         }
-        self.api = P2P(testnet=False, api_key=agent.auth["key"], api_secret=agent.auth["sec"])
+        self.api = P2P(
+            testnet=False,
+            api_key=agent.auth["key"],
+            api_secret=agent.auth["sec"],  # , proxies=kwargs.get("proxies")
+        )
         self.hist: dict | None = None
         self.completed_orders: list[int] | None = None
 
@@ -122,95 +120,11 @@ class AgentClient(BaseAgentClient):  # Bybit client
     def get_payment_method(self, fiat_id: int) -> CredEpyd:
         return self.creds()[fiat_id]
 
-    def creds(self) -> dict[int, CredEpyd]:
+    async def _get_creds(self) -> list[PaymentTerm]:
         data = self.api.get_user_payment_types()
         if data["ret_code"] > 0:
             return data
-        return {credex["id"]: CredEpyd.model_validate(credex) for credex in data["result"]}
-
-    async def cred_epyd2db(self, ecdx: CredEpyd, pers_id: int = None, cur_id: int = None) -> models.CredEx | None:
-        if ecdx.paymentType in (416,):  # what is 416??
-            return None
-        if not (
-            pmex := await models.PmEx.get_or_none(exid=ecdx.paymentType, ex=self.ex_client.ex).prefetch_related(
-                "pm__curs"
-            )
-        ):
-            raise HTTPException(f"No PmEx {ecdx.paymentType} on ex#{self.ex_client.ex.name}", 404)
-        if cred_old := await models.Cred.get_or_none(credexs__exid=ecdx.id, credexs__ex=self.actor.ex).prefetch_related(
-            "pmcur"
-        ):
-            cur_id = cred_old.pmcur.cur_id
-        elif not cur_id:  # is new Cred
-            cur_id = (
-                pmex.pm.df_cur_id
-                or await self.guess_cur(ecdx, len(pmex.pm.curs) > 1 and pmex.pm.curs)
-                or (pmex.pm.country_id and (await pmex.pm.country).cur_id)
-                # or (ecdx.currencyBalance and await models.Cur.get_or_none(ticker=ecdx.currencyBalance[0]))  # это че еще за хуйня?
-            )
-        if not cur_id:
-            raise Exception(f"Set default cur for {pmex.name}")
-        if not (pmcur := await models.PmCur.get_or_none(cur_id=cur_id, pm_id=pmex.pm_id)):
-            raise HTTPException(f"No PmCur with cur#{cur_id} and pm#{ecdx.paymentType}", 404)
-        xtr = ecdx.branchName
-        if ecdx.bankName:
-            xtr += (" | " if xtr else "") + ecdx.bankName
-        elif ecdx.payMessage:
-            xtr += (" | " if xtr else "") + ecdx.payMessage
-        elif ecdx.qrcode:
-            xtr += (" | " if xtr else "") + ecdx.qrcode
-        elif ecdx.paymentExt1:
-            xtr += (" | " if xtr else "") + ecdx.paymentExt1
-        try:
-            cred_db, _ = await models.Cred.update_or_create(
-                {
-                    "name": ecdx.realName,
-                    "extra": xtr,
-                },
-                pmcur=pmcur,
-                person_id=pers_id or self.actor.person_id,
-                detail=ecdx.accountNo or ecdx.payMessage,
-            )
-            if cred_db.ovr_pm_id is None and (cred_db.detail.startswith("XyncPay") or xtr.startswith("XyncPay")):
-                cred_db.ovr_pm_id = 0
-                await cred_db.save()
-            credex_in = models.CredEx.validate({"exid": ecdx.id, "cred_id": cred_db.id, "ex_id": self.actor.ex.id})
-            credex_db, _ = await models.CredEx.update_or_create(**credex_in.df_unq())
-        except IntegrityError as e:
-            raise e
-        return credex_db
-
-    async def guess_cur(self, ecdx: CredEpyd, curs: list[models.Cur]):
-        mbs = ecdx.bankName.split(", ")
-        mbs += ecdx.branchName.split(" / ")
-        mbs = {mb.lower(): mb for mb in mbs}
-        if (
-            pms := await models.Pm.filter(Q(join_type="OR", pmexs__name__in=mbs.values(), norm__in=mbs.keys()))
-            .group_by("pmcurs__cur_id", "pmcurs__cur__ticker")
-            .annotate(ccnt=Count("id"), names=ArrayAgg("norm"))
-            .order_by("-ccnt", "pmcurs__cur__ticker")
-            .values("pmcurs__cur_id", "names", "ccnt")
-        ):
-            return pms[0]["pmcurs__cur_id"]
-        curs = {c.ticker: c.id for c in curs or await models.Cur.all()}
-        for cur, cid in curs.items():
-            if re.search(re.compile(rf"\({cur}\)$"), ecdx.bankName):
-                return cid
-            if re.search(re.compile(rf"\({cur}\)$"), ecdx.branchName):
-                return cid
-            if re.search(re.compile(rf"\({cur}\)$"), ecdx.accountNo):
-                return cid
-            if re.search(re.compile(rf"\({cur}\)$"), ecdx.payMessage):
-                return cid
-            if re.search(re.compile(rf"\({cur}\)$"), ecdx.paymentExt1):
-                return cid
-        return None
-
-    # 25: Список реквизитов моих платежных методов
-    async def set_creds(self) -> list[models.CredEx]:
-        credexs_epyd: dict[int, CredEpyd] = self.creds()
-        credexs: list[models.CredEx] = [await self.cred_epyd2db(f) for f in credexs_epyd.values()]
-        return credexs
+        return [PaymentTerm.model_validate(credex) for credex in data["result"] if credex["id"] != "-1"]
 
     async def ott(self):
         t = await self._post("/x-api/user/private/ott")
@@ -238,7 +152,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
         delete = await self._post("/x-api/fiat/otc/user/payment/new_delete", data)
         return delete
 
-    async def switch_ads(self, new_status: AdStatus) -> dict:
+    async def switch_ads(self, new_status: AdStatusReq) -> dict:
         data = {"workStatus": new_status.name}  # todo: переделать на апи, там status 0 -> 1
         res = await self._post("/x-api/fiat/otc/maker/work-config/switch", data)
         return res
@@ -248,26 +162,16 @@ class AgentClient(BaseAgentClient):  # Bybit client
         ads = [ad for ad in list_ads if set(ad["payments"]) - {"5", "51"}]
         return float(ads[0]["price"])
 
-    def my_ads(self, active: bool = True, page: int = 1) -> list[MyAd]:
-        resp = self.api.get_ads_list(size="30", page=str(page), status=AdStatus.active if active else AdStatus.sold_out)
+    async def get_my_ads(self, active: bool = True, page: int = 1) -> list[MyAd]:
+        resp = self.api.get_ads_list(
+            size="30", page=str(page), status=AdStatusReq.active if active else AdStatusReq.sold_out
+        )
         ads = [MyAd.model_validate(ad) for ad in resp["result"]["items"]]
-        if resp["result"]["count"] > 30 * page:
-            ads.extend(self.my_ads(active, page + 1))
+        # todo: вернуть, что бы спарсил все объявы, а не только первые 30
+        # if resp["result"]["count"] > 30 * page:
+        #     ads.extend(await self.get_my_ads(active, page + 1))
         return ads
 
-    async def export_my_ads(self, active: bool = None) -> int:  # upserted)
-        ads = self.my_ads(True)
-        if not active:
-            ads += self.my_ads(False)
-        for ad in ads:
-            ad_db = await self.ex_client.ad_load(ad, maker=self.actor)
-            mad_db, _ = await models.MyAd.update_or_create(ad=ad_db)
-            exids = [pt.id for pt in ad.paymentTerms]
-            credexs = await models.CredEx.filter(ex_id=self.actor.ex_id, exid__in=exids).prefetch_related("cred")
-            await mad_db.credexs.clear()
-            await mad_db.credexs.add(*credexs)
-        return len(ads)
-
     async def ads_share(self, cur_id: int = None) -> int:
         mq = models.MyAd.hot_mads_query([4]).filter(ad__maker=self.actor)
         if cur_id:
@@ -276,7 +180,9 @@ class AgentClient(BaseAgentClient):  # Bybit client
         return len([await self.ad_share(mad.id) for mad in mads])
 
     async def ad_share(self, maid: int):
-        myad = await models.MyAd.get(id=maid).prefetch_related("ad__pair_side__pair__coin", "ad__pair_side__pair__cur")
+        myad = await models.MyAd.get(id=maid).prefetch_related(
+            "ad__pair_side__pair__coin", "ad__pair_side__pair__cur", "ad__maker"
+        )
         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()})
@@ -373,8 +279,8 @@ class AgentClient(BaseAgentClient):  # Bybit client
         data = self.api.post_new_ad(**ad.model_dump())
         return data["result"]["itemId"] if data["ret_code"] == 0 else data
 
-    async def _ad_upd(self, req: AdUpd):
-        upd = AdUpdateRequest({})
+    async def _ad_upd(self, req: AdUpdReq):
+        upd = AdRequest({})
         params = upd.model_dump()
         data = self.api.update_ad(**params)
         return data["result"] if data["ret_code"] == 0 else data
@@ -411,16 +317,16 @@ class AgentClient(BaseAgentClient):  # Bybit client
             res = res["result"]
         return PreOrderResp.model_validate(res)
 
-    async def _order_request(self, bor: BaseOrderReq) -> OrderResp:
+    async def _order_request(self, bor: BaseOrderReq, bbot: XyncBot) -> OrderResp:
         por: PreOrderResp = await self.__preorder_request(bor.ad_id)
         req = OrderRequest(
             itemId=por.id,
             tokenId=bor.coin_exid,
             currencyId=bor.cur_exid,
             side="1" if bor.is_sell else "0",
-            amount=f"{bor.fiat_amount:.2f}".rstrip("0").rstrip("."),
+            amount=f"{bor.amount:.2f}".rstrip("0").rstrip("."),
             curPrice=por.curPrice,
-            quantity=str(round(bor.fiat_amount / float(por.price), bor.coin_scale)),
+            quantity=str(round(bor.amount / float(por.price), bor.coin_scale)),
             flag="amount",
             # online="0"
         )
@@ -433,9 +339,9 @@ class AgentClient(BaseAgentClient):  # Bybit client
             )
             req = OrderSellRequest(**req.model_dump(), paymentType=bor.pmex_exid, paymentId=str(credex.exid))
         # вот непосредственно сам запрос на ордер
-        return await self.__order_create(req, bor)
+        return await self.__order_create(req, bor, bbot)
 
-    async def __order_create(self, req: OrderRequest | OrderSellRequest, bor: BaseOrderReq) -> OrderResp:
+    async def __order_create(self, req: OrderRequest | OrderSellRequest, bor: BaseOrderReq, bbot: XyncBot) -> OrderResp:
         hdrs = {"Risktoken": self.sec_hdrs["gdfp"]}
         res: dict = await self._post("/x-api/fiat/otc/order/create", json=req.model_dump(), hdrs=hdrs)
         if res["ret_code"] == 0:
@@ -444,16 +350,16 @@ class AgentClient(BaseAgentClient):  # Bybit client
             logging.error(req.model_dump(), "POST", self.session._base_url)
             raise HTTPException()
         elif res["ret_code"] == 912120030 or res["ret_msg"] == "The price has changed, please try again later.":
-            resp = await self._order_request(bor)
+            resp = await self._order_request(bor, bbot)
         else:
             logging.exception(res)
         if not resp.orderId and resp.needSecurityRisk:
             if rc := await self._check_2fa(resp.securityRiskToken):
-                await self.bbot.send(self.actor.person.user.username_id, f"Bybit 2fa: {rc}")
+                await 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)
+            resp = await self.__order_create(req, bor, bbot)
         return resp
 
     async def cancel_order(self, order_id: str) -> bool:
@@ -531,155 +437,6 @@ class AgentClient(BaseAgentClient):  # Bybit client
             },
         )
 
-    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
-        sb_names = order.sellerRealName, order.buyerRealName
-        im_maker = int(int(order.makerUserId) == self.actor.exid)
-        taker_id = (order.userId, order.targetUserId)[im_maker]
-        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 = 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:
-            ecredex = order.paymentTermList[0]
-        if ecredex.paymentType:
-            if ecredex.paymentType == 51:
-                ecredex.accountNo = ecredex.accountNo.replace("p", "P").replace("р", "P").replace("Р", "P")
-                # if not re.match(r"^([Pp])\d{7,10}$", ecredex.accountNo):
-                #     msgs = self.api.get_chat_messages(orderId=order.id, size=100)["result"]["result"]
-                #     msgs = [m["message"] for m in msgs if m["roleType"] == "user" and m["userId"] == order.targetUserId]
-                #     msgs = [g.group() for m in msgs if (g := re.match(r"([PpРр])\d{7,10}\b", m))]
-                #     crd = await models.Cred.get_or_none(
-                #         detail=ecredex.accountNo, credexs__exid=ecredex.id, credexs__ex=self.ex_client.ex
-                #     )
-                #     if not msgs and re.match(r"^\d{7,10}$", ecredex.accountNo):
-                #         ecredex.accountNo = "P" + ecredex.accountNo
-                #     elif msgs:
-                #         ecredex.accountNo = msgs[-1]
-                #     else:
-                #         ...
-                #     if crd:
-                #         crd.detail = ecredex.accountNo
-                #         await crd.save(update_fields=["detail"])
-            if not (credex := await models.CredEx.get_or_none(exid=ecredex.id, ex=self.ex_client.ex)):
-                # cur_id = await Cur.get(ticker=ad.currencyId).values_list('id', flat=True)
-                # await self.cred_epyd2db(ecredex, ad_db.maker.person_id, cur_id)
-                if (
-                    await PmCur.filter(
-                        pm__pmexs__ex=self.ex_client.ex,
-                        pm__pmexs__exid=ecredex.paymentType,
-                        cur__ticker=order.currencyId,
-                    ).count()
-                    != 1
-                ):
-                    ...
-                if not (
-                    pmcur := await PmCur.get_or_none(
-                        pm__pmexs__ex=self.ex_client.ex,
-                        pm__pmexs__exid=ecredex.paymentType,
-                        cur__ticker=order.currencyId,
-                    )
-                ):
-                    ...
-                if not (
-                    crd := await models.Cred.get_or_none(pmcur=pmcur, person=seller_person, detail=ecredex.accountNo)
-                ):
-                    extr = ", ".join(
-                        x
-                        for xtr in [
-                            ecredex.bankName,
-                            ecredex.branchName,
-                            ecredex.qrcode,
-                            ecredex.payMessage,
-                            ecredex.paymentExt1,
-                        ]
-                        if (x := xtr.strip())
-                    )
-                    crd = await models.Cred.create(
-                        detail=ecredex.accountNo,
-                        pmcur=pmcur,
-                        person=seller_person,
-                        name=ecredex.realName,
-                        extra=extr,
-                    )
-                credex = await models.CredEx.create(exid=ecredex.id, ex=self.ex_client.ex, cred=crd)
-        try:
-            taker, _ = await Actor.get_or_create(
-                {"name": taker_nick, "person": taker_person}, ex=self.ex_client.ex, exid=taker_id
-            )
-        except IntegrityError as e:
-            logging.error(e)
-        odb, _ = await models.Order.update_or_create(
-            {
-                "amount": float(order.amount) * 10**cur_scale,
-                "quantity": float(order.quantity) * 10**coin_scale,
-                "status": OrderStatus[Status(order.status).name],
-                "created_at": ms2utc(order.createDate),
-                "payed_at": order.transferDate != "0" and ms2utc(order.transferDate) or None,
-                "confirmed_at": Status(order.status) == Status.completed and ms2utc(order.transferDate) or None,
-                "appealed_at": order.status == 30 and ms2utc(order.transferDate) or None,
-                "cred_id": ecredex.paymentType and credex.cred_id or None,
-                "taker": taker,
-                "ad": ad_db,
-            },
-            exid=order.id,
-        )
-        if order.status == Status.completed and ecredex.paymentType == 51:
-            await odb.fetch_related("cred", "transfer")
-            if odb.cred.detail != ecredex.accountNo:
-                ...
-            frm = (odb.created_at + timedelta(minutes=180 - 1)).isoformat(sep=" ").split("+")[0]
-            to = ((odb.payed_at or odb.created_at) + timedelta(minutes=180 + 30)).isoformat(sep=" ").split("+")[0]
-            tsa = [
-                t
-                for tid, t in (self.hist.items() if self.hist else [])
-                if (ecredex.accountNo == t["to"] and t["from"] != "@merchant" and frm < t["date"] < to)
-            ]
-            buyer_person = (
-                self.actor.person
-                if not order.side
-                else await self.ex_client.person_name_update(order.buyerRealName, int(order.targetUserId))
-            )
-            ts = [t for t in tsa if floor(fa := float(order.amount)) <= float(t["creditedAmount"]) <= round(fa)]
-            if len(ts) != 1:
-                if len(tsa) > 1:
-                    summ = sum(float(t["creditedAmount"]) for t in tsa)
-                    if floor(fa) <= summ <= round(fa):
-                        for tr in tsa:
-                            am = int(float(tr["creditedAmount"]) * 100)
-                            await models.Transfer.create(
-                                pmid=tr["id"], order=odb, amount=am, sender_acc=tr["from"], created_at=tr["date"]
-                            )
-            else:
-                bcred, _ = await models.Cred.get_or_create(
-                    {"detail": ts[0]["from"]}, person=buyer_person, pmcur_id=odb.cred.pmcur_id
-                )
-                am = int(float(ts[0]["creditedAmount"]) * 100)
-                try:
-                    await models.Transfer.create(
-                        pmid=ts[0]["id"], order=odb, amount=am, sender_acc=ts[0]["from"], created_at=ts[0]["date"]
-                    )
-                except IntegrityError as e:
-                    logging.error(e)
-            ...
-
-        await odb.fetch_related("ad")
-        return odb
-
     async def get_api_orders(
         self,
         page: int = 1,
@@ -708,7 +465,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
             if o.status != Status.completed.value or oid in self.completed_orders:
                 continue
             order = await self.get_order_full(o.id)
-            order_db = await self.create_order_db(order)
+            order_db = await self.order_save(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)]
@@ -742,7 +499,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
     #     if round(cpc * new_premium / cpm, 2) == m
     #     mad.premium = new_premium.to_eng_string()
 
-    async def take_ad(self, req: TakeAdReq):
+    async def take_ad(self, req: TakeAdReq, bbot: XyncBot):
         if req.price and req.is_sell and req.cur_:
             ...  # todo call the get_ad_details() only if lack of data
         # res = self.api.get_ad_details(itemId=req.ad_id)["result"]
@@ -771,29 +528,29 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
         bor = BaseOrderReq(
             ad_id=str(req.ad_id),
-            fiat_amount=req.amount,
+            amount=req.amount,
             is_sell=req.is_sell,
             cur_exid=curex.exid,
             coin_exid=coinex.exid,
             coin_scale=coinex.scale,
             pmex_exid=pmexid,
         )
-        resp: OrderResp = await self._order_request(bor)
+        resp: OrderResp = await self._order_request(bor, bbot)
         return resp
 
-    async def watch_payeer(self, mcs: dict[int, "AgentClient"]):
+    async def watch_payeer(self, mcs: dict[int, "AgentClient"], bbot: XyncBot):
         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:
-                breq = GetAds(coin_id=1, cur_id=1, is_sell=False, limit=50)
+                breq = GetAdsReq(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(
+                    await bbot.send(
                         193017646,
                         f"price: {ad.price}\nnick: {ad.nickName}\nprice: {ad.price}"
                         f"\nqty: {ad.quantity} [{ad.minAmount}-{ad.maxAmount}]",
@@ -807,10 +564,10 @@ class AgentClient(BaseAgentClient):  # Bybit client
                         coin_id=1,
                         cur_id=1,
                     )
-                    ord_resp: OrderResp = await self.take_ad(req)
+                    ord_resp: OrderResp = await self.take_ad(req, bbot)
                     # order: OrderFull = OrderFull(**self.api.get_order_details(orderId=ord_resp.orderId)["result"])
                     order: OrderFull = await self.get_order_info(ord_resp.orderId)
-                    odb = await self.create_order_db(order)
+                    odb = await self.order_save(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)
@@ -826,12 +583,12 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
                 await sleep(5)
 
-                sreq = GetAds(coin_id=1, cur_id=1, is_sell=True, limit=50, kwargs={"post_pmexs": post_pmexs})
+                sreq = GetAdsReq(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(
+                    await bbot.send(
                         193017646,
                         f"price: {ad.price}\nnick: {ad.nickName}\nprice: {ad.price}"
                         f"\nqty: {ad.quantity} [{ad.minAmount}-{ad.maxAmount}]",
@@ -845,10 +602,10 @@ class AgentClient(BaseAgentClient):  # Bybit client
                         coin_id=1,
                         cur_id=1,
                     )
-                    ord_resp: OrderResp = await self.take_ad(req)
+                    ord_resp: OrderResp = await self.take_ad(req, bbot)
                     # order: OrderFull = OrderFull(**self.api.get_order_details(orderId=ord_resp.orderId)["result"])
                     order: OrderFull = await self.get_order_info(ord_resp.orderId)
-                    odb = await self.create_order_db(order)
+                    odb = await self.order_save(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)
@@ -879,7 +636,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
             req = TakeAdReq(ad_id="1856989782009487360", amount=am, pm_id=366)
             ord_resp: OrderResp = await self.take_ad(req)
             order: OrderFull = await self.get_order_full(int(ord_resp.orderId))
-            odb = await self.create_order_db(order)
+            odb = await self.order_save(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)
@@ -926,21 +683,31 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
             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):
-                    logging.info(f" {now().strftime('%H:%M:%S')} upd: {data.get('topic')}:{data.get('type')}")
-                    await self.proc(data)
+            try:
+                while resp := await websocket.recv():
+                    if data := json.loads(resp):
+                        logging.info(f" {now().strftime('%H:%M:%S')} upd: {data.get('topic')}:{data.get('type')}")
+                        await self.proc(data)
+            except ConnectionClosedError as e:
+                logging.warning(e)
+                await self._start_listen()
 
     async def proc(self, data: dict):
         match data.get("topic"):
             case "OTC_ORDER_STATUS":
                 match data["type"]:
                     case "STATUS_CHANGE":
-                        upd = StatusChange.model_validate(data["data"])
-                        order_db, order = await self.load_order(upd.id)
+                        try:
+                            upd = StatusChange.model_validate(data["data"])
+                        except ValidationError as e:
+                            logging.error(data["data"])
+                            raise e
+                        if not upd.status:
+                            logging.warning(data["data"])
+                        order_db, order = await self.load_order(upd.exid)
                         match upd.status:
-                            case Status.ws_new:
-                                logging.info(f"Order {upd.id} CREATED at {upd.createDate}")
+                            case OrderStatus.created:
+                                logging.info(f"Order {upd.exid} CREATED at {upd.created_at}")
                                 # await self.got_new_order(order_db, order)
 
                                 # # сразу уменьшаем доступный остаток монеты/валюты
@@ -951,8 +718,8 @@ class AgentClient(BaseAgentClient):  # Bybit client
                                 #         return
                                 #     await order_db.fetch_related("ad__pair_side__pair", "cred__pmcur__cur")
                                 #     await self.send_payment(order_db)
-                            case Status.created:
-                                if upd.side == 0:  # я продавец, ждем когда покупатель оплатит
+                                # case OrderStatus.created:
+                                if upd.ad__pair_side__is_sell == 0:  # я продавец, ждем когда покупатель оплатит
                                     # check_payment() # again
                                     ...
                                     # if not (pmacdx := await self.get_pma_by_cdex(order)):
@@ -990,7 +757,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
                                     #     for o in pos.get("items", [])
                                     #     if (
                                     #         o["amount"] == order.amount
-                                    #         and o["id"] != upd.id
+                                    #         and o["id"] != upd.exid
                                     #         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"][
@@ -1017,53 +784,54 @@ class AgentClient(BaseAgentClient):  # Bybit client
                                     #     return
                                     #
                                     # # !!! ОТПРАВЛЯЕМ ДЕНЬГИ !!!
-                                    # self.api.release_assets(orderId=upd.id)
+                                    # self.api.release_assets(orderId=upd.exid)
                                     # logging.info(
                                     #     f"Order {order.id} created, paid before #{tid}:{am} at {order.createDate}, and RELEASED at {now()}"
                                     # )
-                                elif upd.side == 1:  # я покупатель - ждем мою оплату
+                                elif upd.ad__pair_side__is_sell == 1:  # я покупатель - ждем мою оплату
                                     # pay()
-                                    logging.warning(f"Order {upd.id} CREATED2 at {now()}")
+                                    logging.warning(f"Order {upd.exid} CREATED2 at {now()}")
 
-                            case Status.paid:
+                            case OrderStatus.paid:
                                 if order_db.status == OrderStatus.paid:
                                     return
                                 await order_db.update_from_dict(
                                     {
                                         "status": OrderStatus.paid,
-                                        "payed_at": datetime.fromtimestamp(float(order.transferDate) / 1000),
+                                        "payed_at": order.payed_at,
                                     }
                                 ).save()
-                                logging.info(f"Order {order.id} payed at {order_db.payed_at}")
+                                logging.info(f"Order {order.exid} payed at {order_db.payed_at}")
 
-                            case Status.appealed_by_seller:  # just any appealed
+                            case OrderStatus.appealed_by_seller:  # just any 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),
+                                        "appealed_at": order.appealed_at,
                                     }
                                 ).save()
-                                logging.info(f"Order {order.id} appealed at {order_db.appealed_at}")
+                                logging.info(f"Order {order.exid} appealed at {order_db.appealed_at}")
 
-                            case Status.canceled:
+                            case OrderStatus.canceled:
                                 await order_db.update_from_dict({"status": OrderStatus.canceled}).save()
-                                logging.info(f"Order {order.id} canceled at {datetime.now()}")
+                                logging.info(f"Order {order.exid} canceled at {datetime.now()}")
                                 # await self.money_upd(order_db)
 
-                            case Status.completed:
+                            case OrderStatus.completed:
                                 await order_db.refresh_from_db()
                                 if order_db.status != OrderStatus.completed:
                                     await order_db.update_from_dict(
                                         {
                                             "status": OrderStatus.completed,
-                                            "confirmed_at": datetime.fromtimestamp(float(order.updateDate) / 1000),
+                                            "confirmed_at": order.confirmed_at,
                                         }
                                     ).save(update_fields=["status", "confirmed_at"])
                                 # await self.money_upd(order_db)
-
+                            case OrderStatus.appeal_disputed:
+                                logging.info(f"Order {order.exid} appeal_disputed at {datetime.now()}")
                             case _:
-                                logging.warning(f"Order {order.id} UNKNOWN STATUS {datetime.now()}")
+                                logging.warning(f"Order {order.exid} UNKNOWN STATUS {datetime.now()}")
                     case "COUNT_DOWN":
                         upd = CountDown.model_validate(data["data"])
 
@@ -1080,7 +848,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
                         #     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),
+                        #             "sent_at": upd.createDate,
                         #         },
                         #         txt=upd.message,
                         #         order=order_db,
@@ -1112,29 +880,19 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 #         self.listen(data)
             case "SELLER_CANCEL_CHANGE":
                 upd = SellerCancelChange.model_validate(data["data"])
+                order_db, order = await self.load_order(upd.id)
+                await order_db.cancel_request(self.agent.actor_id)
             case None:
                 if not data.get("success"):
-                    logging.error(data, "NOT SUCCESS!")
+                    raise HTTPException(401 if data["ret_msg"] == "Request not authorized" else data)
                 else:
                     return  # success login, subscribes, input
             case _:
                 logging.warning(data, "UNKNOWN TOPIC")
 
-    async def get_order_full(self, oid: int) -> OrderFull:
-        order = self.api.get_order_details(orderId=oid)
-        return OrderFull.model_validate(order["result"])
-
-    async def load_order(self, oid: int) -> tuple[models.Order, OrderFull]:
-        if not self.orders.get(oid):
-            order = await self.get_order_full(oid)
-            if not (
-                order_db := await models.Order.get_or_none(exid=oid, ad__maker__ex=self.actor.ex).prefetch_related(
-                    "ad__pair_side__pair", "cred__pmcur__cur"
-                )
-            ):
-                order_db = await self.create_order_db(order)
-            self.orders[oid] = order_db, order
-        return self.orders[oid]
+    async def _get_order_full(self, order_exid: int) -> OrderFull:
+        order_dict: dict = self.api.get_order_details(orderId=order_exid)["result"]
+        return OrderFull.model_validate(order_dict)
 
     async def money_upd(self, odb: models.Order):
         # обновляем остаток монеты
@@ -1301,7 +1059,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=5)
+        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",
@@ -1311,16 +1069,14 @@ async def main():
         )
         .first()
     )
-    filebot = FileClient(NET_TOKEN)
-    # await filebot.start()
     # b.add_handler(MessageHandler(cond_start_handler, command("cond")))
     ex = await models.Ex.get(name="Bybit")
-    ecl: ExClient = ex.client(filebot)
+    prx = PRX and "http://" + PRX
+    ecl: ExClient = ex.client(proxy=prx)
     abot = XyncBot(PAY_TOKEN, cn)
     # pmas = await models.PmAgent.filter(active=True, user_id=1).prefetch_related("pm", "user__gmail")
     # pm_clients = {pma.pm_id: pma.client(abot) for pma in pmas}
-    prx = PRX and "http://" + PRX
-    cl: AgentClient = agent.client(ecl, filebot, abot, proxy=prx)
+    cl: AgentClient = agent.client(ecl, proxy=prx)
 
     # req = TakeAdReq(ad_id=1955696985964089344, amount=504, pm_id=128)
     # await cl.take_ad(req)
@@ -1328,11 +1084,13 @@ async def main():
     # await cl.actual_cond()
     # cl.get_api_orders(),  # 10, 1738357200000, 1742504399999
 
+    # await cl.ex_client.set_coins()
+    # await cl.ex_client.set_curs()
     # await cl.ex_client.set_pairs()
     # await cl.ex_client.set_pms()
 
-    await cl.set_creds()
-    await cl.export_my_ads()
+    # await cl.load_creds()
+    # await cl.load_my_ads()
 
     my_ad = await models.MyAd[5]
     await cl.ad_share(my_ad.id)
@@ -1346,11 +1104,11 @@ async def main():
         "actor__my_ads__pair_side__pair__cur",
         "actor__my_ads__pms",
     )
-    mcs = {m.actor.exid: m.client(ecl, filebot, abot) for m in ms}
+    mcs = {m.actor.exid: m.client(ecl) for m in ms}
 
     await gather(
         # create_task(cl.start()),
-        create_task(cl.watch_payeer(mcs)),
+        create_task(cl.watch_payeer(mcs, abot)),
     )
     # ensure_future(cl.start(True))
     # await cl.boost_acc()
@@ -1380,8 +1138,7 @@ async def main():
     # await cl.get_api_orders()  # 43, 1741294800000, 1749157199999)
 
     # await cl.cancel_order(res.orderId)
-    await filebot.stop()
-    await cl.close()
+    await cl.stop()
 
 
 if __name__ == "__main__":