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

xync_client/Abc/Ex.py

@@ -6,7 +6,6 @@ from collections import defaultdict
 from difflib import SequenceMatcher
 
 from aiohttp import ClientSession, ClientResponse
-from google.protobuf.internal.wire_format import INT32_MAX
 from msgspec import Struct
 from pydantic import BaseModel
 from pyro_client.client.file import FileClient
@@ -15,10 +14,10 @@ from x_client.aiohttp import Client as HttpClient
 from xync_client.Bybit.etype.ad import AdsReq
 from xync_schema import models
 from xync_schema.enums import FileType
-from xync_schema.xtype import CurEx, CoinEx, BaseAd, BaseAdIn
+from xync_schema import xtype
 
 from xync_client.Abc.AdLoader import AdLoader
-from xync_client.Abc.xtype import PmEx, MapOfIdsList, GetAds
+from xync_client.Abc.xtype import PmEx, MapOfIdsList, GetAdsReq, BaseActor, BaseAd, BaseCounteragent
 from xync_client.pm_unifier import PmUnifier, PmUni
 
 
@@ -27,41 +26,38 @@ class BaseExClient(HttpClient, AdLoader):
     cur_map: dict[int, str] = {}
     unifier_class: type = PmUnifier
     logo_pre_url: str
-    bot: FileClient
     ex: models.Ex
 
     coin_x2e: dict[int, tuple[str, int]] = {}
     coin_e2x: dict[str, int] = {}
     cur_x2e: dict[int, tuple[str, int, int]] = {}
     cur_e2x: dict[str, int] = {}
-    pm_x2e: dict[int, str] = {}
-    pm_e2x: dict[str, int] = {}
+    pm_x2e: dict[int, str | int] = {}
+    pm_e2x: dict[str | int, int] = {}
     pairs_e2x: dict[int, dict[int, tuple[int, int]]] = defaultdict(defaultdict)
     pairs_x2e: dict[int, tuple[int, int, int]] = defaultdict(defaultdict)
     actor_x2e: dict[int, int] = {}
-    actor_e2x: dict[int, int] = {}
+    actor_e2x: dict[int, models.Actor] = {}
     ad_x2e: dict[int, int] = {}
-    ad_e2x: dict[int, int] = {}
+    ad_e2x: dict[int, models.Ad] = {}
 
     def __init__(
         self,
         ex: models.Ex,
-        bot: FileClient,
         attr: str = "host_p2p",
         headers: dict[str, str] = None,
         cookies: dict[str, str] = None,
         proxy: models.Proxy = None,
     ):
         self.ex = ex
-        self.bot = bot
-        super().__init__(self.host or getattr(ex, attr), headers, cookies, proxy and proxy.str())
+        super().__init__(self.host or getattr(ex, attr), headers, cookies, proxy and str(proxy))
 
     @abstractmethod
     def pm_type_map(self, typ: models.PmEx) -> str: ...
 
     # 19: Список поддерживаемых валют тейкера
     @abstractmethod
-    async def curs(self) -> dict[str, CurEx]:  # {cur.ticker: cur}
+    async def curs(self) -> dict[str, xtype.CurEx]:  # {cur.ticker: cur}
         ...
 
     # 20: Список платежных методов
@@ -74,9 +70,9 @@ class BaseExClient(HttpClient, AdLoader):
     async def cur_pms_map(self) -> MapOfIdsList:  # {cur.exid: [pm.exid]}
         ...
 
-    # 22: Список торгуемых монет (с ограничениям по валютам, если есть)
+    # 22: Список торгуемых монет (с ограничением по валютам, если есть)
     @abstractmethod
-    async def coins(self) -> dict[str, CoinEx]:  # {coin.ticker: coin}
+    async def coins(self) -> dict[str, xtype.CoinEx]:  # {coin.ticker: coin}
         ...
 
     # 23: Список пар валюта/монет
@@ -118,7 +114,7 @@ class BaseExClient(HttpClient, AdLoader):
             self.pm_e2x[self.pm_x2e[pm_id]] = pm_id
         return self.pm_x2e[pm_id]
 
-    async def e2x_pm(self, exid: str) -> int:  # pm.id
+    async def e2x_pm(self, exid: str | int) -> int:  # pm.id
         if not self.pm_e2x.get(exid):
             self.pm_e2x[exid] = (await models.PmEx.get(exid=exid, ex=self.ex)).pm_id
             self.pm_x2e[self.pm_e2x[exid]] = exid
