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

xync_client/Abc/Agent.py

@@ -29,6 +29,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
     bbot: XyncBot
     fbot: FileClient
     ex_client: BaseExClient
+    orders: dict[int, tuple[models.Order, BaseModel]] = {}  # pending
     pm_clients: dict[int, PmAgentClient]  # {pm_id: PmAgentClient}
     api: HttpClient
     cred_x2e: dict[int, int] = {}
@@ -69,11 +70,13 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
         return self.cred_e2x[exid]
 
     async def start(self):
-        if self.agent.status & 1:  # щас пока юзаем статус чисто как бул актив
+        if self.agent.status & 1:  # race
             for race in await models.Race.filter(started=True, road__ad__maker_id=self.agent.actor_id).prefetch_related(
                 "road__ad__pair_side__pair__cur", "road__credexs__cred"
             ):
                 create_task(self.racing(race))
+        if self.agent.status & 2:  # listen
+            await self.start_listen()
 
     async def racing(self, race: models.Race):
         pair = race.road.ad.pair_side.pair
@@ -460,6 +463,16 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
     #         await cred_db.banks.add(*[await PmExBank.get(exid=b) for b in banks])
     #     return True
 
+    @abstractmethod
+    async def _start_listen(self): ...
+
+    @abstractmethod
+    async def load_pending_orders(self): ...
+
+    async def start_listen(self):
+        create_task(self._start_listen())
+        await self.load_pending_orders()
+
 
 def step_is_need(mad, cad) -> bool:
     # todo: пока не решен непонятный кейс, почему то конкурент по всем параметрам слабже, но в списке ранжируется выше.

xync_client/Abc/Ex.py

@@ -431,17 +431,23 @@ class BaseExClient(HttpClient, AdLoader):
 
     async def person_name_update(self, name: str, exid: int) -> models.Person:
         if actor := await models.Actor.get_or_none(exid=exid, ex=self.ex).prefetch_related("person"):
-            actor.person.name = name
+            # мб уже есть персона с этим же name, note, tg_id
+            if person := await models.Person.get_or_none(
+                name=name, note=actor.person.note, tg_id=actor.person.tg_id, id__not=actor.person_id
+            ):
+                actor.person = person
+            else:
+                actor.person.name = name
             await actor.person.save()
             return actor.person
         # tmp dirty fix
         note = f"{self.ex.id}:{exid}"
-        if person := await models.Person.get_or_none(note__startswith=note):
+        if person := await models.Person.get_or_none(note__startswith=note, name__not=name):
             person.name = name
             await person.save()
             return person
         try:
-            return await models.Person.create(name=name, note=note)
+            return (await models.Person.update_or_create(name=name, note=note))[0]
         except OperationalError as e:
             raise e
         await models.Actor.create(person=person, exid=exid, ex=self.ex)
@@ -459,7 +465,7 @@ class BaseExClient(HttpClient, AdLoader):
         curex: models.CurEx = None,
         rname: str = None,
     ) -> models.Ad:
-        self.e2x_actor()
+        # self.e2x_actor()
         if not maker:
             if not (maker := await models.Actor.get_or_none(exid=pad.userId, ex=self.ex)):
                 person = await models.Person.create(name=rname, note=f"{self.ex.id}:{pad.userId}:{pad.nickName}")
@@ -494,6 +500,7 @@ class BaseExClient(HttpClient, AdLoader):
             ad_db, _ = await models.Ad.update_or_create(**df_unq)
         except OperationalError as e:
             raise e
+        await ad_db.pms.clear()
         await ad_db.pms.add(*(await models.Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=pad.payments)))
         return ad_db
 

xync_client/Abc/Order.py

@@ -1,27 +1,20 @@
 from abc import abstractmethod
 
-from asynchuobi.enums import OrderType
-from x_client.aiohttp import Client as HttpClient
-from xync_schema.models import Order, Actor
+from xync_schema.models import Order
 
 from xync_client.Bybit.agent import AgentClient
 
 
