xync-client 0.0.25.dev11__tar.gz → 0.0.25.dev20__tar.gz

{xync_client-0.0.25.dev11/xync_client.egg-info → xync_client-0.0.25.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.25.dev11
+Version: 0.0.25.dev20
 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.25.dev11 → xync_client-0.0.25.dev20}/tests/TestEx.py

@@ -18,7 +18,7 @@ class TestEx(BaseTest):
     @pytest.fixture
     async def clients(self) -> list[BaseClient]:
         exs = await Ex.filter(status__gt=ExStatus.plan)
-        [await ex.fetch_related("contragents__agent") for ex in exs if ex.type_ == ExType.tg]
+        [await ex.fetch_related("actors__agent") 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.dev11 → xync_client-0.0.25.dev20}/xync_client/Abc/Agent.py

@@ -3,20 +3,18 @@ from abc import abstractmethod
 from pydantic import BaseModel
 from tortoise.exceptions import IntegrityError
 from x_model import HTTPException, FailReason
-from xync_client.Abc.Ex import BaseExClient
+from xync_schema.models import OrderStatus, Coin, Cur, Ad, AdStatus, Fiat, Agent, Pmex, Pmcur, Cred, PmexBank
+from xync_schema.pydantic import FiatNew, FiatUpd, BaseAd, FiatPydIn, AdSalePydIn, AdBuyPydIn, CredPydIn, BaseOrder
 
+from xync_client.Abc.Ex import BaseExClient
 from xync_client.Abc.Base import BaseClient
 
-from xync_client.Abc.AuthTrait import BaseAuthTrait
-from xync_schema.models import OrderStatus, Coin, Cur, Ad, AdStatus, Fiat, Agent, Pmex, Pmcur
-from xync_schema.pydantic import FiatNew, FiatUpd, BaseAd, FiatPydIn
 
-
-class BaseAgentClient(BaseClient, BaseAuthTrait):
+class BaseAgentClient(BaseClient):
     def __init__(self, agent: Agent):
         self.agent: Agent = agent
-        self.ex_client: BaseExClient = agent.contragent.ex.client(agent)  # todo: really need?
-        super().__init__(agent.contragent.ex)  # , "host_p2p"
+        super().__init__(self.agent.actor.ex)  # , "host_p2p"
+        self.ex_client: BaseExClient = self.ex.client()
 
     @abstractmethod
     async def start_listen(self) -> bool: ...
@@ -33,7 +31,7 @@ class BaseAgentClient(BaseClient, BaseAuthTrait):
 
     # 1: [T] Запрос на старт сделки
     @abstractmethod
-    async def order_request(self, ad_id: int, amount: float) -> dict: ...
+    async def order_request(self, order: BaseOrder) -> dict: ...
 
     # async def start_order(self, order: Order) -> OrderOutClient:
     #     return OrderOutClient(self, order)
@@ -79,7 +77,7 @@ class BaseAgentClient(BaseClient, BaseAuthTrait):
 
     # 25: Список реквизитов моих платежных методов
     @abstractmethod
-    async def fiats(self) -> list: ...  # {fiat.exid: {fiat}}
+    async def creds(self) -> list: ...  # {fiat.exid: {fiat}}
 
     @staticmethod
     async def fiat_pyd2db(fiat_pyd: FiatNew | FiatUpd, uid: int, fid: int = None) -> tuple[Fiat, bool]:
@@ -97,14 +95,14 @@ class BaseAgentClient(BaseClient, BaseAuthTrait):
     # 26: Создание реквизита моего платежного метода
     @abstractmethod
     async def fiat_f2in(self, fiat_new: FiatNew) -> FiatPydIn:
-        if not (pmcur := await Pmcur.get_or_none(cur_id=fiat_new.cur_id, pm_id=fiat_new.pm_id)):
+        if not (_pmcur := await Pmcur.get_or_none(cur_id=fiat_new.cur_id, pm_id=fiat_new.pm_id)):
             raise HTTPException(FailReason.body, f"No Pmcur with cur#{fiat_new.cur_id} and pm#{fiat_new.pm_id}", 404)
