ccxt 4.4.34__py2.py3-none-any.whl → 4.4.36__py2.py3-none-any.whl

ccxt/onetrading.py

@@ -5,7 +5,7 @@
 
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.onetrading import ImplicitAPI
-from ccxt.base.types import Balances, Currencies, Currency, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFees, Transaction
+from ccxt.base.types import Balances, Currencies, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFees
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -47,7 +47,7 @@ class onetrading(Exchange, ImplicitAPI):
                 'cancelOrders': True,
                 'closeAllPositions': False,
                 'closePosition': False,
-                'createDepositAddress': True,
+                'createDepositAddress': False,
                 'createOrder': True,
                 'createReduceOnlyOrder': False,
                 'createStopLimitOrder': True,
@@ -62,10 +62,10 @@ class onetrading(Exchange, ImplicitAPI):
                 'fetchCrossBorrowRates': False,
                 'fetchCurrencies': True,
                 'fetchDeposit': False,
-                'fetchDepositAddress': True,
+                'fetchDepositAddress': False,
                 'fetchDepositAddresses': False,
                 'fetchDepositAddressesByNetwork': False,
-                'fetchDeposits': True,
+                'fetchDeposits': False,
                 'fetchDepositsWithdrawals': False,
                 'fetchFundingHistory': False,
                 'fetchFundingRate': False,
@@ -98,7 +98,7 @@ class onetrading(Exchange, ImplicitAPI):
                 'fetchTicker': True,
                 'fetchTickers': True,
                 'fetchTime': True,
-                'fetchTrades': True,
+                'fetchTrades': False,
                 'fetchTradingFee': False,
                 'fetchTradingFees': True,
                 'fetchTransactionFee': False,
@@ -107,14 +107,14 @@ class onetrading(Exchange, ImplicitAPI):
                 'fetchTransfer': False,
                 'fetchTransfers': False,
                 'fetchWithdrawal': False,
-                'fetchWithdrawals': True,
+                'fetchWithdrawals': False,
                 'reduceMargin': False,
                 'setLeverage': False,
                 'setMargin': False,
                 'setMarginMode': False,
                 'setPositionMode': False,
                 'transfer': False,
-                'withdraw': True,
+                'withdraw': False,
             },
             'timeframes': {
                 '1m': '1/MINUTES',
@@ -149,32 +149,20 @@ class onetrading(Exchange, ImplicitAPI):
                         'order-book/{instrument_code}',
                         'market-ticker',
                         'market-ticker/{instrument_code}',
-                        'price-ticks/{instrument_code}',
                         'time',
                     ],
                 },
                 'private': {
                     'get': [
                         'account/balances',
-                        'account/deposit/crypto/{currency_code}',
-                        'account/deposit/fiat/EUR',
-                        'account/deposits',
-                        'account/deposits/bitpanda',
-                        'account/withdrawals',
-                        'account/withdrawals/bitpanda',
                         'account/fees',
                         'account/orders',
                         'account/orders/{order_id}',
                         'account/orders/{order_id}/trades',
                         'account/trades',
                         'account/trades/{trade_id}',
-                        'account/trading-volume',
                     ],
                     'post': [
-                        'account/deposit/crypto',
-                        'account/withdraw/crypto',
-                        'account/withdraw/fiat',
-                        'account/fees',
                         'account/orders',
                     ],
                     'delete': [
@@ -636,6 +624,9 @@ class onetrading(Exchange, ImplicitAPI):
     def fetch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+
+        https://docs.onetrading.com/#market-ticker-for-instrument
+
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -669,7 +660,10 @@ class onetrading(Exchange, ImplicitAPI):
     def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
-        :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
+
+        https://docs.onetrading.com/#market-ticker
+
+        :param str[] [symbols]: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
@@ -706,6 +700,9 @@ class onetrading(Exchange, ImplicitAPI):
     def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+
+        https://docs.onetrading.com/#order-book
+
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -828,6 +825,9 @@ class onetrading(Exchange, ImplicitAPI):
     def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+
+        https://docs.onetrading.com/#candlesticks
+
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
         :param int [since]: timestamp in ms of the earliest candle to fetch
@@ -946,44 +946,6 @@ class onetrading(Exchange, ImplicitAPI):
             'info': trade,
         }, market)
 
