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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.25.dev11
+Version: 0.0.25.dev19
 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.dev19}/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.contragent.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,7 +95,7 @@ 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)
         # df = {"detail": fiat_pyd.detail, "name": fiat_pyd.name, "amount": fiat_pyd.amount, "target": fiat_pyd.target}
@@ -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.dev19}/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.dev19}/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.dev19}/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.dev19}/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,
+    Contragent,
 )
-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,64 @@ class AgentClient(BaseAgentClient, AuthClient):
         orders = await self._post("/p2p/public-api/v2/offer/order/get", {"orderId": oid})
         return orders["data"]
 
+    @staticmethod
+    async def order_ad2epydin(ad: Ad, amount: float, cred_id: int) -> OrderEpydIn:
+        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, 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")
-            )
-            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)
+    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, contragent__ex=self.ex)
+        iam_maker = self.agent.contragent == ad.maker
+        taker = (
+            (
+                await Contragent.get(
+                    exid=(order.seller if order.is_sell == iam_maker else order.buyer).userId, ex=self.ex
+                )
+            )
+            if iam_maker
+            else self.agent.contragent
+        )
+        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 +169,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 +182,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,
+            contragent=self.agent.contragent,
+            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 +219,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 +264,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.contragent
+        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 +289,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
+        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(contragent__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.contragent.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 +370,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 +411,40 @@ 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(contragent__ex_id=34, auth__isnull=False, user__status__gte=UserStatus.MEMBER)
+        .order_by("user_id")
+        .limit(2)
+        .prefetch_related("contragent__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)
+    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(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.dev19}/xync_client/TgWallet/auth.py

@@ -1,15 +1,21 @@
 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(contragent__ex=self.ex, auth__isnull=False).prefetch_related("contragent").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.contragent.exid = tokens["user_id"]
+        await self.agent.contragent.save()
         pref = "" if self.__class__.__name__ == "AssetClient" else "Bearer "
         return {"Wallet-Authorization": tokens["jwt"], "Authorization": pref + tokens["value"]}

{xync_client-0.0.25.dev11 → xync_client-0.0.25.dev19}/xync_client/TgWallet/ex.py

@@ -1,19 +1,19 @@
 from asyncio import run
 
 from x_model import init_db
-from xync_schema.pydantic import AdPydIn, PmPyd, PmexBankPyd, CurEpyd, CoinEpyd
+from xync_schema.pydantic import PmPyd, PmexBankPyd, CurEpyd, CoinEpyd, BaseAdPydIn, AdBuyPydIn
 
 from xync_schema import models
-from xync_schema.models import Ex, Agent, Direction, Pair, Coin, Cur, Pm, Fiat, Contragent
+from xync_schema.models import Ex, Direction, Pair, Coin, Cur, Pm, Contragent, PairEx
 
 from xync_client.TgWallet.pyd import (
     PmEpydRoot,
-    _BaseAd,
     OneAdTakerMakerSale,
-    OneAdTakerPurchase,
-    AdTakerSalePurchase,
-    _UserTrait,
+    OneAdTakerBuy,
+    AdTakerSaleBuy,
     _TakerOne,
+    _PmsTrait,
+    _BaseAd,
 )
 from xync_client.loader import PG_DSN
 from xync_client.Abc.Ex import BaseExClient
@@ -22,12 +22,8 @@ from xync_client.TgWallet.auth import AuthClient
 
 
 class ExClient(BaseExClient, AuthClient):
-    def __init__(self, ex: Ex, agent: Agent = None):
-        if not agent:
-            # ex should be with fetched .agents
-            agent = [ctg for ctg in ex.contragents if ctg.agent and ctg.agent.auth][0].agent
-        self.agent: Agent = agent  # need for AuthTrait
-        super().__init__(ex)  # , "host_p2p"
+    def __init__(self, ex: Ex):
+        super().__init__(ex)  # BaseExClient
 
     def pm_type_map(self, pm: Pm) -> str:
         return "V2" if pm.name.startswith("SBP") else "V1"
@@ -92,13 +88,13 @@ class ExClient(BaseExClient, AuthClient):
     async def ad(self, ad_id: int) -> _TakerOne:
         ad = await self._post("/p2p/public-api/v2/offer/get", {"offerId": ad_id})
         ad: dict = ad["data"]
-        model = OneAdTakerMakerSale if ad["type"] == "SALE" else OneAdTakerPurchase
+        model = OneAdTakerMakerSale if ad["type"] == "SALE" else OneAdTakerBuy
         return model(**ad)
 
     # 24: Список объяв по (buy/sell, cur, coin, pm)
     async def ads(
         self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None, amount: int = None
-    ) -> list[AdTakerSalePurchase]:
+    ) -> list[AdTakerSaleBuy]:
         params = {
             "baseCurrencyCode": coin_exid,
             "quoteCurrencyCode": cur_exid,
@@ -108,46 +104,70 @@ class ExClient(BaseExClient, AuthClient):
             # "merchantVerified": "TRUSTED"
         }
         ads = await self._post("/p2p/public-api/v2/offer/depth-of-market/", params, "data")
-        return [AdTakerSalePurchase(**ad) for ad in ads]
+        return [AdTakerSaleBuy(**ad) for ad in ads]
 
-    async def ad_epyd2pydin(self, ad: _BaseAd) -> AdPydIn:
+    async def ad_common_epyd2pydin(self, ad: _BaseAd) -> BaseAdPydIn:
         coin = await Coin.get_or_create_by_name(ad.price.baseCurrencyCode)
         cur = await Cur.get_or_create_by_name(ad.price.quoteCurrencyCode)
-        pair, _ = await Pair.get_or_create(coin=coin, cur=cur, ex=self.ex)
-        dr, _ = await Direction.get_or_create(pair=pair, sell=ad.is_sell)
-        maker, _ = await Contragent.update_or_create({"name": ad.user.nickname}, exid=ad.user.userId, ex=self.ex)
-        adx = AdPydIn(
-            id=ad.id,
+        pair, _ = await Pair.get_or_create(coin=coin, cur=cur)
+        pairex, _ = await PairEx.get_or_create(pair=pair, ex=self.ex)
+        dr, _ = await Direction.get_or_create(pairex=pairex, sell=ad.is_sell)
+        return BaseAdPydIn(
+            exid=ad.id,
             price=ad.price.value,
             min_fiat=ad.orderAmountLimits.min,
             max_fiat=ad.orderAmountLimits.max,
             direction=dr,
             detail=getattr(ad, "comment", None),
-            maker=maker if isinstance(ad, _UserTrait) else self.agent.contragent,
-            # todo: maybe later adpm_banks
         )
-        if ad.is_sell and getattr(ad, "paymentDetails", None):
-            adx.fiats_ = await Fiat.filter(cred__ex=self.ex, cred__exid__in=[p.id for p in ad.paymentDetails])
-        else:
-            adx.pms_ = await Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=[p.code for p in ad.paymentMethods])
-        return adx
+
+    async def ad_taker_epyd2pydin(self, ad: _TakerOne) -> AdBuyPydIn:
+        adx: BaseAdPydIn = await self.ad_common_epyd2pydin(ad)
+        adx.maker = (await Contragent.update_or_create({"name": ad.user.nickname}, ex=self.ex, exid=ad.user.userId))[0]
+        pms = ad.paymentMethods if isinstance(ad, _PmsTrait) else [pd.paymentMethod for pd in ad.paymentDetails]
+        return AdBuyPydIn(
+            **adx.model_dump(), pms_=await Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=[p.code for p in pms])
+        )
 
 
 async def _test():
     await init_db(PG_DSN, models, True)