@@ -153,15 +149,17 @@ class BaseExClient(HttpClient, AdLoader):
 
     async def x2e_actor(self, actor_id: int) -> int:  # actor.exid
         if not self.actor_x2e.get(actor_id):
-            self.actor_x2e[actor_id] = (await models.Actor[actor_id]).exid
-            self.actor_e2x[self.actor_x2e[actor_id]] = actor_id
+            actor = await models.Actor[actor_id]
+            self.actor_x2e[actor_id] = actor.exid
+            self.actor_e2x[self.actor_x2e[actor_id]] = actor
         return self.actor_x2e[actor_id]
 
-    async def e2x_actor(self, exid: int) -> int:  # actor.id
-        if not self.actor_e2x.get(exid):
-            self.actor_e2x[exid] = (await models.Actor.get(exid=exid, ex=self.ex)).id
-            self.actor_x2e[self.actor_e2x[exid]] = exid
-        return self.actor_e2x[exid]
+    async def e2x_actor(self, base_actor: BaseActor) -> models.Actor:
+        if not self.actor_e2x.get(base_actor.exid):
+            actor = await self.actor_save(base_actor)
+            self.actor_e2x[base_actor.exid] = actor
+            self.actor_x2e[actor.id] = base_actor.exid
+        return self.actor_e2x[base_actor.exid]
 
     async def x2e_ad(self, ad_id: int) -> int:  # ad.exid
         if not self.ad_x2e.get(ad_id):
@@ -169,15 +167,15 @@ class BaseExClient(HttpClient, AdLoader):
             self.ad_e2x[self.ad_x2e[ad_id]] = ad_id
         return self.ad_x2e[ad_id]
 
-    async def e2x_ad(self, exid: int) -> int:  # ad.id
-        if not self.ad_e2x.get(exid):
-            self.ad_e2x[exid] = (await models.Ad.get(exid=exid, maker__ex=self.ex)).id
-            self.ad_x2e[self.ad_e2x[exid]] = exid
-        return self.ad_e2x[exid]
+    async def e2x_ad(self, ad_exid: int) -> models.Ad:  # todo: пока только для мейкерных, не создаются если нет в бд
+        if not self.ad_e2x.get(ad_exid):
+            ad = await models.Ad.get_or_none(exid=ad_exid, maker__ex=self.ex)
+            self.ad_e2x[ad_exid] = ad
+            self.ad_x2e[ad.id] = ad_exid
+        return self.ad_e2x[ad_exid]
 
     # 24: Список объяв по (buy/sell, cur, coin, pm)
