xync-client 0.0.164__py3-none-any.whl → 0.0.179.dev4__py3-none-any.whl

xync_client/Bybit/{InAgent.py → inAgent.py}

@@ -1,7 +1,7 @@
 from asyncio import create_task
-from bybit_p2p import P2P
 from pyro_client.client.file import FileClient
 from xync_bot import XyncBot
+from xync_client.Abc.InAgent import BaseInAgentClient
 from xync_schema.models import Agent
 
 from xync_client.Bybit.agent import AgentClient
@@ -9,16 +9,11 @@ from xync_client.Bybit.ex import ExClient
 
 from xync_schema import models
 
-from xync_client.Bybit.etype.order import (
-    OrderItem,
-)
+from xync_client.Bybit.etype.order import OrderItem
 
 
-class InAgentClient(AgentClient):
-    actor: models.Actor
-    agent: models.Agent
-    api: P2P
-    ex_client: ExClient
+class InAgentClient(BaseInAgentClient):
+    agent_client: AgentClient
 
     orders: dict[int, models.Order] = {}
 
@@ -33,4 +28,4 @@ class InAgentClient(AgentClient):
         self.orders = {o.exid: o for o in await models.Order.filter(exid__in=po.keys())}
         for oid in po.keys() - self.orders.keys():
             fo = self.api.get_order_details(orderId=oid)
-            self.orders[oid] = await self.create_order_db(fo)
+            self.orders[oid] = await self.order_save(fo)

xync_client/Bybit/order.py

@@ -1,28 +1,48 @@
-from xync_client.Bybit.etype.cred import PaymentTerm
-from xync_schema.models import CredEx, PmEx
+from asyncio import sleep
+
+from bybit_p2p._exceptions import FailedRequestError
+from xync_client.Bybit.agent import AgentClient
 
 from xync_client.Abc.Order import BaseOrderClient
 
 
 class OrderClient(BaseOrderClient):
-    # 5: Перевод сделки в состояние "оплачено", c отправкой чека
-    async def mark_payed(self, payterm: PaymentTerm = None, receipt: bytes = None):
-        if payterm:
-            pt = str(payterm.paymentType)
-            pid = payterm.id
-        else:
-            pmx = await PmEx.get(pm__pmcurs__id=self.order.cred.pmcur_id, ex=self.agent_client.ex_client.ex)
-            pt = pmx.exid
-            cdx = await CredEx.get(cred_id=self.order.cred_id, ex=self.agent_client.ex_client.ex)
-            pid = str(cdx.exid)
-        self.agent_client.api.mark_as_paid(orderId=str(self.order.exid), paymentType=pt, paymentId=pid)
+    agent_client: AgentClient
 
-    # 6: Отмена одобренной сделки
-    async def cancel_order(self) -> bool: ...
+    # 5: Перевод сделки в состояние "оплачено", c отправкой чека
+    async def _mark_payed(self, credex_exid: int = None, pmex_exid: int | str = None, receipt: bytes = None):
+        params = dict(orderId=str(self.order.exid), paymentType=str(pmex_exid), paymentId=str(credex_exid))
+        try:
+            self.agent_client.api.mark_as_paid(**params)
+        except FailedRequestError as e:
+            if e.status_code == 912100202:  # Server error, please try again later
+                await sleep(5, self.agent_client.api.mark_as_paid(**params))
+            else:
+                raise e
 
     # 7: Подтвердить получение оплаты
     async def confirm(self):
-        self.agent_client.api.release_assets(orderId=str(self.order.exid))
+        try:
+            res = self.agent_client.api.release_assets(orderId=str(self.order.exid))
+        except FailedRequestError as e:
+            if e.status_code == 912100202:  # Server error, please try again later
+                await sleep(5)
+                res = self.agent_client.api.release_assets(orderId=str(self.order.exid))
+            else:
+                raise e
+        return res
+
+    # 6: Отмена одобренной сделки
+    async def cancel(self) -> bool: ...
+
+    # 6: Запрос отмены (оплаченная контрагентом продажа)
+    async def cancel_request(self) -> bool: ...
+
+    # 6: Одобрение запроса на отмену (оплаченная мной покупка)
+    async def cancel_accept(self) -> bool:
+        data = {"orderId": str(self.order.exid), "examineResult": "PASS"}
+        res = await self.agent_client._post("/x-api/fiat/otc/order/buyer/examine/sellerCancelOrderApply", data)
+        return res["ret_code"] == 0
 
     # 9, 10: Подать аппеляцию cо скриншотом/видео/файлом
     async def start_appeal(self, file) -> bool: ...
@@ -33,6 +53,12 @@ class OrderClient(BaseOrderClient):
     # 15: Отмена аппеляции
     async def cancel_appeal(self) -> bool: ...
 
+    async def appeal_accept(self) -> bool:
+        data = {"orderId": str(self.order.exid)}
+        # Принять аппеляцию: я покупатель, прожал оплачено, продавец оспорил, я согл, ордер отменился
+        res = await self.agent_client._post("/x-api/fiat/otc/order/cancelAfterCustomerNegotiation", data)
+        return res["ret_code"] == 0
+
     # 16: Отправка сообщения юзеру в чат по ордеру с приложенным файлом
     async def send_order_msg(self, msg: str, file=None) -> bool: ...
 

xync_client/Gate/ex.py

@@ -94,11 +94,11 @@ async def main():
     _ = await init_db(TORM, True)
     gt = await Ex.get(name="Gate")
     async with FileClient(NET_TOKEN) as b:
-        cl = ExClient(gt, b)
+        cl = ExClient(gt)
         await cl.set_pairs()
         pms = await cl.set_coins()
         pms = await cl.cur_pms_map()
-        pms = await cl.set_pms()
+        pms = await cl.set_pms(b)
         pms = await cl.set_coins()
         pms = await cl.set_curs()
         _ads = await cl.ads("USDT", "RUB", True, ["payeer"], 1000)

xync_client/Htx/agent.py

@@ -4,14 +4,12 @@ from time import time
 from urllib.parse import quote
 
 from aiohttp import ClientResponse
-from pyro_client.client.file import FileClient
 from x_client import df_hdrs
 from x_client.aiohttp import Client
-from xync_bot import XyncBot
 
-from xync_client.Abc.xtype import AdUpd, GetAds
+from xync_client.Abc.xtype import AdUpdReq, GetAdsReq
 from xync_client.Htx.etype.order import OrderItem, OrderFull
-from xync_client.loader import NET_TOKEN, PAY_TOKEN, TORM
+from xync_client.loader import TORM
 
 from xync_schema.enums import AdStatus, PmType, OrderStatus
 from xync_schema import models
@@ -47,9 +45,9 @@ class AgentClient(BaseAgentClient):
                 await self.agent.save(update_fields=["auth"])
                 self.session.headers["Token"] = resp["data"]
 
-    async def creds(self) -> list[test.CredEpyd]:
+    async def get_creds(self) -> list[test.BaseCredEpyd]:
         resp = await self._get("/-/x/otc/v1/user/receipt-account")
-        return [test.CredEpyd(**cred) for cred in resp["data"]]
+        return [test.BaseCredEpyd(**cred) for cred in resp["data"]]
 
     async def cred_del(self, cred_id: int) -> int:
         data = {"id": str(cred_id), "password": self.actor.agent.auth["password"]}
@@ -161,7 +159,7 @@ class AgentClient(BaseAgentClient):
     async def fiat_del(self, fiat_id: int) -> bool:
         pass
 
-    async def my_ads(self) -> list[dict]:
+    async def get_my_ads(self) -> list[dict]:
         res = await self._get(url_my_ads)
         ads: [] = res["data"]
         if (pages := res["totalPage"]) > 1:
@@ -184,7 +182,7 @@ class AgentClient(BaseAgentClient):
     ) -> models.Ad:
         pass
 
-    async def x2e_req_ad_upd(self, xreq: AdUpd) -> ad.AdsUpd:
+    async def x2e_req_ad_upd(self, xreq: AdUpdReq) -> ad.AdsUpd:
         creds = [
             ad.TradeRule(
                 content="Payment method-%s",
@@ -309,10 +307,9 @@ class AgentClient(BaseAgentClient):
 async def _test():
     from x_model import init_db
 
-    cn = await init_db(TORM, True)
+    _cn = await init_db(TORM, True)
     ex = await models.Ex[9]
-    filebot = FileClient(NET_TOKEN)
-    ecl = ex.client(filebot)
+    ecl = ex.client()
     agent = (
         await models.Agent.filter(actor__ex=ex, auth__isnull=False)
         .prefetch_related(
@@ -324,17 +321,17 @@ async def _test():
         )
         .first()
     )
-    cl: AgentClient = agent.client(ecl, filebot, XyncBot(PAY_TOKEN, cn))
+    cl: AgentClient = agent.client(ecl)
     # cred = await models.Cred[89]
     # _ = await cl.cred_new(cred)
     # _creds = await cl.creds()
     # _ = await cl.cred_del(16984748)
 
     while True:
-        breq = GetAds(coin_id=1, cur_id=1, is_sell=False, pm_ids=[366])
-        sreq = GetAds(coin_id=1, cur_id=1, is_sell=True, pm_ids=[366])
-        breq_upd = AdUpd(id=1185713, price=87.01, **{**breq.model_dump(), "amount": 100000.01})
-        sreq_upd = AdUpd(id=1188929, price=98.99, **{**sreq.model_dump(), "amount": 200000.01})
+        breq = GetAdsReq(coin_id=1, cur_id=1, is_sell=False, pm_ids=[366])
+        sreq = GetAdsReq(coin_id=1, cur_id=1, is_sell=True, pm_ids=[366])
+        breq_upd = AdUpdReq(id=1185713, price=87.01, **{**breq.model_dump(), "amount": 100000.01})
+        sreq_upd = AdUpdReq(id=1188929, price=98.99, **{**sreq.model_dump(), "amount": 200000.01})
 
         bads: list[ad.Resp] = await cl.ex_client.ads(breq)
         sads: list[ad.Resp] = await cl.ex_client.ads(sreq)

xync_client/Htx/etype/ad.py

@@ -1,9 +1,7 @@
 from typing import Literal
-
 from pydantic import BaseModel, RootModel
-from xync_schema.xtype import BaseAd
 
-from xync_client.Abc.xtype import BaseAdUpdate
+from xync_client.Abc.xtype import BaseAd
 
 
 class TradeRule(BaseModel):
@@ -21,7 +19,7 @@ class TradeRule(BaseModel):
 TradeRulesV2 = RootModel[list[TradeRule]]
 
 
-class AdsUpd(BaseAdUpdate):
+class AdsUpd(BaseAd):
     tradeType: int
     coinId: int
     currency: int

xync_client/Htx/etype/test.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel, Field
-from xync_client.Abc.xtype import CredExOut
+from xync_client.Abc.xtype import BaseCredEx
 
 
 class ModelField(BaseModel):
@@ -15,7 +15,7 @@ class ModelField(BaseModel):
     value: str | None
 
 
-class CredEpyd(CredExOut):
+class BaseCredEpyd(BaseCredEx):
     id: int
     uid: int
     userName: str
@@ -34,13 +34,13 @@ class CredEpyd(CredExOut):
     payMethodName: str
 
 
-class CredExId(CredExOut):
+class BaseCredExId(BaseCredEx):
     id: int = Field(validation_alias="bankId")
 
 
 class Result(BaseModel):
     code: int
-    data: CredExId
+    data: BaseCredExId
     extend: str | None = None
     message: str
     success: bool

xync_client/Htx/ex.py

@@ -9,7 +9,7 @@ from xync_schema.models import Ex, Cur
 from xync_schema.enums import PmType
 
 from xync_client.Abc.Ex import BaseExClient
-from xync_client.Abc.xtype import PmEx, MapOfIdsList, GetAds
+from xync_client.Abc.xtype import PmEx, MapOfIdsList, GetAdsReq
 from xync_client.Htx.etype import pm, Country, ad
 from xync_client.loader import NET_TOKEN
 from xync_client.loader import TORM
@@ -42,7 +42,7 @@ class ExClient(BaseExClient):
                         pair[rcurs[cur["name"]]] += [coen]
         return tuple(pairs.values())
 
-    async def x2e_req_ads(self, xreq: GetAds) -> ad.AdsReq:
+    async def x2e_req_ads(self, xreq: GetAdsReq) -> ad.AdsReq:
         coin_id, _ = await self.x2e_coin(xreq.coin_id)
         cur_id, _, __ = await self.x2e_cur(xreq.cur_id)
         ereq = ad.AdsReq(
@@ -106,7 +106,39 @@ class ExClient(BaseExClient):
     # 22: Список платежных методов по каждой валюте
     async def cur_pms_map(self) -> dict[int, set[int]]:
         res = await self.data
-        wrong_pms = {4, 34, 498, 548, 20009, 20010}  # , 212, 239, 363  # these ids not exist in pms
+        wrong_pms = {
+            4,
+            34,
+            498,
+            548,
+            20009,
+            20010,
+            10015,
+            20005,
+            20008,
+            10000,
+            10001,
+            10002,
+            10004,
+            20001,
+            20002,
+            20003,
+            20004,
+            20005,
+            20006,
+            20007,
+            10003,
+            10005,
+            10006,
+            10007,
+            10008,
+            10009,
+            10010,
+            10011,
+            10012,
+            10013,
+            10014,
+        }  # , 212, 239, 363  # these ids not exist in pms
         return {c["currencyId"]: set(c["supportPayments"]) - wrong_pms for c in res["currency"] if c["supportPayments"]}
 
     # 23: Список торгуемых монет
@@ -156,9 +188,9 @@ async def main():
     ex = await Ex.get(name="Htx")
     async with FileClient(NET_TOKEN) as b:
         b: FileClient
-        cl = ExClient(ex, b)
+        cl = ExClient(ex)
         await cl.set_curs()
-        await cl.set_pms()
+        await cl.set_pms(b)
         await cl.set_coins()
         await cl.set_pairs()
         # _pms = await cl.pms()

xync_client/KuCoin/ex.py

@@ -81,8 +81,8 @@ async def main():
     _ = await init_db(TORM, True)
     bg = await models.Ex.get(name="KuCoin")
     async with FileClient(NET_TOKEN) as b:
-        cl: ExClient = bg.client(b)
-        await cl.set_pms()
+        cl = ExClient(bg)
+        await cl.set_pms(b)
         await cl.set_coins()
         await cl.set_pairs()
 

xync_client/Mexc/agent.py

@@ -7,17 +7,16 @@ from uuid import uuid4
 
 import websockets
 from blackboxprotobuf import protobuf_to_json
-from pyro_client.client.file import FileClient
 from xync_bot import XyncBot
 
 from xync_client.Mexc.api import MEXCP2PApiClient
 from xync_client.Mexc.etype import ad
 
-from xync_client.Abc.xtype import GetAds, AdUpd
+from xync_client.Abc.xtype import GetAdsReq, AdUpdReq
 from xync_client.Bybit.etype.order import TakeAdReq
 from xync_client.Mexc.etype.order import OrderDetail
 
-from xync_client.loader import PAY_TOKEN, NET_TOKEN
+from xync_client.loader import PAY_TOKEN
 from xync_schema import models
 from xync_schema.enums import UserStatus, AgentStatus
 
@@ -114,7 +113,7 @@ class AgentClient(BaseAgentClient):
         res = await self._post("/api/platform/p2p/api/order/deal?mhash=" + auth["mhash"], data=auth | data, hdrs=hdrs)
         return res["data"]
 
-    async def x2e_req_ad_upd(self, xreq: AdUpd) -> ad.AdUpd:
+    async def x2e_req_ad_upd(self, xreq: AdUpdReq) -> ad.AdUpd:
         coin_id, coin_scale = await self.ex_client.x2e_coin(xreq.coin_id)
         cur_id, cur_scale, minimum = await self.ex_client.x2e_cur(xreq.cur_id)
         ereq = ad.AdUpd(
@@ -161,27 +160,26 @@ async def main():
         .first()
     )
     bbot = XyncBot(PAY_TOKEN, cn)
-    fbot = FileClient(NET_TOKEN)
-    ecl = ex.client(fbot)
-    cl: AgentClient = agent.client(ecl, fbot, bbot)
+    ecl = ex.client()
+    cl: AgentClient = agent.client(ecl)
     cl.api = MEXCP2PApiClient(agent.auth["key"], agent.auth["sec"])
     create_task(cl.ws_prv())
 
     while True:
         bceil = 106
         sceil = 124.98
-        breq = GetAds(coin_id=1, cur_id=1, is_sell=False, pm_ids=[366])
-        sreq = GetAds(coin_id=1, cur_id=1, is_sell=True, pm_ids=[366])
-        breq_upd = AdUpd(
+        breq = GetAdsReq(coin_id=1, cur_id=1, is_sell=False, pm_ids=[366])
+        sreq = GetAdsReq(coin_id=1, cur_id=1, is_sell=True, pm_ids=[366])
+        breq_upd = AdUpdReq(
             id="a1574183931501582340", price=87, **{**breq.model_dump(), "amount": 11000.01}, max_amount=4370
         )  # + 1 cent
-        sreq_upd = AdUpd(id="a1594624084590445568", price=150, **{**sreq.model_dump(), "amount": 30000.01})
+        sreq_upd = AdUpdReq(id="a1594624084590445568", price=150, **{**sreq.model_dump(), "amount": 30000.01})
 
         await sleep(5)
         bads: list[ad.Ad] = await cl.ex_client.ads(breq)
         if bads[0].price >= sceil:
             bad: ad.Ad = bads.pop(0)
-            await cl.bbot.send(
+            await bbot.send(
                 193017646,
                 f"price: {bad.price}\nnick: {bad.merchant.nickName}\nmax:{bad.maxPayLimit}"
                 f"\nqty: {bad.availableQuantity} [{bad.minTradeLimit}-{bad.maxTradeLimit}]",
@@ -219,7 +217,7 @@ async def main():
         sads: list[ad.Ad] = await cl.ex_client.ads(sreq)
         if sads[0].price <= bceil:
             sad: ad.Ad = sads.pop(0)
-            await cl.bbot.send(
+            await bbot.send(
                 193017646,
                 f"price: {sad.price}\nnick: {sad.merchant.nickName}\nmax:{sad.maxPayLimit}"
                 f"\nqty: {sad.availableQuantity} [{sad.minTradeLimit}-{sad.maxTradeLimit}]",

xync_client/Mexc/ex.py

@@ -6,7 +6,7 @@ import requests
 from xync_client.loader import TORM, NET_TOKEN
 
 from xync_client.Abc.Ex import BaseExClient
-from xync_client.Abc.xtype import PmEx, MapOfIdsList, GetAds
+from xync_client.Abc.xtype import PmEx, MapOfIdsList, GetAdsReq
 from xync_client.Mexc.etype import pm, ad
 
 from xync_schema import xtype
@@ -77,7 +77,7 @@ class ExClient(BaseExClient):
                 self.pm_x2e[xid] = (await models.PmEx.get(**fltr)).exid
         return self.pm_x2e[xid]
 
-    async def x2e_req_ads(self, xreq: GetAds) -> ad.AdsReq:
+    async def x2e_req_ads(self, xreq: GetAdsReq) -> ad.AdsReq:
         coin_id, _ = await self.x2e_coin(xreq.coin_id)
         cur_id, _, __ = await self.x2e_cur(xreq.cur_id)
         ereq = ad.AdsReq(
@@ -101,11 +101,11 @@ class ExClient(BaseExClient):
 
 async def main():
     _ = await init_db(TORM)
-    async with FileClient(NET_TOKEN) as b:
+    async with FileClient(NET_TOKEN):
         ex = await Ex.get(name="Mexc")
-        cl: ExClient = ex.client(b)
+        cl = ExClient(ex)
         # await ex.curexs.filter(cur__ticker="EUR")
-        # await cl.set_pms()
+        # await cl.set_pms(b)
         # await cl.set_coinexs()
         coinex = await models.CoinEx.get(ex=cl.ex, coin_id=1)
         _ads = await cl.ads(coinex.exid, "RUB", True, ["5"])

xync_client/Okx/agent.py

@@ -1,13 +1,9 @@
-from pyro_client.client.file import FileClient
-from xync_bot import XyncBot
-
 from xync_client.Abc.Agent import BaseAgentClient
 from asyncio import run
 from x_model import init_db
 from xync_schema.models import Agent, Ex
 
 from xync_client.Okx.ex import ExClient
-from xync_client.loader import NET_TOKEN, PAY_TOKEN
 
 
 class AgentClient(BaseAgentClient):
@@ -22,13 +18,11 @@ class AgentClient(BaseAgentClient):
 async def main():
     from xync_client.loader import TORM
 
-    cn = await init_db(TORM)
+    _cn = await init_db(TORM)
     ex = await Ex.get(name="Okx")
     agent = await Agent.get(actor__ex=ex).prefetch_related("actor__ex", "actor__person__user__gmail")
-    fbot = FileClient(NET_TOKEN)
-    ecl: ExClient = ex.client(fbot)
-    abot = XyncBot(PAY_TOKEN, cn)
-    cl = agent.client(ecl, fbot, abot)
+    ecl: ExClient = ex.client()
+    cl = agent.client(ecl)
 
     _fiats = await cl.my_fiats()
 

xync_client/Okx/ex.py

@@ -102,16 +102,17 @@ class ExClient(BaseExClient):
 async def main():
     _ = await init_db(TORM)
     bg = await models.Ex.get(name="Okx")
-    cl = ExClient(bg, FileClient(NET_TOKEN))
-    await cl.ads("USDT", "EUR", True)
-    # curs = await cl.curs()
-    # coins = await cl.coins()
-    await cl.pms()
-    await cl.cur_pms_map()
-    await cl.pairs()
-    await cl.set_coins()
-    await cl.set_pms()
-    await cl.close()
+    async with FileClient(NET_TOKEN) as b:
+        cl = ExClient(bg)
+        await cl.ads("USDT", "EUR", True)
+        # curs = await cl.curs()
+        # coins = await cl.coins()
+        await cl.pms()
+        await cl.cur_pms_map()
+        await cl.pairs()
+        await cl.set_coins()
+        await cl.set_pms(b)
+        await cl.close()
 
 
 if __name__ == "__main__":

xync_client/TgWallet/agent.py

@@ -10,7 +10,7 @@ from xync_client.TgWallet.ex import ExClient
 from xync_schema import models
 
 from xync_client.TgWallet.pyd import (
-    CredEpyd,
+    BaseCredEpyd,
     Attrs,
     AttrsV2,
     OneAdTakerMakerSale,
@@ -36,7 +36,7 @@ from xync_schema.enums import AdStatus, UserStatus, OrderStatus
 
 from xync_client.Abc.Base import ListOfDicts
 from xync_client.TgWallet.auth import AuthClient
-from xync_schema.xtype import BaseAdIn, AdBuyIn, AdSaleIn, OrderIn
+from xync_schema.xtype import BaseAd, AdBuy, AdSale, OrderIn
 
 from xync_client.Abc.Agent import BaseAgentClient
 
@@ -110,21 +110,21 @@ class AgentClient(BaseAgentClient, AuthClient):
             offerId=base_req.ad_id, type="SALE" if base_req.is_sell else "BUY", paymentDetailsId=credex.exid
         )
         ad = await models.Ad.get(exid=base_req.ad_id).prefetch_related(
-            "direction__pairex__pair__cur" if base_req.fiat_amount else "direction__pairex__pair__coin"
+            "direction__pairex__pair__cur" if base_req.amount else "direction__pairex__pair__coin"
         )
         amount = AvailableAmountVolume(
             currencyCode=ad.direction.pairex.pair.cur.ticker
-            if base_req.fiat_amount
+            if base_req.amount
             else ad.direction.pairex.pair.coin.ticker,
-            amount=str(base_req.fiat_amount if base_req.fiat_amount else base_req.asset_amount),
+            amount=str(base_req.amount if base_req.amount else base_req.quantity),
         )
         req = (
             OrderAmountReq(**common.model_dump(), amount=amount)
-            if base_req.fiat_amount
+            if base_req.amount
             else OrderVolumeReq(**common.model_dump(), volume=amount)
         )
         request = await self._post(
-            f"/p2p/public-api/v2/offer/order/create-by-{'amount' if base_req.fiat_amount else 'volume'}",
+            f"/p2p/public-api/v2/offer/order/create-by-{'amount' if base_req.amount else 'volume'}",
             req.model_dump(exclude_none=True),
         )
         if r := request.get("data"):
@@ -170,8 +170,8 @@ class AgentClient(BaseAgentClient, AuthClient):
 
     # # # CREDS # # #
     @staticmethod
-    def fiat_args2ex_pyd(exid: int | str, cur: str, detail: str, name: str, typ: str, extra=None) -> CredEpyd:
-        cred = CredEpyd(
+    def fiat_args2ex_pyd(exid: int | str, cur: str, detail: str, name: str, typ: str, extra=None) -> BaseCredEpyd:
+        cred = BaseCredEpyd(
             paymentMethodCode=exid,
             currencyCode=cur,
             name=name,
@@ -201,11 +201,11 @@ class AgentClient(BaseAgentClient, AuthClient):
         }
 
     # 25: Список реквизитов моих платежных методов
-    async def creds(self) -> list[CredEpyd]:
+    async def get_creds(self) -> list[BaseCredEpyd]:
         resp = await self._post("/p2p/public-api/v3/payment-details/get/by-user-id")
-        return [CredEpyd(**cred) for cred in resp["data"]]
+        return [BaseCredEpyd(**cred) for cred in resp["data"]]
 
-    async def cred_epyd2db(self, cred: CredEpyd) -> models.CredEx:
+    async def cred_epyd2db(self, cred: BaseCredEpyd) -> models.CredEx:
         if not (pmex := await models.PmEx.get_or_none(exid=cred.paymentMethod.code, ex=self.ex_client.ex)):
             raise HTTPException(f"No PmEx {cred.paymentMethod.code} on ex#{self.ex_client.ex.name}", 404)
         if not (pmcur := await models.PmCur.get_or_none(cur__ticker=cred.currency, pm_id=pmex.pm_id)):
@@ -229,8 +229,8 @@ class AgentClient(BaseAgentClient, AuthClient):
         return credex_db
 
     # 25: Список реквизитов моих платежных методов
-    async def set_creds(self) -> list[models.CredEx]:
-        creds_epyd: list[CredEpyd] = await self.creds()
+    async def load_creds(self) -> list[models.CredEx]:
+        creds_epyd: list[BaseCredEpyd] = await self.creds()
         credexs: list[models.CredEx] = [await self.cred_epyd2db(f) for f in creds_epyd]
         return credexs
 
@@ -272,7 +272,7 @@ class AgentClient(BaseAgentClient, AuthClient):
         else:
             hdrs = {}
         add_cred = await self._post("/p2p/public-api/v3/payment-details/create", cred_new, headers=hdrs)
-        cred_epyd = CredEpyd(**add_cred["data"])
+        cred_epyd = BaseCredEpyd(**add_cred["data"])
         return await self.cred_epyd2db(cred_epyd)
 
     # 27: Редактирование реквизита моего платежного метода
@@ -298,7 +298,7 @@ class AgentClient(BaseAgentClient, AuthClient):
             "x-wallet-device-serial": self.actor.agent.auth["ds"],
         }
         edit_cred = await self._post("/p2p/public-api/v3/payment-details/edit", cred_upd, headers=hdrs)
-        cred_epyd = CredEpyd(**edit_cred["data"])
+        cred_epyd = BaseCredEpyd(**edit_cred["data"])
         return await self.cred_epyd2db(cred_epyd)
 
     # 28: Удаление реквизита моего платежного метода
@@ -310,19 +310,19 @@ class AgentClient(BaseAgentClient, AuthClient):
         else:
             logging.error(res)
 
-    async def ad_epyd2pydin(self, ad_: OneAdTakerMakerSale | OneAdMakerBuy | OneAdTakerBuy) -> AdBuyIn | AdSaleIn:
-        ad_in: BaseAdIn = await self.ex_client.ad_common_epyd2pydin(ad_)
+    async def ad_epyd2pydin(self, ad_: OneAdTakerMakerSale | OneAdMakerBuy | OneAdTakerBuy) -> AdBuy | AdSale:
+        ad_in: BaseAd = await self.ex_client.ad_common_epyd2pydin(ad_)
         ad_in.maker_id = self.actor.id
         if isinstance(ad_, _PmsTrait):
-            return AdBuyIn(
+            return AdBuy(
                 **ad_in.model_dump(),
                 pmexs_=await models.PmEx.filter(ex=self.ex_client.ex, exid__in=[p.code for p in ad_.paymentMethods]),
             )
         credsexs: list[models.CredEx] = [await self.cred_epyd2db(c) for c in ad_.paymentDetails]
-        return AdSaleIn(**ad_in.model_dump(), credexs_=credsexs)
+        return AdSale(**ad_in.model_dump(), credexs_=credsexs)
 
     # 29: Список моих объявлений
-    async def my_ads(self, status: AdStatus = None) -> list[AdMakerBuy | AdMakerSale]:
+    async def get_my_ads(self, status: AdStatus = None) -> list[AdMakerBuy | AdMakerSale]:
         def model(ad: dict) -> (AdMakerBuy | AdMakerSale).__class__:
             return AdMakerSale if ad["type"] == "SALE" else AdMakerBuy