-    tgex = await Ex.get(name="TgWallet").prefetch_related("contragents__agent", "contragents__ex")
+    tgex = await Ex.get(name="TgWallet")
     cl: ExClient = tgex.client()
-    # await cl.pms("RUB")
-    await cl.set_pmcurexs()
-    await cl.set_coinexs()
-    ads: list[AdTakerSalePurchase] = await cl.ads("USDT", "RUB", False)
-    ad: _TakerOne = await cl.ad(ads[0].id)
-    ad_pydin: AdPydIn = await cl.ad_epyd2pydin(ad)
-    await cl.ad_pydin2db(ad_pydin)
-    ads: list[AdTakerSalePurchase] = await cl.ads("USDT", "RUB", True)
-    ad: AdTakerSalePurchase = ads[1]
-    ad_pydin: AdPydIn = await cl.ad_epyd2pydin(ad)
-    await cl.ad_pydin2db(ad_pydin)
+
+    # await cl.set_pmcurexs()
+    # await cl.set_coinexs()
+
+    # # # SALE # # #
+    # get ads list
+    ads: list[AdTakerSaleBuy] = await cl.ads("TON", "RUB", True)
+    # prepare ad list items for saving
+    ads_pydin: list[BaseAdPydIn] = [await cl.ad_taker_epyd2pydin(adp) for adp in ads]
+    # list items save
+    _ads_db = [await cl.ad_pydin2db(adi) for adi in ads_pydin]
+
+    # # get ad fulls
+    # ads_pyd: list[_TakerOne] = [await cl.ad(ad.id) for ad in ads]
+    # # prepare ad fulls for saving
+    # ads_pydin: list[AdBuyPydIn] = [await cl.ad_taker_epyd2pydin(adp) for adp in ads_pyd]
+    # # full ones save
+    # _ads_db = [await cl.ad_pydin2db(adi) for adi in ads_pydin]
+
+    # # # BUY # # #
+    # get ads list
+    ads: list[AdTakerSaleBuy] = await cl.ads("TON", "RUB", False)
+    # prepare ad list items for saving
+    ads_pydin: list[BaseAdPydIn] = [await cl.ad_taker_epyd2pydin(adp) for adp in ads]
+    # list items save
+    _ads_db = [await cl.ad_pydin2db(adi) for adi in ads_pydin]
+
+    # # get ad fulls
+    # ads_pyd = [await cl.ad(ad.id) for ad in ads]
+    # # prepare ad fulls for saving
+    # ads_pydin: list[AdBuyPydIn] = [await cl.ad_taker_epyd2pydin(adp) for adp in ads_pyd]
+    # # full ones save
+    # _ads_db = [await cl.ad_pydin2db(adi) for adi in ads_pydin]
+
     await cl.close()
 
 

