xync-client 0.0.93.dev29__tar.gz → 0.0.95.dev0__tar.gz

{xync_client-0.0.93.dev29/xync_client.egg-info → xync_client-0.0.95.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.93.dev29
+Version: 0.0.95.dev0
 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.93.dev29 → xync_client-0.0.95.dev0}/tests/TestAgent.py

@@ -3,7 +3,7 @@ import logging
 import pytest
 from tortoise.functions import Count
 from xync_schema.enums import ExStatus, ExAction, UserStatus
-from xync_schema.models import Ex, ExStat, Ad, Coin, Cur, Pmcur, Cred, CredEx, Actor, Person
+from xync_schema.models import Ex, ExStat, Ad, Coin, Cur, PmCur, Cred, CredEx, Actor, Person
 from xync_schema.xtype import BaseAd
 
 from xync_client.Abc.BaseTest import BaseTest
@@ -32,9 +32,9 @@ class TestAgent(BaseTest):
     # 26
     async def test_cred_new(self, clients: list[tuple[BaseAgentClient, BaseAgentClient]]):
         for maker, taker in clients:
-            pmcur = await Pmcur.filter(pm__pmexs__ex=taker.actor.ex, cur__ticker="RUB", pm__norm="payeer").first()
+            pmcur = await PmCur.filter(pm__pmexs__ex=taker.actor.ex, cur__ticker="RUB", pm__norm="payeer").first()
             cred = await Cred.create(person_id=taker.actor.person_id, name="Tst", detail="79990001234", pmcur=pmcur)
-            # await cred.banks.add(await PmexBank.get(exid="mts"), await PmexBank.get(exid="sberbankru"))
+            # await cred.banks.add(await PmExBank.get(exid="mts"), await PmExBank.get(exid="sberbankru"))
             cred_new: CredEx = await taker.cred_new(cred)
             ok = isinstance(cred_new, CredEx)
             t, _ = await ExStat.update_or_create({"ok": ok}, ex=taker.actor.ex, action=ExAction.cred_new)

{xync_client-0.0.93.dev29 → xync_client-0.0.95.dev0}/tests/TestEx.py

@@ -104,8 +104,8 @@ class TestEx(BaseTest):
     # 24
     async def test_ads(self, clients: list[BaseExClient]):
         for client in clients:
-            cur = await models.Curex.filter(cur__ticker="EUR", ex=client.ex).first().values_list("exid", flat=True)
-            coin = await models.Coinex.filter(coin__ticker="USDT", ex=client.ex).first().values_list("exid", flat=True)
+            cur = await models.CurEx.filter(cur__ticker="EUR", ex=client.ex).first().values_list("exid", flat=True)
+            coin = await models.CoinEx.filter(coin__ticker="USDT", ex=client.ex).first().values_list("exid", flat=True)
             ads: list[BaseAd] = await client.ads(coin, cur, False)
             ok = self.is_list_of_objects(ads, BaseAd)
             t, _ = await models.ExStat.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.ads)
@@ -123,10 +123,10 @@ class TestEx(BaseTest):
                 continue
             for race in races:
                 # получаем данные направления текущей гонки
-                coinex = await models.Coinex.get(ex=client.ex, coin_id=race.road.ad.pair_side.pair.coin_id)
-                curex = await models.Curex.get(ex=client.ex, cur_id=race.road.ad.pair_side.pair.cur_id)
+                coinex = await models.CoinEx.get(ex=client.ex, coin_id=race.road.ad.pair_side.pair.coin_id)
+                curex = await models.CurEx.get(ex=client.ex, cur_id=race.road.ad.pair_side.pair.cur_id)
                 pm_ids = [pm.id for pm in race.road.ad.pms]
-                pmex_exids = await models.Pmex.filter(ex=client.ex, pm_id__in=pm_ids).values_list("exid", flat=True)
+                pmex_exids = await models.PmEx.filter(ex=client.ex, pm_id__in=pm_ids).values_list("exid", flat=True)
                 # получаем объявления по этому направлению
                 ads = await client.ads(coinex.exid, curex.exid, race.road.ad.pair_side.is_sell, pmex_exids)
                 # if race.vm_filter:

{xync_client-0.0.93.dev29 → xync_client-0.0.95.dev0}/xync_client/Abc/Agent.py

@@ -128,5 +128,5 @@ class BaseAgentClient(HttpClient):
     #     credex_in = models.CredEx.validate({"exid": cred_in.id, "cred_id": cred_db.id})
     #     credex_db, _ = await models.CredEx.update_or_create(**credex_in.df_unq())
     #     if banks:  # only for SBP
-    #         await cred_db.banks.add(*[await PmexBank.get(exid=b) for b in banks])
+    #         await cred_db.banks.add(*[await PmExBank.get(exid=b) for b in banks])
     #     return True

{xync_client-0.0.93.dev29 → xync_client-0.0.95.dev0}/xync_client/Abc/Ex.py

@@ -36,7 +36,7 @@ class BaseExClient(HttpClient):
         super().__init__(getattr(ex, attr), headers, cookies, proxy and proxy.str())
 
     @abstractmethod
-    def pm_type_map(self, typ: models.Pmex) -> str: ...
+    def pm_type_map(self, typ: models.PmEx) -> str: ...
 
     # 19: Список поддерживаемых валют тейкера
     @abstractmethod
@@ -87,7 +87,7 @@ class BaseExClient(HttpClient):
     async def countries(self) -> list[Struct]:
         return []
 
-    # Импорт валют Cur-ов (с Curex-ами)
+    # Импорт валют Cur-ов (с CurEx-ами)
     async def set_curs(self, cookies: dict = None) -> bool:
         # Curs
         cur_pyds: dict[str, CurEx] = await self.curs()
@@ -96,14 +96,12 @@ class BaseExClient(HttpClient):
             for exid, cur_pyd in cur_pyds.items()
         }
         curexs = [
-            models.Curex(**c.model_dump(exclude_none=True), cur=curs[c.exid], ex=self.ex) for c in cur_pyds.values()
+            models.CurEx(**c.model_dump(exclude_none=True), cur=curs[c.exid], ex=self.ex) for c in cur_pyds.values()
         ]
-        # Curex
-        await models.Curex.bulk_create(
-            curexs, update_fields=["minimum", "rounding_scale"], on_conflict=["cur_id", "ex_id"]
-        )
+        # CurEx
+        await models.CurEx.bulk_create(curexs, update_fields=["minimum", "scale"], on_conflict=["cur_id", "ex_id"])
 
-    # Импорт Pm-ов (с Pmcur-, Pmex- и Pmcurex-ами) и валют (с Curex-ами) с биржи в бд
+    # Импорт Pm-ов (с PmCur-, PmEx- и Pmcurex-ами) и валют (с CurEx-ами) с биржи в бд
     async def set_pms(self, cookies: dict = None) -> bool:
         if cookies:
             self.session.cookie_jar.update_cookies(cookies)
@@ -134,19 +132,19 @@ class BaseExClient(HttpClient):
                 logging.warning(f"Pm: '{pmex.name}' duplicated with ids {prev[0]}: {k} on {self.ex.name}")
                 # новый Pm не добавляем, а берем старый с этим названием
                 pm_ = pms.get(prev[0], await models.Pm.get_or_none(norm=prev[1], country_id=country_id))
-                # и добавляем Pmex для него
-                await models.Pmex.update_or_create({"name": pmex.name}, ex=self.ex, exid=k, pm=pm_)
+                # и добавляем PmEx для него
+                await models.PmEx.update_or_create({"name": pmex.name}, ex=self.ex, exid=k, pm=pm_)
             elif (
                 prev[1] == pmu.norm and pmu.country == prev[3]
             ):  # 2 разных оригинальных имени на этой бирже совпали при нормализации
                 logging.error(
                     f"Pm: {pmex.name}&{prev[2]} overnormd as {pmu.norm} with ids {prev[0]}: {k} on {self.ex.name}"
                 )
-                # новый Pm не добавляем, только Pmex для него
+                # новый Pm не добавляем, только PmEx для него
                 # новый Pm не добавляем, а берем старый с этим названием
                 pm_ = pms.get(prev[0], await models.Pm.get_or_none(norm=prev[1], country_id=country_id))