-        # cred = await Cred.create({"exid": }, pmcur=pmcur, contragent=self.agent.contragent)
+        # cred = await Cred.create({"exid": }, pmcur=pmcur, actor=self.agent.actor)
         # df = {"detail": fiat_pyd.detail, "name": fiat_pyd.name, "amount": fiat_pyd.amount, "target": fiat_pyd.target}
         # unq = {"pmcur": pmcur, "user_id": uid}
 
     # async def fiat_new(self, fiat: FiatNew) -> Fiat:
-    #     contragent = await Contragent.get_or_create({"name": }, ex=self.ex_client.ex, exid=self.agent.contragent.exid)
+    #     actor = await Actor.get_or_create({"name": }, ex=self.ex_client.ex, exid=self.agent.actor.exid)
     #     FiatPydIn()
     #     fiat_db: Fiat = (await self.fiat_pyd2db(fiat, self.agent.user_id))[0]
     #     if not (fiatex := Fiatex.get_or_none(fiat=fiat_db, ex=self.agent.ex)):
@@ -182,3 +180,22 @@ class BaseAgentClient(BaseClient, BaseAuthTrait):
     # 39: Балансы моих монет
     @abstractmethod
     async def my_assets(self) -> dict: ...
+
+    # Сохранение объявления (с Pm/Cred-ами) в бд
+    async def ad_pydin2db(self, ad_pydin: AdSalePydIn | AdBuyPydIn) -> 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_pydin2db(cred: CredPydIn) -> Cred:
+        df, unq = cred.args()
+        cred_db, _ = await Cred.update_or_create(df, **unq)
+        if cred.banks:
+            await cred_db.banks.add(*[await PmexBank.get(exid=b) for b in cred.banks])
+        return cred_db
+
+    @staticmethod
+    async def fiat_cred2db(cred: Cred) -> Fiat:
+        fiat, _ = await Fiat.get_or_create(cred=cred)
+        return fiat

{xync_client-0.0.25.dev11 → xync_client-0.0.25.dev20}/xync_client/Abc/AuthTrait.py

@@ -6,11 +6,9 @@ from aiohttp.http_exceptions import HttpProcessingError
 from x_client.aiohttp import Client
 from xync_schema.models import Agent
 
-# from x_client.aiohttp import Client
-
 
 class BaseAuthTrait(Client):
-    agent: Agent
+    agent: Agent = None
 
     @abstractmethod
     async def _get_auth_hdrs(self) -> dict[str, str]: ...

{xync_client-0.0.25.dev11 → xync_client-0.0.25.dev20}/xync_client/Abc/Base.py

@@ -8,5 +8,8 @@ MapOfIdsList = dict[int | str, list[int | str]]
 
 
 class BaseClient(Client):
+    ex: Ex
+
     def __init__(self, ex: Ex, attr: str = "host_p2p"):
+        self.ex = ex
         super().__init__(getattr(ex, attr))

{xync_client-0.0.25.dev11 → xync_client-0.0.25.dev20}/xync_client/Abc/Ex.py

@@ -2,8 +2,8 @@ import logging
 import re
 from abc import abstractmethod
 
-from xync_schema.pydantic import AdPydIn, PmPyd, BaseAd, CurEpyd, CoinEpyd
-from xync_schema.models import Ex, Coin, Cur, Pm, Pmex, Curex, Pmcur, Coinex, PmexBank, Ad, Agent
+from xync_schema.pydantic import BaseAdPydIn, PmPyd, BaseAd, CurEpyd, CoinEpyd
+from xync_schema.models import Ex, Coin, Cur, Pm, Pmex, Curex, Pmcur, Coinex, PmexBank, Ad
 
 from xync_client.Abc.Base import BaseClient, DictOfDicts, MapOfIdsList
 
@@ -21,8 +21,7 @@ class BaseExClient(BaseClient):
         "GTB Bank (Guarantee Trust Bank)": "GTBank",
     }
 
-    def __init__(self, ex: Ex, _: Agent = None):
-        self.ex: Ex = ex
+    def __init__(self, ex: Ex):
         self.acronyms: dict[str, str] = {}  # for pm norm
         super().__init__(ex)  # , "host_p2p"
 
@@ -66,7 +65,7 @@ class BaseExClient(BaseClient):
 
     # Преобразрование объекта объявления из формата биржи в формат xync
     @abstractmethod