{xync_client-0.0.25.dev11 → xync_client-0.0.25.dev19}/xync_client/TgWallet/pyd.py

@@ -1,6 +1,6 @@
 from typing import Literal
 from pydantic import BaseModel, computed_field
-from xync_schema.pydantic import BaseAd
+from xync_schema.pydantic import BaseAd, BaseOrder
 
 
 # Модели для вложенных структур
@@ -44,7 +44,7 @@ class OrderLimits(OrderLimitsIn):
     approximate: bool
 
 
-Status = Literal["ACTIVE", "INACTIVE", "ACTIVATING", "DEACTIVATING"]
+Status = Literal["ACTIVE", "INACTIVE", "ACTIVATING", "DEACTIVATING", "UPDATING"]
 
 
 class ChangeLogItem(BaseModel):
@@ -120,7 +120,7 @@ class FiatEpydIn(BaseModel):
     attributes: Attrs | AttrsV2In
 
 
-class FiatEpyd(BaseModel):
+class CredEpyd(BaseModel):
     id: int
     userId: int
     paymentMethod: PmEpydRoot
@@ -134,16 +134,19 @@ class InitVolume(BaseModel):
     amount: str  # of asset
 
 
+AdType = Literal["PURCHASE", "SALE"]
+
+
 # Основные модели
 class _BaseInOutAd(BaseAd):
