xync-client 0.0.233__tar.gz → 0.0.235.dev3__tar.gz

{xync_client-0.0.233 → xync_client-0.0.235.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.233
+Version: 0.0.235.dev3
 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.233 → xync_client-0.0.235.dev3}/README.md

@@ -188,4 +188,41 @@ classDef red stroke:#f00
 - 40: Получить реквизиты для депозита монеты `deposit(amount: int) => bool` 
 - 40N: Получена монета `deposited => amount`
 - 41: Вывести монету `withdraw(amount: int) => bool`
-- 41N: Монета выведена `withdrew => amount`
+- 41N: Монета выведена `withdrew => amount`
+
+
+## Общий флоу для всех сущностей
+
+```mermaid
+block-beta
+columns 5
+  eOut["eOut"] space xIn["xIn"] space fOut["fOut"]
+  space:5
+  Exs((("Exs"))) space db[("DataBase")] space Front(("Front"))
+  space:5
+  eIn["eIn"] space xOut["xOut"] space fIn["fIn"]
+  Exs   --"A"--> eOut
+  eOut  --"B"--> xIn
+  xIn   --"C"--> db
+  db    --"D"--> xOut
+  xOut  --"E"--> fIn
+  fIn   --"F"--> Front
+  Front --"G"--> fOut
+  fOut  --"H"--> xIn
+  xOut  --"I"--> eIn
+  eIn   --"J"--> Exs
+```
+
+```mermaid
+mindmap
+root(transfer)
+    order
+        ad
+            pair_side
+                pair
+                    coin
+                    cur
+            maker
+                person
+                    user
+```

{xync_client-0.0.233 → xync_client-0.0.235.dev3}/xync_client/Abc/Agent.py

@@ -8,14 +8,15 @@ from pydantic import BaseModel
 from tortoise.exceptions import IntegrityError
 from x_client import df_hdrs
 from x_client.aiohttp import Client as HttpClient
+from xync_client.details import hot_ad_cond
+from xync_schema.enums import AdStatus, OrderStatus
+
 from xync_client.Abc.PmAgent import PmAgentClient
 
 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, Actor, Agent, MyAd
-from xync_schema import xtype
 
 from xync_client.Abc.Ex import BaseExClient
 from xync_client.Abc.xtype import (
@@ -26,14 +27,16 @@ from xync_client.Abc.xtype import (
     GetAdsReq,
     BaseCredexsExidsTrait,
     BaseOrderFull,
+    BaseOrder,
+    MyAdXOut,
 )
 
 
 class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
-    actor: Actor
-    agent: Agent
+    actor: models.Actor
+    agent: models.Agent
     ex_client: BaseExClient
-    orders: dict[int, tuple[models.Order, xtype.BaseOrder]] = {}  # pending
+    orders: dict[int, tuple[models.Order, BaseOrder]] = {}  # pending
     pm_clients: dict[int, PmAgentClient]  # {pm_id: PmAgentClient}
     api: HttpClient
     cred_x2e: dict[int, int] = {}
@@ -44,15 +47,15 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
 
     def __init__(
         self,
-        agent: Agent,  # agent.actor.person.user
+        agent: models.Agent,  # agent.actor.person.user
         ex_client: BaseExClient,
         pm_clients: dict[int, PmAgentClient] = None,
         headers: dict[str, str] = df_hdrs,
         cookies: dict[str, str] = None,
         proxy: models.Proxy = None,
     ):
-        self.agent: Agent = agent
-        self.actor: Actor = agent.actor
+        self.agent: models.Agent = agent
+        self.actor: models.Actor = agent.actor
         # self.gmail = agent.actor.person.user.gmail and GmClient(agent.actor.person.user)
         self.ex_client: BaseExClient = ex_client
         self.pm_clients: dict[int, PmAgentClient] = defaultdict()
@@ -111,6 +114,11 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
             await self.load_pending_orders()
             await self.ads_share()
 
+    async def load_assets(self, coin_ids: list[int] = None) -> dict:
+        assets = {cid: await self.get_asset(cid) for cid in coin_ids} if coin_ids else await self.my_assets()
+        for cid, amount in assets.items():
+            await self.asset_save(cid, amount)
+
     @abstractmethod
     async def _get_creds(self) -> list[BaseModel]: ...
 
@@ -180,7 +188,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
     @abstractmethod
     async def _get_order_full(self, order_exid: int) -> BaseOrderFull: ...
 
-    async def get_order_full(self, order_exid: int) -> xtype.BaseOrder:
+    async def get_order_full(self, order_exid: int) -> 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))
@@ -195,11 +203,11 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
             amount=int(eorder.amount * 10**cur_scale),
             quantity=int(eorder.quantity * 10**coin_scale),
         )
