xync-client 0.0.162__py3-none-any.whl → 0.0.172__py3-none-any.whl

xync_client/Abc/Agent.py

@@ -6,6 +6,7 @@ from typing import Literal
 
 from pydantic import BaseModel
 from pyro_client.client.file import FileClient
+from tortoise.exceptions import IntegrityError
 from x_client import df_hdrs
 from x_client.aiohttp import Client as HttpClient
 from xync_bot import XyncBot
@@ -15,25 +16,36 @@ from xync_client.Abc.InAgent import BaseInAgentClient
 
 from xync_client.Bybit.etype.order import TakeAdReq
 from xync_schema import models
-from xync_schema.models import OrderStatus, Coin, Cur, Ad, AdStatus, Actor, Agent
-from xync_schema.xtype import BaseAd
+from xync_schema.models import OrderStatus, Coin, Cur, Ad, Actor, Agent
+from xync_schema import xtype
 
 from xync_client.Abc.Ex import BaseExClient
-from xync_client.Abc.xtype import CredExOut, BaseOrderReq, BaseAdUpdate, AdUpd, GetAds
+from xync_client.Abc.xtype import (
+    BaseCredEx,
+    BaseOrderReq,
+    BaseAd,
+    AdUpdReq,
+    GetAdsReq,
+    BaseCredexsExidsTrait,
+    BaseOrderFull,
+)
 from xync_client.Gmail import GmClient
 
 
-class BaseAgentClient(HttpClient, BaseInAgentClient):
+class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
     actor: Actor
     agent: Agent
     bbot: XyncBot
     fbot: FileClient
     ex_client: BaseExClient
-    orders: dict[int, tuple[models.Order, BaseModel]] = {}  # pending
+    orders: dict[int, tuple[models.Order, xtype.BaseOrder]] = {}  # pending
     pm_clients: dict[int, PmAgentClient]  # {pm_id: PmAgentClient}
     api: HttpClient
     cred_x2e: dict[int, int] = {}