-    type: Literal["PURCHASE", "SALE"]
+    type: AdType
     price: Price
 
 
 class _BaseAd(_BaseInOutAd):
     number: str
-    orderAmountLimits: OrderLimits
-    orderVolumeLimits: OrderLimits
+    orderAmountLimits: OrderLimits  # fiat
+    orderVolumeLimits: OrderLimits  # asset
     availableVolume: AvailableVolume
 
     @computed_field
@@ -165,38 +168,41 @@ class _UserTrait:
     user: User  # taker | One
 
 
+PaymentConfirmTimeout = Literal["PT3M", "PT15M", "PT30M", "PT45M", "PT1H", "PT2H", "PT3H"]
+
+
 class _OneTrait(_StatusTrait, _UserTrait):
     comment: str
     changeLog: ChangeLog
     createDateTime: str
-    paymentConfirmTimeout: Literal["PT3M", "PT15M", "PT30M"]
+    paymentConfirmTimeout: PaymentConfirmTimeout
 
 
 class _TakerOne(_BaseAd, _OneTrait):
-    orderConfirmationTimeout: Literal["PT3M", "PT15M"]
+    orderConfirmationTimeout: Literal["PT1M30S", "PT3M", "PT15M"]
     orderAcceptTimeout: Literal["PT10M"]
 
 
-class AdTakerSalePurchase(_BaseAd, _PmsTrait, _UserTrait):
+class AdTakerSaleBuy(_BaseAd, _PmsTrait, _UserTrait):
     availableVolume: str
 
 
 class OneAdTakerMakerSale(_TakerOne):
-    paymentDetails: list[FiatEpyd]
+    paymentDetails: list[CredEpyd]
     fee: Fee
 
 
-class OneAdTakerPurchase(_TakerOne, _PmsTrait): ...
+class OneAdTakerBuy(_TakerOne, _PmsTrait): ...
 
 
-class AdMakerPurchase(_BaseAd, _PmsTrait, _StatusTrait): ...
+class AdMakerBuy(_BaseAd, _PmsTrait, _StatusTrait): ...
 
 
-class OneAdMakerPurchase(_BaseAd, _OneTrait, _PmsTrait): ...
+class OneAdMakerBuy(_BaseAd, _OneTrait, _PmsTrait): ...
 
 
 class AdMakerSale(_BaseAd, _StatusTrait):
-    paymentDetails: list[FiatEpyd]
+    paymentDetails: list[CredEpyd]
 
 
 # # #
@@ -206,9 +212,9 @@ class AdMakerSale(_BaseAd, _StatusTrait):
 class _BaseIn(_BaseInOutAd):
     orderRoundingRequired: bool
     orderAmountLimits: OrderLimitsIn
-    paymentConfirmTimeout: str
+    paymentConfirmTimeout: PaymentConfirmTimeout
     comment: str
-    takerFilter: TakerFilter
+    takerFilter: TakerFilter | None = None
 
 
 class _AdNew(_BaseIn):
@@ -224,7 +230,7 @@ class _SaleInTrait:
     paymentDetailsIds: list[int]
 
 
-class _PurchaseInTrait:
+class _BuyInTrait:
     paymentMethodCodes: list[str]
 
 
@@ -234,77 +240,46 @@ class AdMakerNewSale(_AdNew, _SaleInTrait): ...
 class AdMakerUpdSale(_AdUpd, _SaleInTrait): ...
 
 