-    def fetch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
-        """
-        get the list of most recent trades for a particular symbol
-        :param str symbol: unified symbol of the market to fetch trades for
-        :param int [since]: timestamp in ms of the earliest trade to fetch
-        :param int [limit]: the maximum amount of trades to fetch
-        :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns Trade[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
-        """
-        self.load_markets()
-        market = self.market(symbol)
-        request: dict = {
-            'instrument_code': market['id'],
-            # 'from': self.iso8601(since),
-            # 'to': self.iso8601(self.milliseconds()),
-        }
-        if since is not None:
-            # returns price ticks for a specific market with an interval of maximum of 4 hours
-            # sorted by latest first
-            request['from'] = self.iso8601(since)
-            request['to'] = self.iso8601(self.sum(since, 14400000))
-        response = self.publicGetPriceTicksInstrumentCode(self.extend(request, params))
-        #
-        #     [
-        #         {
-        #             "instrument_code":"BTC_EUR",
-        #             "price":"8137.28",
-        #             "amount":"0.22269",
-        #             "taker_side":"BUY",
-        #             "volume":"1812.0908832",
-        #             "time":"2020-07-10T14:44:32.299Z",
-        #             "trade_timestamp":1594392272299,
-        #             "sequence":603047
-        #         }
-        #     ]
-        #
-        return self.parse_trades(response, market, since, limit)
-
     def parse_balance(self, response) -> Balances:
         balances = self.safe_value(response, 'balances', [])
         result: dict = {'info': response}
@@ -1000,6 +962,9 @@ class onetrading(Exchange, ImplicitAPI):
     def fetch_balance(self, params={}) -> Balances:
         """
         query for balance and get the amount of funds available for trading or funds locked in orders
+
+        https://docs.onetrading.com/#balances
+
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """
@@ -1023,317 +988,6 @@ class onetrading(Exchange, ImplicitAPI):
         #
         return self.parse_balance(response)
 