-    async def ad_epyd2pydin(self, ad: BaseAd) -> AdPydIn: ...  # my_uid: for MyAd
+    async def ad_epyd2pydin(self, ad: BaseAd) -> BaseAdPydIn: ...  # my_uid: for MyAd
 
     def _pmnorm(self, s: str) -> str:
         def get_and_remove_acro(title: str) -> str:
@@ -196,8 +195,9 @@ class BaseExClient(BaseClient):
         await Coinex.bulk_create(coinexs, update_fields=["minimum"], on_conflict=["coin_id", "ex_id"])
 
     # Сохранение чужого объявления (с Pm-ами) в бд
-    @staticmethod
-    async def ad_pydin2db(ad_pydin: AdPydIn) -> Ad:
-        ad_db, _ = await Ad.update_or_create(ad_pydin.model_dump(exclude_none=True), id=ad_pydin.id)
-        await ad_db.pms.add(*getattr(ad_pydin, "pms_", ad_pydin.fiats_))
+    async def ad_pydin2db(self, ad_pydin: BaseAdPydIn) -> Ad:
+        df, unq = ad_pydin.args()
+        ad_db, _ = await Ad.update_or_create(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.dev11 → xync_client-0.0.25.dev20}/xync_client/TgWallet/agent.py

@@ -1,23 +1,28 @@
 import logging
 from asyncio import run
 from enum import StrEnum
-
+from tg_auth import UserStatus
 from x_model import init_db, HTTPException, FailReason
+from xync_client.TgWallet.ex import ExClient
 from xync_schema import models
 
 from xync_client.TgWallet.pyd import (
-    Banks,
-    FiatEpyd,
+    CredEpyd,
     Attrs,
     AttrsV2,
     OneAdTakerMakerSale,
-    OneAdMakerPurchase,
-    AdMakerPurchase,
+    OneAdMakerBuy,
+    AdMakerBuy,
     AdMakerSale,
     AdMakerNewSale,
-    _TakerOne,
     _AdNew,
     FiatEpydIn,
+    _PmsTrait,
+    OneAdTakerBuy,
+    OrderEpyd,
+    AdMakerNewBuy,
+    OrderEpydIn,
+    AvailableVolume,
 )
 from xync_client.loader import PG_DSN
 from xync_schema.enums import AdStatus
@@ -33,20 +38,25 @@ from xync_schema.models import (
     Ad,
     Pmcur,
     Cred,
-    PmexBank,
     Agent,
     Curex,
     Coinex,
+    Pm,
+    Order,
+    Actor,
 )
-from xync_schema.pydantic import FiatNew, FiatPydIn
+from xync_schema.pydantic import FiatNew, BaseAdPydIn, AdBuyPydIn, AdSalePydIn, CredPydIn, OrderPydIn
 
 from xync_client.Abc.Agent import BaseAgentClient
 
 
 class Exceptions(StrEnum):
+    ORDER_KYC = "FIAT_COUNTRY_NOT_SUPPORTED_BY_USER_KYC_COUNTRY"
     PM_KYC = "OFFER_FIAT_COUNTRY_NOT_SUPPORTED_BY_USER_KYC_COUNTRY"
     ROUND = "ROUNDING_IS_NOT_SUPPORTED"
     CUR = "CURRENCY_IS_NOT_SUPPORTED_BY_PAYMENT_METHOD"
+    MAX_ADS = "ACTIVE_OFFER_COUNT_LIMIT_REACHED"
+    INACTIVE_AD = "OFFER_ILLEGAL_STATE"
 
 
 # class Status(IntEnum):
@@ -54,6 +64,8 @@ class Exceptions(StrEnum):
 
 
 class AgentClient(BaseAgentClient, AuthClient):