-        return xtype.BaseOrder.model_validate(border)
+        return BaseOrder.model_validate(border)
 
-    async def load_order(self, order_exid: int, force_refresh: bool = False) -> tuple[models.Order, xtype.BaseOrder]:
+    async def load_order(self, order_exid: int, force_refresh: bool = False) -> tuple[models.Order, BaseOrder]:
         if not self.orders.get(order_exid) or force_refresh:
-            order: xtype.BaseOrder = await self.get_order_full(order_exid)
+            order: 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
@@ -214,7 +222,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
             self.orders[order_exid] = order_db, order
         return self.orders[order_exid]
 
-    async def order_save(self, order: xtype.BaseOrder) -> models.Order:
+    async def order_save(self, order: BaseOrder) -> models.Order:
         order_in = models.Order.validate(order.model_dump())
         odb, _ = await models.Order.update_or_create(**order_in.df_unq())
 
@@ -265,10 +273,12 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
                 coin_id=pair.coin_id, cur_id=pair.cur_id, is_sell=bool(taker_side), pm_ids=pm_ids, amount=amt, limit=50
             )
             try:
-                ads: list[Ad] = await self.ex_client.ads(get_ads_req)
+                ads: list[BaseAd] = await self.ex_client.ads(get_ads_req)
             except Exception:
                 await sleep(1)
-                ads: list[Ad] = await self.ads(coinex, curex, taker_side, pmexs, amt, 50, race.vm_filter, post_pmexs)
+                ads: list[BaseAd] = await self.ads(
+                    coinex, curex, taker_side, pmexs, amt, 50, race.vm_filter, post_pmexs
+                )
 
             self.overprice_filter(ads, race.ceil * 10**-curex.scale, k)  # обрезаем сверху все ads дороже нашего потолка
 
@@ -289,7 +299,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
             #     ]
             #     for plc, ad in enumerate(rads)
             # ]
-            mad: Ad = ads.pop(cur_plc)
+            mad: BaseAd = ads.pop(cur_plc)
             # if (
             #     not (lstat := lstat or await race.stats.order_by("-created_at").first())
             #     or lstat.place != cur_plc
@@ -386,50 +396,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
             #     logging.warning("Connection failed. Restarting..")
             await sleep(6)
 
-    async def get_books(
-        self,
-        coinex: models.CoinEx,
-        curex: models.CurEx,
-        pmexs: list[models.PmEx],
-        amount: int,
-        post_pmexs: list[models.PmEx] = None,
-    ) -> tuple[list[Ad], list[Ad]]:
-        buy: list[Ad] = await self.ads(coinex, curex, False, pmexs, amount, 40, False, post_pmexs)
-        sell: list[Ad] = await self.ads(coinex, curex, True, pmexs, amount, 30, False, post_pmexs)
-        return buy, sell
-
-    async def get_spread(
-        self, bb: list[Ad], sb: list[Ad], perc: float, place: int = 0
-    ) -> tuple[tuple[float, float], float, int] | None:
-        if len(bb) and len(sb):
-            buy_price, sell_price = float(bb[place].price), float(sb[place].price)
-            half_spread = (buy_price - sell_price) / (buy_price + sell_price)
-            if half_spread * 2 < perc:
-                return await self.get_spread(bb, sb, perc, place)
-            return (buy_price, sell_price), half_spread, place
-        return None
-
-    async def get_ceils(
-        self,
-        coinex: models.CoinEx,
-        curex: models.CurEx,
-        pmexs: list[models.PmEx],
-        min_prof=0.02,
-        place: int = 0,
-        amount: int = None,
-        post_pmexs: set[models.PmEx] = None,
-    ) -> tuple[float, float]:  # todo: refact to Pairex
-        for pmc_id in {pmx.pm_id for pmx in pmexs} | set(self.pm_clients.keys()):
-            if ceils := self.pm_clients[pmc_id].get_ceils():
-                return ceils
-        bb, sb = await self.get_books(coinex, curex, pmexs, amount, post_pmexs)
-        perc = list(post_pmexs or pmexs)[0].pm.fee * 0.0001 + min_prof
-        (bf, sf), _hp, _zplace = await self.get_spread(bb, sb, perc, place)
-        mdl = (bf + sf) / 2  # middle price
-        bc, sc = mdl + mdl * (perc / 2), mdl - mdl * (perc / 2)
-        return bc, sc
-
-    async def mad_upd(self, mad: Ad, attrs: dict, cxids: list[str]):
+    async def mad_upd(self, mad: BaseAd, attrs: dict, cxids: list[str]):
         if not [setattr(mad, k, v) for k, v in attrs.items() if getattr(mad, k) != v]:
             print(end="v" if mad.side else "^", flush=True)
             return await sleep(5)
