xync-client 0.1.3__py3-none-any.whl

xync_client/Binance/web_c2c.py

@@ -0,0 +1,227 @@
+from asyncio import run
+from time import time
+
+from xync_schema.models import Agent
+
+gap = 0.01
+HOST = 'https://c2c.binance.com/'
+ADS = 'bapi/c2c/v2/friendly/c2c/adv/search'
+AD = 'bapi/c2c/v2/public/c2c/adv/selected-adv/'
+FIAT_NEW = 'bapi/c2c/v2/private/c2c/pay-method/add'
+AD_NEW = 'bapi/c2c/v3/private/c2c/adv/publish'
+AD_UPD = 'bapi/c2c/v3/private/c2c/adv/update'
+AD_UPD_ST = 'bapi/c2c/v2/private/c2c/adv/update-status'
+MY_ADS = 'bapi/c2c/v2/private/c2c/adv/list-by-page'
+PTS = 'bapi/c2c/v2/private/c2c/pay-method/user-paymethods'
+ORD = 'bapi/c2c/v2/private/c2c/order-match/order-list'
+ORD_ARCH = 'bapi/c2c/v1/private/c2c/order-match/order-list-archived-involved'
+CUR_MIN_AMT = 'bapi/c2c/v1/private/c2c/sys-config/adv-trans-amount-limit'
+RATES = 'bapi/c2c/v1/private/c2c/merchant/get-exchange-rate-list'
+RATE = 'bapi/c2c/v2/public/c2c/adv/quoted-price'
+BLNC_URL = 'https://www.binance.com/bapi/asset/v2/private/asset-service/wallet/balance?needBalanceDetail=true'
+
+# class C2cWeb(Private):
+
+
+async def breq(path: str, user: Agent = None, data=None, is_post=True):
+    headers = {
+        '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',
+    }
+    if user:
+        headers.update({
+            'csrftoken': user.auth['tok'],
+            'cookie': f'p20t=web.{user.id}.{user.auth["cook"]}',
+        })
+    async with aiohttp.ClientSession() as session:
+        reqf = session.post if is_post else session.get
+        # noinspection PyArgumentList
+        async with reqf(('' if path.startswith('https://') else HOST) + path, headers=headers, json=data) as response:
+            # if response.status == 401:
+            #     await hc(user)
+            if response.status != 200:
+                print(response)
+            return (await response.json()) or response.status
+
+
+async def ping(user: Agent):
+    res = await breq('bapi/accounts/v1/public/authcenter/auth', user)
+    return res['success']
+
+
+# async def hc(user: {}):
+#     if not await ping(user):
+#         msg = 'You need to log in binance.com'
+#         await bot.send_message(user['tg_id'], msg)
+#         users_db.update({'ran': False}, user['key'])
+
+
+async def get_my_pts(user: Agent = None):  # payment methods
+    user = user or await Agent.get(nickName='Deals')
+    res = await breq(PTS, user, {})
+    return res['data']
+
+
+async def get_my_ads(user: Agent):
+    res = await breq(MY_ADS, user, {"inDeal": 1, "rows": 50, "page": 1})
+    return res['data']
+
+
+async def act_orders(user: Agent):  # payment methods
+    res = await breq(ORD, user, {"page": 1, "rows": 20, "orderStatusList": [0, 1, 2, 3, 5]})
+    return res['data'], res['total']
+
+
+async def get_arch_orders(user: Agent, part: int = 0, page: int = 1):  # payment methods
+    res = await breq(ORD_ARCH, user,
+                     {"page": page or 1, "rows": 50, "startDate": int((time() - m6 * (part + 1)) * 1000),
+                      "endDate": int((time() - m6 * part) * 1000)})
+    return res['data'], res['total']
+
+
+m6 = 60 * 60 * 24 * 30 * 6
+
+
+async def balance(user: Agent, spot0fond1: 0 | 1 = 1):  # payment methods
+    res = await breq(
+        BLNC_URL,
+        user,
+        is_post=False
+    )
+    return res['data'][spot0fond1]['assetBalances'] if res.get('data') else None
+
+
+async def get_ads(asset: str, cur: str, sell: int = 0, pts: [str] = None, rows: int = 20, page: int = 1):
+    payload = {"page": page,
+               "rows": rows,
+               "payTypes": pts,
+               "asset": asset,
+               "tradeType": "SELL" if sell else "BUY",
+               "fiat": cur,
+               # "transAmount": amount
+               }
+    return await breq(ADS, None, payload)
+
+
+async def get_ad(aid: str):
+    res = await breq(AD + aid, is_post=False)
+    return res.get('data')
+
+
+async def ad_fiat(coin: str, cur: str, sell: bool, price_type: int, price: float, amount: float):  # user
+    user = await Agent.get(nickName='Deals')
+    data = {"fields": [{"fieldId": "0000000000000000010", "fieldValue": "SHAINA CABANDO ABEJAR"},
+                       {"fieldId": "0000000000000000021", "fieldValue": "Meet in Cebu City"}],
+            "identifier": "CashInPerson",
+            "payStatus": "ACTIVE",
+            "googleVerifyCode": "465802"
+            }
+    data = {"fields": [{"fieldId": "30129764664654118912", "fieldValue": "SHAINA CABANDO ABEJAR"},  # real name
+                       {"fieldId": "30129764812512600064", "fieldValue": ""},  # nick in advcash
+                       {"fieldId": "30129764931661045760", "fieldValue": "mixartemev@gmail.com"},  # advcash email
+                       {"fieldId": "30129765053537591296", "fieldValue": "L 1808 3788 4260"}],  # wallet ID
+            "identifier": "Advcash",
+            "payStatus": "ACTIVE",
+            "googleVerifyCode": "836384"
+            }
+    res = await breq(FIAT_NEW, user, data)
+    return res.get('data', False)
+
+
+async def ad_new(coin: str, cur: str, sell: bool, price_type: int, price: float, amount: float):  # user
+    user = await Agent.get(nickName='Deals')
+    data = {"classify": "mass",
+            "autoReplyMsg": "Если не отвечаю дольше 5 минут, напишите пожалуйста сообщение, не всегда приходят уведомления о новых заявках",
+            "tradeType": "SELL" if sell else "BUY",
+            "onlineNow": True,
+            "fiatUnit": cur,
+            "asset": coin,
+            "initAmount": amount,  # todo take amount from found wallet
+            "maxSingleTransAmount": 50000,  # default
+            "minSingleTransAmount": 50,  # default
+            "payTimeLimit": 15 if sell else 60,
+            "priceType": price_type,
+            "priceFloatingRatio" if price_type-1 else "price": price,  # 1: stable, 2: float
+            "remarks": "Взаимный отзыв приветствуется:)",
+            "buyerKycLimit": 1,
+            "onlineDelayTime": 2,
+            "tradeMethods": [{"identifier": "BANK", "payId": 27973858, "payType": "BANK", "payAccount": "766-0-193538"}]
+            # "tradeMethods": [{"identifier": "YandexMoneyNew", "payId": 24956898},
+            #                  {"identifier": "TinkoffNew", "payId": 24956617},
+            #                  {"identifier": "RosBankNew", "payId": 24951855},
+            #                  {"identifier": "QIWI", "payId": 20023779, "payType": "QIWI", "payAccount": "79536515700"},
+            #                  {"identifier": "RUBfiatbalance", "payId": 16026051}]
+    }
+    res = await breq(AD_NEW, user, data)
+    return res.get('data', False)
+
+
+async def ad_upd():  # user, data: {}
+    user = await Agent.get(nickName='Deals')
+    data = {"asset": "RUB",
+            "fiatUnit": "RUB",
+            "priceType": 1,
+            # "priceScale": 2,
+            "advNo": 11419177391185489920,
+            "autoReplyMsg": "Взаимный лайк приветствуется:)\nЕсли усну, напишите сюда плиз или в tg: @ex212",
+            "initAmount": 50000,
+            "payTimeLimit": 30,
+            "price": 1.00,
+            "priceFloatingRatio": 100.12,
+            "minSingleTransAmount": 500,
+            "maxSingleTransAmount": 870000,
+            "remarks": "Оплачиваю быстро.\n",
+            "tradeMethods": [
+                {"identifier": "RaiffeisenBank"},
+                {"identifier": "RosBankNew"},
+                {"identifier": "TinkoffNew"},
+                {"identifier": "QIWI"},
+                {"identifier": "YandexMoneyNew"}
+            ],
+            "tradeType": "BUY",
+            "launchCountry": []  # "AE", "TR"
+            }
+    res = await breq(AD_UPD, user, data)
+    return res.get('data')
+
+
+async def ad_status_upd(aid: int, pub: bool = True):  # user, data: {}
+    user = await Agent.get(nickName='Deals')
+    data = {"advNos": [f"1{aid}"], "advStatus": int(pub)}
+    res = await breq(AD_UPD_ST, user, data)
+    return res.get('data')
+
+
+async def cur_min_amount(cur: str = 'RUB', coin: str = 'USDT'):  # user, data: {}
+    user = await Agent.get(nickName='Deals')
+    data = {"asset": coin, "fiatCurrency": cur, "tradeType": "BUY", "limitScene": "mass"}
+    res = await breq(CUR_MIN_AMT, user, data)
+    return res.get('data')
+
+
+async def get_rates():  # user, data: {}
+    user = await Agent.get(nickName='Deals')
+    res = await breq(RATES, user, is_post=False)
+    return {rate['fiatCurrency']: float(rate['exchangeRate']) for rate in res.get('data')}
+
+
+async def get_cur_rate(cur_id: str):
+    user = await Agent.get(nickName='Deals')
+    res = await breq(RATE, user, {"assets": ["USDT"], "fiatCurrency": cur_id, "tradeType": "BUY", "fromUserRole": "USER"})
+    return res['data'][0]['referencePrice']
+
+
+async def get_cur_pms(cur: str):
+    data = {"fiat": cur, "classifies": ["mass", "profession"]}
+    res = await post('https://p2p.binance.com/bapi/c2c/v2/public/c2c/adv/filter-conditions', user, {"assets": ["USDT"], "fiatCurrency": cur_id, "tradeType": "BUY", "fromUserRole": "USER"})
+    return res['data'][0]['referencePrice']
+
+
+if __name__ == "__main__":
+    try:
+        # pts = run(get_my_pts())
+        res = run(ad_new('DOGE', 'RUB', False, 2, 95.5, 1000))
+        print(res)
+    except KeyboardInterrupt:
+        print('Stopped.')