-    def parse_deposit_address(self, depositAddress, currency: Currency = None) -> DepositAddress:
-        code = None
-        if currency is not None:
-            code = currency['code']
-        address = self.safe_string(depositAddress, 'address')
-        tag = self.safe_string(depositAddress, 'destination_tag')
-        self.check_address(address)
-        return {
-            'info': depositAddress,
-            'currency': code,
-            'network': None,
-            'address': address,
-            'tag': tag,
-        }
-
-    def create_deposit_address(self, code: str, params={}):
-        """
-        create a currency deposit address
-        :param str code: unified currency code of the currency for the deposit address
-        :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
-        """
-        self.load_markets()
-        currency = self.currency(code)
-        request: dict = {
-            'currency': currency['id'],
-        }
-        response = self.privatePostAccountDepositCrypto(self.extend(request, params))
-        #
-        #     {
-        #         "address":"rBnNhk95FrdNisZtXcStzriFS8vEzz53DM",
-        #         "destination_tag":"865690307",
-        #         "enabled":true,
-        #         "is_smart_contract":false
-        #     }
-        #
-        return self.parse_deposit_address(response, currency)
-
-    def fetch_deposit_address(self, code: str, params={}) -> DepositAddress:
-        """
-        fetch the deposit address for a currency associated with self account
-        :param str code: unified currency code
-        :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
-        """
-        self.load_markets()
-        currency = self.currency(code)
-        request: dict = {
-            'currency_code': currency['id'],
-        }
-        response = self.privateGetAccountDepositCryptoCurrencyCode(self.extend(request, params))
-        #
-        #     {
-        #         "address":"rBnNhk95FrdNisZtXcStzriFS8vEzz53DM",
-        #         "destination_tag":"865690307",
-        #         "enabled":true,
-        #         "is_smart_contract":false,
-        #         "can_create_more":false
-        #     }
-        #
-        return self.parse_deposit_address(response, currency)
-
-    def fetch_deposits(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
-        """
-        fetch all deposits made to an account
-        :param str code: unified currency code
-        :param int [since]: the earliest time in ms to fetch deposits for
-        :param int [limit]: the maximum number of deposits structures to retrieve
-        :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
-        """
-        self.load_markets()
-        request: dict = {
-            # 'cursor': 'string',  # pointer specifying the position from which the next pages should be returned
-        }
-        currency = None
-        if code is not None:
-            currency = self.currency(code)
-            request['currency_code'] = currency['id']
-        if limit is not None:
-            request['max_page_size'] = limit
-        if since is not None:
-            to = self.safe_string(params, 'to')
-            if to is None:
-                raise ArgumentsRequired(self.id + ' fetchDeposits() requires a "to" iso8601 string param with the since argument is specified')
-            request['from'] = self.iso8601(since)
-        response = self.privateGetAccountDeposits(self.extend(request, params))
-        #
-        #     {
-        #         "deposit_history": [
-        #             {
-        #                 "transaction_id": "e5342efcd-d5b7-4a56-8e12-b69ffd68c5ef",
-        #                 "account_id": "c2d0076a-c20d-41f8-9e9a-1a1d028b2b58",
-        #                 "amount": "100",
-        #                 "type": "CRYPTO",
-        #                 "funds_source": "INTERNAL",
-        #                 "time": "2020-04-22T09:57:47Z",
-        #                 "currency": "BTC",
-        #                 "fee_amount": "0.0",
-        #                 "fee_currency": "BTC"
-        #             },
-        #             {
-        #                 "transaction_id": "79793d00-2899-4a4d-95b7-73ae6b31384f",
-        #                 "account_id": "c2d0076a-c20d-41f8-9e9a-1a1d028b2b58",
-        #                 "time": "2020-05-05T11:22:07.925Z",
-        #                 "currency": "EUR",
-        #                 "funds_source": "EXTERNAL",
-        #                 "type": "FIAT",
-        #                 "amount": "50.0",
-        #                 "fee_amount": "0.01",
-        #                 "fee_currency": "EUR"
-        #             }
-        #         ],
-        #         "max_page_size": 2,
-        #         "cursor": "eyJhY2NvdW50X2lkIjp7InMiOiJlMzY5YWM4MC00NTc3LTExZTktYWUwOC05YmVkYzQ3OTBiODQiLCJzcyI6W10sIm5zIjpbXSwiYnMiOltdLCJtIjp7fSwibCI6W119LCJpdGVtX2tleSI6eyJzIjoiV0lUSERSQVdBTDo6MmFlMjYwY2ItOTk3MC00YmNiLTgxNmEtZGY4MDVmY2VhZTY1Iiwic3MiOltdLCJucyI6W10sImJzIjpbXSwibSI6e30sImwiOltdfSwiZ2xvYmFsX3dpdGhkcmF3YWxfaW5kZXhfaGFzaF9rZXkiOnsicyI6ImUzNjlhYzgwLTQ1NzctMTFlOS1hZTA4LTliZWRjNDc5MGI4NCIsInNzIjpbXSwibnMiOltdLCJicyI6W10sIm0iOnt9LCJsIjpbXX0sInRpbWVzdGFtcCI6eyJuIjoiMTU4ODA1ODc2Nzk0OCIsInNzIjpbXSwibnMiOltdLCJicyI6W10sIm0iOnt9LCJsIjpbXX19"
-        #     }
-        #
-        depositHistory = self.safe_list(response, 'deposit_history', [])
-        return self.parse_transactions(depositHistory, currency, since, limit, {'type': 'deposit'})
-
-    def fetch_withdrawals(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
-        """
-        fetch all withdrawals made from an account
-        :param str code: unified currency code
-        :param int [since]: the earliest time in ms to fetch withdrawals for
-        :param int [limit]: the maximum number of withdrawals structures to retrieve
-        :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
-        """
-        self.load_markets()
-        request: dict = {
-            # 'cursor': 'string',  # pointer specifying the position from which the next pages should be returned
-        }
-        currency = None
-        if code is not None:
-            currency = self.currency(code)
-            request['currency_code'] = currency['id']
-        if limit is not None:
-            request['max_page_size'] = limit
-        if since is not None:
-            to = self.safe_string(params, 'to')
-            if to is None:
-                raise ArgumentsRequired(self.id + ' fetchWithdrawals() requires a "to" iso8601 string param with the since argument is specified')
-            request['from'] = self.iso8601(since)
-        response = self.privateGetAccountWithdrawals(self.extend(request, params))
-        #
-        #     {
-        #         "withdrawal_history": [
-        #             {
-        #                 "account_id": "e369ac80-4577-11e9-ae08-9bedc4790b84",
-        #                 "amount": "0.1",
-        #                 "currency": "BTC",
-        #                 "fee_amount": "0.00002",
-        #                 "fee_currency": "BTC",
-        #                 "funds_source": "EXTERNAL",
-        #                 "related_transaction_id": "e298341a-3855-405e-bce3-92db368a3157",
-        #                 "time": "2020-05-05T11:11:32.110Z",
-        #                 "transaction_id": "6693ff40-bb10-4dcf-ada7-3b287727c882",
-        #                 "type": "CRYPTO"
-        #             },
-        #             {
-        #                 "account_id": "e369ac80-4577-11e9-ae08-9bedc4790b84",
-        #                 "amount": "0.1",
-        #                 "currency": "BTC",
-        #                 "fee_amount": "0.0",
-        #                 "fee_currency": "BTC",
-        #                 "funds_source": "INTERNAL",
-        #                 "time": "2020-05-05T10:29:53.464Z",
-        #                 "transaction_id": "ec9703b1-954b-4f76-adea-faac66eabc0b",
-        #                 "type": "CRYPTO"
-        #             }
-        #         ],
-        #         "cursor": "eyJhY2NvdW50X2lkIjp7InMiOiJlMzY5YWM4MC00NTc3LTExZTktYWUwOC05YmVkYzQ3OTBiODQiLCJzcyI6W10sIm5zIjpbXSwiYnMiOltdLCJtIjp7fSwibCI6W119LCJpdGVtX2tleSI6eyJzIjoiV0lUSERSQVdBTDo6ZWM5NzAzYjEtOTU0Yi00Zjc2LWFkZWEtZmFhYzY2ZWFiYzBiIiwic3MiOltdLCJucyI6W10sImJzIjpbXSwibSI6e30sImwiOltdfSwiZ2xvYmFsX3dpdGhkcmF3YWxfaW5kZXhfaGFzaF9rZXkiOnsicyI6ImUzNjlhYzgwLTQ1NzctMTFlOS1hZTA4LTliZWRjNDc5MGI4NCIsInNzIjpbXSwibnMiOltdLCJicyI6W10sIm0iOnt9LCJsIjpbXX0sInRpbWVzdGFtcCI6eyJuIjoiMTU4ODY3NDU5MzQ2NCIsInNzIjpbXSwibnMiOltdLCJicyI6W10sIm0iOnt9LCJsIjpbXX19",
-        #         "max_page_size": 2
-        #     }
-        #
-        withdrawalHistory = self.safe_list(response, 'withdrawal_history', [])
-        return self.parse_transactions(withdrawalHistory, currency, since, limit, {'type': 'withdrawal'})
-
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
-        """
-        make a withdrawal
-        :param str code: unified currency code
-        :param float amount: the amount to withdraw
-        :param str address: the address to withdraw to
-        :param str tag:
-        :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict: a `transaction structure <https://docs.ccxt.com/#/?id=transaction-structure>`
-        """
-        tag, params = self.handle_withdraw_tag_and_params(tag, params)
-        self.check_address(address)
-        self.load_markets()
-        currency = self.currency(code)
-        request: dict = {
-            'currency': code,
-            'amount': self.currency_to_precision(code, amount),
-            # 'payout_account_id': '66756a10-3e86-48f4-9678-b634c4b135b2',  # fiat only
-            # 'recipient': { # crypto only
-            #     'address': address,
-            #     # 'destination_tag': '',
-            # },
-        }
-        options = self.safe_value(self.options, 'fiat', [])
-        isFiat = self.in_array(code, options)
-        method = 'privatePostAccountWithdrawFiat' if isFiat else 'privatePostAccountWithdrawCrypto'
-        if isFiat:
-            payoutAccountId = self.safe_string(params, 'payout_account_id')
-            if payoutAccountId is None:
-                raise ArgumentsRequired(self.id + ' withdraw() requires a payout_account_id param for fiat ' + code + ' withdrawals')
-        else:
-            recipient: dict = {'address': address}
-            if tag is not None:
-                recipient['destination_tag'] = tag
-            request['recipient'] = recipient
-        response = getattr(self, method)(self.extend(request, params))
-        #
-        # crypto
-        #
-        #     {
-        #         "amount": "1234.5678",
-        #         "fee": "1234.5678",
-        #         "recipient": "3NacQ7rzZdhfyAtfJ5a11k8jFPdcMP2Bq7",
-        #         "destination_tag": "",
-        #         "transaction_id": "d0f8529f-f832-4e6a-9dc5-b8d5797badb2"
-        #     }
-        #
-        # fiat
-        #
-        #     {
-        #         "transaction_id": "54236cd0-4413-11e9-93fb-5fea7e5b5df6"
-        #     }
-        #
-        return self.parse_transaction(response, currency)
-
-    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
-        #
-        # fetchDeposits, fetchWithdrawals
-        #
-        #     {
-        #         "transaction_id": "C2b42efcd-d5b7-4a56-8e12-b69ffd68c5ef",
-        #         "type": "FIAT",
-        #         "account_id": "c2d0076a-c20d-41f8-9e9a-1a1d028b2b58",
-        #         "amount": "1234.5678",
-        #         "time": "2019-08-24T14:15:22Z",
-        #         "funds_source": "INTERNAL",
-        #         "currency": "BTC",
-        #         "fee_amount": "1234.5678",
-        #         "fee_currency": "BTC",
-        #         "blockchain_transaction_id": "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
-        #         "related_transaction_id": "e298341a-3855-405e-bce3-92db368a3157"
-        #     }
-        #
-        # withdraw
-        #
-        #
-        #     crypto
-        #
-        #     {
-        #         "amount": "1234.5678",
-        #         "fee": "1234.5678",
-        #         "recipient": "3NacQ7rzZdhfyAtfJ5a11k8jFPdcMP2Bq7",
-        #         "destination_tag": "",
-        #         "transaction_id": "d0f8529f-f832-4e6a-9dc5-b8d5797badb2"
-        #     }
-        #
-        #     fiat
-        #
-        #     {
-        #         "transaction_id": "54236cd0-4413-11e9-93fb-5fea7e5b5df6"
-        #     }
-        #
-        id = self.safe_string(transaction, 'transaction_id')
-        amount = self.safe_number(transaction, 'amount')
-        timestamp = self.parse8601(self.safe_string(transaction, 'time'))
-        currencyId = self.safe_string(transaction, 'currency')
-        currency = self.safe_currency(currencyId, currency)
-        status = 'ok'  # the exchange returns cleared transactions only
-        feeCost = self.safe_number_2(transaction, 'fee_amount', 'fee')
-        fee = None
-        addressTo = self.safe_string(transaction, 'recipient')
-        tagTo = self.safe_string(transaction, 'destination_tag')
-        if feeCost is not None:
-            feeCurrencyId = self.safe_string(transaction, 'fee_currency', currencyId)
-            feeCurrencyCode = self.safe_currency_code(feeCurrencyId)
-            fee = {
-                'cost': feeCost,
-                'currency': feeCurrencyCode,
-            }
-        return {
-            'info': transaction,
-            'id': id,
-            'currency': currency['code'],
-            'amount': amount,
-            'network': None,
-            'address': addressTo,
-            'addressFrom': None,
-            'addressTo': addressTo,
-            'tag': tagTo,
-            'tagFrom': None,
-            'tagTo': tagTo,
-            'status': status,
-            'type': None,
-            'updated': None,
-            'txid': self.safe_string(transaction, 'blockchain_transaction_id'),
-            'comment': None,
-            'internal': None,
-            'timestamp': timestamp,
-            'datetime': self.iso8601(timestamp),
-            'fee': fee,
-        }
-
     def parse_order_status(self, status: Str):
         statuses: dict = {
             'FILLED': 'open',
@@ -1535,6 +1189,9 @@ class onetrading(Exchange, ImplicitAPI):
     def cancel_order(self, id: str, symbol: Str = None, params={}):
         """
         cancels an open order
+
+        https://docs.onetrading.com/#close-order-by-order-id
+
         :param str id: order id
         :param str symbol: not used by bitmex cancelOrder()
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1559,6 +1216,9 @@ class onetrading(Exchange, ImplicitAPI):
     def cancel_all_orders(self, symbol: Str = None, params={}):
         """
         cancel all open orders
+
+        https://docs.onetrading.com/#close-all-orders
+
         :param str symbol: unified market symbol, only orders in the market of self symbol are cancelled when symbol is not None
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
@@ -1579,6 +1239,9 @@ class onetrading(Exchange, ImplicitAPI):
     def cancel_orders(self, ids, symbol: Str = None, params={}):
         """
         cancel multiple orders
+
+        https://docs.onetrading.com/#close-all-orders
+
         :param str[] ids: order ids
         :param str symbol: unified market symbol, default is None
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1599,6 +1262,9 @@ class onetrading(Exchange, ImplicitAPI):
     def fetch_order(self, id: str, symbol: Str = None, params={}):
         """
         fetches information on an order made by the user
+
+        https://docs.onetrading.com/#get-order
+
         :param str id: the order id
         :param str symbol: not used by onetrading fetchOrder
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1655,6 +1321,9 @@ class onetrading(Exchange, ImplicitAPI):
     def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         fetch all unfilled currently open orders
+
+        https://docs.onetrading.com/#get-orders
+
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch open orders for
         :param int [limit]: the maximum number of  open orders structures to retrieve
@@ -1769,6 +1438,9 @@ class onetrading(Exchange, ImplicitAPI):
     def fetch_closed_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         fetches information on multiple closed orders made by the user
+
+        https://docs.onetrading.com/#get-orders
+
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: the earliest time in ms to fetch orders for
         :param int [limit]: the maximum number of order structures to retrieve
@@ -1783,6 +1455,9 @@ class onetrading(Exchange, ImplicitAPI):
     def fetch_order_trades(self, id: str, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetch all the trades made from a single order
+
+        https://docs.onetrading.com/#trades-for-order
+
         :param str id: order id
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch trades for
@@ -1838,6 +1513,9 @@ class onetrading(Exchange, ImplicitAPI):
     def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetch all trades made by the user
+
+        https://docs.onetrading.com/#all-trades
+
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch trades for
         :param int [limit]: the maximum number of trades structures to retrieve

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.34'
+__version__ = '4.4.36'
 
 # ----------------------------------------------------------------------------
 
@@ -46,6 +46,7 @@ from ccxt.pro.coinex import coinex                                        # noqa
 from ccxt.pro.coinone import coinone                                      # noqa: F401
 from ccxt.pro.cryptocom import cryptocom                                  # noqa: F401
 from ccxt.pro.currencycom import currencycom                              # noqa: F401
+from ccxt.pro.defx import defx                                            # noqa: F401
 from ccxt.pro.deribit import deribit                                      # noqa: F401
 from ccxt.pro.exmo import exmo                                            # noqa: F401
 from ccxt.pro.gate import gate                                            # noqa: F401
@@ -121,6 +122,7 @@ exchanges = [
     'coinone',
     'cryptocom',
     'currencycom',
+    'defx',
     'deribit',
     'exmo',
     'gate',

ccxt/pro/bitrue.py

@@ -36,15 +36,17 @@ class bitrue(ccxt.async_support.bitrue):
             },
             'api': {
                 'open': {
-                    'private': {
-                        'post': {
-                            'poseidon/api/v1/listenKey': 1,
-                        },
-                        'put': {
-                            'poseidon/api/v1/listenKey/{listenKey}': 1,
-                        },
-                        'delete': {
-                            'poseidon/api/v1/listenKey/{listenKey}': 1,
+                    'v1': {
+                        'private': {
+                            'post': {
+                                'poseidon/api/v1/listenKey': 1,
+                            },
+                            'put': {
+                                'poseidon/api/v1/listenKey/{listenKey}': 1,
+                            },
+                            'delete': {
+                                'poseidon/api/v1/listenKey/{listenKey}': 1,
+                            },
                         },
                     },
                 },
@@ -405,7 +407,7 @@ class bitrue(ccxt.async_support.bitrue):
     async def authenticate(self, params={}):
         listenKey = self.safe_value(self.options, 'listenKey')
         if listenKey is None:
-            response = await self.openPrivatePostPoseidonApiV1ListenKey(params)
+            response = await self.openV1PrivatePostPoseidonApiV1ListenKey(params)
             #
             #     {
             #         "msg": "succ",
@@ -429,7 +431,7 @@ class bitrue(ccxt.async_support.bitrue):
             'listenKey': listenKey,
         }
         try:
-            await self.openPrivatePutPoseidonApiV1ListenKeyListenKey(self.extend(request, params))
+            await self.openV1PrivatePutPoseidonApiV1ListenKeyListenKey(self.extend(request, params))
             #
             # ಠ_ಠ
             #     {