@@ -452,14 +419,14 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
         # print("-" if mad.side else "+", end=req.price, flush=True)
         await sleep(60)
 
-    def overprice_filter(self, ads: list[Ad], ceil: float, k: Literal[-1, 1]):
+    def overprice_filter(self, ads: list[BaseAd], ceil: float, k: Literal[-1, 1]):
         # вырезаем ads с ценами выше потолка
         if ads and (ceil - float(ads[0].price)) * k > 0:
             if int(ads[0].userId) != self.actor.exid:
                 ads.pop(0)
                 self.overprice_filter(ads, ceil, k)
 
-    def get_cad(self, ads: list[Ad], ceil: float, k: Literal[-1, 1], target_place: int, cur_plc: int) -> Ad:
+    def get_cad(self, ads: list[BaseAd], ceil: float, k: Literal[-1, 1], target_place: int, cur_plc: int) -> BaseAd:
         if not ads:
             return None
         # чью цену будем обгонять, предыдущей или слещующей объявы?
@@ -468,7 +435,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
         if len(ads) <= target_place:
             logging.error(f"target place {target_place} not found in ads {len(ads)}-lenght list")
             target_place = len(ads) - 1
-        cad: Ad = ads[target_place]
+        cad: BaseAd = ads[target_place]
         # а цена обгоняемой объявы не выше нашего потолка?
         if (float(cad.price) - ceil) * k <= 0:
             # тогда берем следующую
@@ -480,7 +447,11 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
     # 0: Получшение ордеров в статусе status, по монете coin, в валюте coin, в направлении is_sell: bool
     @abstractmethod
     async def get_orders(
-        self, status: OrderStatus = OrderStatus.created, coin: Coin = None, cur: Cur = None, is_sell: bool = None
+        self,
+        status: OrderStatus = OrderStatus.created,
+        coin: models.Coin = None,
+        cur: models.Cur = None,
+        is_sell: bool = None,
     ) -> list: ...
 
     # 1: [T] Запрос на старт сделки
@@ -535,9 +506,9 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
 
     # 30: Создание объявления
     @abstractmethod
-    async def ad_new(self, ad: BaseAd) -> Ad: ...
+    async def ad_new(self, ad: BaseAd) -> int: ...
 
-    async def ad_upd(self, xreq: AdUpdReq) -> Ad:
+    async def ad_upd(self, xreq) -> int:
         xreq.credexs = await models.CredEx.filter(
             ex_id=self.actor.ex_id,
             cred__pmcur__pm_id__in=xreq.pm_ids,
@@ -545,14 +516,143 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
             cred__person_id=self.actor.person_id,
         ).prefetch_related("cred__pmcur")
         # xreq.credexs = credexs
+
         ereq = await self.x2e_req_ad_upd(xreq)
-        return await self._ad_upd(ereq)
+        return await self._ad_upd_api(ereq)
 
     # 31: Редактирование объявления
     @abstractmethod