-                # и добавляем.обновляем Pmex для него
-                await models.Pmex.update_or_create({"pm": pm_}, ex=self.ex, exid=k, name=pmex.name)
+                # и добавляем.обновляем PmEx для него
+                await models.PmEx.update_or_create({"pm": pm_}, ex=self.ex, exid=k, name=pmex.name)
             else:
                 pmin = models.Pm.validate({**pmu.model_dump(), "country_id": country_id, "typ": pmex.typ})
                 try:
@@ -154,14 +152,14 @@ class BaseExClient(HttpClient):
                 except (MultipleObjectsReturned, IntegrityError) as e:
                     raise e
             prev = k, pmu.norm, pmex.name, pmu.country
-        await models.Pmcur.update_or_create(  # todo: NA HU YA???
+        await models.PmCur.update_or_create(  # todo: NA HU YA???
             cur=await models.Cur.get(ticker="THB"), pm=await models.Pm.get(norm="cash in person")
         )
 
         # Pmexs
         async with ClientSession(headers=getattr(self, "logo_headers", None)) as ss:
             pmexs = [
-                models.Pmex(
+                models.PmEx(
                     # todo: refact logo
                     exid=k,
                     ex=self.ex,
@@ -172,13 +170,13 @@ class BaseExClient(HttpClient):
                 for k, pm in pms.items()
             ]
 
-        await models.Pmex.bulk_create(pmexs, on_conflict=["ex_id", "exid"], update_fields=["pm_id", "logo_id", "name"])
-        # Pmex banks
+        await models.PmEx.bulk_create(pmexs, on_conflict=["ex_id", "exid"], update_fields=["pm_id", "logo_id", "name"])
+        # PmEx banks
         for k, pmex in pmexs_epyds.items():
             if banks := pmex.banks:
-                pmex = await models.Pmex.get(ex=self.ex, exid=k)  # pm=pms[k],
+                pmex = await models.PmEx.get(ex=self.ex, exid=k)  # pm=pms[k],
                 for b in banks:
-                    await models.PmexBank.update_or_create({"name": b.name}, exid=b.exid, pmex=pmex)
+                    await models.PmExBank.update_or_create({"name": b.name}, exid=b.exid, pmex=pmex)
 
         cur2pms = await self.cur_pms_map()
         # # Link PayMethods with currencies
@@ -186,13 +184,13 @@ class BaseExClient(HttpClient):
         for cur_id, exids in cur2pms.items():
             for exid in exids:
                 if not (pm_id := pms.get(exid) and pms[exid].id):
-                    if pmex := await models.Pmex.get_or_none(ex=self.ex, exid=exid):
+                    if pmex := await models.PmEx.get_or_none(ex=self.ex, exid=exid):
                         pm_id = pmex.pm_id
                     else:
                         logging.critical(f"For cur {cur_id} not found pm#{exid}")
                         continue
                 if cur_db := curs.get(cur_id):
-                    pmcurs.add((await models.Pmcur.update_or_create(cur=cur_db, pm_id=pm_id))[0])
+                    pmcurs.add((await models.PmCur.update_or_create(cur=cur_db, pm_id=pm_id))[0])
         # pmcurexs = [Pmcurex(pmcur=pmcur, ex=self.ex) for pmcur in pmcurs]
         # await Pmcurex.bulk_create(pmcurexs)
         return True
@@ -206,7 +204,7 @@ class BaseExClient(HttpClient):
             return await self.file_upsert(url, ss)
         return file
 
-    # Импорт монет (с Coinex-ами) с биржи в бд
+    # Импорт монет (с CoinEx-ами) с биржи в бд
     async def set_coins(self):
         coins: dict[str, CoinEx] = await self.coins()
         coins_db: dict[int, models.Coin] = {
@@ -215,10 +213,10 @@ class BaseExClient(HttpClient):
             )[0]
             for c in coins.values()
         }
-        coinexs: list[models.Coinex] = [
-            models.Coinex(coin=coins_db[c.exid], ex=self.ex, exid=c.exid, minimum=c.minimum) for c in coins.values()
+        coinexs: list[models.CoinEx] = [
+            models.CoinEx(coin=coins_db[c.exid], ex=self.ex, exid=c.exid, minimum=c.minimum) for c in coins.values()
         ]
-        await models.Coinex.bulk_create(coinexs, update_fields=["minimum"], on_conflict=["coin_id", "ex_id"])
+        await models.CoinEx.bulk_create(coinexs, update_fields=["minimum"], on_conflict=["coin_id", "ex_id"])
         return True
 
     # Импорт пар биржи в бд

{xync_client-0.0.93.dev29 → xync_client-0.0.95.dev0}/xync_client/Abc/PmAgent.py

@@ -1,4 +1,6 @@
 from abc import abstractmethod, ABCMeta
+from asyncio import get_running_loop
+from datetime import datetime, timedelta
 from decimal import Decimal
 from enum import StrEnum
 
@@ -25,6 +27,8 @@ class PmAgentClient(metaclass=ABCMeta):
     bot: FileClient
     page: Page
     pages: type(StrEnum) = Pages
+    last_page: int = 0
+    last_active: datetime = datetime.now()
     _is_started: bool = False
 
     async def start(self, pw: Playwright, headed: bool = False) -> "PmAgentClient":
@@ -49,15 +53,18 @@ class PmAgentClient(metaclass=ABCMeta):
         if not self.page.url.startswith(self.pages.SEND):  # Если в итоге не удалось попасть на отправку
             await self.bot.send(self.norm + " not logged in!", self.uid, photo=await self.page.screenshot())
             raise LoginFailedException(f"User {self.agent.user_id} has not logged in")
-        # loop = get_running_loop()
-        # loop.create_task(self._idle())  # Бесконечно пасёмся в фоне на странице отправки, что бы куки не протухли
+        loop = get_running_loop()
+        self.last_active = datetime.now()
+        loop.create_task(self._idle())  # Бесконечно пасёмся в фоне на странице отправки, что бы куки не протухли
         self._is_started = True
         return self
 
     async def _idle(self):  # todo: не мешать другим процессам, обновлять на другой вкладке?
         while (await User.get(username_id=self.uid)).status >= UserStatus.ACTIVE:
-            await self.page.wait_for_timeout(30 * 1000)
-            await self.page.reload()
+            await self.page.wait_for_timeout(15 * 1000)
+            if self.last_active < datetime.now() - timedelta(seconds=20):
+                await self.page.reload()
+                self.last_active = datetime.now()
         await self.bot.send(self.norm + " stoped", self.uid)
         await self.stop()
 
@@ -75,7 +82,7 @@ class PmAgentClient(metaclass=ABCMeta):
     async def _login(self): ...
 
     @abstractmethod
-    async def send(self, dest, amount: int, cur: str) -> tuple[int, bytes]: ...
+    async def send(self, dest, amount: int, cur: str) -> tuple[int, bytes, float]: ...
 
     @abstractmethod  # проверка поступления определенной суммы за последние пол часа (минимум), return точную сумму
     async def check_in(self, amount: int | Decimal | float, cur: str, tid: str | int = None) -> float | None: ...

{xync_client-0.0.93.dev29 → xync_client-0.0.95.dev0}/xync_client/Abc/xtype.py

@@ -4,7 +4,7 @@ from pydantic import BaseModel, model_validator
 from x_model.types import BaseUpd
 from xync_schema.enums import PmType
 from xync_schema.models import Country, Pm, Ex
-from xync_schema.xtype import PmexBank
+from xync_schema.xtype import PmExBank
 
 from xync_client.pm_unifier import PmUni
 
@@ -17,7 +17,7 @@ MapOfIdsList = dict[int | str, list[int | str]]
 class PmTrait:
     typ: PmType | None = None
     logo: str | None = None
-    banks: list[PmexBank] | None = None
+    banks: list[PmExBank] | None = None
 
 
 class PmEx(BaseModel, PmTrait):

{xync_client-0.0.93.dev29 → xync_client-0.0.95.dev0}/xync_client/BingX/agent.py

@@ -2,7 +2,8 @@ from xync_client.Abc.Agent import BaseAgentClient
 from xync_schema.pydantic import FiatNew
 from xync_schema.models import Cur, Fiat
 from xync_client.Abc.Base import DictOfDicts
-from xync_schema.models import Cur, Coin, OrderStatus, Pmex, Fiat, Ad, Pmcur, Fiatex
+from xync_schema.models import Coin, OrderStatus
+
 
 class AgentClient(BaseAgentClient):
     headers = {
@@ -37,18 +38,20 @@ class AgentClient(BaseAgentClient):
     }
 
     # 0: Получшение заявок за заданное время, в статусе, по валюте, монете
-    async def get_orders(self, status: OrderStatus = OrderStatus.created, coin: Coin = None, cur: Cur = None, is_sell: bool = None):
+    async def get_orders(
+        self, status: OrderStatus = OrderStatus.created, coin: Coin = None, cur: Cur = None, is_sell: bool = None
+    ):
         params = {
-            'pageId': '0',
-            'pageSize': '10',
-            'messageStatus': '0',
-            'orderType': '1',
-            'orderStatus': '',
-            'fiat': '',
-            'searchKeyword': '',
-            'tradeType': '',
-            'beginTime': '1706475600000',
-            'endTime': '1738184399999',
+            "pageId": "0",
+            "pageSize": "10",
+            "messageStatus": "0",
+            "orderType": "1",
+            "orderStatus": "",
+            "fiat": "",
+            "searchKeyword": "",
+            "tradeType": "",
+            "beginTime": "1706475600000",
+            "endTime": "1738184399999",
         }
         order = await self._get("/api/c2c/v2/order/list", params=params)
         return order["data"]["result"]
@@ -56,14 +59,14 @@ class AgentClient(BaseAgentClient):
     # 1: [T] Запрос на старт сделки
     async def order_request(self, ad_id: int, amount: float):
         json_data = {
-            'advertNo': f'{ad_id}',
-            'asset': 'USDT',
-            'fiat': 'RUB',
-            'type': 1,
-            'userPrice': 103,
-            'areaType': 2,
-            'amount': f'{amount}',
-            'paymentMethodId': 110,
+            "advertNo": f"{ad_id}",
+            "asset": "USDT",
+            "fiat": "RUB",
+            "type": 1,
+            "userPrice": 103,
+            "areaType": 2,
+            "amount": f"{amount}",
+            "paymentMethodId": 110,
         }
         order = await self._post("/api/c2c/v1/order/create", json=json_data)
         if order["data"]:

{xync_client-0.0.93.dev29 → xync_client-0.0.95.dev0}/xync_client/Bybit/InAgent.py

@@ -2,7 +2,7 @@ import json
 import logging
 import re
 from datetime import datetime, timezone
-# from uuid import uuid4
+from uuid import uuid4
 
 import websockets
 from asyncio import run
@@ -10,6 +10,9 @@ from decimal import Decimal
 
 from playwright.async_api import async_playwright
 from pyro_client.client.file import FileClient
+from tortoise.transactions import in_transaction
+from xync_schema.models import CredEx
+
 from xync_client.Abc.PmAgent import PmAgentClient
 from xync_schema import models
 from xync_schema.enums import UserStatus, OrderStatus
@@ -89,17 +92,22 @@ class InAgentClient(BaseInAgentClient):
                                                 dest = order.paymentTermList[0].accountNo
                                                 if not re.match(r"^P\d{8,10}$", dest):
                                                     continue
-                                                await order_db.fetch_related("cred__pmcur__cur")
-                                                if order_db.status in (OrderStatus.created, OrderStatus.requested):
-                                                    await self.send_payment(order_db, dest)
-                                                ...
+                                                await order_db.fetch_related("ad__pair_side__pair", "cred__pmcur__cur")
+                                                await self.send_payment(order_db, dest)
                                         case StatusApi.wait_for_buyer:
                                             if upd.side == 0:  # ждем когда покупатель оплатит
                                                 if not (pmacdx := await self.get_pma_by_cdex(order)):
                                                     continue
                                                 pma, cdx = pmacdx
-                                                am, tid = pma.check_in(Decimal(order.amount), cdx.cred.pmcur.cur.ticker)
+                                                am, tid = pma.check_in(
+                                                    Decimal(order.amount),
+                                                    cdx.cred.pmcur.cur.ticker,
+                                                    datetime.fromtimestamp(float(order.createDate) / 1000),
+                                                )
                                                 if not tid:
+                                                    logging.info(
+                                                        f"Order {order.id} created at {order.createDate}, not paid yet"
+                                                    )
                                                     continue
                                                 t, is_new = await models.Transfer.update_or_create(
                                                     dict(
@@ -109,15 +117,26 @@ class InAgentClient(BaseInAgentClient):
                                                     order=order_db,
                                                     pmid=tid,
                                                 )
-                                                if is_new:
+                                                if not is_new:
+                                                    continue
+                                                await order_db.fetch_related("ad__pair_side__pair")
+                                                async with in_transaction():
+                                                    # добавляем остаток монеты
+                                                    ass = await models.Asset.get(
+                                                        addr__coin_id=order_db.ad.pair_side.pair.coin_id,
+                                                        addr__actor=self.agent_client.actor,
+                                                    )
+                                                    ass.free -= float(order_db.amount / order_db.ad.price)
+                                                    await ass.save(update_fields=["free"])
+                                                    # обновляем остаток валюты
+                                                    fiat = await models.Fiat.get(cred_id=order_db.cred_id)
+                                                    fiat.amount += order_db.amount
+                                                    await fiat.save(update_fields=["amount"])
+                                                    # отправляем деньги
                                                     self.agent_client.api.release_assets(orderId=upd.id)
                                                     logging.info(
                                                         f"Order {order.id} created, paid before #{tid}:{am} at {order.createDate}, and RELEASED at {datetime.now()}"
                                                     )
-                                                else:
-                                                    logging.info(
-                                                        f"Order {order.id} created at {order.createDate} but no paid yet"
-                                                    )
                                             elif upd.side == 1:  # я покупатель - ждем мою оплату
                                                 continue  # logging.warning(f"Order {order.id} PAID at {datetime.now()}: {int_am}")
                                             else:
@@ -173,7 +192,7 @@ class InAgentClient(BaseInAgentClient):
                                     upd = Receive.model_validate(data["data"])
                                     if order_db := await models.Order.get_or_none(
                                         exid=upd.orderId, ad__maker__ex=self.agent_client.actor.ex
-                                    ).prefetch_related("ad__pair_side", "cred__pmcur__cur"):
+                                    ).prefetch_related("ad__pair_side__pair", "cred__pmcur__cur"):
                                         im_taker = order_db.taker_id == self.agent_client.actor.id
                                         im_buyer = order_db.ad.pair_side.is_sell == im_taker
                                         if order_db.ad.auto_msg != upd.message and upd.roleType not in ("sys", "alarm"):
@@ -188,9 +207,7 @@ class InAgentClient(BaseInAgentClient):
                                             if not upd.message:
                                                 ...
                                             if im_buyer and re.match(r"^P\d{8,10}$", upd.message):
-                                                if order_db.status in (OrderStatus.created, OrderStatus.requested):
-                                                    await self.send_payment(order_db, upd.message)
-                                                ...
+                                                await self.send_payment(order_db, upd.message)
                                 case "READ":
                                     upd = Read.model_validate(data["data"])
                                     # if upd.status not in (StatusWs.created, StatusWs.canceled, 10, StatusWs.completed):
@@ -227,33 +244,53 @@ class InAgentClient(BaseInAgentClient):
                     if not upd:
                         logging.warning(data, "NOT PROCESSED UPDATE")
 
-    async def send_payment(self, order_db: models.Order, dest) -> tuple[PmAgentClient, models.CredEx]:
+    async def send_payment(self, order_db: models.Order, dest):
+        if order_db.status not in (OrderStatus.created, OrderStatus.requested):
+            return
         int_am = int(float(order_db.amount))
         pma, cur = await self.get_pma_by_pmex(order_db)
-        tid, img = await pma.send(dest=dest, amount=int_am, cur=cur)
-        t, is_new = await models.Transfer.update_or_create(
-            {"amount": int_am * 100},
-            order=order_db,
-            pmid=tid,
-        )
-        pmex = await models.Pmex.get(pm_id=order_db.cred.pmcur.pm_id, ex=self.agent_client.actor.ex)
-        credex = await models.CredEx.get(cred=order_db.cred, ex=self.agent_client.actor.ex)
-        self.agent_client.api.mark_as_paid(
-            orderId=str(order_db.exid),
-            paymentType=pmex.exid,  # pmex.exid
-            paymentId=str(credex.exid),  # credex.exid
-        )
-        order_db.status = OrderStatus.paid
-        order_db.payed_at = datetime.now(timezone.utc)
-        await order_db.save()
-        # models.Fiat.get()
-        # if res := self.agent_client.api.upload_chat_file(upload_file=f"tmp/{dest}.png").get('result'):
-        #     self.agent_client.api.send_chat_message(
-        #         orderId=str(order_db.exid), contentType="pic", message=res['url'], msgUuid=uuid4().hex
-        #     )
-        logging.warning(f"Order {order_db.exid} PAID at {datetime.now()}: {int_am}")
+        async with in_transaction():
+            # отмечаем ордер на бирже "оплачен"
+            pmex = await models.PmEx.get(pm_id=order_db.cred.pmcur.pm_id, ex=self.agent_client.actor.ex)
+            credex = await models.CredEx.get(cred=order_db.cred, ex=self.agent_client.actor.ex)
+            self.agent_client.api.mark_as_paid(
+                orderId=str(order_db.exid),
+                paymentType=pmex.exid,  # pmex.exid
+                paymentId=str(credex.exid),  # credex.exid
+            )
+            # проверяем не отправляли ли мы уже перевод по этому ордеру
+            if t := await models.Transfer.get_or_none(order=order_db, amount=int_am):
+                await pma.bot.send(f"Order# {order_db.exid}: Double send {int_am}{cur} to {dest} #{t.pmid}!")
+                raise Exception(f"Order# {order_db.exid}: Double send {int_am}{cur} to {dest} #{t.pmid}!")
+
+            # ставим в бд статус "оплачен"
+            order_db.status = OrderStatus.paid
+            order_db.payed_at = datetime.now(timezone.utc)
+            await order_db.save()
+            # добавляем остаток монеты
+            ass = await models.Asset.get(
+                addr__coin_id=order_db.ad.pair_side.pair.coin_id, addr__actor=self.agent_client.actor
+            )
+            ass.free += float(order_db.amount / order_db.ad.price)
+            await ass.save(update_fields=["free"])
+            # отправляем деньги
+            tid, img, rest_amount = await pma.send(dest=dest, amount=int_am, cur=cur)
+            # создаем перевод в бд
+            t, _ = await models.Transfer.update_or_create(
+                {"amount": int_am * 100},
+                order=order_db,
+                pmid=tid,
+            )
+            # обновляем остаток валюты
+            await models.Fiat.update_or_create({"amount": rest_amount}, cred_id=order_db.cred_id)
+            # отправляем продавцу чек
+            if res := self.agent_client.api.upload_chat_file(upload_file=f"tmp/{dest}.png").get("result"):
+                self.agent_client.api.send_chat_message(
+                    orderId=str(order_db.exid), contentType="pic", message=res["url"], msgUuid=uuid4().hex
+                )
+            logging.info(f"Order {order_db.exid} PAID at {datetime.now()}: {int_am}!")
 
-    async def get_pma_by_cdex(self, order: OrderFull) -> tuple[PmAgentClient, models.CredEx]:
+    async def get_pma_by_cdex(self, order: OrderFull) -> tuple[PmAgentClient | None, CredEx] | None:
         cdxs = await models.CredEx.filter(
             ex=self.agent_client.ex_client.ex,
             exid__in=[ptl.id for ptl in order.paymentTermList],
@@ -261,7 +298,7 @@ class InAgentClient(BaseInAgentClient):
         ).prefetch_related("cred__pmcur__cur")
         pmas = [pma for cdx in cdxs if (pma := self.pmacs.get(cdx.cred.pmcur.pm_id))]
         if not len(pmas):
-            logging.error(order.paymentTermList, f"No pm_agents for {order.paymentTermList[0].paymentType}")
+            raise Exception(order.paymentTermList, f"No pm_agents for {order.paymentTermList[0].paymentType}")
         elif len(pmas) > 1:
             logging.error(order.paymentTermList, f">1 pm_agents for {cdxs[0].cred.pmcur.pm_id}")
         else: