xync-client 0.0.3__tar.gz → 0.0.7.dev0__tar.gz

{xync_client-0.0.3/xync_client.egg-info → xync_client-0.0.7.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xync-client
-Version: 0.0.3
+Version: 0.0.7.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.3/tests/test_wallet.py → xync_client-0.0.7.dev0/tests/wallet/test_agent.py

@@ -2,14 +2,12 @@ from asyncio import AbstractEventLoop, get_running_loop
 
 import pytest
 import uvloop
-from tortoise import connections
 from tortoise.backends.asyncpg import AsyncpgDBClient
 from x_model import init_db
 from xync_schema import models
 from xync_schema.models import Agent, ExAction, TestEx
 
-from xync_client.TgWallet.p2p import AgentClient
-from xync_client.TgWallet.pub import PublicClient
+from xync_client.TgWallet.agent import AgentClient
 from xync_client.loader import DSN
 
 
@@ -24,8 +22,7 @@ class TestWallet:
     @pytest.fixture(scope="class")
     async def cn(self) -> AsyncpgDBClient:
         TestWallet.loop = get_running_loop()
-        await init_db(DSN, models, True)
-        cn: AsyncpgDBClient = connections.get("default")
+        cn: AsyncpgDBClient = await init_db(DSN, models, True)
         yield cn
         await cn.close()
 
@@ -36,47 +33,15 @@ class TestWallet:
         yield tg
         await tg.close()
 
-    @pytest.fixture(scope="class")
-    async def pc(self, cn) -> PublicClient:
-        agent = await Agent.get(user_id=1038938370).prefetch_related("ex")
-        tg = PublicClient(agent)
-        yield tg
-        await tg.close()
-
-    # # 5 - fiats
-    # async def test_fiats(self, ac):
-    #     fiats = await ac.my_fiats()
-    #     await TestEx.update_or_create({"ok": fiats['status'] == 'SUCCESS'}, ex__name=ac.agent.ex.name, action=ExAction.fiats)
-    #     assert fiats['status'] == 'SUCCESS', "Failed to get fiats"
-
-    # 1 - all_curs
-    async def test_all_curs(self, pc):
-        curs = await pc.curs()
-        await TestEx.update_or_create({"ok": bool(curs)}, ex__name="TgWallet", action=ExAction.all_curs_taker)
-        assert curs, "No data"
+    # 25 - fiats
+    async def test_fiats(self, ac):
+        fiats = await ac.my_fiats()
+        await TestEx.update_or_create(
+            {"ok": fiats["status"] == "SUCCESS"}, ex__name=ac.agent.ex.name, action=ExAction.fiats
+        )
+        assert fiats["status"] == "SUCCESS", "Failed to get fiats"
 
-    # 2 - all_coins
-    async def test_all_coins(self, pc):
-        coins = await pc.coins()
-        await TestEx.update_or_create({"ok": bool(coins)}, ex__name="TgWallet", action=ExAction.all_coins)
-        assert coins, "No data"
-
-    # 3 - all_pms
-    async def test_all_pms(self, pc):
-        pms = await pc.pms()
-        await TestEx.update_or_create({"ok": bool(pms)}, ex__name="TgWallet", action=ExAction.all_pms)
-        assert pms, "No data"
-
-    # # 4 - all_ads
-    # async def test_cur_filter(self, pc):
-    #     for cur in 'RUB', 'AZN', 'GEL':
-    #         for coin in 'TON', 'USDT', 'BTC':
-    #             for tt in 'SALE', 'PURCHASE':
-    #                 ads = await pc.get_ads(coin, cur, tt)
-    #                 assert len(ads), "No data"
-    #     await TestEx.update_or_create({"ok": bool(ads)}, ex__name="TgWallet", action=ExAction.all_ads)
-    #
-    # # 6 - fiat_new
+    # # 26 - fiat_new
     # async def test_fiat_new(self, ac):
     #     pms = await ac.all_pms()
     #     add_pm = await ac.fiat_new(pms[0]['code'], 'RUB', pms[0]['name'], '123456789098765')
@@ -84,7 +49,7 @@ class TestWallet:
     #                                   action=ExAction.fiat_new)
     #     assert add_pm['status'] == 'SUCCESS', "Failed to create"
     #
-    # # 7 - fiat_edit
+    # # 27 - fiat_edit
     # async def test_fiat_edit(self, ac):
     #     editid = await ac.fiats()
     #     pms = await ac.all_pms()
@@ -93,19 +58,19 @@ class TestWallet:
     #                                   action=ExAction.fiat_upd)
     #     assert add_pm['status'] == 'SUCCESS', "Failed to edit"
     #
-    # # 8 - fiat_del
+    # # 28 - fiat_del
     # async def test_fiat_del(self, ac):
     #     delid = await ac.fiats()
     #     dl = await ac.fiat_del(delid['data'][0]['id'])
     #     await TestEx.update_or_create({"ok": dl['status'] == 'SUCCESS'}, ex__name="TgWallet", action=ExAction.fiat_del)
     #     assert dl['status'] == "SUCCESS", "Fiat doesn't delete"
     #
-    # # 9 - my_ads
+    # # 29 - my_ads
     # async def test_my_ads(self, ac):
     #     ads = await ac.my_ads()
     #     await TestEx.update_or_create({"ok": ads['status'] == 'SUCCESS'}, ex__name="TgWallet", action=ExAction.my_ads)
     #     assert ads['status'] == "SUCCESS", "No data"
-    #
+
     # # 10 - ad_new
     # async def test_ad_new(self, ac):
     #     fiats = [(await ac.fiats())['data'][0]['id']]

xync_client-0.0.7.dev0/tests/wallet/test_ex.py

@@ -0,0 +1,67 @@
+from asyncio import AbstractEventLoop, get_running_loop
+
+import pytest
+import uvloop
+from tortoise.backends.asyncpg import AsyncpgDBClient
+from x_model import init_db
+from xync_schema import models
+from xync_schema.models import Agent, ExAction, TestEx
+
+from xync_client.TgWallet.ex import PublicClient
+from xync_client.loader import DSN
+
+
+@pytest.mark.asyncio(loop_scope="class")
+class TestWallet:
+    loop: AbstractEventLoop
+
+    @pytest.fixture(scope="class")
+    def event_loop_policy(self):
+        return uvloop.EventLoopPolicy()
+
+    @pytest.fixture(scope="class")
+    async def cn(self) -> AsyncpgDBClient:
+        TestWallet.loop = get_running_loop()
+        cn: AsyncpgDBClient = await init_db(DSN, models, True)
+        yield cn
+        await cn.close()
+
+    @pytest.fixture(scope="class")
+    async def cl(self, cn) -> PublicClient:
+        agent = await Agent.get(user_id=1038938370).prefetch_related("ex")
+        tg = PublicClient(agent)
+        yield tg
+        await tg.close()
+
+    # 20 - all_pms
+    async def test_all_pms(self, cl):
+        pms = await cl.pms()
+        test, _ = await TestEx.update_or_create({"ok": bool(pms)}, ex__name="TgWallet", action=ExAction.pms)
+        assert test.ok, "No pms"
+
+    # 21 - all_curs
+    async def test_all_curs(self, cl):
+        curs = await cl.curs()
+        test, _ = await TestEx.update_or_create({"ok": bool(curs)}, ex__name="TgWallet", action=ExAction.curs)
+        assert test.ok, "No curs"
+
+    # 22 - all_pms
+    async def test_cur_pms_map(self, cl):
+        pms = await cl.cur_pms_map()
+        test, _ = await TestEx.update_or_create({"ok": bool(pms)}, ex__name="TgWallet", action=ExAction.pms)
+        assert test.ok, "No pms"
+
+    # 23 - all_coins
+    async def test_all_coins(self, cl):
+        coins = await cl.coins()
+        test, _ = await TestEx.update_or_create({"ok": bool(coins)}, ex__name="TgWallet", action=ExAction.coins)
+        assert test.ok, "No coins"
+
+    # 24 - all_ads
+    async def test_cur_filter(self, cl):
+        for cur in "RUB", "AZN", "GEL":
+            for coin in "TON", "USDT", "BTC":
+                for tt in True, False:
+                    ads = await cl.ads(coin, cur, tt)
+                    assert len(ads), "No data"
+        await TestEx.update_or_create({"ok": bool(ads)}, ex__name="TgWallet", action=ExAction.ads)

{xync_client-0.0.3 → xync_client-0.0.7.dev0}/xync_client/Abc/Agent.py

@@ -4,7 +4,8 @@ from abc import abstractmethod
 from aiohttp import ClientResponse
 from aiohttp.http_exceptions import HttpProcessingError
 from x_client.aiohttp import Client
-from xync_schema.models import Agent, Ex, User, OrderStatus, Coin, Cur, Order, Pm, PmType, Ad, AdStatus, Fiat
+from xync_schema.enums import PmType
+from xync_schema.models import Agent, Ex, User, OrderStatus, Coin, Cur, Order, Pm, Ad, AdStatus, Fiat
 
 
 class AgentClient(Client):

{xync_client-0.0.3 → xync_client-0.0.7.dev0}/xync_client/Abc/Ex.py

@@ -116,17 +116,21 @@ class ExClient(Client):
             norm = self._pmnorm(pm["name"])
             if prev[1:] == (norm, pm["name"]):
                 logging.warning(f"Pm: '{pm['name']}' duplicated with ids {prev[0]}:{k} on {self.ex.name}")
-                await Pmex.update_or_create({"pm": pms.get(prev[0], await Pm.get(name=prev[2]))}, ex=self.ex, exid=k)
+                await Pmex.update_or_create(
+                    {"pm": pms.get(prev[0], await Pm.get(name=prev[2]))}, ex=self.ex, exid=k, name=pm["name"]
+                )
             elif prev[1] == norm:
                 logging.error(
                     f"Pm: '{pm['name']}' and '{prev[2]}' overnormed as '{norm}' with ids {prev[0]}:{k} on {self.ex.name}"
                 )
-                await Pmex.update_or_create({"pm": pms.get(prev[0], await Pm.get(name=prev[2]))}, ex=self.ex, exid=k)
+                await Pmex.update_or_create(
+                    {"pm": pms.get(prev[0], await Pm.get(name=prev[2]))}, ex=self.ex, exid=k, name=pm["name"]
+                )
             else:
                 pms[k], _ = await Pm.update_or_create(**pm, identifier=norm)
             prev = k, norm, pm["name"]
         # Pmexs
-        pmexs = [Pmex(exid=k, ex=self.ex, pm=pm) for k, pm in pms.items()]
+        pmexs = [Pmex(exid=k, ex=self.ex, pm=pm, name=pm.name) for k, pm in pms.items()]
         await Pmex.bulk_create(pmexs, ignore_conflicts=True)
         # Curs
         cursd = await self.curs()

xync_client-0.0.3/xync_client/Binance/web.py → xync_client-0.0.7.dev0/xync_client/Binance/ex.py

@@ -1,14 +1,20 @@
 from asyncio import run
 
 from x_model import init_db
+from xync_schema.enums import PmType
 
 from xync_client.Abc.Ex import ExClient
-from xync_client.loader import DSN
+from xync_client.Binance.sapi import Sapi
+from xync_client.loader import DSN, BKEY, BSEC
 from xync_schema import models
 from xync_schema.models import Ex
 
 
-class Public(ExClient):
+class Client(ExClient):
+    def __init__(self, ex: Ex, bkeys):
+        self.sapi = Sapi(*bkeys)
+        super().__init__(ex)
+
     async def curs(self) -> dict:
         curs = await self._post("/bapi/c2c/v1/friendly/c2c/trade-rule/fiat-list")
         return {c["currencyCode"]: c["countryCode"] for c in curs["data"]}
@@ -16,13 +22,22 @@ class Public(ExClient):
     async def coins(self) -> list[dict]:
         pass
 
-    async def pms(self) -> list[dict]:
-        pass
+    async def pms(self) -> dict[str, dict]:
+        pms = await self.sapi.get_pay_meths()
+        return {
+            pm["id"]: {
+                "name": pm["name"],
+                "identifier": pm["identifier"],
+                "type_": PmType[pm["typeCode"].replace("-", "_")].value,
+                "logo": pm["iconUrlColor"],
+            }
+            for pm in pms["data"]
+        }
 
     # 22: Cur -> [Pm] rels
     async def cur_pms_map(self) -> dict[int, set[int]]:  # {cur.exid: [pm.exid], [pm.exid]}
         res = await self.curs()
-        mp = {c: await self._get_pms_and_country_for_cur(c) for c in res.keys()}
+        mp = {c: await self._get_pms_for_cur(c) for c in res.keys()}
         return mp
 
     # # 22: Cur -> [Pm] rels
@@ -34,12 +49,13 @@ class Public(ExClient):
     async def ads(self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str] = None) -> list[dict]:
         pass
 