-class BaseOrderClient(HttpClient):
+class BaseOrderClient:
     order: Order
     im_maker: bool
     im_seller: bool
 
-    @abstractmethod
-    @property
-    def type_map(self) -> dict[OrderType, str]: ...
-
-    def __init__(self, actor: Actor, order: Order):
+    def __init__(self, order: Order, agent_client: AgentClient):
         self.order = order
-        self.im_maker = order.taker_id != actor.id  # or order.ad.agent_id == agent.id
-        self.im_seller = order.ad.direction.sell and self.im_maker
-        super().__init__(actor.ex.host_p2p)
-        self.agent_client = AgentClient(actor)
+        self.im_maker = order.taker_id != agent_client.actor.id  # or order.ad.agent_id == agent.id
+        self.im_seller = order.ad.pair_side.is_sell and self.im_maker
+        self.agent_client = agent_client
 
     # 2: [T] Отмена запроса на сделку
     @abstractmethod
@@ -37,7 +30,7 @@ class BaseOrderClient(HttpClient):
 
     # 5: [B] Перевод сделки в состояние "оплачено", c отправкой чека
     @abstractmethod
-    async def mark_payed(self, receipt): ...
+    async def mark_payed(self, receipt: bytes = None): ...
 
     # 6: [B] Отмена сделки
     @abstractmethod

xync_client/Abc/xtype.py

@@ -1,4 +1,4 @@
-from typing import Literal
+from typing import Literal, ClassVar
 
 from pydantic import BaseModel, model_validator, model_serializer
 from x_model.types import BaseUpd
@@ -16,7 +16,7 @@ MapOfIdsList = dict[int | str, list[int | str]]
 
 class RemapBase(BaseModel):
     # Переопределяешь это в наследнике:
-    _remap: dict[str, dict] = {}
+    _remap: ClassVar[dict[str, dict]] = {}
 
     @model_validator(mode="before")
     def _map_in(cls, data):

xync_client/Bybit/InAgent.py

@@ -1,11 +1,6 @@
-import logging
-import re
 from asyncio import create_task
-from datetime import datetime, timedelta
 from bybit_p2p import P2P
 from pyro_client.client.file import FileClient
-from tortoise.exceptions import IntegrityError
-from tortoise.timezone import now
 from xync_bot import XyncBot
 from xync_schema.models import Agent
 
@@ -13,17 +8,9 @@ from xync_client.Bybit.agent import AgentClient
 from xync_client.Bybit.ex import ExClient
 
 from xync_schema import models
-from xync_schema.enums import OrderStatus
 
 from xync_client.Bybit.etype.order import (
-    StatusChange,
-    CountDown,
-    SellerCancelChange,
-    Read,
-    Receive,
-    OrderFull,
     OrderItem,
-    Status,
 )
 
 
@@ -47,208 +34,3 @@ class InAgentClient(AgentClient):
         for oid in po.keys() - self.orders.keys():
             fo = self.api.get_order_details(orderId=oid)
             self.orders[oid] = await self.create_order_db(fo)