+    ex_client: ExClient
+
     # 0: Получение ордеров в статусе status, по монете coin, в валюте coin, в направлении is_sell
     async def orders(
         self, status: OrderStatus = OrderStatus.created, coin: Coin = None, cur: Cur = None, is_sell: bool = None
@@ -69,48 +81,74 @@ class AgentClient(BaseAgentClient, AuthClient):
         orders = await self._post("/p2p/public-api/v2/offer/order/get", {"orderId": oid})
         return orders["data"]
 
-    # 1: [T] Запрос на старт сделки
-    async def order_request(self, ad_id: int, amount: float = None) -> dict | bool:
-        await self.agent.fetch_related("ex", "ex__agents")
-        ad: _TakerOne = await self.ex_client.ad(ad_id=ad_id)
-        fiats: list[FiatEpyd] = await self.fiats()
-        fiats_pms: dict[str, int] = {fiat.paymentMethod.code: fiat.id for fiat in fiats}
-        pmfs: dict[str, int]
-        if ad.is_sell:
-            pmfs = {pd.paymentMethod.code: pd.id for pd in ad.paymentDetails if pd.paymentMethod.code in fiats_pms}
-            fiatex = (
-                await Cred.filter(
-                    fiat__user_id=self.agent.user_id,
-                    ex=self.ex_client.ex,
-                    fiat__pmcur__pm__pmexs__exid__in=pmfs.keys(),
-                )
-                .order_by("-fiat__amount")
-                .first()
-                .prefetch_related("fiat__pmcur")
+    async def order_ad2epydin(self, ad: Ad, amount: float, cred_id: int = None) -> OrderEpydIn:
+        if not cred_id:  # i am taker
+            iam_maker = self.agent.actor_id == ad.maker_id
+            iam_seller = ad.direction.sell == iam_maker
+            cred_filter = (
+                {"actor__agent__user_id": self.agent.user_id}
+                if iam_seller
+                else {  # its a buy ad, i am taker
+                    "actor": ad.maker
+                }
             )
-            pmex = await Pmex.get(ex=self.ex_client.ex, pm_id=fiatex.fiat.pmcur.pm_id)
-        # else:
-        #     pmfs = {pm.code: fid for pm in ad.paymentMethods if (fid := fiats_pms.get(pm.code))}
-        #     f = await Cred.filter(
-        #         fiat__user_id=self.agent.user_id, ex_id=self.ex_client.ex_id, fiat__pmcur__pm__pmexs__exid__in=pmfs.keys()
-        #     ).order_by("-fiat__amount").first()
-        # p = max(pmfs, key=lambda x: fiats_pms)
-        req_body = {
-            "offerId": ad_id,
-            "paymentDetailsId": pmfs[pmex.exid],  # fiats_pms[pid],
-            "amount": {"currencyCode": ad.orderAmountLimits.currencyCode, "amount": amount},
-            "type": ad.type,
-        }
-        request = await self._post("/p2p/public-api/v2/offer/order/create-by-amount", req_body)
+            await Cred.filter(
+                **cred_filter,
+                pmcur__pms__in=ad.pms,
+                # todo: ordering and filtering by fiat.amount-target
+            ).first() if iam_seller else 0
+        await ad.fetch_related("direction__pairex__pair__cur")
+        return OrderEpydIn(
+            offerId=ad.exid,
+            amount=AvailableVolume(currencyCode=ad.direction.pairex.pair.cur.ticker, amount=str(int(amount))),
+            type="SALE" if ad.direction.sell else "PURCHASE",
+            paymentDetailsId=cred_id,
+        )
+
+    # 1: [T] Запрос на старт сделки
+    async def order_request(self, req: OrderEpydIn) -> OrderEpyd | dict:
+        request = await self._post("/p2p/public-api/v2/offer/order/create-by-amount", req.model_dump(exclude_none=True))
         if r := request.get("data"):
-            return await self._post("/p2p/public-api/v2/offer/order/confirm", {"orderId": r["id"], "type": ad.type})
+            res = await self._post("/p2p/public-api/v2/offer/order/confirm", {"orderId": r["id"], "type": req.type})
+            if res.get("status") == "SUCCESS":
+                return OrderEpyd(**r)
         logging.error(request)
         return request
 
+    async def order_epyd2pydin(self, order: OrderEpyd) -> OrderPydIn:
+        ad = await Ad.get(exid=order.offerId, direction__pairex__ex=self.ex)
+        cred = await Cred.get(exid=order.paymentDetails.id, actor__ex=self.ex)
+        iam_maker = self.agent.actor == ad.maker
+        taker = (
+            (await Actor.get(exid=(order.seller if order.is_sell == iam_maker else order.buyer).userId, ex=self.ex))
+            if iam_maker
+            else self.agent.actor
+        )
+        return OrderPydIn(
+            exid=order.id,
+            amount=order.amount.amount,
+            maker_topic=None,
+            taker_topic=None,
+            status=OrderStatus.created,
+            created_at=order.createDateTime,
+            payed_at=None,
+            confirmed_at=None,
+            appealed_at=None,
+            ad=ad,
+            cred=cred,
+            taker=taker,
+        )
+
+    @staticmethod
+    async def order_pydin2db(order: OrderPydIn) -> Order:
+        df, unq = order.args()
+        order_db, _ = await Order.update_or_create(df, **unq)
+        return order_db
+
     # # # FIATS # # #
     def fiat_args2ex_pyd(
         self, exid: int | str, cur: str, detail: str, name: str, fid: int, typ: str, extra=None
-    ) -> FiatEpyd:
+    ) -> CredEpyd:
         fiat = self.fiat_pyd(
             paymentMethodCode=exid,
             currencyCode=cur,
@@ -141,11 +179,11 @@ class AgentClient(BaseAgentClient, AuthClient):
         }
 
     # 25: Список реквизитов моих платежных методов
-    async def fiats(self) -> list[FiatEpyd]:
+    async def creds(self) -> list[CredEpyd]:
         resp = await self._post("/p2p/public-api/v3/payment-details/get/by-user-id")
-        return [FiatEpyd(**fiat) for fiat in resp["data"]]
+        return [CredEpyd(**fiat) for fiat in resp["data"]]
 
-    async def _fiat_epyd2pydin(self, fiat: FiatEpyd) -> FiatPydIn:
+    async def cred_epyd2pydin(self, fiat: CredEpyd) -> CredPydIn:
         if not (pmex := await Pmex.get_or_none(exid=fiat.paymentMethod.code, ex=self.ex_client.ex)):
             raise HTTPException(
                 FailReason.body, f"No Pmex {fiat.paymentMethod.code} on ex#{self.ex_client.ex.name}", 404
@@ -154,36 +192,26 @@ class AgentClient(BaseAgentClient, AuthClient):
             raise HTTPException(
                 FailReason.body, f"No Pmcur with cur#{fiat.currency} and pm#{fiat.paymentMethod.code}", 404
             )
-        ftx = FiatPydIn(
-            id=fiat.id,
-            detail="",
-            name=fiat.name,
-            amount=0,
-            user_id=self.agent.user_id,
+        cred_pin = CredPydIn(
+            exid=fiat.id,
             pmcur=pmcur,
+            actor=self.agent.actor,
+            name=fiat.name,
         )
         for val in fiat.attributes.values:
-            if val.name != "BANKS":
-                ftx.detail = val.value
+            if val.name == "BANKS":
+                cred_pin.banks = [b.code for b in val.value]
             else:
-                val: Banks
-                ftx.banks = [b.code for b in val.value]
-        return ftx
+                cred_pin.detail = val.value
+        return cred_pin
 
     # 25: Список реквизитов моих платежных методов
-    async def set_fiatexs(self) -> list[Cred]:
-        fiat_epyds = await self.fiats()
-        fiat_xpyds: list[FiatPydIn] = [await self._fiat_epyd2pydin(f) for f in fiat_epyds]
-        fxs: list[Cred] = []
-        for fx in fiat_xpyds:
-            df, unq = fx.args()
-            cred_db, _ = await Cred.update_or_create(
-                {"name": fx.cred.name, "detail": fx.cred.detail}, exid=fx.id, ex=self.ex_client.ex
-            )
-            fiat_db, _ = await Fiat.update_or_create(df, **unq)
-            banks = [await PmexBank.get(exid=bn) for bn in fx.banks]
-            await cred_db.banks.add(*banks)
-        return fxs
+    async def set_fiats(self) -> list[Fiat]:
+        creds_epyd: list[CredEpyd] = await self.creds()
+        creds_pyd_in: list[CredPydIn] = [await self.cred_epyd2pydin(f) for f in creds_epyd]
+        creds_db = [await self.cred_pydin2db(crd) for crd in creds_pyd_in]
+        fiats_db = [await self.fiat_cred2db(cd) for cd in creds_db]
+        return fiats_db
 
     # 26: Создание реквизита моего платежного метода
     async def fiat_new(self, fiat: FiatNew) -> Fiat:
@@ -201,7 +229,7 @@ class AgentClient(BaseAgentClient, AuthClient):
             attributes={"values": vals},
         )
         add_fiat = await self._post("/p2p/public-api/v3/payment-details/create", fiat_in.model_dump())
-        FiatEpyd(**add_fiat["data"])
+        CredEpyd(**add_fiat["data"])
         cred, _ = await Cred.update_or_create(
             {"name": fiat.name, "detail": fiat.detail}, ex=self.ex_client.ex, exid=add_fiat["data"]["id"]
         )
@@ -246,10 +274,22 @@ class AgentClient(BaseAgentClient, AuthClient):
         del_fiat = await self._post("/p2p/public-api/v3/payment-details/delete", {"id": fiat_id})
         return del_fiat
 
+    async def ad_epyd2pydin(self, ad_: OneAdTakerMakerSale | OneAdMakerBuy | OneAdTakerBuy) -> AdBuyPydIn | AdSalePydIn:
+        ad_in: BaseAdPydIn = await self.ex_client.ad_common_epyd2pydin(ad_)
+        ad_in.maker = self.agent.actor
+        if isinstance(ad_, _PmsTrait):
+            return AdBuyPydIn(
+                **ad_in.model_dump(),
+                pms_=await Pm.filter(pmexs__ex=self.ex_client.ex, pmexs__exid__in=[p.code for p in ad_.paymentMethods]),
+            )
+        creds_pin: list[CredPydIn] = [await self.cred_epyd2pydin(c) for c in ad_.paymentDetails]
+        creds_ = [(await Cred.update_or_create((a := cp.args())[0], **a[1]))[0] for cp in creds_pin]
+        return AdSalePydIn(**ad_in.model_dump(), creds_=creds_)
+
     # 29: Список моих объявлений
-    async def my_ads(self, status: AdStatus = None) -> list[AdMakerPurchase | AdMakerSale]:
-        def model(ad: dict) -> (AdMakerPurchase | AdMakerSale).__class__:
-            return AdMakerSale if ad["type"] == "SALE" else AdMakerPurchase
+    async def my_ads(self, status: AdStatus = None) -> list[AdMakerBuy | AdMakerSale]:
+        def model(ad: dict) -> (AdMakerBuy | AdMakerSale).__class__:
+            return AdMakerSale if ad["type"] == "SALE" else AdMakerBuy
 
         mapping = {AdStatus.defActive: "INACTIVE", AdStatus.active: "ACTIVE"}
         ads = await self._post(
@@ -259,18 +299,46 @@ class AgentClient(BaseAgentClient, AuthClient):
         return [model(ad)(**ad) for ad in ads["data"] if not status or (status and ad["status"] == mapping[status])]
 
     # 43: Моя объява по id
-    async def my_ad(self, ad_id: int) -> OneAdMakerPurchase | OneAdTakerMakerSale:
+    async def my_ad(self, ad_id: int) -> OneAdMakerBuy | OneAdTakerMakerSale:
         ad = await self._post("/p2p/public-api/v2/offer/get-user-own", {"offerId": ad_id})
         ad: dict = ad["data"]
-        assert ad["user"]["userId"] == self.agent.contragent.exid, "Not your ad"
-        model = OneAdTakerMakerSale if ad["type"] == "SALE" else OneAdMakerPurchase
+        assert ad["user"]["userId"] == self.agent.actor.exid, "Not your ad"
+        model = OneAdTakerMakerSale if ad["type"] == "SALE" else OneAdMakerBuy
         return model(**ad)
 
+    async def ad_f2ein(
+        self, coin: Coin, cur: Cur, is_sell: bool, vol: int = None, cur_min: int = None
+    ) -> AdMakerNewSale | AdMakerNewBuy:
+        coinex = await Coinex.get(coin=coin, ex=self.ex)
+        curex = await Curex.get(ex=self.ex, cur=cur)
+        creds = await Cred.filter(actor__agent__user_id=self.agent.user_id, pmcur__cur=cur).limit(5)
+        # todo: ordering and filtering by fiat.amount-target
+        ad_ein = _AdNew(
+            type="SALE" if is_sell else "PURCHASE",
+            initVolume=AvailableVolume(currencyCode=coinex.exid, amount=str(vol or coinex.minimum)),
+            orderRoundingRequired=curex.rounding_scale is not None,
+            price={
+                "type": "FLOATING",
+                "baseCurrencyCode": coinex.exid,
+                "quoteCurrencyCode": curex.exid,
+                "value": "120" if is_sell else "80",
+            },
+            orderAmountLimits={"min": str(cur_min or curex.minimum)},
+            paymentConfirmTimeout="PT15M",
+            comment="tst",
+        )
+        if ad_ein.type == "SALE":
+            ad_ein = AdMakerNewSale(**ad_ein.model_dump(exclude_none=True), paymentDetailsIds=[c.exid for c in creds])
+        else:
+            pmexs = await Pmex.filter(ex=self.agent.actor.ex, pm__pmcurs__id__in=[c.pmcur_id for c in creds])
+            ad_ein = AdMakerNewBuy(**ad_ein.model_dump(exclude_none=True), paymentMethodCodes=[p.exid for p in pmexs])
+        return ad_ein
+
     # 30: Создание объявления
-    async def ad_new(self, ad: _AdNew) -> OneAdMakerPurchase | OneAdTakerMakerSale:
+    async def ad_new(self, ad: _AdNew) -> OneAdMakerBuy | OneAdTakerMakerSale:
         create = await self._post("/p2p/public-api/v2/offer/create", ad.model_dump())
         if res := create.get("data"):
-            return OneAdTakerMakerSale(**res) if res["type"] == "SALE" else OneAdMakerPurchase(**res)
+            return OneAdTakerMakerSale(**res) if res["type"] == "SALE" else OneAdMakerBuy(**res)
         raise Exception(create)
 
     # 31: Редактирование объявления
@@ -312,7 +380,7 @@ class AgentClient(BaseAgentClient, AuthClient):
 
     # 33: Вкл/выкл объявления
     async def ad_switch(self, ad_id: int, active: bool) -> bool:
-        ad: OneAdMakerPurchase | OneAdTakerMakerSale = await self.my_ad(ad_id)
+        ad: OneAdMakerBuy | OneAdTakerMakerSale = await self.my_ad(ad_id)
         pre = "" if active else "de"
         switch = await self._post(f"/p2p/public-api/v2/offer/{pre}activate", {"type": ad.type, "offerId": ad_id})
         return switch["status"] == "SUCCESS"
@@ -353,50 +421,45 @@ class AgentClient(BaseAgentClient, AuthClient):
 
 async def main():
     await init_db(PG_DSN, models, True)
-    agents: tuple[Agent, Agent] = (
-        await Agent.filter(ex_id=34, auth__isnull=False).order_by("user_id").limit(2).prefetch_related("ex")
+    maker: Agent
+    taker: Agent
+    maker, taker = (
+        await Agent.filter(actor__ex_id=34, auth__isnull=False, user__status__gte=UserStatus.MEMBER)
+        .order_by("user_id")
+        .limit(2)
+        .prefetch_related("actor__ex")
     )
-    maker, taker = agents
     mcl: AgentClient = maker.client()
     tcl: AgentClient = taker.client()
-    # msale_ad: list[AdEpyd] = await mcl.ex_client.ad(1941011)
-    # mbuy_ad: list[AdEpyd] = await mcl.ex_client.ad(1813220)
-    # fiatexs = await tcl.set_fiatexs()
-    # fiatexs = await mcl.set_fiatexs()
-    # await mcl.my_ads()
-    coinex = await Coinex.get(coin__ticker="USDT")
-    taker_fiats = await Fiat.filter(user_id=taker.user_id)
-    maker_fiats = await Fiat.filter(user_id=maker.user_id)
-    common_mfs: set[Fiat] = {mf for mf in maker_fiats if mf.pmcur_id in {tf.pmcur_id for tf in taker_fiats}}
-    mfs: list[Fiat] = sorted(common_mfs, key=lambda x: x.amount, reverse=True)[:5]
-    curex = await Curex.get(ex=maker.ex, cur_id=(await mfs[0].pmcur).cur_id)
-    ad_ein = AdMakerNewSale(
-        type="SALE",
-        initVolume={"currencyCode": coinex.exid, "amount": f"{coinex.minimum}"},
-        orderRoundingRequired=curex.rounding_scale is not None,
-        price={
-            "type": "FLOATING",
-            "baseCurrencyCode": coinex.exid,
-            "quoteCurrencyCode": curex.exid,
-            "value": "120",
-        },
-        orderAmountLimits={"min": str(curex.minimum)},
-        paymentConfirmTimeout="PT15M",
-        comment="test1",
-    )
-    if ad_ein.type == "SALE":
-        mfiatexids = [(await Cred.get(ex=maker.ex, fiat=mf)).exid for mf in mfs]
-        ad_ein.paymentDetailsIds = mfiatexids[:1]
-    else:
-        pmexsids = [(await Pmex.get(ex=maker.ex, pm__pmcurs__id=mf.pmcur_id)).exid for mf in mfs]
-        ad_ein.paymentMethodCodes = pmexsids[:1]
-
-    mad = await mcl.ad_new(ad_ein)
-    await mcl.ad_switch(mad.id, True)
-    await tcl.order_request(mad.id, float(mad.orderAmountLimits.min))
-    ad_in = await mcl.ex_client.ad_epyd2pydin(mad)
-    ad_db = await Ad.create(**ad_in.model_dump(exclude_none=True))
-    print(ad_db)
+    # fiats = await tcl.set_fiats()
+    # fiats = await mcl.set_fiats()
+    # my_ads = await mcl.my_ads()
+    # my_ads_in = [await mcl.ad_epyd2pydin(ma) for ma in my_ads]
+    # _my_ads_db = [await mcl.ad_pydin2db(ma) for ma in my_ads_in]
+
+    coin = await Coin.get(ticker="USDT")
+    cur = await Cur.get(ticker="RUB")
+    ad_sell_ein = await tcl.ad_f2ein(coin, cur, True)
+    ad_buy_ein = await mcl.ad_f2ein(coin, cur, False)
+    sad = await tcl.ad_new(ad_sell_ein)
+    bad = await mcl.ad_new(ad_buy_ein)
+    await tcl.ad_switch(sad.id, True)
+    await mcl.ad_switch(bad.id, True)
+    sad_in = await tcl.ad_epyd2pydin(sad)
+    sad_db = await Ad.create(**sad_in.model_dump(exclude_none=True))
+    bad_in = await mcl.ad_epyd2pydin(bad)
+    await Ad.create(**bad_in.model_dump(exclude_none=True))
+
+    order_epin: OrderEpydIn = await tcl.order_ad2epydin(sad_db, float(sad.orderAmountLimits.min))
+    new_order: OrderEpyd = await tcl.order_request(order_epin)
+    order_pin: OrderPydIn = await tcl.order_epyd2pydin(new_order)
+    _order_db = await tcl.order_pydin2db(order_pin)
+
+    # order_epin: OrderEpydIn = await tcl.order_ad2epydin(ad_db, float(mad.orderAmountLimits.min), cred_ids[0])
+    # new_order: OrderEpyd = await tcl.order_request(order_epin)
+    # order_pin: OrderPydIn = await tcl.order_epyd2pydin(new_order)
+    # _order_db = await tcl.order_pydin2db(order_pin)
+
     await tcl.close(), await mcl.close()
 
 

{xync_client-0.0.25.dev11 → xync_client-0.0.25.dev20}/xync_client/TgWallet/auth.py

@@ -1,15 +1,19 @@
 from x_client.http import Client as HttpClient
+from xync_schema.models import Agent
 
 from xync_client.Abc.AuthTrait import BaseAuthTrait
+from xync_client.Abc.Base import BaseClient
 from xync_client.TgWallet.pyro import PyroClient
 
 
-class AuthClient(BaseAuthTrait):
+class AuthClient(BaseAuthTrait, BaseClient):
     async def _get_auth_hdrs(self) -> dict[str, str]:
+        if not self.agent:
+            self.agent = await Agent.filter(actor__ex=self.ex, auth__isnull=False).prefetch_related("actor").first()
         pyro = PyroClient(self.agent)
         init_data = await pyro.get_init_data()
         tokens = HttpClient("walletbot.me")._post("/api/v1/users/auth/", init_data)
-        self.agent.exid = tokens["user_id"]
-        await self.agent.save()
+        self.agent.actor.exid = tokens["user_id"]
+        await self.agent.actor.save()
         pref = "" if self.__class__.__name__ == "AssetClient" else "Bearer "
         return {"Wallet-Authorization": tokens["jwt"], "Authorization": pref + tokens["value"]}