-    async def _get_pms_and_country_for_cur(self, cur: str) -> ([str], [str]):
+    async def _get_pms_for_cur(self, cur: str) -> ([str], [str]):
         data = {"fiat": cur, "classifies": ["mass", "profession"]}
         res = await self._post("/bapi/c2c/v2/public/c2c/adv/filter-conditions", data)
-        return [(r["identifier"], r["id"], r["tradeMethodName"]) for r in res["data"]["tradeMethods"]], [
-            r["scode"] for r in res["data"]["countries"] if r["scode"] != "ALL"
-        ]  # countries,tradeMethods,periods
+        return [r["identifier"] for r in res["data"]["tradeMethods"]]
+        # , [
+        #     r["scode"] for r in res["data"]["countries"] if r["scode"] != "ALL"
+        # ]  # countries,tradeMethods,periods
 
 
 # class Private(Public): # todo: base class: Public or Client?
@@ -61,8 +77,8 @@ class Public(ExClient):
 async def main():
     _ = await init_db(DSN, models, True)
     ex = await Ex.get(name="Binance")
-    cl = Public(ex)
-    await cl.cur_pms_map()
+    cl = Client(ex, (BKEY, BSEC))
+    await cl.set_pmcurexs()
     await cl.close()
 
 

{xync_client-0.0.3 → xync_client-0.0.7.dev0}/xync_client/Binance/sapi.py