-
-    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"])
-
-                        if order_db := self.orders.get(upd.id):
-                            order_db.status = OrderStatus[Status(data["status"]).name]
-                            await order_db.save()
-                        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(order)
-                        match upd.status:
-                            case Status.ws_new:
-                                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):
-                                        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:  # ждем когда покупатель оплатит
-                                    if not (pmacdx := await self.get_pma_by_cdex(order)):
-                                        return
-                                    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")
-                                        return
-                                    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:  # если по этому платежу уже отпущен другая продажа
-                                        return
-
-                                    # если висят незавершенные продажи с такой же суммой
-                                    pos = (await self.get_orders_active(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!")
-                                        return
-
-                                    # !!! ОТПРАВЛЯЕМ ДЕНЬГИ !!!
-                                    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:  # я покупатель - ждем мою оплату
-                                    return  # 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:
-                                    return
-                                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":
-                        return
-                    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)
-                return
-            case "SELLER_CANCEL_CHANGE":
-                upd = SellerCancelChange.model_validate(data["data"])
-            case None:
-                if not data.get("success"):
-                    logging.error(data, "NOT SUCCESS!")
-                else:
-                    return  # success login, subscribes, input
-            case _:
-                logging.warning(data, "UNKNOWN TOPIC")
-        ...
-        if not upd:
-            logging.warning(data, "NOT PROCESSED UPDATE")

xync_client/Bybit/agent.py

@@ -19,7 +19,6 @@ from aiohttp.http_exceptions import HttpProcessingError
 from bybit_p2p import P2P
 from bybit_p2p._exceptions import FailedRequestError
 from payeer_api import PayeerAPI
-from pydantic import ValidationError
 from pyro_client.client.file import FileClient
 from tortoise import BaseDBAsyncClient
 from tortoise.exceptions import IntegrityError
@@ -77,34 +76,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
     sec_hdrs: dict[str, str]
     # rewrite token for public methods
     api: P2P
-    last_ad_id: list[str] = []
-    update_ad_body = {
-        "priceType": "1",
-        "premium": "118",
-        "quantity": "0.01",
-        "minAmount": "500",
-        "maxAmount": "3500000",
-        "paymentPeriod": "30",
-        "remark": "",
-        "price": "398244.84",
-        "paymentIds": ["3162931"],
-        "tradingPreferenceSet": {
-            "isKyc": "1",
-            "hasCompleteRateDay30": "0",
-            "completeRateDay30": "",
-            "hasOrderFinishNumberDay30": "0",
-            "orderFinishNumberDay30": "0",
-            "isMobile": "0",
-            "isEmail": "0",
-            "hasUnPostAd": "0",
-            "hasRegisterTime": "0",
-            "registerTimeThreshold": "0",
-            "hasNationalLimit": "0",
-            "nationalLimit": "",
-        },
-        "actionType": "MODIFY",
-        "securityRiskToken": "",
-    }
+    orders: dict[int, tuple[models.Order, OrderFull]] = {}  # pending
 
     def __init__(
         self,
@@ -292,19 +264,21 @@ class AgentClient(BaseAgentClient):  # Bybit client
             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)
-            # 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 ads_share(self, cur_id: int = None) -> int:
+        mq = models.MyAd.hot_mads_query([4]).filter(ad__maker=self.actor)
+        if cur_id:
+            mq = mq.filter(ad__pair_side__pair__cur_id=cur_id)
+        mads: list[models.MyAd] = await mq.all()
+        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")
+        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()})
@@ -312,15 +286,22 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 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} выключена")
+            raise ShareException(
+                f"Объява {myad.id}:{myad.ad.id}:{myad.ad.exid} агента {myad.ad.maker.agent_id} выключена"
+            )
         if data["ret_code"] == 912300059:
-            raise ShareException("Торговля выключена")
+            raise ShareException(f"Торговля агента {myad.ad.maker.agent_id} выключена")
+        if data["ret_code"] == 10007:
+            raise ShareException(f"Авторизация агента {myad.ad.maker.agent_id} слетела")
         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())
+        side = "buy" if myad.ad.pair_side.is_sell else "sell"  # inverse for taker
+        coin, cur = myad.ad.pair_side.pair.coin.ticker, myad.ad.pair_side.pair.cur.ticker
+        pref = models.MyAd.WEB.format(side=side, coin=coin, cur=cur)
+        hx = resp.url.query["by_web_link"].replace(pref, "")
+        _r = await models.MyAd.filter(id=maid).update(hex=bytes.fromhex(hx), shared_at=now())
         await myad.refresh_from_db()
         return myad.get_url()
 
@@ -535,7 +516,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
             },
         )
         if res["ret_code"] == 0:
-            return {o.id: OrderItem(**o) for o in res["result"]["items"]}
+            return {int(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):
@@ -728,8 +709,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
         for oid, o in ords.items():
             if o.status != Status.completed.value or oid in self.completed_orders:
                 continue
-            fo = self.api.get_order_details(orderId=o.id)
-            order = OrderFull.model_validate(fo["result"])
+            order = await self.get_order_full(o.id)
             order_db = await self.create_order_db(order)
             await sleep(1)
             dmsgs = self.api.get_chat_messages(orderId=oid, size=200)["result"]["result"][::-1]
@@ -900,27 +880,30 @@ class AgentClient(BaseAgentClient):  # Bybit client
             am = 500 + i
             req = TakeAdReq(ad_id="1856989782009487360", amount=am, pm_id=366)
             ord_resp: OrderResp = await self.take_ad(req)
-            order: OrderFull = OrderFull(**self.api.get_order_details(orderId=ord_resp.orderId)["result"])
+            order: OrderFull = await self.get_order_full(int(ord_resp.orderId))
             odb = await self.create_order_db(order)
             t = await models.Transfer(order=odb, amount=odb.amount, updated_at=now())
             await t.fetch_related("order__cred__pmcur__cur")
             await self.pm_clients[366].send(t)
         ...
 
-    pm_clients: dict[int, PmAgentClient]
+    async def load_pending_orders(self):
+        po: dict[int, OrderItem] = await self.get_pending_orders()
+        if isinstance(po, int):  # если код ошибки вместо результата
+            raise ValueError(po)
+        self.orders = {
+            o.exid: (o, await self.get_order_full(o.exid)) for o in await models.Order.filter(exid__in=po.keys())
+        }
+        for oid in po.keys() - self.orders.keys():
+            await self.load_order(oid)
 
-    async def start_listen(self):
+    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):
+        did = self.agent.auth["cookies"]["deviceId"]
         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]})
+            auth_msg = json.dumps({"req_id": did, "op": "login", "args": [t["result"]]})
             await websocket.send(auth_msg)
 
             sub_msg = json.dumps({"op": "subscribe", "args": ["FIAT_OTC_TOPIC", "FIAT_OTC_ONLINE_TOPIC"]})
@@ -947,222 +930,213 @@ class AgentClient(BaseAgentClient):  # Bybit client
             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")
+                    await self.proc(data)
+
+    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)
+                        match upd.status:
+                            case Status.ws_new:
+                                logging.info(f"Order {upd.id} CREATED at {upd.createDate}")
+                                # await self.got_new_order(order_db, order)
+
+                                # # сразу уменьшаем доступный остаток монеты/валюты
+                                # 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):
+                                #         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:  # я продавец, ждем когда покупатель оплатит
+                                    # check_payment() # again
+                                    ...
+                                    # if not (pmacdx := await self.get_pma_by_cdex(order)):
+                                    #     return
+                                    # 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")
+                                    #     return
+                                    # 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:  # если по этому платежу уже отпущен другая продажа
+                                    #     return
+                                    #
+                                    # # если висят незавершенные продажи с такой же суммой
+                                    # pos = (await self.get_orders_active(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!")
+                                    #     return
+                                    #
+                                    # # !!! ОТПРАВЛЯЕМ ДЕНЬГИ !!!
+                                    # 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:  # я покупатель - ждем мою оплату
+                                    # pay()
+                                    logging.warning(f"Order {upd.id} CREATED2 at {now()}")
+
+                            case Status.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),
+                                    }
+                                ).save()
+                                logging.info(f"Order {order.id} payed at {order_db.payed_at}")
+
+                            case Status.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),
+                                    }
+                                ).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.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),
+                                        }
+                                    ).save(update_fields=["status", "confirmed_at"])
+                                # 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 "OTC_USER_CHAT_MSG":
+                match data["type"]:
+                    case "RECEIVE":
+                        upd = Receive.model_validate(data["data"])
+                        order_db, order = await self.load_order(upd.orderId)
+                        # got_msg()
+                        ...
+                        # 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":
+                        # msg_read()
+                        upd = Read.model_validate(data["data"])
+
+                    case "CLEAR":
+                        return
+            case "OTC_USER_CHAT_MSG_V2":
+                # msg dup
+                ...
+                # 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)
+            case "SELLER_CANCEL_CHANGE":
+                upd = SellerCancelChange.model_validate(data["data"])
+            case None:
+                if not data.get("success"):
+                    logging.error(data, "NOT SUCCESS!")
+                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 money_upd(self, odb: models.Order):
         # обновляем остаток монеты
