xync-client 0.1.3__py3-none-any.whl

xync_client/Binance/binance_async.py

@@ -0,0 +1,83 @@
+import hashlib
+import hmac
+from asyncio import run
+from time import time
+
+from aiohttp import ClientSession
+
+# mixartemev
+client = {
+    'key': 'yvF6tsx2hOsn4kDclN8VlHArWZ9FOeZBHuUpIINKfQxyYPZziQsLPJiGMo1amkE1',
+    'secret': 'oTTnWwbOTR3RcjWOXaQuE8JzxZ7P6v7UnAn08azt79l5ZkbKJUXjF5syc9mRS96C'
+}
+# alena
+# client = Spot(key='dtyLk0I4S4zlWMN6sqO1aFtHKfjDcjstTbG2fuSpfZVEvr2NJLnUnSt0UFyCyHGv', secret='EE3tnb8I2IZGYtWUt72wXZ3NrIaKqUkaGFgMoHxRtkTas2y8EuKK0sQg1jcbGwTI')
+
+host = 'https://api.binance.com/'
+ws_host = 'wss://stream.binance.com:9443'
+
+earn_lock = '/sapi/v1/simple-earn/locked/list'
+earn_flex = '/sapi/v1/simple-earn/locked/list'
+c2c_hist = 'sapi/v1/c2c/orderMatch/listUserOrderHistory'
+ex_data = 'sapi/v1/convert/exchangeInfo'
+
+
+
+async def get_prv(path: str, params: {} = None, cln: {} = None):
+    cln, params = cln or client, params or {}
+    def sign(prms: {}) -> {}:
+        """Makes a signature and adds it to the params dictionary."""
+        data = list(prms.items())
+        query: str = '&'.join(["{}={}".format(d[0], d[1]) for d in data])
+        m = hmac.new(cln['secret'].encode(), query.encode(), hashlib.sha256)
+        prms.update({'signature': m.hexdigest()})
+        return prms
+
+    headers = {'X-MBX-APIKEY': cln['key']}
+    params.update({'timestamp': f'{round(time() * 1000)}'})
+    params = sign(params)
+
+    async with ClientSession() as session:
+        resp = await session.get(host + path, headers=headers, params=params)
+        return await resp.json()
+
+
+async def spot_prices(*tickers: str):
+    symbols = '["' + '","'.join(tickers) + '"]'
+    resp = await get_prv('api/v3/ticker/price', {'symbols': symbols} if tickers else None)
+    return {r['symbol']: float(r['price']) for r in resp} if type(resp) is list else {}
+
+
+async def c2c_hst(user: {}, tt: str):
+    resp = await get_prv(c2c_hist, user, {'tradeType': tt})
+    return resp['data'], resp['total']
+
+async def get_earn_locks(page: int = 1, size: int = 100):
+    resp = await get_prv(earn_lock, {'current': page, 'size': 100})
+    return resp['data'], resp['total']
+
+
+# # spot assets
+# a = client.user_asset()
+# print(a)
+#
+# # funding assets
+# f = client.funding_wallet()
+# print(f)
+#
+# # transfer
+# # t = client.user_universal_transfer(type='FUNDING_MAIN', asset='BUSD', amount=11)
+# # print(t)
+#
+# n = client.ticker_price('USDTRUB')
+#
+# r = client.enable_fast_withdraw()
+# r = client.withdraw(coin='SHIB', amount=100000, walletType=1, address='0x2469f1a2aa61dba2107d9905d94f1efa9f60eadc', network='BSC', withdrawOrderId=357058112)
+# print(r)
+
+
+if __name__ == "__main__":
+    # res = run(spot_prices())
+    # res = run(c2c_hst(client, 'BUY'))
+    res = run(get_earn_locks(3))
+    print(res)

xync_client/Binance/earn_api.py