-    cred_e2x: dict[int, int] = {}
+    cred_e2x: dict[int, models.CredEx] = {}
+    order_x2e: dict[int, int] = {}
+    order_e2x: dict[int, int] = {}
+    cdx_cls: type[BaseCredEx]
 
     def __init__(
         self,
@@ -59,15 +71,30 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
 
     async def x2e_cred(self, cred_id: int) -> int:  # cred.exid
         if not self.cred_x2e.get(cred_id):
-            self.cred_x2e[cred_id] = (await models.CredEx.get(cred_id=cred_id)).exid
-            self.cred_e2x[self.cred_x2e[cred_id]] = cred_id
+            credex = await models.CredEx.get(cred_id=cred_id)
+            self.cred_x2e[cred_id] = credex.exid
+            self.cred_e2x[credex.exid] = credex
         return self.cred_x2e[cred_id]
 
-    async def e2x_cred(self, exid: int) -> int:  # cred.id
-        if not self.cred_e2x.get(exid):
-            self.cred_e2x[exid] = (await models.CredEx.get(exid=exid, ex=self.ex_client.ex)).cred_id
-            self.cred_x2e[self.cred_e2x[exid]] = exid
-        return self.cred_e2x[exid]
+    async def e2x_cred(self, base_credex: BaseCredEx) -> models.CredEx:  # cred.id
+        if not self.cred_e2x.get(base_credex.exid):
+            if not (credex := await models.CredEx.get_or_none(exid=base_credex.exid, ex=self.ex_client.ex)):
+                credex = await self.credex_save(base_credex)
+            self.cred_e2x[base_credex.exid] = credex
+            self.cred_x2e[credex.cred_id] = base_credex.exid
+        return self.cred_e2x[base_credex.exid]
+
+    async def x2e_order(self, order_id: int) -> int:  # order.exid
+        if not self.order_x2e.get(order_id):
+            self.order_x2e[order_id] = (await models.Order[order_id]).exid
+            self.order_e2x[self.order_x2e[order_id]] = order_id
+        return self.order_x2e[order_id]
+
+    async def e2x_order(self, exid: int) -> int:  # order.id
+        if not self.order_e2x.get(exid):
+            self.order_e2x[exid] = (await models.Order.get(exid=exid, taker__ex=self.ex_client.ex)).id
+            self.order_x2e[self.order_e2x[exid]] = exid
+        return self.order_e2x[exid]
 
     async def start(self):
         if self.agent.status & 1:  # race
@@ -78,6 +105,115 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
         if self.agent.status & 2:  # listen
             await self.start_listen()
 
+    @abstractmethod
+    async def _get_creds(self) -> list[BaseModel]: ...
+
+    async def get_creds(self) -> list[BaseCredEx]:
+        creds: list[BaseModel] = await self._get_creds()
+        return [self.cdx_cls.model_validate(cred, from_attributes=True) for cred in creds]
+
+    async def credex_save(self, cdx: BaseCredEx, pers_id: int = None, cur_id: int = None) -> models.CredEx | None:
+        pmex = None
+        if cred_old := await models.Cred.get_or_none(
+            credexs__exid=cdx.exid, credexs__ex=self.actor.ex
+        ).prefetch_related("pmcur"):  # is old Cred
+            cur_id = cur_id or cred_old.pmcur.cur_id
+        elif not cur_id:  # is new Cred
+            if cdx.curex_exid:
+                cur_id = (await models.CurEx.get(exid=cdx.curex_exid, ex=self.actor.ex)).cur_id
+            else:
+                pmex = await models.PmEx.get_or_none(exid=cdx.pmex_exid, ex=self.ex_client.ex).prefetch_related(
+                    "pm__curs"
+                )
+                cur_id = (
+                    pmex.pm.df_cur_id
+                    or (await cdx.guess_cur(pmex.pm.curs) if len(pmex.pm.curs) != 1 else pmex.pm.curs[0].cur_id)
+                    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 ValueError(f"Set default cur for {pmex.name}")
+        pm_id = pmex and pmex.pm_id or await self.ex_client.e2x_pm(cdx.pmex_exid)
+        if not (pmcur := await models.PmCur.get_or_none(cur_id=cur_id, pm_id=pm_id)):
+            raise ValueError(f"No PmCur with cur#{cur_id} and pm#{cdx.pmex_exid}", 404)
+        try:
+            pers_id = pers_id or cdx.seller.exid and (await self.ex_client.e2x_actor(cdx.seller)).person_id
+            cred_db, _ = await models.Cred.update_or_create(
+                {"name": cdx.name, "extra": cdx.extra},
+                pmcur=pmcur,
+                person_id=pers_id,
+                detail=cdx.detail,
+            )
+            if not cred_db.ovr_pm_id and ("XyncPay" in cred_db.detail or "XyncPay" in cred_db.extra):
+                cred_db.ovr_pm_id = 0
+                await cred_db.save()
+            credex_db, _ = await models.CredEx.update_or_create(exid=cdx.exid, cred=cred_db, ex=self.actor.ex)
+        except IntegrityError as e:
+            raise e
+        return credex_db
+
+    # 25: Список реквизитов моих платежных методов
+    async def load_creds(self) -> list[models.CredEx]:
+        credexs_epyd: list[BaseCredEx] = await self.get_creds()
+        credexs: list[models.CredEx] = [await self.credex_save(f) for f in credexs_epyd]
+        return credexs
+
+    async def my_ad_save(
+        self,
+        bmad: BaseAd | BaseCredexsExidsTrait,
+        rname: str = None,
+    ) -> models.MyAd:
+        ad_db = await self.ex_client.ad_save(bmad)
+        mad_db, _ = await models.MyAd.update_or_create(ad=ad_db)
+        credexs = await models.CredEx.filter(ex_id=self.actor.ex_id, exid__in=bmad.credex_exids)
+        await mad_db.credexs.clear()
+        await mad_db.credexs.add(*credexs)
+        return mad_db
+
+    async def load_my_ads(self, only_active: bool = None) -> list[models.MyAd]:  # upserted)
+        ads = await self.get_my_ads(True)
+        if not only_active:
+            ads += await self.get_my_ads(False)
+        return [await self.my_ad_save(ad) for ad in ads]
+
+    @abstractmethod
+    async def _get_order_full(self, order_exid: int) -> BaseOrderFull: ...
+
+    async def get_order_full(self, order_exid: int) -> xtype.BaseOrder:
+        eorder: BaseOrderFull = await self._get_order_full(order_exid)
+        _, cur_scale, __ = await self.ex_client.x2e_cur(await self.ex_client.e2x_cur(eorder.curex_exid))
+        _, coin_scale = await self.ex_client.x2e_coin(await self.ex_client.e2x_coin(eorder.coinex_exid))
+        ad = await self.ex_client.e2x_ad(eorder.ad_id)
+        credex = await self.e2x_cred(eorder.credex)
+        taker = await self.ex_client.e2x_actor(eorder.taker)
+        border = eorder.model_dump()
+        border.update(
+            ad_id=ad.id,
+            cred_id=credex.cred_id,
+            taker_id=taker.id,
+            amount=int(eorder.amount * 10**cur_scale),
+            quantity=int(eorder.quantity * 10**coin_scale),
+        )
+        return xtype.BaseOrder.model_validate(border)
+
+    async def load_order(self, order_exid: int, force_refresh: bool = False) -> tuple[models.Order, xtype.BaseOrder]:
+        if not self.orders.get(order_exid) or force_refresh:
+            order: xtype.BaseOrder = await self.get_order_full(order_exid)
+            if not (
+                order_db := await models.Order.get_or_none(
+                    exid=order_exid, ad__maker__ex=self.actor.ex
+                ).prefetch_related("ad__pair_side__pair", "cred__pmcur__cur")
+            ):
+                order_db = await self.order_save(order)
+            self.orders[order_exid] = order_db, order
+        return self.orders[order_exid]
+
+    async def order_save(self, order: xtype.BaseOrder) -> models.Order:
+        order_in = models.Order.validate(order.model_dump())
+        odb, _ = await models.Order.update_or_create(**order_in.df_unq())
+        # await odb.fetch_related("ad")  # todo: for what?
+        return odb
+
     async def racing(self, race: models.Race):
         pair = race.road.ad.pair_side.pair
         taker_side: int = not race.road.ad.pair_side.is_sell
@@ -116,7 +252,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
                 asset = await models.Asset.get(addr__actor=self.actor, addr__coin_id=coinex.coin_id)
                 volume = asset.free * 10**-coinex.scale
             volume = str(round(volume, coinex.scale))
-            get_ads_req = GetAds(
+            get_ads_req = GetAdsReq(
                 coin_id=pair.coin_id, cur_id=pair.cur_id, is_sell=bool(taker_side), pm_ids=pm_ids, amount=amt, limit=50
             )
             try:
@@ -363,10 +499,6 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
         self, exid: int | str, cur: str, detail: str, name: str, fid: int, typ: str, extra=None
     ) -> fiat_pyd: ...
 
-    # 25: Список реквизитов моих платежных методов
-    @abstractmethod
-    async def creds(self) -> list[CredExOut]: ...  # {credex.exid: {cred}}
-
     # Создание реквизита на бирже
     async def cred_new(self, cred: models.Cred) -> models.CredEx: ...
 
@@ -387,16 +519,16 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
     # # # Ad
     # 29: Список моих объявлений
     @abstractmethod
-    async def my_ads(self, status: AdStatus = None) -> list[BaseAd]: ...
+    async def get_my_ads(self, status: bool = None) -> list[BaseAd | BaseCredexsExidsTrait]: ...
 
     @abstractmethod
-    async def x2e_req_ad_upd(self, xreq: AdUpd) -> BaseAdUpdate: ...
+    async def x2e_req_ad_upd(self, xreq: AdUpdReq) -> BaseAd: ...
 
     # 30: Создание объявления
     @abstractmethod
     async def ad_new(self, ad: BaseAd) -> Ad: ...
 
-    async def ad_upd(self, xreq: AdUpd) -> Ad:
+    async def ad_upd(self, xreq: AdUpdReq) -> Ad:
         xreq.credexs = await models.CredEx.filter(
             ex_id=self.actor.ex_id,
             cred__pmcur__pm_id__in=xreq.pm_ids,
@@ -409,7 +541,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
 
     # 31: Редактирование объявления
     @abstractmethod
-    async def _ad_upd(self, ad: BaseAdUpdate) -> Ad: ...
+    async def _ad_upd(self, ad: BaseAd) -> Ad: ...
 
     # 32: Удаление
     @abstractmethod

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
 
 
@@ -34,14 +33,14 @@ class BaseExClient(HttpClient, AdLoader):
     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,
@@ -54,14 +53,14 @@ class BaseExClient(HttpClient, AdLoader):
     ):
         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 +73,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 +117,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 +152,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 +170,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 +196,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 +209,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: (
@@ -330,7 +331,7 @@ class BaseExClient(HttpClient, AdLoader):
 
     # Импорт монет (с 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 +353,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()
@@ -394,7 +395,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 +433,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 +520,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 +536,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)