-class AdMakerNewPurchase(_AdNew, _PurchaseInTrait): ...
-
-
-class AdMakerUpdPurchase(_AdUpd, _PurchaseInTrait): ...
-
-
-# class _BaseInOutAd(BaseAd):
-#     type: Literal["PURCHASE", "SALE"]
-#     price: Price
-#     orderAmountLimits: OrderLimits  # cur/fiat
-#     paymentConfirmTimeout: Literal["PT3M", "PT15M", "PT30M"] | None = None  # sale?
-#
-#     @computed_field
-#     @property
-#     def is_sell(self) -> bool:
-#         return self.type == "SALE"
-#
-#
-# class MyAdEpydIn(_BaseInOutAd):
-#     comment: str = ""
-#     initVolume: InitVolume  # of asset
-#     orderRoundingRequired: bool
-#     paymentMethodCodes: list[str] | None = None  # purchase
-#     paymentDetailsIds: list[int] | None = None  # sale
-#
-#     @classmethod
-#     @model_validator(mode="before")
-#     def check_at_least_one_field(cls, values):
-#         if values.get("paymentMethodCodes") or values.get("paymentDetailsIds"):
-#             return values
-#         raise ValueError("paymentMethodCodes or paymentDetailsIds is required")
-#
-#
-# class _BaseAd(_BaseInOutAd):
-#     availableVolume: str  # of asset
-#     number: str
-#     orderVolumeLimits: OrderLimits  # coin/asset
-#     paymentDetails: list[FiatEpyd] | None = None  # SALE
-#     paymentMethods: list[PmEpydRoot] | None = None  # PURCHASE
-#
-#
-# class AdEpyd(_BaseAd):
-#     takerFilter: TakerFilter
-#     user: User
-#     orderConfirmationTimeout: Literal["PT3M", "PT15M"] | None = None  # purchase?
-#     orderAcceptTimeout: Literal["PT10M"] | None = None  # TAKER
-#
-#     @classmethod
-#     @model_validator(mode="before")
-#     def check_at_least_one_field(cls, values):
-#         if values.get("paymentMethods") or values.get("paymentDetails"):
-#             return values
-#         raise ValueError("paymentMethods or paymentDetails is required")
-#
-#
-# class MyAdEpyd(_BaseAd):
-#     availableVolume: AvailableVolume  # of asset
-#     status: Status
-#
-#
-# class _AllAdFullTrait:
-#     createDateTime: str
-#     changeLog: ChangeLog
-#     takerFilter: TakerFilter
-#     fee: Fee | None = None
-#     comment: str
-#
-#
-# class MyAdFullEpyd(MyAdEpyd, _AllAdFullTrait): ...
-#
-#
-# class AdFullEpyd(AdEpyd, _AllAdFullTrait):
-#     availableVolume: AvailableVolume  # of asset
-#     status: Status
+class AdMakerNewBuy(_AdNew, _BuyInTrait): ...
+
+
+class AdMakerUpdBuy(_AdUpd, _BuyInTrait): ...
+
+
+OrderStatus = Literal["ACTIVE", "DRAFT"]
+
+
+class OrderEpydIn(BaseOrder):
+    offerId: int
+    type: AdType
+    paymentDetailsId: int
+    amount: AvailableVolume
+
+
+class OrderEpyd(BaseModel):
+    id: int
+    number: str
+    seller: User
+    buyer: User
+    offerId: int
+    offerType: AdType
+    offerComment: str = ""
+    isExpress: bool
+    price: Price
+    paymentDetails: CredEpyd
+    volume: AvailableVolume
+    amount: AvailableVolume
+    feeVolume: AvailableVolume
+    paymentConfirmTimeout: PaymentConfirmTimeout
+    buyerSendingPaymentConfirmationTimeout: Literal["PT15M"]
+    createDateTime: str
+    statusUpdateDateTime: str
+    holdRestrictionsWillBeApplied: bool
+    status: OrderStatus
+    changeLog: ChangeLog
+    isAutoAccept: bool
+
+    @computed_field
+    @property
+    def is_sell(self) -> bool:
+        return self.offerType == "SALE"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.25.dev11
+Version: 0.0.25.dev19
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client