xync_client/Bybit/web_earn.py

@@ -0,0 +1,78 @@
+from enum import IntEnum
+
+from xync_schema.models import DepType
+from http_client import Client, repeat_on_fault
+
+
+class ProductType(IntEnum):
+    dual_assets = 2
+    flexible_saving_products = 4
+    liquidity_mining = 5
+    fixed_term_saving_products = 6
+    pos_staking_products = 8
+    fund_pool = 9
+
+type_map = {
+    ProductType.flexible_saving_products: DepType.earn,
+    ProductType.fixed_term_saving_products: DepType.earn,
+    ProductType.pos_staking_products: DepType.stake,
+}
+
+
+class BybitEarn(Client):  # Bybit async client
+    base_url = 'https://api2.bybit.com'
+    middle_url = '/'
+
+    def __init__(self, token: str = None):
+        self.headers = {
+            'content-type': 'application/json',
+            # 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36',
+            # 'Accept': '*/*',
+            # 'Accept-Encoding': 'gzip, deflate, br',
+            'origin': 'https://www.bybit.com',
+            'usertoken': token,
+        }
+        super().__init__()
+
+    """ PUBLIC METHS """
+    @repeat_on_fault()
+    async def get_coins(self) -> dict:
+        res = await self.post('s1/byfi/list-coins')
+        return {c['coin_enum']: c['coin_name'] for c in res['result']['coins']}
+
+    @repeat_on_fault()
+    async def get_home_earn_products(self, typ: ProductType = ProductType.flexible_saving_products):
+        res = await self.post('s1/byfi/get-homepage-product-cards', {'product_type': typ})
+        return res['result']
+
+    @repeat_on_fault()
+    async def get_lend_products(self):
+        res = await self.post('spot/api/lending/v1/token/list')
+        res = [{
+            'pid': f'{r["token"]}_lend',
+            'coin': r["token"],
+            'apr': r["apr"],
+            'duration': r["period"],
+            'min_limit': r["minPurchaseLimit"],
+            'max_limit': r["depositLimit"],
+            'type': 4,
+            'ex_id': 4,
+        } for r in res['result']]
+
+    # async def get_earn_products(self):
+    #     res = await self.post('s1/byfi/api/v1/get-overview-products')
+    #     coins = await self.get_coins()
+    #     eps = [{
+    #             'coin': await _ccoin(coins[coin]),
+    #             'pid': f"{coins[coin]}-{(pt:=ProductType(ep['product_type'])).name}",
+    #             'apr': tal[0]['apy_min_e8'] if (tal:=ep['tiered_apy_list']) and tal['apy_min_e8']==tal['apy_min_e8'] else 2,
+    #             'type': ProductType(ep['product_type']),
+    #             'duration': '',
+    #         } for coin, ep in {grp['coin']: grp['product_types'] for grp in res['result']['coin_products']}.items()]
+    #     return eps
+
+    @repeat_on_fault()
+    async def get_product_detail(self, typ: ProductType = ProductType.pos_staking_products, pid: str = "1"):
+        res = await self.post('s1/byfi/get-product-detail', {'product_id': pid, 'product_type': typ})
+        return res['result']
+