@@ -0,0 +1,83 @@
+from binance import AsyncClient
+
+
+class Ebac(AsyncClient):  # Earn Binance async client
+    HOST = 'https://api-gcp.binance.com/sapi/v1/simple-earn/'
+
+    async def _req(self, url: str, params: dict = None, is_post: bool = True) -> dict:
+        return await self._request('post' if is_post else 'get', self.HOST+url, True, data=params or {})
+
+    async def _get_pub(self, url: str, params: dict = None) -> dict:
+        return await self._request('get', url, False, data=params or {})
+
+    async def flex_products(self, page: int = 1, asset: str = None) -> []:
+        res = await self._req('flexible/list', {'current': page, 'size': 100, 'asset': asset}, False)
+        for i in range(res['total'] // 100):
+            res['rows'] += (await self._req('flexible/list', {'current': i+2, 'size': 100, 'asset': asset}, False))['rows']
+        return res['rows']
+
+    async def lock_products(self, page: int = 1, asset: str = None) -> []:
+        res = await self._req('locked/list', {'current': page, 'size': 100, 'asset': asset}, False)
+        for i in range(res['total'] // 100):
+            res['rows'] += (await self._req('locked/list', {'current': i+2, 'size': 100, 'asset': asset}, False))['rows']
+        return res['rows']
+
+    async def buy_flex_product(self, product_id: str, amount: float) -> dict:
+        return await self._req('flexible/subscribe', {'productId': product_id, 'amount': amount, 'autoSubscribe': True})
+
+    async def buy_lock_product(self, product_id: str, amount: float) -> dict:
+        return await self._req('locked/subscribe', {'productId': product_id, 'amount': amount, 'autoSubscribe': True})
+
+    async def redeem_lock_product(self, position_id: int) -> dict:
+        return await self._req('locked/redeem', {'positionId': position_id})
+
+    async def redeem_flex_product(self, position_id: int, amount: float = None) -> dict:
+        params = {'positionId': position_id, **({'amount': amount} if amount else {'redeemAll': True})}
+        return await self._req('flexible/redeem', params)
+
+    async def flex_position(self, product_id: str = None) -> []:
+        res = await self._req('flexible/position', {'productId': product_id, 'size': 100}, False)
+        return res['rows']
+
+    async def lock_position(self, position_id: int = None, project_id: str = None, page: int = 1) -> []:
+        res = await self._req('locked/position', {'positionId': position_id, 'projectId': project_id, 'size': 100, 'current': page}, False)
+        return res['rows']
+
+    async def account(self) -> dict:
+        return await self._req('account', is_post=False)
+
+    async def flex_buy_history(self, product_id: str, purchase_id: int = None, asset: str = None) -> []:
+        res = await self._req('flexible/history/subscriptionRecord', {
+            'productId': product_id, 'purchaseId': purchase_id, 'asset': asset, 'size': 100
+        }, False)
+        return res['rows']
+
+    async def lock_buy_history(self, purchase_id: int = None, asset: str = None) -> []:
+        res = await self._req('locked/history/subscriptionRecord', {
+            'purchaseId': purchase_id, 'asset': asset, 'size': 100
+        }, False)
+        return res['rows']
+
+    async def flex_redeem_history(self, product_id: str, redeem_id: int = None, asset: str = None) -> []:
+        res = await self._req('flexible/history/subscriptionRecord', {
+            'productId': product_id, 'redeemId': redeem_id, 'asset': asset, 'size': 100
+        }, False)
+        return res['rows']
+
+    async def lock_redeem_history(self, position_id: int, redeem_id: int = None, asset: str = None) -> []:
+        res = await self._req('locked/history/subscriptionRecord', {
+            'positionId': position_id, 'redeemId': redeem_id, 'asset': asset, 'size': 100
+        }, False)
+        return res['rows']
+
+    async def flex_quota(self, product_id: str) -> float:
+        res = await self._req('locked/personalLeftQuota', {'productId': product_id}, False)
+        return float(res['leftPersonalQuota'])
+
+    async def lock_quota(self, product_id: str) -> float:
+        res = await self._req('locked/personalLeftQuota', {'productId': product_id}, False)
+        return float(res['leftPersonalQuota'])
+
+    async def get_beth_rate(self) -> float:
+        res = await self._get_pub('https://www.binance.com/bapi/earn/v1/public/pos/cftoken/project/getPurchasableProject')
+        return float(res['data']['annualInterestRate'])

xync_client/Binance/sapi.py

@@ -0,0 +1,267 @@
+import hashlib
+import hmac
+from enum import StrEnum
+from time import time
+
+from xync_schema import models
+from xync_schema.models import Pm, Coin, Ex, TradeType, Cur, Pair, Ad
+from binance.exceptions import BinanceAPIException, BinanceRequestException
+from asyncio import run
+from aiohttp import ClientResponse
+from http_client import Client
+from more_itertools import batched
+from tortoise_api_model import init_db
+
+from cex_clients.loader import BKEY, BSEC, DSN
+from requests import get
+
+
+class Ep(StrEnum):
+    GET_AD = 'ads/getDetailByNo'  # 2
+    GET_REF_PRICE = 'ads/getReferencePrice'  # 3
+    GET_MY_ADS = 'ads/listWithPagination'  # 4
+    POST_AD = 'ads/post'  # 5
+    GET_PMS = 'paymentMethod/listAll'  # 37
+    GET_CHAT = 'chat/retrieveChatMessagesWithPagination'  # 43
+
+
+class Sapi(Client):
+    base_url = 'https://api-gcp.binance.com'
+    middle_url = '/sapi/v1/c2c/'
+
+    def __init__(self, key: str, secret: str):
+        self.key = key
+        self.secret = secret
+        self.headers = {'X-MBX-APIKEY': key}
+        super().__init__()
+
+    def __sign(self, params: dict):
+        ts = get('https://api-gcp.binance.com/api/v3/time').json()['serverTime']
+        params = {**(params or {}), 'timestamp': ts}
+        """Makes a signature and adds it to the params dictionary."""
+        query: str = '&'.join(f'{k}={v}' for k, v in params.items())
+        m = hmac.new(self.secret.encode('utf-8'), query.encode('utf-8'), hashlib.sha256)
+        return {**params, 'signature': m.hexdigest()}
+
+    async def _get(self, endpoint: str, params: dict = None):
+        res = await self.get(endpoint, self.__sign(params))
+        return res.get('data', res)
+
+    async def _post(self, endpoint: str, data: dict = None, params: dict = None):
+        res = await self.post(endpoint, data, self.__sign(params))
+        return res
+
+    """ PUBLIC METHS """
+    # 2: Get details of a specific advertisement
+    async def get_ad(self, ad_num: int):
+        return await self._post(Ep.GET_AD, {'adsNo': ad_num})
+
+    # 3
+    async def get_ref_price(self, assets: [Coin], fiat: Cur, tt: TradeType):
+        body = {
+            'assets': [a.ticker for a in assets], # len <= 3
+            'fiatCurrency': fiat.ticker,
+            'fromUserRole': 'USER', # ADVERTISER
+            'payType': 'BANK', # WECHAT
+            'tradeType': tt.name
+        }
+        return await self._post(Ep.GET_REF_PRICE, body)
+
+    # 4
+    async def get_my_ads(self, page: int = 1, rows: int = 100):
+        body = {
+            # "advNo": "string",
+            # "advStatus": 0,
+            # "asset": "string",
+            # "classify": "string",
+            # "endDate": "2019-08-24T14:15:22Z", "fiatUnit": "string",
+            # "inDeal": 0,
+            # "order": "string",
+            'page': page,
+            'rows': rows,
+            # "sort": "string",
+            # "startDate": "2019-08-24T14:15:22Z", "tradeType": "string"
+        }
+        return await self._post(Ep.GET_MY_ADS, body)
+
+    # 5
+    async def post_ad(self, asset: [Coin], fiat: Cur, tt: TradeType, amount: float, price: float, min_limit: int, max_limit: int, auto_reply: str = ''):
+        body = {
+            "asset": asset,
+            "authType": "GOOGLE",
+            "autoReplyMsg": auto_reply,
+            "buyerBtcPositionLimit": 0,
+            "buyerKycLimit": 0,
+            "buyerRegDaysLimit": 0,
+            "classify": "mass",  # profession, block, f2f
+            "code": "string",
+            # "emailVerifyCode": "string",
+            "fiatUnit": fiat,
+            "googleVerifyCode": "string",
+            "initAmount": amount,
+            "maxSingleTransAmount": min_limit,
+            "minSingleTransAmount": max_limit,
+            # "mobileVerifyCode": "string",
+            # "onlineDelayTime": 0,
+            # "onlineNow": True,
+            "payTimeLimit": (90, 15)[tt],
+            "price": price,
+            # "priceFloatingRatio": 0,
+            "priceType": 1,  # 1: fix, 2: float
+            # "rateFloatingRatio": 0,
+            "remarks": "string",
+            "saveAsTemplate": 0,
+            # "templateName": "string",
+            "tradeMethods": [
+                {
+                    "identifier": "string",
+                    "payId": 0,
+                    "payType": "string"
+                }
+            ],
+            "tradeType": tt.name,
+            # "userAllTradeCountMax": 0,
+            # "userAllTradeCountMin": 0,
+            # "userBuyTradeCountMax": 0,
+            # "userBuyTradeCountMin": 0,
+            # "userSellTradeCountMax": 0,
+            # "userSellTradeCountMin": 0,
+            # "userTradeCompleteCountMin": 0,
+            # "userTradeCompleteRateFilterTime": 0,
+            # "userTradeCompleteRateMin": 0,
+            # "userTradeCountFilterTime": 0,
+            # "userTradeType": 0,
+            # "userTradeVolumeAsset": "string",
+            # "userTradeVolumeFilterTime": 0,
+            # "userTradeVolumeMax": 0,
+            # "userTradeVolumeMin": 0,
+            # "yubikeyVerifyCode": "string"
+        }
+        return await self._post(Ep.GET_MY_ADS, body)
+
+    # 6. Search Ads
+    async def search_ads(self, asset, fiat, trade_type, pms: [str] = None, amount: int = None,  page=1, rows=20):
+        """
+        Search advertisements based on search criteria.
+
+        Args:
+            asset (str): Asset.
+            fiat (str): Fiat currency.
+            trade_type (str): Trade type ('BUY' or 'SELL').
+            pms ([string]): payment types,
+            amount (int, optional): payment types,
+            page (int, optional): Page number. Defaults to 1.
+            rows (int, optional): Number of rows per page. Defaults to 20.
+
+        Returns:
+            dict: List of matching advertisements.
+        """
+        data = {
+            'page': page,
+            'rows': rows,
+            'asset': asset,
+            'fiat': fiat,
+            'tradeType': trade_type,
+            "payTypes": pms,
+            # "sort": "asc",
+            "transAmount": amount
+        }
+        return await self._post('ads/search', data)
+
+    # 7. Update Ad
+    async def update_ad(self, adv_no, price):
+        """
+        Update the price of an advertisement.
+
+        Args:
+            adv_no (str): Advertisement number.
+            price (str): New price.
+
+        Returns:
+            dict: Updated advertisement details.
+        """
+        return await self._post('ads/update', {'advNo': adv_no, 'price': price})
+
+    # 9. Get coins
+    async def get_coins(self):
+        return await self._post('digitalCurrency/list')
+
+    # 10. Get fiats
+    async def get_fiats(self):
+        return await self._post('fiatCurrency/list')
+
+    # 22. Get details of a specific order.
+    async def get_order_details(self, order_number):
+        return await self._post('orderMatch/getUserOrderDetail', {'adOrderNo': order_number})
+
+    # 24. List orders
+    async def get_order_list(self, request_body):
+        """
+        Get a list of orders.
+
+        Args:
+            request_body (dict): Request body parameters.
+
+        Returns:
+            dict: List of orders.
+        """
+        return await self._post('orderMatch/listOrders', request_body)
+
+    # 36. Get My Payment Method info by ID
+    async def get_my_pay_meth(self, idd):
+        return await self._get('paymentMethod/getPayMethodById', {'id': idd})
+
+    # 37. Get available Payment Methods List for current user
+    async def get_pay_meths(self):
+        return await self._post(Ep.GET_PMS)
+
+    # 38. Get current user info
+    async def get_user(self):
+        return await self._post('user/baseDetail')
+
+    # 42. Get wss-url, lister key and token
+    async def get_chat_creds(self, client_type='web'):
+        return await self._get('chat/retrieveChatCredential', {'clientType': client_type})
+
+    # 43. Get chat messages related to a specific order
+    async def get_chat(self, order_number, page=1, rows=10):
+        return await self._get(Ep.GET_CHAT, params={'page': page, 'rows': rows, 'orderNo': order_number})
+
+
+async def main():
+    await init_db(DSN, models)  # init db
+    sapi = Sapi(BKEY, BSEC)
+    # user = await sapi.get_user()
+
+    coins = await Coin.filter(exs__id__contains=1)
+    curs = await Cur.filter(exs__id__contains=1, ticker__in=('RUB', 'PHP', 'TRY', 'USD', 'EUR', 'GEL', 'THB', 'INR'))
+    # coin_ids = [coin.ticker for coin in coins]
+    # for chunk in batched(coin_ids, 3):
+    #     for cur in await Cur.filter(exs__id__contains=1):
+    #         for tt in TradeType:
+    #             rp = await sapi.get_ref_price(chunk, cur.ticker, tt)
+    #             print(rp)
+
+    # pm = await sapi.get_my_pay_meth(31986806)
+    # ads = await sapi.get_my_ads()
+
+    # pms = await sapi.get_pay_meths()
+    # [await Pm.update_or_create({'name': pm['name'], 'identifier': pm['identifier'], 'type': pm['typeCode']}, binance_id=pm['id']) for pm in pms]
+
+    for coin in coins:
+        for cur in curs:
+            for tt in TradeType:
+                rp = await sapi.get_ref_price([coin], cur, tt)
+                r = await sapi.search_ads(coin.ticker, cur.ticker, tt.name)
+                if r0 := r[0]['data']['adv']:
+                    pd = {'fee': r0['commissionRate'], 'price': r0['price'], 'total': r[0]['total']}
+                    pms = [Pm.get(identifier=pm['identifier']) for pm in r0['tradeMethods']]
+                    ad = {'price': r0['price'], 'id': r0['total']}
+                    p, _ = await Pair.update_or_create(pd, ex_id=1, cur=cur, coin=coin, sell=tt.value)
+                    a, _ = await Ad.update_or_create(ad, pair=p, cur=cur, coin=coin, sell=tt.value)
+                    await a.pms.add(*pms)
+
+
+if __name__ == "__main__":
+    res = run(main())
+    print(res)

xync_client/Binance/web.py

@@ -0,0 +1,30 @@
+from http_client import Client
+
+
+class BinanceClient(Client):
+    base_url = 'https://p2p.binance.com'
+
+
+class Public(BinanceClient):
+    middle_url = '/bapi/c2c/v2/public/c2c/'
+
+    async def get_pms_and_country_for_cur(self, cur: str) -> ([str], [str]):
+        data = {"fiat": cur, "classifies": ["mass", "profession"]}
+        res = await self.post('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
+
+
+# class Private(Public): # todo: base class: Public or Client?
+class Private(BinanceClient):
+    # auth: dict =
+    headers: dict = {
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.134 Safari/537.36',
+        'Content-Type': 'application/json',
+        'clienttype': 'web',
+    }
+
+    def seq_headers(self):
+        return {
+            'csrftoken': self.auth['tok'],
+            'cookie': f'p20t=web.{self.id}.{self.auth["cook"]}',
+        }