-    async def ads(self, xreq: GetAds, **kwargs) -> list[BaseAd]:
-        self.ex.etype().ad.AdsReq
+    async def ads(self, xreq: GetAdsReq, **kwargs) -> list[xtype.BaseAd]:
         ereq = AdsReq(
             coin_id=(await self.x2e_coin(xreq.coin_id))[0],
             cur_id=(await self.x2e_cur(xreq.cur_id))[0],
@@ -195,11 +193,11 @@ class BaseExClient(HttpClient, AdLoader):
 
     # 42: Чужая объява по id
     @abstractmethod
-    async def ad(self, ad_id: int) -> BaseAd: ...
+    async def ad(self, ad_id: int) -> xtype.BaseAd: ...
 
     # Преобразрование объекта объявления из формата биржи в формат xync
     @abstractmethod
-    async def ad_epyd2pydin(self, ad: BaseAd) -> BaseAdIn: ...  # my_uid: for MyAd
+    async def ad_epyd2pydin(self, ad: BaseAd) -> xtype.BaseAd: ...  # my_uid: for MyAd
 
     # 99: Страны
     async def countries(self) -> list[Struct]:
@@ -208,7 +206,7 @@ class BaseExClient(HttpClient, AdLoader):
     # Импорт валют Cur-ов (с CurEx-ами)
     async def set_curs(self, cookies: dict = None) -> bool:
         # Curs
-        cur_pyds: dict[str, CurEx] = await self.curs()
+        cur_pyds: dict[str, xtype.CurEx] = await self.curs()
         old_curs = {c.ticker: c.id for c in await models.Cur.all()}
         curs: dict[int | str, models.Cur] = {
             exid: (
@@ -226,7 +224,7 @@ class BaseExClient(HttpClient, AdLoader):
         await models.CurEx.bulk_create(curexs, update_fields=["minimum", "scale"], on_conflict=["cur_id", "ex_id"])
 
     # Импорт Pm-ов (с PmCur-, PmEx- и Pmcurex-ами) и валют (с CurEx-ами) с биржи в бд
-    async def set_pms(self, cookies: dict = None) -> bool:
+    async def set_pms(self, bot: FileClient, cookies: dict = None) -> bool:
         if cookies:
             self.session.cookie_jar.update_cookies(cookies)
         curs: dict[int | str, models.Cur] = {
@@ -289,7 +287,7 @@ class BaseExClient(HttpClient, AdLoader):
                     ex=self.ex,
                     pm=pm,
                     name=pmexs_epyds[k].name,
-                    logo=await self.logo_save(pmexs_epyds[k].logo, ss),
+                    logo=await self.logo_save(pmexs_epyds[k].logo, bot, ss),
                 )
                 for k, pm in pms.items()
             ]
@@ -319,18 +317,18 @@ class BaseExClient(HttpClient, AdLoader):
         # await Pmcurex.bulk_create(pmcurexs)
         return True
 
-    async def logo_save(self, url: str | None, ss: ClientSession) -> models.File | None:
+    async def logo_save(self, url: str | None, bot: FileClient, ss: ClientSession) -> models.File | None:
         if url or (file := None):
             if not url.startswith("https:"):
                 if not url.startswith("/"):
                     url = "/" + url
                 url = "https://" + self.logo_pre_url + url
-            return await self.file_upsert(url, ss)
+            return await self.file_upsert(url, bot, ss)
         return file
 
     # Импорт монет (с CoinEx-ами) с биржи в бд
     async def set_coins(self):
-        coinexs: dict[str, CoinEx] = await self.coins()
+        coinexs: dict[str, xtype.CoinEx] = await self.coins()
         coins_db: dict[int, models.Coin] = {
             c.exid: (
                 await models.Coin.update_or_create({"scale": c.scale or self.coin_scales[c.ticker]}, ticker=c.ticker)
@@ -352,10 +350,10 @@ class BaseExClient(HttpClient, AdLoader):
 
     # Импорт пар биржи в бд
     async def set_pairs(self):
-        curs: dict[str, CurEx] = {
+        curs: dict[str, models.Cur] = {
             k: (await models.Cur.get_or_create(ticker=c.ticker))[0] for k, c in (await self.curs()).items()
         }
-        coins: dict[str, CoinEx] = {
+        coins: dict[str, xtype.CoinEx] = {
             k: (await models.Coin.get_or_create(ticker=c.ticker))[0] for k, c in (await self.coins()).items()
         }
         prs: tuple[dict, dict] = await self.pairs()
@@ -377,12 +375,12 @@ class BaseExClient(HttpClient, AdLoader):
     #     await ad_db.pmexs.add(*getattr(ad_pydin, "pmexs_", []))
     #     return ad_db
 
-    async def file_upsert(self, url: str, ss: ClientSession = None) -> models.File:
+    async def file_upsert(self, url: str, bot: FileClient, ss: ClientSession = None) -> models.File:
         if not (file := await models.File.get_or_none(name__startswith=url.split("?")[0])):
             ss = ss or self.session
             if (resp := await ss.get(url)).ok:
                 byts = await resp.read()
-                upf, ref = await self.bot.save_doc(byts, resp.content_type)
+                upf, ref = await bot.save_doc(byts, resp.content_type)
                 await sleep(0.3)
                 typ = FileType[resp.content_type.split("/")[-1]]
                 file, _ = await models.File.update_or_create({"ref": ref, "size": len(byts), "typ": typ}, name=url)
@@ -394,7 +392,10 @@ class BaseExClient(HttpClient, AdLoader):
             proxy = await models.Proxy.filter(valid=True, country__short__not="US").order_by("-updated_at").first()
             cookies = self.session.cookie_jar.filter_cookies(self.session._base_url)
             self.session = ClientSession(
-                self.session._base_url, headers=self.session.headers, cookies=cookies or None, proxy=proxy.str()
+                self.session._base_url,
+                headers=self.session.headers,
+                cookies=cookies or None,
+                proxy=proxy and str(proxy),
             )
             return await self.METHS[resp.method](self, resp.url.path, bp)
         return await super()._proc(resp, bp)
@@ -429,106 +430,82 @@ class BaseExClient(HttpClient, AdLoader):
         if ct := set(self.tree.keys()) & a:
             logging.exception(f"cycle cids: {ct}")
 
-    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"):
-            # мб уже есть персона с этим же 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, name__not=name):
-            person.name = name
-            await person.save()
-            return person
-        try:
-            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)
+    async def person_save(self, base_person: BaseActor) -> models.Person:
+        if not (person := await models.Person.get_or_none(note=(note := f"{self.ex.id}:{base_person.exid}"))):
+            name = base_person.name if isinstance(base_person, BaseCounteragent) else base_person.nick
+            person = await models.Person.create(name=name, note=note)
+        elif isinstance(base_person, BaseCounteragent) and not person.name:
+            # если персона не новая, но имени не было, а щас передано - обновим
+            person.name = base_person.name
+            await person.save(update_fields=["name"])
         return person
-        # person = await models.Person.create(note=f'{actor.ex_id}:{actor.exid}:{name}') # no person for just ads with no orders
-        # raise ValueError(f"Agent #{exid} not found")
 
-    async def ad_load(
-        self,
-        pad: BaseAd,
-        cid: int = None,
-        ps: models.PairSide = None,
-        maker: models.Actor = None,
-        coinex: models.CoinEx = None,
-        curex: models.CurEx = None,
-        rname: str = None,
-    ) -> models.Ad:
-        # 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}")
-                maker = await models.Actor.create(name=pad.nickName, person=person, exid=pad.userId, ex=self.ex)
-        if rname:
-            await self.person_name_update(rname, int(pad.userId))
-        ps = ps or await models.PairSide.get_or_none(
-            is_sell=pad.side,
-            pair__coin__ticker=pad.tokenId,
-            pair__cur__ticker=pad.currencyId,
-        ).prefetch_related("pair")
-        # if not ps or not ps.pair:
-        #     ...  # THB/USDC: just for initial filling
-        ad_upd = models.Ad.validate(pad.model_dump(by_alias=True))
-        cur_scale = 10 ** (curex or await models.CurEx.get(cur_id=ps.pair.cur_id, ex=self.ex)).scale
-        coin_scale = 10 ** (coinex or await models.CoinEx.get(coin_id=ps.pair.coin_id, ex=self.ex)).scale
-        amt = int(float(pad.quantity) * float(pad.price) * cur_scale)
-        mxf = pad.maxAmount and int(float(pad.maxAmount) * cur_scale)
-        df_unq = ad_upd.df_unq(
-            maker_id=maker.id,
-            pair_side_id=ps.id,
-            amount=min(amt, INT32_MAX),
-            quantity=int(float(pad.quantity) * coin_scale),
-            min_fiat=int(float(pad.minAmount) * cur_scale),
-            max_fiat=min(mxf, INT32_MAX),
-            price=int(float(pad.price) * cur_scale),
-            premium=int(float(pad.premium) * 100),
-            cond_id=cid,
-            status=self.ad_status(ad_upd.status),
+    async def actor_save(self, base_actor: BaseActor) -> models.Actor:
+        if not (actor := await models.Actor.get_or_none(exid=base_actor.exid, ex=self.ex)):
+            # если это новый актор - делаем создание персоны со стороны биржи
+            person = await self.person_save(base_actor)
+            actor = await models.Actor.create(exid=base_actor.exid, name=base_actor.nick, person=person, ex=self.ex)
+        return actor
+
+    async def ad_save(self, base_ad: BaseAd) -> models.Ad:
+        if ad_db := await models.Ad.get_or_none(exid=base_ad.exid, maker__ex=self.ex):
+            ...  # load new data
+            return ad_db
+        cond = await self.load_cond(base_ad.cond_txt, base_ad.maker_exid)
+        _, cur_scale, _cur_min = await self.x2e_cur(await self.e2x_cur(base_ad.curex_exid))
+        _, coin_scale = await self.x2e_coin(await self.e2x_coin(base_ad.coinex_exid))
+        badd = base_ad.model_dump()
+        badd.update(
+            amount=int((base_ad.amount or base_ad.quantity * base_ad.price) * 10**cur_scale),
+            max_fiat=int(base_ad.max_fiat * 10**cur_scale),
+            min_fiat=int(base_ad.min_fiat * 10**cur_scale),
+            premium=int(base_ad.premium * 100_00),
+            price=int(base_ad.price * 10**cur_scale),
+            quantity=int((base_ad.quantity or base_ad.amount / base_ad.price) * 10**coin_scale),
+            maker_id=(await self.e2x_actor(base_ad.maker)).id,
+            cond_id=cond and cond.id,
+            pair_side_id=await self.e2x_pair(base_ad.coinex_exid, base_ad.curex_exid, bool(base_ad.side.value)),
+            pms=await models.Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=base_ad.pmex_exids),
         )
+        ad = xtype.BaseAd.model_validate(badd)
+        ad_upd = models.Ad.validate(ad.model_dump(), with_pk=False)
         try:
-            ad_db, _ = await models.Ad.update_or_create(**df_unq)
+            ad_db, _ = await models.Ad.update_or_create(**ad_upd.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)))
+        await ad_db.pms.add(*ad.pms)
         return ad_db
 
-    async def cond_load(  # todo: refact from Bybit Ad format to universal
-        self,
-        ad: BaseAd,
-        ps: models.PairSide = None,
-        force: bool = False,
-        rname: str = None,
-        coinex: models.CoinEx = None,
-        curex: models.CurEx = None,
-        pms_from_cond: bool = False,
-    ) -> tuple[models.Ad, bool]:
+    async def load_cond(self, txt: str, maker_exid: int) -> models.Cond | None:
+        # если текст пустой
+        if not (cleaned := clean(txt)):
+            return None
+        # если точно такое условие уже есть в бд
+        if cid := {oc[0]: ci for ci, oc in self.all_conds.items()}.get(cleaned):
+            return await models.Cond[cid]
+        # создаем новое условие
+        return await self.cond_new(cleaned, {maker_exid})
+
+    async def old_load_cond(self, ad: BaseAd) -> models.Ad:
         _sim, cid = None, None
-        ad_db = await models.Ad.get_or_none(exid=ad.id, maker__ex=self.ex).prefetch_related("cond")
+        ad_db = await models.Ad.get_or_none(exid=ad.exid, maker__ex=self.ex).prefetch_related("cond")
         # если точно такое условие уже есть в бд
-        if not (cleaned := clean(ad.remark)) or (cid := {oc[0]: ci for ci, oc in self.all_conds.items()}.get(cleaned)):
+        if not (cleaned := clean(ad.cond_txt)) or (
+            cid := {oc[0]: ci for ci, oc in self.all_conds.items()}.get(cleaned)
+        ):
             # и объява с таким ид уже есть, но у нее другое условие
             if ad_db and ad_db.cond_id != cid:
+                old_cid = ad_db.cond_id
                 # то обновляем ид ее условия
                 ad_db.cond_id = cid
-                await ad_db.save()
-                logging.info(f"{ad.nickName} upd cond#{ad_db.cond_id}->{cid}")
-                # old_cid = ad_db.cond_id # todo: solve race-condition, а пока что очищаем при каждом запуске
-                # if not len((old_cond := await Cond.get(id=old_cid).prefetch_related('ads')).ads):
-                #     await old_cond.delete()
-                #     logging.warning(f"Cond#{old_cid} deleted!")
-            return (ad_db or force and await self.ad_load(ad, cid, ps, coinex=coinex, curex=curex, rname=rname)), False
+                await ad_db.save(update_fields=["cond_id"])
+                logging.info(f"{ad.maker_name} upd cond#{ad_db.cond_id}->{cid}")
+                # если после переназначения объяве нового условия, со старым условием не осталось объяв, то удаляем его
+                if not len((old_cond := await models.Cond.get(id=old_cid).prefetch_related("ads")).ads):
+                    await old_cond.delete()
+                    logging.warning(f"Cond#{old_cid} deleted!")
+            return ad_db or await self.ad_save(ad)
         # если эта объява в таким ид уже есть в бд, но с другим условием (или без), а текущего условия еще нет в бд
         if ad_db:
             await ad_db.fetch_related("cond__ads", "maker")
@@ -540,11 +517,11 @@ class BaseExClient(HttpClient, AdLoader):
                 {ra.maker_id for ra in rest_ads} - {ad_db.maker_id}
             ):
                 # создадим новое условие и присвоим его только текущей объяве
-                cond = await self.cond_new(cleaned, {int(ad.userId)})
+                cond = await self.cond_new(cleaned, {int(ad.maker_exid)})
                 ad_db.cond_id = cond.id
-                await ad_db.save()
-                ad_db.cond = cond
-                return ad_db, True
+                await ad_db.save(update_fields=["cond_id"])
+                ad_db.cond = cond  # todo: а это зачем?
+                return ad_db
             # а если других объяв со старым условием этой обявы нет, либо они все этого же юзера
             # обновляем условие (в тч во всех ЕГО объявах)
             ad_db.cond.last_ver = ad_db.cond.raw_txt
@@ -556,12 +533,12 @@ class BaseExClient(HttpClient, AdLoader):
             await self.cond_upd(ad_db.cond, {ad_db.maker.exid})
             # и подправим коэфициенты похожести нового текста
             await self.fix_rel_sims(ad_db.cond_id, cleaned)
-            return ad_db, False
-
-        cond = await self.cond_new(cleaned, {int(ad.userId)})
-        ad_db = await self.ad_load(ad, cond.id, ps, coinex=coinex, curex=curex, rname=rname)
+            return ad_db
+        # нет ни объяв ни таких условий еще в бд, все новое
+        cond = await self.cond_new(cleaned, {int(ad.maker_exid)})
+        ad_db = await self.ad_save(ad, cond.id)
         ad_db.cond = cond
-        return ad_db, True
+        return ad_db
 
     async def cond_new(self, txt: str, uids: set[int]) -> models.Cond:
         new_cond, _ = await models.Cond.update_or_create(raw_txt=txt)

xync_client/Abc/Order.py

@@ -1,41 +1,41 @@
 from abc import abstractmethod
 
-from xync_schema.models import Order
-
-from xync_client.Bybit.agent import AgentClient
+from xync_client.Abc.Agent import BaseAgentClient
+from xync_schema.models import Order, PmEx, CredEx
 
 
 class BaseOrderClient:
     order: Order
+    agent_client: BaseAgentClient
     im_maker: bool
     im_seller: bool
 
-    def __init__(self, order: Order, agent_client: AgentClient):
+    def __init__(self, order: Order, agent_client: BaseAgentClient):
         self.order = order
         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
-    async def cancel_request(self) -> Order: ...
-
-    # 3: [M] Одобрить запрос на сделку
-    @abstractmethod
-    async def accept_request(self) -> bool: ...
-
-    # 4: [M] Отклонить запрос на сделку
-    @abstractmethod
-    async def reject_request(self) -> bool: ...
-
     # 5: [B] Перевод сделки в состояние "оплачено", c отправкой чека
+    async def mark_payed(self, cred_id: int = None, receipt: bytes = None):
+        cred_id = cred_id or self.order.cred_id
+        pmex = await PmEx.get(pm__pmcurs__id=self.order.cred.pmcur_id, ex=self.agent_client.ex_client.ex)
+        credex = await CredEx.get(cred_id=cred_id, ex=self.agent_client.ex_client.ex)
+        await self._mark_payed(credex.exid, pmex.exid, receipt)
+
     @abstractmethod
-    async def mark_payed(self, receipt: bytes = None): ...
+    async def _mark_payed(self, credex_exid: int = None, pmex_exid: int | str = None, receipt: bytes = None): ...
 
     # 6: [B] Отмена сделки
     @abstractmethod
     async def cancel_order(self) -> bool: ...
 
+    # 6: Запрос отмены (оплаченная контрагентом продажа)
+    async def cancel_request(self) -> bool: ...
+
+    # 6: Одобрение запроса на отмену (оплаченная мной покупка)
+    async def cancel_accept(self): ...
+
     # 7: [S] Подтвердить получение оплаты
     @abstractmethod
     async def confirm(self) -> bool: ...
@@ -52,6 +52,9 @@ class BaseOrderClient:
     @abstractmethod
     async def cancel_appeal(self) -> bool: ...
 
+    # 15: Принять аппеляцию
+    async def appeal_accept(self): ...
+
     # 16: Отправка сообщения юзеру в чат по ордеру с приложенным файлом
     @abstractmethod
     async def send_order_msg(self, msg: str, file=None) -> bool: ...