xync_client/Bybit/web_p2p.py

@@ -0,0 +1,329 @@
+from enum import IntEnum
+from time import sleep
+
+import pyotp
+
+from cex_clients.loader import BYT2FA
+from cex_clients.rs import RsClient
+
+
+class NoMakerException(Exception):
+    pass
+
+
+class AdsStatus(IntEnum):
+    REST = 0
+    WORKING = 1
+
+
+class BybitP2P(RsClient):  # Bybit client
+    host = 'api2.bybit.com'
+
+    pub_header = {"cookie": ";"}  # rewrite token for public methods
+
+    last_ad_id: list[str] = []
+    create_ad_body = {
+        "priceType": "1",
+        "premium": "119",
+        "quantity": "0.01",
+        "minAmount": "500",
+        "maxAmount": "3500",
+        "paymentPeriod": "15",
+        "remark": "",
+        "price": "",
+        "paymentIds": [
+            "3162981"
+        ],
+        "tradingPreferenceSet": {
+            "isKyc": "1",
+            "hasCompleteRateDay30": "0",
+            "completeRateDay30": "",
+            "hasOrderFinishNumberDay30": "0",
+            "orderFinishNumberDay30": "",
+            "isMobile": "0",
+            "isEmail": "0",
+            "hasUnPostAd": "0",
+            "hasRegisterTime": "0",
+            "registerTimeThreshold": "",
+            "hasNationalLimit": "0",
+            "nationalLimit": ""
+        },
+        "tokenId": "ETH",
+        "currencyId": "RUB",
+        "side": "1",
+        "securityRiskToken": ""
+    }
+    update_ad_body = {
+        "priceType": "1",
+        "premium": "118",
+        "quantity": "0.01",
+        "minAmount": "500",
+        "maxAmount": "3500000",
+        "paymentPeriod": "30",
+        "remark": "",
+        "price": "398244.84",
+        "paymentIds": [
+            "3162931"
+        ],
+        "tradingPreferenceSet": {
+            "isKyc": "1",
+            "hasCompleteRateDay30": "0",
+            "completeRateDay30": "",
+            "hasOrderFinishNumberDay30": "0",
+            "orderFinishNumberDay30": "0",
+            "isMobile": "0",
+            "isEmail": "0",
+            "hasUnPostAd": "0",
+            "hasRegisterTime": "0",
+            "registerTimeThreshold": "0",
+            "hasNationalLimit": "0",
+            "nationalLimit": ""
+        },
+        "actionType": "MODIFY",
+        "securityRiskToken": ""
+    }
+
+    """ PUBLIC METHS """
+    def get_ads(self, coin: str, cur: str, sell: bool = False, amount: int = None, payment: list[str] = None) -> list:
+        data = {
+            "userId": "",
+            "tokenId": coin,
+            "currencyId": cur,
+            "payment": payment or [],
+            "side": '0' if sell else '1',
+            "size": "10",
+            "page": "1",
+            "amount": str(amount) if amount else '',
+            "authMaker": False,
+            "canTrade": False
+        }
+        ads = self.post('/fiat/otc/item/online/', data, self.pub_header)
+        return ads['result']['items']
+
+    def get_config(self):
+        resp = self.get('/fiat/p2p/config/initial', self.pub_header)
+        return resp['result']  # todo: tokens, pairs, ...
+
+    def get_currencies(self):
+        config = self.get_config()
+        return config['symbols']
+
+    def get_coins(self):
+        coins = self.get('/spot/api/basic/symbol_list', self.pub_header)
+        return coins
+
+    def get_payment_methods(self):
+        pms = self.post('/fiat/otc/configuration/queryAllPaymentList/', headers=self.pub_header)
+        return pms
+
+    """ Private METHs"""
+    def create_payment_method(self, payment_type: int, real_name: str, account_number: str) -> dict:
+        method1 = self.post('/fiat/otc/user/payment/new_create', {
+            'paymentType': payment_type,
+            'realName': real_name,
+            'accountNo': account_number,
+            'securityRiskToken': ''
+        })
+        if srt := method1["result"]["securityRiskToken"]:
+            self.check_2fa(srt)
+            method2 = self.post('/fiat/otc/user/payment/new_create', {
+                'paymentType': payment_type,
+                'realName': real_name,
+                'accountNo': account_number,
+                'securityRiskToken': srt
+            })
+            return method2
+        else:
+            print(method1)
+
+    def get_payment_method(self, fiat_id: int = None) -> dict:
+        list_methods = self.get_user_pay_methods()
+        if fiat_id:
+            fiat = [m for m in list_methods if m['id'] == fiat_id][0]
+            return fiat
+        return list_methods[1]
+
+    def update_payment_method(self, real_name: str, account_number: str, fiat_id: int = None) -> dict:
+        fiat = self.get_payment_method(fiat_id)
+        fiat['realName'] = real_name
+        fiat['accountNo'] = account_number
+        result = self.post('/fiat/otc/user/payment/new_update', fiat)
+        srt = result["result"]["securityRiskToken"]
+        self.check_2fa(srt)
+        fiat['securityRiskToken'] = srt
+        result2 = self.post('/fiat/otc/user/payment/new_update', fiat)
+        return result2
+
+    def delete_payment_method(self, ids: str) -> dict:
+        data = {
+            'id': ids,
+            'securityRiskToken': ''
+        }
+        method = self.post('/fiat/otc/user/payment/new_delete', data)
+        srt = method["result"]["securityRiskToken"]
+        self.check_2fa(srt)
+        data['securityRiskToken'] = srt
+        delete = self.post('/fiat/otc/user/payment/new_delete', data)
+        return delete
+
+    def switch_ads(self, new_status: AdsStatus) -> dict:
+        data = {'workStatus': new_status.name}
+        res = self.post('/fiat/otc/maker/work-config/switch', data)
+        return res
+
+    def online_ads(self) -> str:
+        online = self.get('/fiat/otc/maker/work-config/get')
+        return online['result']['workStatus']
+
+    @staticmethod
+    def get_rate(list_ads: list) -> float:
+        ads = [ad for ad in list_ads if set(ad['payments']) - {'5', '51'}]
+        return float(ads[0]['price'])
+
+    def get_user_pay_methods(self):
+        upm = self.post('/fiat/otc/user/payment/list')
+        return upm['result']
+
+    def get_user_ads(self, active: bool = True) -> list:
+        uo = self.post('/fiat/otc/item/personal/list', {
+            "page": "1",
+            "size": "10",
+            "status": '2' if active else '0'
+        })
+        return uo['result']['items']
+
+    def get_security_token_create(self):
+        data = self.post('/fiat/otc/item/create', self.create_ad_body)
+        if data['ret_code'] == 912120019:  # Current user can not to create add as maker
+            raise NoMakerException(data)
+        security_risk_token = data["result"]["securityRiskToken"]
+        return security_risk_token
+
+    def check_2fa(self, risk_token):
+        # 2fa code
+        bybit_secret = BYT2FA
+        totp = pyotp.TOTP(bybit_secret)
+        totp_code = totp.now()
+
+        res = self.post('/user/public/risk/verify', {
+            "risk_token": risk_token,
+            "component_list": {
+                "google2fa": totp_code
+            }
+        })
+        if res['ret_msg'] != "success":
+            print('Wrong 2fa, wait 5 secs and retry..')
+            sleep(5)
+            self.check_2fa(risk_token)
+        return res
+
+    def post_ad(self, risk_token: str):
+        self.create_ad_body.update({'securityRiskToken': risk_token})
+        data = self.post('/fiat/otc/item/create', self.create_ad_body)
+        return data
+
+    # создание объявлений
+    def post_create_ad(self, token: str):
+        result_check_2fa = self.check_2fa(token)
+        assert result_check_2fa['ret_msg'] == 'success', '2FA code wrong'
+
+        result_add_ad = self.post_ad(token)
+        if result_add_ad['ret_msg'] != 'SUCCESS':
+            print('Wrong 2fa on Ad creating, wait 9 secs and retry..')
+            sleep(9)
+            return self.post_create_ad(token)
+        self.last_ad_id.append(result_add_ad['result']['itemId'])
+
+    def get_security_token_update(self) -> str:
+        self.update_ad_body['id'] = self.last_ad_id
+        data = self.post('/fiat/otc/item/update', self.update_ad_body)
+        security_risk_token = data["result"]["securityRiskToken"]
+        return security_risk_token
+
+    def post_update_ad(self, token):
+        result_check_2fa = self.check_2fa(token)
+        assert result_check_2fa['ret_msg'] == 'success', '2FA code wrong'
+
+        result_update_ad = self.update_ad(token)
+        if result_update_ad['ret_msg'] != 'SUCCESS':
+            print('Wrong 2fa on Ad updating, wait 10 secs and retry..')
+            sleep(10)
+            return self.post_update_ad(token)
+        # assert result_update_ad['ret_msg'] == 'SUCCESS', "Ad isn't updated"
+
+    def update_ad(self, risk_token: str):
+        self.update_ad_body.update({'securityRiskToken': risk_token})
+        data = self.post('/fiat/otc/item/update', self.update_ad_body)
+        return data
+
+    def delete_ad(self, ad_id: str):
+        data = self.post('/fiat/otc/item/cancel', {"itemId": ad_id})
+        return data
+
+    def create_order_taker(self, item_id: str, coin: str, cur: str, sell: bool, quantity: str, amount: float, cur_price: str):
+        data = self.post('/fiat/otc/order/create', json={
+            "itemId": item_id,
+            "tokenId": coin,
+            "currencyId": cur,
+            "side": '0' if sell else '1',
+            "quantity": quantity,
+            "amount": amount,
+            "curPrice": cur_price,
+            "flag": "amount",
+            "version": "1.0",
+            "securityRiskToken": ""
+        })
+        return data["result"]["securityRiskToken"]
+
+    def get_order_info(self, order_id: str) -> dict:
+        data = self.post('/fiat/otc/order/info', json={
+            "orderId": order_id
+        })
+        return data['result']
+
+    def get_chat_msg(self, order_id):
+        data = self.post('/fiat/otc/order/message/listpage', json={
+            "orderId": order_id,
+            "size": 100
+        })
+        msgs = [{'text': msg['message'], 'type': msg['contentType'], 'role': msg['roleType'], 'user_id': msg['userId']} for msg in data['result']['result'] if msg['roleType'] not in ('sys', 'alarm')]
+        return msgs
+
+    def block_user(self, user_id: str):
+        return self.post('/fiat/p2p/user/add_block_user', {
+            "blockedUserId": user_id
+        })
+
+    def unblock_user(self, user_id: str):
+        return self.post('/fiat/p2p/user/delete_block_user', {"blockedUserId": user_id})
+
+    def user_review_post(self, order_id: str):
+        return self.post('/fiat/otc/order/appraise/modify', {
+            "orderId": order_id,
+            "anonymous": "0",
+            "appraiseType": "1",  # тип оценки 1 - хорошо, 0 - плохо. При 0 - обязательно указывать appraiseContent
+            "appraiseContent": "",
+            "operateType": "ADD"  # при повторном отправлять не 'ADD' -> а 'EDIT'
+        })
+
+    def get_orders_active(self, begin_time: int, end_time: int, status: int, side: int, token_id: str):
+        return self.post('/fiat/otc/order/pending/simplifyList', {
+            "status": status,
+            "tokenId": token_id,
+            "beginTime": begin_time,
+            "endTime": end_time,
+            "side": side,  # 1 - продажа, 0 - покупка
+            "page": 1,
+            "size": 10
+        })
+
+    def get_orders_done(self, begin_time: int, end_time: int, status: int, side: int, token_id: str):
+        return self.post('/fiat/otc/order/simplifyList', {
+            "status": status,  # 50 - завершено
+            "tokenId": token_id,
+            "beginTime": begin_time,
+            "endTime": end_time,
+            "side": side,  # 1 - продажа, 0 - покупка
+            "page": 1,
+            "size": 10
+        })