-    async def _ad_upd(self, ad: BaseAd) -> Ad: ...
+    async def _ad_upd_api(self, ad: MyAdXOut) -> int: ...
+
+    async def ads_fresh(self, cur_id: int = 1, coin_id: int = 1):
+        """
+        Обновляем/добавляем объявления агента, в зависимости от кол-ва объявлений которое он может размещать
+        одновременно `same_dir_ad` (от 1 до 4), и его текущего coin_balance.
+        """
+        curex = await models.CurEx.get(cur_id=cur_id, ex_id=self.actor.ex_id)
+        usdt_bal = (await self.agent.coins_balance())[coin_id]
+        xbals = await self.actor.person.user.balances()
+        xbal = xbals[cur_id]
+        # В идеале, если он может размещать сразу 4 объявления, и имеет баланс не менее 50 минимальных размеров ордера,
+        # то постим 4 объявления:
+        #    1) с минимальным нижним лимитом размера ордера, и без фильтрации контрагентов
+        #    2) с минимальным лимитом, но с фильтрацией контрагентов
+        #    3) с 10x мин лимитом, и с фильтрацией (если вообще есть баланс от 10x min)
+        #    4) 50x мин лимит, либо весь баланс если он меньше, с фильтрацией (если есть баланс от 20x min)
+        if usdt_bal < curex.minimum:
+            return
+        fltr = dict(
+            my_ad__credexs__cred__ovr_pm_id=0,
+            my_ad__credexs__cred__pmcur__cur_id=cur_id,
+            pair_side__pair__coin_id=coin_id,
+            maker_id=self.agent.actor_id,
+        )
+        prftch = "my_ad__credexs", "pair_side__pair__coin", "pair_side__pair__cur"
 
-    async def ads_fresh(self) -> list[MyAd]: ...
+        bads = (
+            await models.Ad.filter(**fltr, status=AdStatus.active, pair_side__is_sell=False)
+            .order_by("min_fiat", "filtered")
+            .prefetch_related(*prftch)
+            .limit(self.agent.same_dir_ad)
+        )
+        if not bads:
+            return
+        bad = await bads.pop(0).to_float(ex_id=self.actor.ex_id)
+        if bad.min_fiat != curex.minimum and bad.filtered:
+            logging.error(bad.min_fiat)  # need debug
+        if bad.amount != xbal:
+            bad.amount = xbal
+            bad.quantity = None
+            xma = MyAdXOut.model_validate(bad, from_attributes=True)
+            xma.cond_txt = hot_ad_cond
+            await self._ad_upd_api(xma)
+
+        if not bads:
+            return
+        bad = await bads.pop(0).to_float(ex_id=self.actor.ex_id)
+        if bad.min_fiat != curex.minimum and not bad.filtered:
+            logging.error(bad.min_fiat)  # need debug
+        if bad.amount != xbal:
+            bad.amount = xbal
+            bad.quantity = None
+            xma = MyAdXOut.model_validate(bad, from_attributes=True)
+            xma.cond_txt = hot_ad_cond
+            await self._ad_upd_api(xma)
+
+        if not bads:
+            return
+        bad = await bads.pop(0).to_float(ex_id=self.actor.ex_id)
+        if curex.minimum * 2 <= bad.min_fiat < curex.minimum * 10 or bad.amount != xbal:
+            bad.min_fiat = min(xbal, curex.minimum * 10)
+            bad.amount = xbal
+            bad.quantity = None
+            xma = MyAdXOut.model_validate(bad, from_attributes=True)
+            xma.cond_txt = hot_ad_cond
+            await self._ad_upd_api(xma)
+
+        if not bads:
+            return
+        bad = await bads.pop(0).to_float(ex_id=self.actor.ex_id)
+        if curex.minimum * 20 <= bad.min_fiat < curex.minimum * 50 or bad.amount != xbal:
+            bad.min_fiat = min(xbal, curex.minimum * 10)
+            bad.amount = xbal
+            bad.quantity = None
+            xma = MyAdXOut.model_validate(bad, from_attributes=True)
+            xma.cond_txt = hot_ad_cond
+            await self._ad_upd_api(xma)
+
+        # sell
+        sads = (
+            await models.Ad.filter(**fltr, status=AdStatus.active, pair_side__is_sell=False)
+            .order_by("min_fiat", "filtered")
+            .prefetch_related(*prftch)
+            .limit(self.agent.same_dir_ad)
+        )
+        if not sads:
+            return
+        sad = await sads.pop(0).to_float(ex_id=self.actor.ex_id)
+        if sad.min_fiat != curex.minimum and sad.filtered:
+            logging.error(sad.min_fiat)  # need debug
+        if sad.quantity != usdt_bal:
+            sad.quantity = usdt_bal
+            sad.amount = None
+            xma = MyAdXOut.model_validate(sad, from_attributes=True)
+            xma.cond_txt = hot_ad_cond
+            await self._ad_upd_api(xma)
+
+        if not sads:
+            return
+        sad = await sads.pop(0).to_float(ex_id=self.actor.ex_id)
+        if sad.min_fiat != curex.minimum and not sad.filtered:
+            logging.error(sad.min_fiat)  # need debug
+        if sad.quantity != usdt_bal:
+            sad.quantity = usdt_bal
+            sad.amount = None
+            xma = MyAdXOut.model_validate(sad, from_attributes=True)
+            xma.cond_txt = hot_ad_cond
+            await self._ad_upd_api(xma)
+
+        if not sads:
+            return
+        sad = await sads.pop(0).to_float(ex_id=self.actor.ex_id)
+        if curex.minimum * 2 <= sad.min_fiat < curex.minimum * 10 or sad.quantity != usdt_bal:
+            sad.min_fiat = min(usdt_bal, curex.minimum * 10)
+            sad.quantity = usdt_bal
+            sad.amount = None
+            xma = MyAdXOut.model_validate(sad, from_attributes=True)
+            xma.cond_txt = hot_ad_cond
+            await self._ad_upd_api(xma)
+
+        if not sads:
+            return
+        sad = await sads.pop(0).to_float(ex_id=self.actor.ex_id)
+        if curex.minimum * 20 <= sad.min_fiat < curex.minimum * 50 or sad.quantity != usdt_bal:
+            sad.min_fiat = min(usdt_bal, curex.minimum * 10)
+            sad.quantity = usdt_bal
+            sad.amount = None
+            xma = MyAdXOut.model_validate(sad, from_attributes=True)
+            xma.cond_txt = hot_ad_cond
+            await self._ad_upd_api(xma)
 
     # 32: Удаление
     @abstractmethod

{xync_client-0.0.233 → xync_client-0.0.235.dev3}/xync_client/Abc/Ex.py

@@ -4,6 +4,7 @@ from abc import abstractmethod
 from asyncio import sleep
 from collections import defaultdict
 from difflib import SequenceMatcher
+from math import floor
 
 from aiohttp import ClientSession, ClientResponse
 from msgspec import Struct
@@ -72,7 +73,7 @@ class BaseExClient(HttpClient, AdLoader):
 
     # 22: Список торгуемых монет (с ограничением по валютам, если есть)
     @abstractmethod
-    async def coins(self) -> dict[str, xtype.CoinEx]:  # {coin.ticker: coin}
+    async def coins(self, p2p_only: bool = False, cks: dict = None) -> dict[str, xtype.CoinEx]:  # {coin.ticker: coin}
         ...
 
     # 23: Список пар валюта/монет
@@ -182,16 +183,15 @@ class BaseExClient(HttpClient, AdLoader):
 
     # 24: Список объяв по (buy/sell, cur, coin, pm)
     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],
-            is_sell=str(int(xreq.is_sell)),
-            pm_ids=[await self.x2e_pm(pid) for pid in xreq.pm_ids],
-            # size=str(xreq.limit),
-            # page=str(xreq.page),
+        src = xreq.model_copy(
+            update=dict(
+                coin_id=(await self.x2e_coin(xreq.coin_id))[0],
+                cur_id=(await self.x2e_cur(xreq.cur_id))[0],
+                is_sell=str(int(xreq.is_sell)),
+                pm_ids=xreq.pm_ids and [await self.x2e_pm(pid) for pid in xreq.pm_ids],
+            )
         )
-        if xreq.amount:
-            ereq.amount = str(xreq.amount)
+        ereq = AdsReq.model_validate(src.model_dump(exclude_none=True))
         return await self._ads(ereq, **kwargs)
 
     @abstractmethod
@@ -332,25 +332,34 @@ class BaseExClient(HttpClient, AdLoader):
         return file
 
     # Импорт монет (с CoinEx-ами) с биржи в бд
-    async def set_coins(self):
-        coinexs: dict[str, xtype.CoinEx] = await self.coins()
+    async def set_coins(self, p2p_only: bool = True, cks: dict = None):
+        coinexs: dict[str, xtype.CoinEx] = await self.coins(p2p_only, cks)
         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)
+                await models.Coin.update_or_create(
+                    {
+                        "scale": c.scale if c.scale is not None else self.coin_scales[c.ticker],
+                        "typ": c.typ,
+                    },
+                    ticker=c.ticker,
+                )
             )[0]
             for c in coinexs.values()
         }
         coinexs_db: list[models.CoinEx] = [
             models.CoinEx(
-                scale=(scl := c.scale or self.coin_scales[c.ticker]),
+                scale=(scl := c.scale if c.scale is not None else self.coin_scales[c.ticker]),
                 coin=coins_db[c.exid],
                 ex=self.ex,
                 exid=c.exid,
                 minimum=c.minimum and c.minimum * 10**scl,
+                p2p=c.p2p,
             )
             for c in coinexs.values()
         ]
-        await models.CoinEx.bulk_create(coinexs_db, update_fields=["minimum"], on_conflict=["coin_id", "ex_id"])
+        await models.CoinEx.bulk_create(
+            coinexs_db, update_fields=["minimum", "scale", "p2p"], on_conflict=["coin_id", "ex_id"]
+        )
         return True
 
     # Импорт пар биржи в бд
@@ -463,8 +472,8 @@ class BaseExClient(HttpClient, AdLoader):
         pms = await models.Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=base_ad.pmex_exids)
         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),
+            max_fiat=int(base_ad.max_fiat),
+            min_fiat=int(base_ad.min_fiat),
             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),
@@ -665,6 +674,57 @@ class BaseExClient(HttpClient, AdLoader):
 
         self.tree = tree
 
+    async def get_books(
+        self,
+        coin_id: int,
+        cur_id: int,
+        pm_ids: list[int] = None,
+        amount: int = None,
+        post_pms: list[models.Pm] = None,
+    ) -> tuple[list[BaseAd], list[BaseAd]]:
+        sell_req = GetAdsReq(
+            coin_id=coin_id, cur_id=cur_id, is_sell=True, pm_ids=pm_ids, amount=amount, vm_only=True, limit=10
+        )
+        buy_req = GetAdsReq(
+            coin_id=coin_id, cur_id=cur_id, is_sell=False, pm_ids=pm_ids, amount=amount, vm_only=True, limit=10
+        )
+        return await self.ads(sell_req, post_pms=post_pms), await self.ads(buy_req, post_pms=post_pms)
+
+    async def get_spread(
+        self, bb: list[models.Ad], sb: list[models.Ad], perc: float, place: int = 0
+    ) -> tuple[tuple[float, float], float, int] | None:
+        if len(bb) and len(sb):
+            buy_price, sell_price = float(bb[place].price), float(sb[place].price)
+            half_spread = (buy_price - sell_price) / (buy_price + sell_price)
+            if half_spread * 2 < perc:
+                return await self.get_spread(bb, sb, perc, place)
+            return (buy_price, sell_price), half_spread, place
+        return None
+
+    async def get_ceils(
+        self,
+        coinex: models.CoinEx,
+        curex: models.CurEx,
+        pmexs: list[models.PmEx],
+        min_prof=0.02,
+        place: int = 0,
+        amount: int = None,
+        post_pms: set[models.PmEx] = None,
+    ) -> tuple[float, float]:  # todo: refact to Pairex
+        for pmc_id in {pmx.pm_id for pmx in pmexs} | set(self.pm_clients.keys()):
+            if ceils := self.pm_clients[pmc_id].get_ceils():
+                return ceils
+        bb, sb = await self.get_books(coinex, curex, pmexs, amount, post_pms)
+        perc = list(post_pms or pmexs)[0].pm.fee * 0.0001 + min_prof
+        (bf, sf), _hp, _zplace = await self.get_spread(bb, sb, perc, place)
+        mdl = (bf + sf) / 2  # middle price
+        bc, sc = mdl + mdl * (perc / 2), mdl - mdl * (perc / 2)
+        return bc, sc
+
+    async def rate(self, cur_id: int, coin_id: int = 1) -> int:
+        bp, sp = await self.get_books(cur_id, coin_id)
+        return floor((sum(b.price for b in bp[5:]) + sum(s.price for s in sp[5:])) * 0.1)
+
     async def init_seed(self, fbot: FileClient):
         await self.set_curs()
         await self.set_coins()