@@ -136,7 +136,7 @@ class Sapi(Client):
             # "userTradeVolumeMin": 0,
             # "yubikeyVerifyCode": "string"
         }
-        return await self._post(Ep.GET_MY_ADS, body)
+        return await self._post(Ep.POST_AD, body)
 
     # 6. Search Ads
     async def search_ads(self, asset, fiat, trade_type, pms: [str] = None, amount: int = None, page=1, rows=20):

{xync_client-0.0.3 → xync_client-0.0.7.dev0}/xync_client/Bybit/web_earn.py

@@ -1,8 +1,8 @@
 from enum import IntEnum
 
-from xync_schema.models import DepType
 from x_client import repeat_on_fault
 from x_client.aiohttp import Client
+from xync_schema.enums import DepType
 
 
 class ProductType(IntEnum):

{xync_client-0.0.3 → xync_client-0.0.7.dev0}/xync_client/Htx/ex.py

@@ -31,7 +31,7 @@ class Client(ExClient):
     # 22: Список платежных методов по каждой валюте
     async def cur_pms_map(self) -> dict[int, set[int]]:
         res = await self._coin_curs_pms()
-        wrong_pms = {4, 34, 212, 239, 363, 498, 548, 20009, 20010}  # these ids not exist in pms
+        wrong_pms = {4, 34, 498, 548, 20009, 20010}  # , 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"]}
 
     async def coins(self) -> dict[int, str]:

{xync_client-0.0.3 → xync_client-0.0.7.dev0}/xync_client/TgWallet/agent.py

@@ -2,10 +2,10 @@ from enum import StrEnum, IntEnum
 from typing import Literal
 
 from x_client.http import Client
-from xync_schema.models import User, Cur, Fiat, Order, Coin, OrderStatus, Pmex
-from xync_schema.pydantic import FiatForm
+from xync_schema.models import User, Cur, Order, Coin, OrderStatus, Pmex
+from xync_schema.pydantic import FiatNew
 
-from xync_client.Abc import AgentClient as BaseClient
+from xync_client.Abc.Agent import AgentClient as BaseClient
 from xync_client.TgWallet.pyro import PyroClient
 
 
@@ -38,13 +38,12 @@ class AgentClient(BaseClient):
 
     async def order_request(self, ad_id: int, amount: float) -> Order: ...
 
-    async def my_fiats(self, cur: Cur = None) -> list[FiatForm]:
+    async def my_fiats(self, cur: Cur = None) -> dict:
         fiats = await self._post("/p2p/public-api/v3/payment-details/get/by-user-id")
-        for fiat in fiats["data"]:
-            f, _ = Fiat.get_or_create({}, id=fiat["id"])
-        fiats = [await Fiat()]
+        fiats = {fiat["id"]: fiat for fiat in fiats["data"]}
+        return fiats
 
