xync-client 0.0.25.dev91__tar.gz → 0.0.25.dev109__tar.gz

{xync_client-0.0.25.dev91 → xync_client-0.0.25.dev109}/.gitignore

@@ -7,4 +7,5 @@ __pycache__
 /*.egg-info
 /build
 .vscode
-/xync_client/Gate/res.js
+/xync_client/Gate/res.js
+/tests/res.js

{xync_client-0.0.25.dev91/xync_client.egg-info → xync_client-0.0.25.dev109}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.25.dev91
+Version: 0.0.25.dev109
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client
@@ -12,9 +12,10 @@ Requires-Dist: msgspec
 Requires-Dist: python-binance
 Requires-Dist: pybit
 Requires-Dist: pyotp
-Requires-Dist: pyrogram
+Requires-Dist: kurigram
 Requires-Dist: python-dotenv
 Requires-Dist: python-okx
+Requires-Dist: tgcrypto
 Requires-Dist: xn-client>=0.0.3dev3
 Requires-Dist: xync-schema
 Provides-Extra: dev

{xync_client-0.0.25.dev91 → xync_client-0.0.25.dev109}/pyproject.toml

@@ -14,10 +14,10 @@ dependencies = [
     "python-binance",
     "pybit",
     "pyotp",
-    "pyrogram",
+    "kurigram",
     "python-dotenv",
     "python-okx",
-#    "tgcrypto",
+    "tgcrypto",
     "xn-client>=0.0.3dev3",
     "xync-schema"
 ]

{xync_client-0.0.25.dev91 → xync_client-0.0.25.dev109}/tests/TestEx.py

@@ -17,7 +17,7 @@ class TestEx(BaseTest):
     @pytest.fixture
     async def clients(self) -> list[BaseClient]:
         exs = await Ex.filter(status__gt=ExStatus.plan)
-        [await ex.fetch_related("actors__agent") for ex in exs if ex.type_ == ExType.tg]
+        [await ex for ex in exs if ex.type_ == ExType.tg]
         clients: list[BaseExClient] = [ex.client() for ex in exs]
         yield clients
         [await cl.close() for cl in clients]

xync_client-0.0.25.dev109/xync_client/Abc/Agent.py

@@ -0,0 +1,141 @@
+from abc import abstractmethod
+
+from pydantic import BaseModel
+from xync_schema import models
+from xync_schema.models import OrderStatus, Coin, Cur, Ad, AdStatus, Agent, Cred
+from xync_schema.types import BaseAd, AdSaleIn, AdBuyIn, BaseOrder
+
+from xync_client.Abc.Ex import BaseExClient
+from xync_client.Abc.Base import BaseClient
+from xync_client.Abc.types import CredExOut
+
+
+class BaseAgentClient(BaseClient):
+    def __init__(self, agent: Agent):
+        self.agent: Agent = agent
+        super().__init__(self.agent.actor.ex)  # , "host_p2p"
+        self.ex_client: BaseExClient = self.ex.client()
+
+    # 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
+    ) -> list: ...
+
+    # 1: [T] Запрос на старт сделки
+    @abstractmethod
+    async def order_request(self, order: BaseOrder) -> dict: ...
+
+    # async def start_order(self, order: Order) -> OrderOutClient:
+    #     return OrderOutClient(self, order)
+
+    # 1N: [M] - Запрос мейкеру на сделку
+    @abstractmethod
+    async def order_request_ask(self) -> dict: ...  # , ad: Ad, amount: float, pm: Pm, taker: Agent
+
+    # 2N: [M] - Уведомление об отмене запроса на сделку
+    @abstractmethod
+    async def request_canceled_notify(self) -> int: ...  # id
+
+    # # # Cred
+    @property
+    @abstractmethod
+    def fiat_pyd(self) -> BaseModel.__class__: ...
+
+    @abstractmethod
+    def fiat_args2pyd(
+        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: ...  # {credex.exid: {cred}}
+
+    # Создание реквизита на бирже
+    async def cred_new(self, cred: models.Cred) -> CredExOut: ...
+
+    # await models.Actor.get_or_create({"name": cred.exid}, ex=self.ex_client.ex, exid=self.agent.actor.exid)
+    # cred_db: Cred = (await self.cred_pyd2db(cred, self.agent.user_id))[0]
+    # if not (credex := models.CredEx.get_or_none(cred=cred_db, ex=self.agent.ex)):
+    #     credex, _ = models.CredEx.update_or_create({}, cred=cred_db, ex=self.agent.ex)
+    # return credex
+
+    # 27: Редактирование реквизита моего платежного метода
+    @abstractmethod
+    async def cred_upd(self, cred: models.Cred, exid: int) -> CredExOut: ...
+
+    # 28: Удаление реквизита моего платежного метода
+    @abstractmethod
+    async def cred_del(self, exid: int) -> int: ...
+
+    # # # Ad
+    # 29: Список моих объявлений
+    @abstractmethod
+    async def my_ads(self, status: AdStatus = None) -> list[BaseAd]: ...
+
+    # 30: Создание объявления
+    @abstractmethod
+    async def ad_new(self, ad: BaseAd) -> Ad: ...
+
+    # 31: Редактирование объявления
+    @abstractmethod
+    async def ad_upd(
+        self,
+        offer_id: int,
+        amount: int,
+        creds: list[Cred] = None,
+        price: float = None,
+        is_float: bool = None,
+        min_fiat: int = None,
+        details: str = None,
+        autoreply: str = None,
+        status: AdStatus = None,
+    ) -> Ad: ...
+
+    # 32: Удаление
+    @abstractmethod
+    async def ad_del(self, ad_id: int) -> bool: ...
+
+    # 33: Вкл/выкл объявления
+    @abstractmethod
+    async def ad_switch(self, offer_id: int, active: bool) -> bool: ...
+
+    # 34: Вкл/выкл всех объявлений
+    @abstractmethod
+    async def ads_switch(self, active: bool) -> bool: ...
+
+    # # # User
+    # 35: Получить объект юзера по его ид
+    @abstractmethod
+    async def get_user(self, user_id) -> dict: ...
+
+    # 36: Отправка сообщения юзеру с приложенным файлом
+    @abstractmethod
+    async def send_user_msg(self, msg: str, file=None) -> bool: ...
+
+    # 37: (Раз)Блокировать юзера
+    @abstractmethod
+    async def block_user(self, is_blocked: bool = True) -> bool: ...
+
+    # 38: Поставить отзыв юзеру
+    @abstractmethod
+    async def rate_user(self, positive: bool) -> bool: ...
+
+    # 39: Балансы моих монет
+    @abstractmethod
+    async def my_assets(self) -> dict: ...
+
+    # Сохранение объявления (с Pm/Cred-ами) в бд
+    async def ad_pydin2db(self, ad_pydin: AdSaleIn | AdBuyIn) -> Ad:
+        ad_db = await self.ex_client.ad_pydin2db(ad_pydin)
+        await ad_db.creds.add(*getattr(ad_pydin, "creds_", []))
+        return ad_db
+
+    # @staticmethod
+    # async def cred_e2db(cred_in: BaseUpd, banks: list[str] = None) -> bool:
+    #     cred_db, _ = await models.Cred.update_or_create(**cred_in.df_unq())
+    #     credex_in = models.CredEx.validate({"exid": cred_in.id, "cred_id": cred_db.id})
+    #     credex_db, _ = await models.CredEx.update_or_create(**credex_in.df_unq())
+    #     if banks:  # only for SBP
+    #         await cred_db.banks.add(*[await PmexBank.get(exid=b) for b in banks])
+    #     return True

{xync_client-0.0.25.dev91 → xync_client-0.0.25.dev109}/xync_client/Abc/AuthTrait.py

@@ -18,10 +18,11 @@ class BaseAuthTrait(Client):
         # noinspection PyUnresolvedReferences
         self.session.headers.update(auth_hdrs)
 
-    async def _post(self, url: str, data: dict = None, data_key: str = None):
+    async def _post(self, url: str, data: dict = None, data_key: str = None, headers: dict = None):
         dt = {"json" if isinstance(data, dict) else "data": data}
         # noinspection PyUnresolvedReferences
-        resp = await self.session.post(url, **dt, headers=self._prehook(data))
+        hdrs = {**self._prehook(data), **(headers or {})}
+        resp = await self.session.post(url, **dt, headers=hdrs)
         return await self._proc(resp, data_key, data)
 
     async def _proc(self, resp: ClientResponse, data_key: str = None, body: dict | str = None) -> dict | str:

{xync_client-0.0.25.dev91 → xync_client-0.0.25.dev109}/xync_client/Abc/Ex.py

@@ -8,7 +8,9 @@ from xync_schema import models
 from xync_schema.types import CurEx, CoinEx, BaseAd, BaseAdIn
 
 from xync_client.Abc.Base import BaseClient, MapOfIdsList
-from xync_client.Abc.types import PmEx, PmIn
+from xync_client.Abc.types import PmEx
+from xync_client.TgWallet.pyro import PyroClient
+from xync_client.loader import bot
 from xync_client.pm_unifier import PmUnifier, PmUni
 
 
@@ -64,6 +66,7 @@ class BaseExClient(BaseClient):
 
     # Импорт Pm-ов (с Pmcur-, Pmex- и Pmcurex-ами) и валют (с Curex-ами) с биржи в бд
     async def set_pmcurexs(self):
+        PyroClient(bot)
         # Curs
         cur_pyds: dict[str, CurEx] = await self.curs()
         curs: dict[int | str, models.Cur] = {
@@ -127,11 +130,15 @@ class BaseExClient(BaseClient):
         uni = self.unifier_class(cntrs)
         for k, pm in pms_epyds.items():
             pmu: PmUni = uni(pm.name)
-            country = await models.Country.get(name__iexact=cnt) if (cnt := pmu.country) else None
+            country_id = (
+                await models.Country.get(name__iexact=cnt).values_list("id", flat=True)
+                if (cnt := pmu.country)
+                else None
+            )
             if prev[2] == pm.name and pmu.country == prev[3]:  # оригинальное имя не уникально на этой бирже
                 logging.warning(f"Pm: '{pm.name}' duplicated with ids {prev[0]}: {k} on {self.ex.name}")
                 # новый Pm не добавляем, а берем старый с этим названием
-                pm_ = pms.get(prev[0], await models.Pm.get_or_none(norm=prev[1], country=country))
+                pm_ = pms.get(prev[0], await models.Pm.get_or_none(norm=prev[1], country_id=country_id))
                 # и добавляем Pmex для него
                 await models.Pmex.update_or_create({"name": pm.name}, ex=self.ex, exid=k, pm=pm_)
             elif (
@@ -142,11 +149,30 @@ class BaseExClient(BaseClient):
                 )
                 # новый Pm не добавляем, только Pmex для него
                 # новый Pm не добавляем, а берем старый с этим названием
-                pm_ = pms.get(prev[0], await models.Pm.get_or_none(norm=prev[1], country=country))
+                pm_ = pms.get(prev[0], await models.Pm.get_or_none(norm=prev[1], country_id=country_id))
                 # и добавляем.обновляем Pmex для него
                 await models.Pmex.update_or_create({"pm": pm_}, ex=self.ex, exid=k, name=pm.name)
             else:
-                pmin = PmIn(**{**pmu.model_dump(exclude_none=True), "country": country, "typ": pm.typ, "logo": pm.logo})
+                pmin = models.Pm.validate({**pmu.model_dump(), "country_id": country_id, "typ": pm.typ})
+                # # logo
+                # if pm.logo and not await models.File.exists(name=pm.logo):
+                #     if not pm.logo.startswith("https:"):
+                #         if not pm.logo.startswith("/"):
+                #             pm.logo = "/" + pm.logo
+                #         pm.logo = "https://" + pm.logo
+                #     async with ClientSession() as ss:
+                #         resp = await ss.get(pm.logo)
+                #         if resp.ok:
+                #             byts = await resp.read()
+                #             upf, ref = await pyro.save_file(byts, resp.content_type)
+                #             await sleep(1)
+                #             typ = FileType[resp.content_type.split("/")[-1]]
+                #             file, _ = await models.File.update_or_create(
+                #                 {"ref": ref, "size": len(byts), "typ": typ}, name=pm.logo
+                #             )
+                #             # fil = await pyro.get_file(file.ref)  # check
+                #             pmin.logo_id = file.id
+                # # /logo
                 try:
                     pms[k], _ = await models.Pm.update_or_create(**pmin.df_unq())
                 except (MultipleObjectsReturned, IntegrityError) as e:
@@ -208,7 +234,8 @@ class BaseExClient(BaseClient):
 
     # Сохранение чужого объявления (с Pm-ами) в бд
     async def ad_pydin2db(self, ad_pydin: BaseAdIn) -> models.Ad:
-        ad_db, _ = await models.Ad.update_or_create(**ad_pydin.df_unq())
+        ad_in = models.Ad.validate(ad_pydin.model_dump())
+        ad_db, _ = await models.Ad.update_or_create(**ad_in.df_unq())
         if getattr(ad_pydin, "pms_", None):  # if it ListItem, not Full One # todo: remove?
             await ad_db.pms.add(*ad_pydin.pms_)
         return ad_db

xync_client-0.0.25.dev109/xync_client/Abc/InAgent.py

@@ -0,0 +1,12 @@
+from abc import abstractmethod
+
+
+class BaseInAgentClient:
+    def __init__(self): ...
+
+    @abstractmethod
+    async def start_listen(self) -> bool: ...
+
+    # 3N: [T] - Уведомление об одобрении запроса на сделку
+    @abstractmethod
+    async def request_accepted_notify(self) -> int: ...  # id

{xync_client-0.0.25.dev91 → xync_client-0.0.25.dev109}/xync_client/Abc/types.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel
-from x_model.types import New
+from x_model.types import BaseUpd
 from xync_schema.enums import PmType
 from xync_schema.models import Country, Pm, Ex
 from xync_schema.types import PmexBank
@@ -18,7 +18,7 @@ class PmEx(BaseModel, PmTrait):
     name: str
 
 
-class PmIn(New, PmUni, PmTrait):
+class PmIn(BaseUpd, PmUni, PmTrait):
     _unq = "norm", "country"
     country: Country | None = None
 
@@ -34,3 +34,7 @@ class PmExIn(BaseModel):
 
     class Config:
         arbitrary_types_allowed = True
+
+
+class CredExOut(BaseModel):
+    id: int

xync_client-0.0.25.dev109/xync_client/Binance/etype/ad.py

@@ -0,0 +1,125 @@
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel
+from xync_schema.types import BaseAd
+
+
+class TradeMethod(BaseModel):
+    iconUrlColor: Optional[str] = None
+    identifier: str
+    payAccount: Optional[str] = None
+    payBank: Optional[str] = None
+    payId: Optional[str] = None
+    payMethodId: str
+    paySubBank: Optional[str] = None
+    payType: str
+    tradeMethodBgColor: str
+    tradeMethodName: str
+    tradeMethodShortName: Optional[str] = None
+
+
+class Adv(BaseModel):
+    abnormalStatusList: Optional[List[str]] = None
+    adAdditionalKycVerifyItems: Optional[List[Any]] = None
+    adTradeInstructionTagInfoRets: Optional[List[Any]] = None
+    advNo: str
+    advStatus: Optional[str] = None
+    advUpdateTime: Optional[str] = None
+    advVisibleRet: Optional[Dict[str, Any]] = None
+    allowTradeMerchant: Optional[bool] = None
+    amountAfterEditing: Optional[str] = None
+    asset: str
+    assetLogo: Optional[str] = None
+    assetScale: int
+    assetVo: Optional[Dict[str, Any]] = None
+    autoReplyMsg: Optional[str] = None
+    buyerBtcPositionLimit: Optional[str] = None
+    buyerKycLimit: Optional[str] = None
+    buyerRegDaysLimit: Optional[str] = None
+    classify: str
+    closeReason: Optional[str] = None
+    commissionRate: str
+    createTime: Optional[str] = None
+    currencyRate: Optional[str] = None
+    dynamicMaxSingleTransAmount: str
+    dynamicMaxSingleTransQuantity: str
+    fiatScale: int
+    fiatSymbol: str
+    fiatUnit: str
+    fiatVo: Optional[Dict[str, Any]] = None
+    initAmount: Optional[str] = None
+    inventoryType: Optional[str] = None
+    invisibleReason: Optional[str] = None
+    invisibleType: Optional[str] = None
+    isSafePayment: bool
+    isTradable: bool
+    launchCountry: Optional[List[str]] = None
+    maxSingleTransAmount: str
+    maxSingleTransQuantity: str
+    minFiatAmountForAdditionalKyc: Optional[str] = None
+    minSingleTransAmount: str
+    minSingleTransQuantity: str
+    minTakerFee: Optional[str] = None
+    nonTradableRegions: Optional[List[str]] = None
+    offlineReason: Optional[str] = None
+    payTimeLimit: int
+    price: str
+    priceFloatingRatio: Optional[str] = None
+    priceScale: int
+    priceType: Optional[str] = None
+    rateFloatingRatio: Optional[str] = None
+    remarks: Optional[str] = None
+    storeInformation: Optional[Dict[str, Any]] = None
+    surplusAmount: str
+    takerAdditionalKycRequired: int
+    takerCommissionRate: Optional[str] = None
+    tradableQuantity: str
+    tradeMethodCommissionRates: Optional[List[Any]] = None
+    tradeMethods: List[TradeMethod]
+    tradeType: str
+    userAllTradeCountMax: Optional[str] = None
+    userAllTradeCountMin: Optional[str] = None
+    userBuyTradeCountMax: Optional[str] = None
+    userBuyTradeCountMin: Optional[str] = None
+    userSellTradeCountMax: Optional[str] = None
+    userSellTradeCountMin: Optional[str] = None
+    userTradeCompleteCountMin: Optional[str] = None
+    userTradeCompleteRateFilterTime: Optional[str] = None
+    userTradeCompleteRateMin: Optional[str] = None
+    userTradeCountFilterTime: Optional[str] = None
+    userTradeType: Optional[str] = None
+    userTradeVolumeAsset: Optional[str] = None
+    userTradeVolumeFilterTime: Optional[str] = None
+    userTradeVolumeMax: Optional[str] = None
+    userTradeVolumeMin: Optional[str] = None
+
+
+class Advertiser(BaseModel):
+    activeTimeInSecond: int
+    advConfirmTime: Optional[str] = None
+    badges: Optional[List[str]] = None
+    email: Optional[str] = None
+    isBlocked: bool
+    margin: Optional[str] = None
+    marginUnit: Optional[str] = None
+    mobile: Optional[str] = None
+    monthFinishRate: float
+    monthOrderCount: int
+    nickName: str
+    orderCount: Optional[int] = None
+    positiveRate: float
+    proMerchant: Optional[Dict[str, Any]] = None
+    realName: Optional[str] = None
+    registrationTime: Optional[str] = None
+    tagIconUrls: List[str]
+    userGrade: int
+    userIdentity: str
+    userNo: str
+    userType: str
+    vipLevel: Optional[int] = None
+
+
+class Ad(BaseAd):
+    adv: Adv
+    advertiser: Advertiser
+    privilegeDesc: Optional[str] = None
+    privilegeType: int | None = None

xync_client-0.0.25.dev109/xync_client/Binance/etype/pm.py

@@ -0,0 +1,15 @@
+from typing import Optional
+from pydantic import BaseModel
+
+class PmE(BaseModel):
+    id: Optional[int] = None
+    payMethodId: str = ""
+    payAccount: Optional[str] = None
+    payBank: Optional[str] = None
+    paySubBank: Optional[str] = None
+    payType: Optional[str] = None
+    identifier: str
+    iconUrlColor: str
+    tradeMethodName: str
+    tradeMethodShortName: Optional[str] = None
+    tradeMethodBgColor: str

xync_client-0.0.25.dev109/xync_client/Binance/ex.py

@@ -0,0 +1,139 @@
+from asyncio import run
+
+from x_model import init_db
+
+from xync_client.Abc.Ex import BaseExClient
+from xync_client.Binance.etype import pm, ad
+from xync_client.Abc.types import PmEx
+from xync_client.Abc.Base import MapOfIdsList
+from xync_client.loader import PG_DSN
+from xync_client.pm_unifier import PmUnifier
+
+from xync_schema.models import Ex
+from xync_schema import types
+from xync_schema import models
+
+
+class ExClient(BaseExClient):
+    def __init__(self, ex: Ex):
+        # self.sapi = Sapi(*bkeys)
+        super().__init__(ex)
+
+    class BinanceUnifier(PmUnifier):
+        pm_map = {"Banque de développement local (BDL)": "Banque de développement local (BDL)"}
+
+    unifier_class = BinanceUnifier
+
+    async def _pms(self, cur) -> list[pm.PmE]:
+        json_data = {
+            "fiat": cur,
+            "classifies": [
+                "mass",
+                "profession",
+                "fiat_trade",
+            ],
+        }
+        pms = await self._post("/bapi/c2c/v2/public/c2c/adv/filter-conditions", data=json_data)
+        return [pm.PmE(**_pm) for _pm in pms["data"]["tradeMethods"]]
+
+    async def curs(self) -> dict[int, types.CurEx]:
+        curs = await self._post("/bapi/c2c/v1/friendly/c2c/trade-rule/fiat-list")
+        return {c["currencyCode"]: types.CurEx(exid=c["currencyCode"], ticker=c["currencyCode"], scale=c["currencyScale"]) for c in curs["data"]}
+
+    async def coins(self) -> dict[int, types.CoinEx]:
+        for cur in (await self.curs()).keys():
+            coins = (await self._post("/bapi/c2c/v2/friendly/c2c/portal/config", {"fiat": cur}))["data"]["areas"][0][
+                "tradeSides"
+            ][0]["assets"]
+            return {coin["asset"]: types.CoinEx(exid=coin["asset"], ticker=coin["asset"]) for coin in coins}
+
+    async def pairs(self) -> MapOfIdsList:
+        coins = (await self.coins()).keys()
+        curs = (await self.curs()).keys()
+        p = {cur: {c for c in coins} for cur in curs}
+        return p, p
+
+    async def pms(self, cur: models.Cur = None) -> dict[int | str, PmEx]:
+        all_pms = {}
+        for cur in (await self.curs()).values():
+            pms = await self._pms(cur.ticker)
+            for p in pms:
+                all_pms[p.identifier] = PmEx(exid=p.identifier, name=p.tradeMethodName, logo=p.iconUrlColor)
+        return all_pms
+
+    # 22: Cur -> [Pm] rels
+    async def cur_pms_map(self) -> MapOfIdsList:  # {cur.exid: [pm.exid], [pm.exid]}
+        res = await self.curs()
+        mp = {c: await self._get_pms_for_cur(c) for c in res.keys()}
+        return mp
+
+    # # 22: Cur -> [Pm] rels
+    # async def cur_countries_map(self) -> dict[int, set[int]]:  # {cur.exid: [pm.exid]}
+    #     res = await self._get_pms_and_country_for_cur()
+    #     wrong_pms = {4, 34, 212, 239, 363, 498, 548, 20009, 20010}  # these ids not exist in pms
+    #     return {c['currencyId']: set(c['supportPayments']) - wrong_pms for c in res['currency'] if c["supportPayments"]}
+
+    async def ads(self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str] = None) -> list[ad.Ad]:
+        data = {
+            "fiat": cur_exid,
+            "page": 1,
+            "rows": 10,
+            "tradeType": "BUY" if is_sell else "SELL",
+            "asset": coin_exid,
+            "countries": [],
+            "proMerchantAds": False,
+            "shieldMerchantAds": False,
+            "filterType": "all",
+            "periods": [],
+            "additionalKycVerifyFilter": 0,
+            "publisherType": "merchant",
+            "payTypes": pm_exids,
+            "classifies": [
+                "mass",
+                "profession",
+                "fiat_trade",
+            ],
+            "tradedWith": False,
+            "followed": False,
+        }
+        ads = await self._post("/bapi/c2c/v2/friendly/c2c/adv/search", data=data)
+        return [ad.Ad(id=_ad["adv"]["advNo"], price=_ad["adv"]["price"], **_ad) for _ad in ads["data"]]
+
+    async def _get_pms_for_cur(self, cur: str) -> ([str], [str]):
+        data = {"fiat": cur, "classifies": ["mass", "profession"]}
+        res = await self._post("/bapi/c2c/v2/public/c2c/adv/filter-conditions", data)
+        return [r["identifier"] for r in res["data"]["tradeMethods"]]
+        # , [
+        #     r["scode"] for r in res["data"]["countries"] if r["scode"] != "ALL"
+        # ]  # countries,tradeMethods,periods
+
+
+# class Private(Public): # todo: base class: Public or Client?
+# class Private(Client):
+#     # auth: dict =
+#     headers: dict = {
+#         "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.134 Safari/537.36",
+#         "Content-Type": "application/json",
+#         "clienttype": "web",
+#     }
+#
+#     def seq_headers(self):
+#         return {
+#             "csrftoken": self.auth["tok"],
+#             "cookie": f'p20t=web.{self.id}.{self.auth["cook"]}',
+#         }
+
+
+async def main():
+    _ = await init_db(PG_DSN, models)
+    ex = await Ex.get(name="Binance")
+    cl = ExClient(ex)
+    await cl.pairs()
+    await cl.pms()
+    await cl.ads("ETH", "GEL", False)
+    await cl.set_pmcurexs()
+    await cl.close()
+
+
+if __name__ == "__main__":
+    run(main())

{xync_client-0.0.25.dev91 → xync_client-0.0.25.dev109}/xync_client/BitGet/ex.py

@@ -30,6 +30,15 @@ class ExClient(BaseExClient):
         "accept-language": "ru,en;q=0.9",
         "content-type": "application/json;charset=UTF-8",
         "deviceid": "883e1394d8a2278418b6f02804df16c4",
+        "devicelanguage": "ru_RU",
+        "gaclientid": "2005612572.1744132981",
+        "securitynew": "true",
+        "terminalcode": "534488ac72b9b87c3ba87725387639ac",
+        "terminaltype": "1",
+        "timezone": "GMT+03:00",
+        "tm": "1744133012568",
+        "uhti": "w17441330126555b55e2d8627",
+        "usenewpwdversion": "true",
     }
 
     async def _coin_cur_pms(self, trying: int = 0) -> dict:
@@ -52,12 +61,25 @@ class ExClient(BaseExClient):
 
     async def curs(self) -> dict[str, types.CurEx]:
         curs = (await self._coin_cur_pms())["fiatInfoRespList"]
-        return {cur["fiatCode"]: types.CurEx(exid=cur["fiatCode"], ticker=cur["fiatCode"]) for cur in curs}
+        return {
+            cur["fiatCode"]: types.CurEx(
+                exid=cur["fiatCode"],
+                ticker=cur["fiatCode"],
+                scale=cur["fiatPrecision"],
+                minimum=int(float(cur["orderMinLimit"])),
+            )
+            for cur in curs
+        }
 
     async def coins(self) -> dict[str, types.CoinEx]:
         coins: list[dict] = (await self._coin_cur_pms())["coinInfoRespList"]
         return {
-            coin["coinCode"]: types.CoinEx(exid=coin["coinCode"], ticker=coin["coinCode"], scale=coin["coinPrecision"])
+            coin["coinCode"]: types.CoinEx(
+                exid=coin["coinCode"],
+                ticker=coin["coinCode"],
+                scale=coin["coinPrecision"],
+                minimum=int(float(coin["orderMinLimit"])),
+            )
             for coin in coins
         }
 
@@ -72,7 +94,7 @@ class ExClient(BaseExClient):
         pms: list[dict] = (await self._coin_cur_pms())["fiatInfoRespList"]
         for pm in pms:
             for p in pm["paymethodInfo"]:
-                pp[p["paymethodId"]] = PmEx(exid=p["paymethodId"], name=p["paymethodName"])
+                pp[p["paymethodId"]] = PmEx(exid=p["paymethodId"], name=p["paymethodName"], logo=p.get("iconUrl"))
         return pp
 
     async def ads(