@@ -1279,11 +1253,6 @@ class AgentClient(BaseAgentClient):  # Bybit client
             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"))
@@ -1334,7 +1303,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=2)
+        await models.Agent.filter(actor__ex_id=4, auth__isnull=False, status__gt=AgentStatus.off, id=5)
         .prefetch_related(
             "actor__ex",
             "actor__person__user__gmail",
@@ -1364,12 +1333,11 @@ async def main():
     # await cl.ex_client.set_pairs()
     # await cl.ex_client.set_pms()
 
-    # await cl.set_creds()
-    # await cl.export_my_ads()
+    await cl.set_creds()
+    await cl.export_my_ads()
 
     my_ad = await models.MyAd[5]
     await cl.ad_share(my_ad.id)
-    await cl.start_listen()
 
     ms = await models.Agent.filter(
         actor__ex_id=4, auth__isnull=False, status__gt=AgentStatus.off, actor__person__user__id__in=[3]

xync_client/Bybit/etype/order.py

@@ -1,5 +1,5 @@
 from enum import IntEnum
-from typing import Literal
+from typing import Literal, ClassVar
 
 from pydantic import BaseModel
 
@@ -20,9 +20,9 @@ class Status(IntEnum):
     created = 10  # waiting for buyer to pay
     paid = 20  # waiting for seller to release
     appealed_by_seller = 30  # appealing
-    appealed_by_buyer = 30  # the same appealing
+    # appealed_by_buyer = 30  # the same appealing
     canceled = 40  # order cancelled
-    complete = 50  # order finished
+    completed = 50  # order finished
     # a = 60  # paying (only when paying online)
     # a = 70  # pay fail (only when paying online)
     # a = 80  # exception cancelled (the coin convert to other coin only hotswap)
@@ -137,7 +137,7 @@ class PaymentTerm(CredPaymentTerm):
 
 
 class _BaseOrder(RemapBase):
-    _remap = {"status": {}}
+    _remap: ClassVar[dict[str, dict]] = {"status": {}}
 
     id: int
     userId: int
@@ -290,7 +290,7 @@ class CountDown(_BaseChange):
 
 class _BaseMsg(BaseModel):
     userId: int
-    orderId: str
+    orderId: int
     message: str = None
     msgUuid: str
     msgUuId: str

xync_client/Bybit/order.py

@@ -1,26 +1,28 @@
-from xync_schema.models import Order
+from xync_client.Bybit.etype.cred import PaymentTerm
+from xync_schema.models import CredEx, PmEx
 
 from xync_client.Abc.Order import BaseOrderClient
 
 
 class OrderClient(BaseOrderClient):
-    # 2: Отмена своего запроса на сделку
-    async def cancel_request(self) -> Order: ...
-
-    # 3: Одобрить запрос на сделку
-    async def accept_request(self) -> bool: ...
-
-    # 4: Отклонить чужой запрос на сделку
-    async def reject_request(self) -> bool: ...
-
     # 5: Перевод сделки в состояние "оплачено", c отправкой чека
-    async def mark_payed(self, receipt): ...
+    async def mark_payed(self, payterm: PaymentTerm = None, receipt: bytes = None):
+        if payterm:
+            pt = str(payterm.paymentType)
+            pid = payterm.id
+        else:
+            pmx = await PmEx.get(pm__pmcurs__id=self.order.cred.pmcur_id, ex=self.agent_client.ex_client.ex)
+            pt = pmx.exid
+            cdx = await CredEx.get(cred_id=self.order.cred_id, ex=self.agent_client.ex_client.ex)
+            pid = str(cdx.exid)
+        self.agent_client.api.mark_as_paid(orderId=str(self.order.exid), paymentType=pt, paymentId=pid)
 
     # 6: Отмена одобренной сделки
     async def cancel_order(self) -> bool: ...
 
     # 7: Подтвердить получение оплаты
-    async def confirm(self) -> bool: ...
+    async def confirm(self):
+        self.agent_client.api.release_assets(orderId=str(self.order.exid))
 
     # 9, 10: Подать аппеляцию cо скриншотом/видео/файлом
     async def start_appeal(self, file) -> bool: ...

xync_client/Pms/Volet/{__init__.py → agent.py}

@@ -10,7 +10,6 @@ from PGram import Bot
 from playwright.async_api import async_playwright, Page, Locator, Position, Playwright, Browser  # , FloatRect
 from pyotp import TOTP
 
-# noinspection PyProtectedMember
 from playwright._impl._errors import TimeoutError
 from pyro_client.client.user import UserClient
 from pyrogram.handlers import MessageHandler
@@ -268,7 +267,7 @@ async def _test():
     playwright: Playwright = await async_playwright().start()
 
     try:
-        o = await models.Order.create(ad_id=7, exid=1, amount=900, cred_id=522, taker_id=419)
+        o = await models.Order.create(ad_id=7, exid=1, amount=900, cred_id=522, taker_id=1794)
         await o.fetch_related("cred__pmcur__cur", "ad")
         pma = await models.PmAgent.get(
             active=True,

{xync_client-0.0.156.dev18.dist-info → xync_client-0.0.162.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.156.dev18
+Version: 0.0.162
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client

{xync_client-0.0.156.dev18.dist-info → xync_client-0.0.162.dist-info}/RECORD

@@ -3,17 +3,17 @@ xync_client/details.py,sha256=21itVPCgAtaYRR1H9J9oYudj95gafcFjExUN6QL17OI,1330
 xync_client/loader.py,sha256=DA6lHUxGidULjpHyKGS1POc5r11rlOThQRdueOgr04A,617
 xync_client/pm_unifier.py,sha256=DYkFYXzmhVEh8WJvI---3Geas34mZ83cT1O-88D68YQ,6568
 xync_client/Abc/AdLoader.py,sha256=PkVl6CwRvXkL7dd9HA124hBgXVMOQiXac73rYKL0PIk,67
-xync_client/Abc/Agent.py,sha256=GMHYZlosHotO6XdQHJ_rPnmHAB5jrkRXwNLxeiQMUY0,22971
+xync_client/Abc/Agent.py,sha256=IN3CsgXdzQ9L0dtkConnVLnqVLhLYfLQ19bwJDCl7_c,23296
 xync_client/Abc/Asset.py,sha256=hlgyFaU9byr2N2r8Heh-_ICx49SKuKxfRTUA4yQWmEw,454
 xync_client/Abc/Auth.py,sha256=OPQXN7_XYQZP9431ylFksd6JDusbKG8N_1g6CXTZ6yY,1495
 xync_client/Abc/BaseTest.py,sha256=vaAs5Z4HYV7k_C3zQz6JKO75s2hXtVbBI3-0Srkzv5Q,2388
-xync_client/Abc/Ex.py,sha256=TtbOseV7b4qKfjdWOf4zPGNpra3hFF-CuR2oOyCdzlQ,32359
+xync_client/Abc/Ex.py,sha256=TaRbQpl9hQmTzYxGkweYaYPuYMmFQ3UwRM77AeRhBYU,32743
 xync_client/Abc/Exception.py,sha256=Sts7RpP370NBdjaH_cyXDdHtjge8zXNUGWCrKw49Zyk,482
 xync_client/Abc/HasAbotUid.py,sha256=LsTHHjMHBauCwJoqgDa9Lx4R6xsDOHfsN4jM539Bpqg,279
 xync_client/Abc/InAgent.py,sha256=8BnZ7VzWLIJY93xnNTqlpY3JdarQkkpRRjDDEALaVAA,303
-xync_client/Abc/Order.py,sha256=7-FGIJu5z9aYi0A_eJV4F-cp_6Mz_izNpefexDQZvHw,2428
+xync_client/Abc/Order.py,sha256=TJhCvE9FZ_29KIKvDPO1sJxTj2tYxIQar5yFgUaP22Q,2226
 xync_client/Abc/PmAgent.py,sha256=Xl-0-KMwcTp_7qIt7NV7-aD22j955tFYFqcHHbmGMTQ,4193
-xync_client/Abc/xtype.py,sha256=mABfxNxUjkKkv65YgEbOq5lciYpIZaERImgloui83tA,4010
+xync_client/Abc/xtype.py,sha256=rp-to40BqNgT76zj5jyIdzLeRRHwpa6-fdD3OKJUXT4,4030
 xync_client/Binance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xync_client/Binance/binance_async.py,sha256=LP2DZaHwkfsp_4Tjvetb-1ntjQtJfODF0OgZpoPx4KU,2688
 xync_client/Binance/earn_api.py,sha256=hvk0MaVTLszIglQXVhbUjGcaHfbF9Ul7FFXmy94U2so,4411
@@ -36,17 +36,17 @@ xync_client/BitGet/agent.py,sha256=YVs3bDY0OcEJGU7m2A8chzO6PFhWDnQQrA-E6MVkBBg,3
 xync_client/BitGet/ex.py,sha256=uEvvXuLaJv8o8BFi0bMA3XyBuTfVDWagAjLOHZl-xlE,3765
 xync_client/BitGet/etype/ad.py,sha256=fysSW47wGYjSOPUqY864z857AJz4gjN-nOkI1Jxd27U,1838
 xync_client/BitPapa/ex.py,sha256=U-RRB_RSOtErfRgxOZYWegZ_td_uZO37YKo3Jxchf_w,912
-xync_client/Bybit/InAgent.py,sha256=jmqqglT_YTkhg_EDxvrOl1Q5VUcz-nudtr7LYhplyYY,14100
-xync_client/Bybit/agent.py,sha256=ycQcVkf82oiT6PmRDCkaoot8E8mCLhc9dAFVPgASMd8,69654
+xync_client/Bybit/InAgent.py,sha256=HJzy-avXlGu7yh11WqYmx8whTGKU3HTng2dtkbLtTCQ,1234
+xync_client/Bybit/agent.py,sha256=MyZRc5sbbuivw8N1LeFcjwba4AJytplStFldku_ESaM,66356
 xync_client/Bybit/ex.py,sha256=W_bYXafNR3aWdx0qpr06bGHl52xGBaKKcABleveHXng,4468
-xync_client/Bybit/order.py,sha256=H4UIb8hxFGnw1hZuSbr0yZ4qeaCOIZOMc6jEst0ycBs,1713
+xync_client/Bybit/order.py,sha256=qDE6WDlpbYDdVJeIG33bIOPuMfgBBhbaVOR8LJa8Bms,2006
 xync_client/Bybit/web_earn.py,sha256=qjqS10xlFc8r40IhDdPZ0LxA2dFEGbvBGXdsrUUJCMo,3019
 xync_client/Bybit/web_p2p.py,sha256=sAXzK03t6jwDnz4rrvP2IzI0KxfKa7C_5GuzH1HwLuA,11768
 xync_client/Bybit/ws.py,sha256=OQjZHo_MiAH1dlOs3c-aUZBKyqToNTmH560udh6RYDE,1431
 xync_client/Bybit/etype/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xync_client/Bybit/etype/ad.py,sha256=qGCVc9eqc7lRRk0Hh3gD5i3HY0TXX-JdNY91VDoNg1I,5830
 xync_client/Bybit/etype/cred.py,sha256=CH6xqHh1214bLhHy_K9eVBb1SJVhWBfGb0l3LtBf3fU,1701
-xync_client/Bybit/etype/order.py,sha256=GbaBXBGAOdFC748qqsPAjEGdTy63IzUCb7f4tb9LddY,7868
+xync_client/Bybit/etype/order.py,sha256=FAQ8ILI1E_Ow25KF8a9hinbI6kXY-t0aC0Xnrp4069o,7908
 xync_client/Gate/ex.py,sha256=QbhB3u7TWnvVGD-AknB2nay6KZjEXQ-1JT9UacX4sWI,3735
 xync_client/Gate/premarket.py,sha256=IW-CgkmNJePJR2j_NRfULNKTePMX35XlhldqdiO76zY,2138
 xync_client/Gate/etype/ad.py,sha256=-EwtFcOWWvtE6UjaOdsuXWDTCVjAIRK0kSEsqPP4Yls,1296
@@ -87,7 +87,7 @@ xync_client/Pms/Payeer/trade.py,sha256=Z_PSrXsFsecPam2sjuzImiwTXX-9cKGuJTbYOwLnL
 xync_client/Pms/Sber/__init__.py,sha256=dxQfd9ZPhFTc_C4xrwaxrV6p0SijDCLNzBeUv3oQG38,4926
 xync_client/Pms/Sber/utils.py,sha256=gIeJspwvoBbOBt-fjxwW4WDHPoL2Evs8LVufsjrFOfo,1870
 xync_client/Pms/Tinkoff/__init__.py,sha256=ZyLvBEUn-vh-85oPUUDS586AHgvx3c-mkQE3yBQtbw8,5580
-xync_client/Pms/Volet/__init__.py,sha256=mYJEmZwFoNU2B2erv7n8k6RA0PsXU12K7hpyrdEocrk,12088
+xync_client/Pms/Volet/agent.py,sha256=K9GhwTHPQUK3TgobOZd_EYVp0GV-pGq_7MdcTUJJkPM,12056
 xync_client/Pms/Volet/api.py,sha256=6_dH2rzmyyvha3PeoiZdSltiAzKDWn8roSUJOAErX4M,3673
 xync_client/Pms/Volet/pl.py,sha256=l7lvUrpjFoObXPHaseOIAcSbkNqJdpy6OLDutxYJH3U,2451
 xync_client/Pms/Volet/_todo_req/req.mjs,sha256=ut3Jw37rL5lY7SskjZ9f1l0VE33tuP-PZEYUTcJMc2I,817
@@ -104,7 +104,7 @@ xync_client/TgWallet/order.py,sha256=BOmBx5WWfJv0-_-A8DcR-Xd8utqO_VTmSqSegm0cteQ
 xync_client/TgWallet/pyd.py,sha256=Ys3E8b3RLuyQ26frWT0F0BorkNxVpxnd18tY4Gp9dik,5636
 xync_client/TgWallet/pyro.py,sha256=2K7QWdo48k4MbbgQt90gdz_HiPck69Njm4xaMjIVgoo,1440
 xync_client/TgWallet/web.py,sha256=kDcv9SKKQPe91mw1qJBpbuyKYCAmZdfdHJylHumLBVU,1608
-xync_client-0.0.156.dev18.dist-info/METADATA,sha256=9bvLxkPjU71Y-6Ur0-1dbXTfTDqFnucO3LLzMJrqLAs,1187
-xync_client-0.0.156.dev18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xync_client-0.0.156.dev18.dist-info/top_level.txt,sha256=bmYEVIIrD3v7yFwH-X15pEfRvzhuAdfsAZ2igvNI4O8,12
-xync_client-0.0.156.dev18.dist-info/RECORD,,
+xync_client-0.0.162.dist-info/METADATA,sha256=fObLDRD-fDTgXnRXbmMBiioSGGgr0WgwS12thRoLeII,1181
+xync_client-0.0.162.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xync_client-0.0.162.dist-info/top_level.txt,sha256=bmYEVIIrD3v7yFwH-X15pEfRvzhuAdfsAZ2igvNI4O8,12
+xync_client-0.0.162.dist-info/RECORD,,