-    async def fiat_new(self, fiat: FiatForm):
+    async def fiat_new(self, fiat: FiatNew):
         pmex = await Pmex.get(pm_id=fiat.pm_id, ex=self.agent.ex)  # .prefetch_related('pm')
         cur = await Cur[fiat.cur_id]
         add_fiat = await self._post(

xync_client-0.0.7.dev0/xync_client/TgWallet/ex.py

@@ -0,0 +1,78 @@
+import logging
+
+from aiohttp import ClientResponse
+from aiohttp.http_exceptions import HttpProcessingError
+from x_client.http import Client
+from xync_schema.models import Pm, Agent, Ex
+
+from xync_client.Abc.Ex import ExClient
+from xync_client.TgWallet.pyro import PyroClient
+
+
+class PublicClient(ExClient):
+    def __init__(self, agent: Agent):
+        self.agent: Agent = agent
+        assert isinstance(agent.ex, Ex), "`ex` should be fetched in `agent`"
+        assert agent.ex.host_p2p, "`ex.host_p2p` shouldn't be empty"
+        self.meth = {
+            "GET": self._get,
+            "POST": self._post,
+        }
+        super().__init__(agent.ex)
+
+    async def _get_auth_hdrs(self) -> dict[str, str]:
+        pyro = PyroClient(self.agent)
+        init_data = await pyro.get_init_data()
+        # async with ClientSession(self.agent.ex.url_login) as sess:
+        #     resp = await sess.post('/api/v1/users/auth/', data=init_data, headers={'content-type': 'application/json;charset=UTF-8'})
+        #     tokens = await resp.json()
+        tokens = Client("walletbot.me")._post("/api/v1/users/auth/", init_data)
+        return {"Wallet-Authorization": tokens["jwt"], "Authorization": "Bearer " + tokens["value"]}
+
+    async def login(self) -> None:
+        auth_hdrs: dict[str, str] = await self._get_auth_hdrs()
+        self.session.headers.update(auth_hdrs)
+
+    async def _proc(self, resp: ClientResponse, data: dict = None) -> dict | str:
+        try:
+            return await super()._proc(resp)
+        except HttpProcessingError as e:
+            if e.code == 401:
+                logging.warning(e)
+                await self.login()
+                res = await self.meth[resp.method](resp.url.path, data)
+                return res
+
+    async def curs(self) -> dict[str, str]:
+        coins_curs = await self._post("/p2p/public-api/v2/currency/all-supported")
+        return {c["code"]: c["code"] for c in coins_curs["data"]["fiat"]}
+
+    async def coins(self) -> dict[str, str]:
+        coins_curs = await self._post("/p2p/public-api/v2/currency/all-supported")
+        return {c["code"]: c["code"] for c in coins_curs["data"]["crypto"]}
+
+    async def _pms(self, cur: str = "RUB") -> dict[str, dict]:
+        pms = await self._post("/p2p/public-api/v3/payment-details/get-methods/by-currency-code", {"currencyCode": cur})
+        return {pm["code"]: {"name": pm["nameEng"]} for pm in pms["data"]}
+
+    async def pms(self) -> dict[str, dict]:
+        pms = {}
+        for cur in await self.curs():
+            for k, pm in (await self._pms(cur)).items():
+                pms.update({k: pm})
+        return pms
+
+    async def cur_pms_map(self) -> dict[str, list[str]]:
+        return {cur: list(await self._pms(cur)) for cur in await self.curs()}
+
+    async def ads(self, coin: str, cur: str, is_sell: bool, pms: list[Pm] = None) -> list[dict]:
+        params = {
+            "baseCurrencyCode": coin,
+            "quoteCurrencyCode": cur,
+            "offerType": "SALE" if is_sell else "PURCHASE",
+            "offset": 0,
+            "limit": 10,
+            # ,"merchantVerified":"TRUSTED"
+        }
+        ads = await self._post("/p2p/public-api/v2/offer/depth-of-market/", params)
+        return ads

{xync_client-0.0.3 → xync_client-0.0.7.dev0/xync_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xync-client
-Version: 0.0.3
+Version: 0.0.7.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.3 → xync_client-0.0.7.dev0}/xync_client.egg-info/SOURCES.txt

@@ -5,13 +5,8 @@ README.md
 makefile
 pyproject.toml
 tests/__init__.py
-tests/test_abc.py
-tests/test_binance.py
-tests/test_bybit.py
-tests/test_bybit_p2p.py
-tests/test_gate.py
-tests/test_htx_p2p.py
-tests/test_wallet.py
+tests/wallet/test_agent.py
+tests/wallet/test_ex.py
 xync_client/__init__.py
 xync_client/loader.py
 xync_client.egg-info/PKG-INFO
@@ -24,9 +19,9 @@ xync_client/Abc/Ex.py
 xync_client/Abc/Order.py
 xync_client/Binance/binance_async.py
 xync_client/Binance/earn_api.py
+xync_client/Binance/ex.py
 xync_client/Binance/exceptions.py
 xync_client/Binance/sapi.py
-xync_client/Binance/web.py
 xync_client/Binance/web_c2c.py
 xync_client/BitGet/pub.py
 xync_client/Bybit/web_earn.py

xync_client-0.0.3/tests/test_abc.py

@@ -1,8 +0,0 @@
-import asyncio
-from xync_client.Abc import AgentClient
-
-async def test_payment_methods():
-    result = await AgentClient.payment_methods()
-    return result
-
-asyncio.run(test_payment_methods())

xync_client-0.0.3/tests/test_binance.py

@@ -1,14 +0,0 @@
-from x_model import init_db
-from xync_client.loader import DSN
-from xync_schema import models
-from xync_schema.models import Ex
-
-from xync_client.Binance.web import Public
-
-
-async def test_cur_filter():
-    _ = await init_db(DSN, models, True)
-    ex = await Ex.get(name="Binance")
-    bn = Public(ex)
-    resp = await bn.cur_pms_map()
-    assert len(resp[0]) and len(resp[1]), "No data"

xync_client-0.0.3/tests/test_bybit.py

@@ -1,83 +0,0 @@
-from datetime import datetime
-from uuid import uuid4
-from pybit.unified_trading import HTTP
-
-from xync_client.Bybit.web_earn import BybitEarn, type_map
-from xync_client.loader import BYT, BYKEY, BYSEC
-
-client = HTTP(
-    testnet=False,
-    api_key=BYKEY,
-    api_secret=BYSEC,
-)
-
-
-async def test_get_home_products():
-    bbt = BybitEarn(BYT)
-    for pt in type_map:
-        resp = await bbt.get_home_earn_products(pt.value)
-        assert len(resp[pt.name]), "No home products"
-
-
-async def test_get_coins():
-    bbt = BybitEarn(BYT)
-    resp = await bbt.get_coins()
-    assert resp, "No coins"
-
-
-async def test_get_eth():
-    bbt = BybitEarn(BYT)
-    resp = await bbt.get_product_detail()
-    assert resp, "No eth"
-
-
-def test_get_rate():
-    resp = client.get_tickers(category="spot", symbol="TONUSDT")
-    assert float(resp["result"]["list"][0]["lastPrice"]) > 0
-
-
-def test_send_coin_internal():
-    coin = "USDT"
-    old_sender_balance = client.get_coins_balance(
-        accountType="FUND",
-        coin=coin,
-    )["result"]["balance"][0]
-    # sender_id = 23477628
-    # receiver_id = 138687729
-    receiver_id = 69798104
-    sent_amount = 24.9266
-    assert float(old_sender_balance["transferBalance"]) >= sent_amount, "sender have not enough money"
-
-    trans_sent_id = client.withdraw(
-        coin=coin,
-        # chain=None,
-        address=str(receiver_id),
-        amount=str(sent_amount),
-        timestamp=int(datetime.now().timestamp() * 1000),
-        forceChain=2,
-        accountType="FUND",
-    )["result"]
-    new_sender_balance = client.get_coins_balance(
-        accountType="FUND",
-        coin=coin,
-    )["result"]["balance"][0]
-    assert (
-        trans_sent_id
-        and float(new_sender_balance["walletBalance"]) == float(old_sender_balance["walletBalance"]) - sent_amount
-    ), "transfer failed"
-
-
-def test_send_coin_subaccount():
-    sender_id = 23477628
-    receiver_id = 69798104
-    sent_amount = 15.5
-    sent = client.create_universal_transfer(  # its only for subaccount transfers
-        transferId=str(uuid4()),
-        coin="USDT",
-        amount=str(sent_amount),
-        fromMemberId=sender_id,
-        toMemberId=receiver_id,
-        fromAccountType="FUND",
-        toAccountType="FUND",
-    )["result"]
-    assert sent, "transfer failed"

xync_client-0.0.3/tests/test_bybit_p2p.py

@@ -1,193 +0,0 @@
-from time import sleep
-
-import pytest
-from tortoise import Tortoise, connections
-from tortoise.backends.asyncpg import AsyncpgDBClient
-from xync_schema import models
-from xync_schema.models import TestEx, ExAction, Pmcur
-
-from xync_client.Bybit.web_p2p import BybitP2P, NoMakerException, AdsStatus
-from xync_client.loader import BYTP2P, DSN
-
-bybit_p2p = BybitP2P(headers={"cookie": "secure-token=" + BYTP2P})
-
-
-@pytest.fixture(scope="module")
-async def dbc() -> AsyncpgDBClient:
-    await Tortoise.init(db_url=DSN, modules={"models": [models]})
-    cn: AsyncpgDBClient = connections.get("default")
-    yield cn
-    await cn.close()
-
-
-# получение валют (1)
-async def test_get_currencies(dbc):
-    currencies = bybit_p2p.get_currencies()
-    Pmcur.update_or_create(
-        {},
-    )
-    ok = True if len(currencies) > 0 else False
-    await TestEx.update_or_create({"ok": ok}, ex_id=10, action=ExAction.all_curs_taker)
-    assert ok, "No currencies found"
-
-
-# получение не тестовых монет торгуемых на p2p (2)
-async def test_get_coins(dbc):
-    result_get_coins = bybit_p2p.get_coins()
-    ok = (
-        True
-        if len([c for c in result_get_coins["result"] if c["tokenType"] == "CHAIN_TOKEN" and not c["isTest"]]) > 0
-        else False
-    )
-    await TestEx.update_or_create({"ok": ok}, ex_id=10, action=ExAction.all_coins)
-    assert ok, "No coins found"
-
-
-# получение платежных методов (3)
-async def test_get_payment_methods(dbc):
-    result_get_payment_methods = bybit_p2p.get_payment_methods()
-    ok = True if len(result_get_payment_methods["result"]["paymentConfigVo"]) > 0 else False
-    await TestEx.update_or_create({"ok": ok}, ex_id=10, action=ExAction.all_pms)
-    assert ok, "No payment method found"
-
-
-# получение первого объявления на покупку USDT за рубли (покупка - "side": "1", продажа - "side": "0") (4)
-async def test_get_best_price(dbc):
-    all_ads = bybit_p2p.get_ads("USDT", "RUB")
-    ok1 = True if bybit_p2p.get_rate(all_ads) > 0 else False  # "Ad's price USDT/RUB no found no Payeer, no Advcash"
-    ok2 = True if len(all_ads) > 0 else False
-    await TestEx.update_or_create({"ok": ok1 and ok2}, ex_id=10, action=ExAction.all_ads)
-    assert ok2, "Ad's price USDT/RUB no found"
-
-
-# получение платежных методов залогиненного юзера (5)
-async def test_get_user_pay_methods(dbc):
-    result_get_user_pay_methods = bybit_p2p.get_user_pay_methods()
-    ok = True if len(result_get_user_pay_methods) > 0 else False
-    await TestEx.update_or_create({"ok": ok}, ex_id=10, action=ExAction.fiats)
-    assert ok, "No payment method requisites found"
-
-
-# создание моего платежного реквизита (fiat) (6)
-async def test_create_user_payment_methods(dbc):
-    result = bybit_p2p.create_payment_method(379, "ЕЛЕНА АРТЕМЬЕВА", "42454342536453")
-    ok = True if result["ret_msg"] == "SUCCESS" else False
-    await TestEx.update_or_create({"ok": ok}, ex_id=10, action=ExAction.fiat_new)
-    assert ok, "Fiat isn't created: " + result["ret_msg"]
-
-
-# редактирование моего платежного реквизита (fiat) (7)
-async def test_update_user_payment_methods(dbc):
-    result = bybit_p2p.update_payment_method("ЕЛЕНА АРТЕМЬЕВА", "424543425364532")
-    if result["ret_msg"] != "SUCCESS":
-        print("Wrong 2fa on Fiat updating, wait 10 secs and retry..")
-        sleep(10)
-        return await test_update_user_payment_methods(dbc)
-    await TestEx.update_or_create({"ok": True}, ex_id=10, action=ExAction.fiat_upd)
-    assert True, "Fiat isn't updated: " + result["ret_msg"]
-
-
-# удаление моего платежного реквизита (fiat) (8)
-async def test_delete_user_payment_methods(dbc):
-    last_fiat = bybit_p2p.get_payment_method()
-    result = bybit_p2p.delete_payment_method(last_fiat["id"])
-    if result["ret_msg"] != "SUCCESS":
-        print("Wrong 2fa on Fiat deleting, wait 10 secs and retry..")
-        sleep(10)
-        return await test_delete_user_payment_methods(dbc)
-    await TestEx.update_or_create({"ok": True}, ex_id=10, action=ExAction.fiat_del)
-    assert True, "Fiat isn't deleted: " + result["ret_msg"]
-
-
-# получение списка объявлений залогиненного юзера (9)
-async def test_get_user_ads(dbc):
-    result_get_user_ads = bybit_p2p.get_user_ads()
-    ok = True if len(result_get_user_ads) >= 0 else False
-    await TestEx.update_or_create({"ok": ok}, ex_id=10, action=ExAction.my_ads)
-    assert ok, "No ads found"
-
-
-# создание/редактирование/удаление объявления (10,11,12)
-async def test_delete_ad(dbc):
-    try:
-        token = bybit_p2p.get_security_token_create()
-        bybit_p2p.post_create_ad(token)
-        token = bybit_p2p.get_security_token_update()
-        bybit_p2p.post_update_ad(token)
-        result_delete_ad = bybit_p2p.delete_ad(bybit_p2p.last_ad_id[0])
-    except NoMakerException as e:
-        print(e.args[0]["ret_msg"])
-        result_delete_ad = e.args[0]
-    ok = True if result_delete_ad["ret_msg"] == "SUCCESS" else False
-    await TestEx.update_or_create({"ok": ok}, ex_id=10, action=ExAction.ad_new)
-    await TestEx.update_or_create({"ok": ok}, ex_id=10, action=ExAction.ad_upd)
-    await TestEx.update_or_create({"ok": ok}, ex_id=10, action=ExAction.ad_del)
-    assert ok, "Ad isn't deleted"
-
-
-async def _switch_ad(new_status: AdsStatus, dbc):
-    result = bybit_p2p.switch_ads(new_status)
-    ok = True if result["ret_msg"] == "SUCCESS" else False
-    action = {AdsStatus.REST: ExAction.ad_off, AdsStatus.WORKING: ExAction.ad_on}[new_status]
-    await TestEx.update_or_create({"ok": ok}, ex_id=10, action=action)
-    return ok
-
-
-# выключение/включение объявления (13,14)
-async def test_on_off_ads(dbc):
-    old_status = AdsStatus[bybit_p2p.online_ads()]
-    new_status = AdsStatus(int(not bool(old_status.name)))
-    ok = await _switch_ad(new_status, dbc)
-    assert ok, "Ads no " + new_status.name
-    # возвращаем как было:
-    ok = await _switch_ad(old_status, dbc)
-    assert ok, "Ads no " + old_status.name
-
-
-# старт заявки (тейкером 17)
-async def test_create_order_taker():
-    ads = bybit_p2p.get_ads("USDT", "RUB", payment=["51"])
-    ad = ads[0]
-    # get_order_info = bybit_p2p.get_order_info(ad["id"])
-    result = bybit_p2p.create_order_taker(
-        ad["id"], "USDT", "RUB", False, ad["minAmount"], float(ad["minAmount"]) / float(ad["price"]), ad["price"]
-    )
-    ok = True if result["ret_msg"] == "SUCCESS" else False
-    await TestEx.update_or_create({"ok": ok}, ex_id=10, action=ExAction.take_ad)
-
-
-# сообщения чата (тейкером 21)
-async def test_get_chat_msgs(dbc):
-    msgs = bybit_p2p.get_chat_msg("1832490804709646336")
-    assert len(msgs) > 0, "No have msgs"
-
-
-async def test_user_block(dbc):
-    bu = bybit_p2p.block_user("146246740")
-    assert bu["result"], "User don't block"
-    ubu = bybit_p2p.unblock_user("146246740")
-    assert ubu["result"], "User don't unblock"
-
-
-# поставить отзыв (27)
-async def test_user_review_post(dbc):
-    result = bybit_p2p.user_review_post("1831422797854318592")
-    assert result["ret_msg"] == "SUCCESS", "Review post failed"
-
-
-# получшение заявок по всем ордерам за заданное время, статус, направление, монета (32)
-async def test_get_orders_done(dbc):
-    result = bybit_p2p.get_orders_done(1717189200000, 1722545999999, 50, 1, "USDT")
-    assert result["ret_msg"] == "SUCCESS", "No orders done"
-
-
-# получшение заявок по активным ордерам за заданное время, статус, направление, монета (32)
-async def test_get_orders_active(dbc):
-    result = bybit_p2p.get_orders_active(1717189200000, 1722545999999, 50, 1, "USDT")
-    assert result["ret_msg"] == "SUCCESS", "No active orders"
-
-
-# 33
-async def test_get_order_info(dbc):
-    get_order_info = bybit_p2p.get_order_info("1819108572048125952")
-    assert get_order_info, "No order info"

xync_client-0.0.3/tests/test_gate.py

@@ -1,38 +0,0 @@
-from xync_client.Gate.premarket import Priv
-from xync_client.loader import GATE_UID, GATE_PVER
-
-
-async def test_get_premarket_ads():
-    gate = Priv(GATE_UID, GATE_PVER)
-    resp = await gate.get_premarket_ads()
-    assert len(resp), "No premarket ads"
-
-
-async def test_get_my_premarket_ads():
-    gate = Priv(GATE_UID, GATE_PVER)
-    resp = await gate.get_my_premarket_ads()
-    assert len(resp), "No my premarket ads"
-
-
-async def test_create_premarket_ad():
-    gate = Priv(GATE_UID, GATE_PVER)
-    resp = await gate.post_premarket_ad(0.649, 5)
-    assert resp, "Premarket ad not created"
-
-
-async def test_delate_premarket_ad():
-    gate = Priv(GATE_UID, GATE_PVER)
-    resp = await gate.del_premarket_ad(62089)
-    assert resp, "Premarket ad not delated"
-
-
-async def test_set_premarket_ads():
-    gate = Priv(GATE_UID, GATE_PVER)
-    my_ads = await gate.get_my_premarket_ads()
-    my_ids = [ad["order_id"] for ad in my_ads]
-    resp = await gate.get_premarket_ads()
-    for ad in resp:
-        if ad["order_id"] in my_ids:
-            pass
-
-    assert len(resp), "No premarket ads"

xync_client-0.0.3/xync_client/TgWallet/ex.py

@@ -1,101 +0,0 @@
-import logging
-
-from aiohttp import ClientResponse
-from aiohttp.http_exceptions import HttpProcessingError
-from x_client.http import Client
-from xync_schema.models import Coin, Cur, Pm, Ad, Curex, Agent, Ex
-
-from xync_client.Abc import PublicClient as BasePublicClient
-from xync_client.TgWallet.pyro import PyroClient
-
-
-class PublicClient(BasePublicClient):
-    def __init__(self, agent: Agent):
-        self.agent: Agent = agent
-        assert isinstance(agent.ex, Ex), "`ex` should be fetched in `agent`"
-        assert agent.ex.host_p2p, "`ex.host_p2p` shouldn't be empty"
-        self.meth = {
-            "GET": self._get,
-            "POST": self._post,
-        }
-        super().__init__(agent.ex)
-
-    async def _get_auth_hdrs(self) -> dict[str, str]:
-        pyro = PyroClient(self.agent)
-        init_data = await pyro.get_init_data()
-        # async with ClientSession(self.agent.ex.url_login) as sess:
-        #     resp = await sess.post('/api/v1/users/auth/', data=init_data, headers={'content-type': 'application/json;charset=UTF-8'})
-        #     tokens = await resp.json()
-        tokens = Client("walletbot.me")._post("/api/v1/users/auth/", init_data)
-        return {"Wallet-Authorization": tokens["jwt"], "Authorization": "Bearer " + tokens["value"]}
-
-    async def login(self) -> None:
-        auth_hdrs: dict[str, str] = await self._get_auth_hdrs()
-        self.session.headers.update(auth_hdrs)
-
-    async def _proc(self, resp: ClientResponse, data: dict = None) -> dict | str:
-        try:
-            return await super()._proc(resp)
-        except HttpProcessingError as e:
-            if e.code == 401:
-                logging.warning(e)
-                await self.login()
-                res = await self.meth[resp.method](resp.url.path, data)
-                return res
-
-    async def _curs(self) -> list[str]:
-        coins_curs = await self._post("/p2p/public-api/v2/currency/all-supported")
-        return [c["code"] for c in coins_curs["data"]["fiat"]]
-
-    async def curs(self) -> list[Cur.pyd_list_item()]:
-        curs = [(await Cur.update_or_create(ticker=c))[0] for c in await self._curs()]
-        [await Curex.update_or_create(cur=c, ex=self.agent.ex) for c in curs]  # add curexs
-        return [Cur.pyd_list_item().model_validate(c, from_attributes=True) for c in curs]
-
-    async def _coins(self) -> list[str]:
-        coins_curs = await self._post("/p2p/public-api/v2/currency/all-supported")
-        return [c["code"] for c in coins_curs["data"]["crypto"]]
-
-    async def coins(self, cur: Cur = None) -> list[Coin.pyd_list_item()]:
-        coins = [(await Coin.update_or_create(ticker=c))[0] for c in await self._coins()]
-        [await Curex.update_or_create(coin=c, ex=self.agent.ex) for c in coins]  # add coinexs
-        return [Coin.pyd_list_item().model_validate(c, from_attributes=True) for c in coins]
-
-    async def _pms(self, cur: str = "RUB") -> list[Pm]:
-        pms = await self._post("/p2p/public-api/v3/payment-details/get-methods/by-currency-code", {"currencyCode": cur})
-        return pms["data"]
-
-    async def pms(self, cur: str = "RUB") -> list[Pm]:
-        # get from api
-        pmcurs = {cur: await self._pms(cur) for cur in await self._curs()}
-        pp = {}
-        [[pp.update({p["code"]: p["nameEng"]}) for p in ps] for ps in pmcurs.values()]
-        pp = {k: v for k, v in sorted(pp.items(), key=lambda x: x[0])}
-        return pp
-        # pms_new = await self._post(
-        #     "/p2p/public-api/v3/payment-details/get-methods/by-currency-code", {"currencyCode": cur}
-        # )
-        # pms_new_idfs: dict[str, str] = {
-        #     pn["code"]: pn["nameEng"].lower().replace(" ", "").replace("-", "") for pn in pms_new["data"]
-        # }
-        # pms_new_names = {name: idf for idf, name in pms_new_idfs.items()}
-        # # prepare old payMeths
-        # pms_old = await Pm.all()
-        # pms_old_idfs: dict[str, Pm] = {
-        #     pm.identifier.lower().replace(" ", "").replace("-", ""): pm for pm in pms_old if pm.identifier
-        # }
-        # pms_old_names: dict[str, Pm] = {
-        #     pm.name.lower().replace(" ", "").replace("-", ""): pm for pm in pms_old if pm.name
-        # }
-
-    async def ads(self, coin: Coin, cur: Cur, is_sell: bool, pms: list[Pm] = None) -> list[Ad.pyd_list_item()]:
-        params = {
-            "baseCurrencyCode": coin,
-            "quoteCurrencyCode": cur,
-            "offerType": is_sell,
-            "offset": 0,
-            "limit": 100,
-            # ,"merchantVerified":"TRUSTED"
-        }
-        ads = await self._post("/p2p/public-api/v2/offer/depth-of-market/", params)
-        return ads