ccxt 4.4.35__py2.py3-none-any.whl → 4.4.37__py2.py3-none-any.whl

ccxt/bitfinex2.py

@@ -15,7 +15,6 @@ from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import BadSymbol
 from ccxt.base.errors import InsufficientFunds
-from ccxt.base.errors import InvalidAddress
 from ccxt.base.errors import InvalidOrder
 from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import NotSupported
@@ -432,12 +431,10 @@ class bitfinex2(Exchange, ImplicitAPI):
                     'temporarily_unavailable': ExchangeNotAvailable,
                 },
                 'broad': {
-                    'address': InvalidAddress,
                     'available balance is only': InsufficientFunds,
                     'not enough exchange balance': InsufficientFunds,
                     'Order not found': OrderNotFound,
                     'symbol: invalid': BadSymbol,
-                    'Invalid order': InvalidOrder,
                 },
             },
             'commonCurrencies': {
@@ -781,7 +778,10 @@ class bitfinex2(Exchange, ImplicitAPI):
             name = self.safe_string(label, 1)
             pool = self.safe_value(indexed['pool'], id, [])
             rawType = self.safe_string(pool, 1)
-            type = 'other' if (rawType is None) else 'crypto'
+            isCryptoCoin = (rawType is not None) or (id in indexed['explorer'])  # "hacky" solution
+            type = None
+            if isCryptoCoin:
+                type = 'crypto'
             feeValues = self.safe_value(indexed['fees'], id, [])
             fees = self.safe_value(feeValues, 1, [])
             fee = self.safe_number(fees, 1)
@@ -1680,7 +1680,8 @@ class bitfinex2(Exchange, ImplicitAPI):
             raise ExchangeError(self.id + ' ' + response[6] + ': ' + errorText + '(#' + errorCode + ')')
         orders = self.safe_list(response, 4, [])
         order = self.safe_list(orders, 0)
-        return self.parse_order(self.extend({'result': order}), market)
+        newOrder = {'result': order}
+        return self.parse_order(newOrder, market)
 
     def create_orders(self, orders: List[OrderRequest], params={}):
         """
@@ -1776,6 +1777,9 @@ class bitfinex2(Exchange, ImplicitAPI):
         self.load_markets()
         cid = self.safe_value_2(params, 'cid', 'clientOrderId')  # client order id
         request = None
+        market = None
+        if symbol is not None:
+            market = self.market(symbol)
         if cid is not None:
             cidDate = self.safe_value(params, 'cidDate')  # client order id date
             if cidDate is None:
@@ -1791,8 +1795,8 @@ class bitfinex2(Exchange, ImplicitAPI):
             }
         response = self.privatePostAuthWOrderCancel(self.extend(request, params))
         order = self.safe_value(response, 4)
-        orderObject = {'result': order}
-        return self.parse_order(orderObject)
+        newOrder = {'result': order}
+        return self.parse_order(newOrder, market)
 
     def cancel_orders(self, ids, symbol: Str = None, params={}):
         """
@@ -2293,6 +2297,8 @@ class bitfinex2(Exchange, ImplicitAPI):
                 status = 'failed'
             tag = self.safe_string(data, 3)
             type = 'withdrawal'
+            networkId = self.safe_string(data, 2)
+            network = self.network_id_to_code(networkId.upper())  # withdraw returns in lowercase
         elif transactionLength == 22:
             id = self.safe_string(transaction, 0)
             currencyId = self.safe_string(transaction, 1)
@@ -2589,10 +2595,7 @@ class bitfinex2(Exchange, ImplicitAPI):
         text = self.safe_string(response, 7)
         if text != 'success':
             self.throw_broadly_matched_exception(self.exceptions['broad'], text, text)
-        transaction = self.parse_transaction(response, currency)
-        return self.extend(transaction, {
-            'address': address,
-        })
+        return self.parse_transaction(response, currency)
 
     def fetch_positions(self, symbols: Strings = None, params={}):
         """
@@ -3501,7 +3504,8 @@ class bitfinex2(Exchange, ImplicitAPI):
         #     ]
         #
         order = self.safe_list(response, 0)
-        return self.parse_order(order, market)
+        newOrder = {'result': order}
+        return self.parse_order(newOrder, market)
 
     def edit_order(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}):
         """
@@ -3616,4 +3620,5 @@ class bitfinex2(Exchange, ImplicitAPI):
             errorText = response[7]
             raise ExchangeError(self.id + ' ' + response[6] + ': ' + errorText + '(#' + errorCode + ')')
         order = self.safe_list(response, 4, [])
-        return self.parse_order(order, market)
+        newOrder = {'result': order}
+        return self.parse_order(newOrder, market)

ccxt/bitmex.py

@@ -286,6 +286,108 @@ class bitmex(Exchange, ImplicitAPI):
                     'SOL': 'sol',
                     'ADA': 'ada',
                 },
+                'features': {
+                    'default': {
+                        'sandbox': True,
+                        'createOrder': {
+                            'marginMode': True,
+                            'triggerPrice': True,
+                            'triggerPriceType': {
+                                'last': True,
+                                'mark': True,
+                            },
+                            'triggerDirection': True,
+                            'stopLossPrice': False,
+                            'takeProfitPrice': False,
+                            'attachedStopLossTakeProfit': None,
+                            'timeInForce': {
+                                'IOC': True,
+                                'FOK': True,
+                                'PO': True,
+                                'GTD': False,
+                            },
+                            'hedged': False,
+                            'trailing': True,
+                            'marketBuyRequiresPrice': False,
+                            'marketBuyByCost': False,
+                            # exchange-supported features
+                            # 'selfTradePrevention': True,
+                            # 'twap': False,
+                            # 'iceberg': False,
+                            # 'oco': False,
+                        },
+                        'createOrders': None,
+                        'fetchMyTrades': {
+                            'marginMode': False,
+                            'limit': 500,
+                            'daysBack': None,
+                            'untilDays': 1000000,
+                        },
+                        'fetchOrder': {
+                            'marginMode': False,
+                            'trigger': False,
+                            'trailing': False,
+                        },
+                        'fetchOpenOrders': {
+                            'marginMode': False,
+                            'limit': 500,
+                            'trigger': False,
+                            'trailing': False,
+                        },
+                        'fetchOrders': {
+                            'marginMode': False,
+                            'limit': 500,
+                            'daysBack': None,
+                            'untilDays': 1000000,
+                            'trigger': False,
+                            'trailing': False,
+                        },
+                        'fetchClosedOrders': {
+                            'marginMode': False,
+                            'limit': 500,
+                            'daysBackClosed': None,
+                            'daysBackCanceled': None,
+                            'untilDays': 1000000,
+                            'trigger': False,
+                            'trailing': False,
+                        },
+                        'fetchOHLCV': {
+                            'limit': 10000,
+                        },
+                    },
+                    'spot': {
+                        'extends': 'default',
+                        'createOrder': {
+                            'triggerPriceType': {
+                                'index': False,
+                            },
+                        },
+                    },
+                    'forDeriv': {
+                        'extends': 'default',
+                        'createOrder': {
+                            'triggerPriceType': {
+                                'index': True,
+                            },
+                        },
+                    },
+                    'swap': {
+                        'linear': {
+                            'extends': 'forDeriv',
+                        },
+                        'inverse': {
+                            'extends': 'forDeriv',
+                        },
+                    },
+                    'future': {
+                        'linear': {
+                            'extends': 'forDeriv',
+                        },
+                        'inverse': {
+                            'extends': 'forDeriv',
+                        },
+                    },
+                },
             },
             'commonCurrencies': {
                 'USDt': 'USDT',
@@ -991,7 +1093,7 @@ class bitmex(Exchange, ImplicitAPI):
         if since is not None:
             request['startTime'] = self.iso8601(since)
         if limit is not None:
-            request['count'] = limit
+            request['count'] = min(500, limit)
         until = self.safe_integer_2(params, 'until', 'endTime')
         if until is not None:
             params = self.omit(params, ['until'])

ccxt/bitopro.py

@@ -153,6 +153,7 @@ class bitopro(Exchange, ImplicitAPI):
                         'wallet/withdraw/{currency}/id/{id}': 1,
                         'wallet/depositHistory/{currency}': 1,
                         'wallet/withdrawHistory/{currency}': 1,
+                        'orders/open': 1,
                     },
                     'post': {
                         'orders/{pair}': 1 / 2,  # 1200/m => 20/s => 10/20 = 1/2
@@ -1248,10 +1249,26 @@ class bitopro(Exchange, ImplicitAPI):
         return self.parse_orders(orders, market, since, limit)
 
     def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
-        request: dict = {
-            'statusKind': 'OPEN',
-        }
-        return self.fetch_orders(symbol, since, limit, self.extend(request, params))
+        """
+        fetch all unfilled currently open orders
+
+        https://github.com/bitoex/bitopro-offical-api-docs/blob/master/api/v3/private/get_open_orders_data.md
+
+        :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
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.load_markets()
+        request: dict = {}
+        market = None
+        if symbol is not None:
+            market = self.market(symbol)
+            request['pair'] = market['id']
+        response = self.privateGetOrdersOpen(self.extend(request, params))
+        orders = self.safe_list(response, 'data', [])
+        return self.parse_orders(orders, market, since, limit)
 
     def fetch_closed_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """

ccxt/bitso.py

@@ -1683,6 +1683,7 @@ class bitso(Exchange, ImplicitAPI):
         if api == 'private':
             self.check_required_credentials()
             nonce = str(self.nonce())
+            endpoint = '/api' + endpoint
             request = ''.join([nonce, method, endpoint])
             if method != 'GET' and method != 'DELETE':
                 if query:
@@ -1692,7 +1693,7 @@ class bitso(Exchange, ImplicitAPI):
             auth = self.apiKey + ':' + nonce + ':' + signature
             headers = {
                 'Authorization': 'Bitso ' + auth,
-                'Content-Type': 'application/json',
+                # 'Content-Type': 'application/json',
             }
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 

ccxt/bybit.py

@@ -257,6 +257,9 @@ class bybit(Exchange, ImplicitAPI):
                         'v5/spot-cross-margin-trade/data': 5,
                         'v5/spot-cross-margin-trade/pledge-token': 5,
                         'v5/spot-cross-margin-trade/borrow-token': 5,
+                        # crypto loan
+                        'v5/crypto-loan/collateral-data': 5,
+                        'v5/crypto-loan/loanable-data': 5,
                         # institutional lending
                         'v5/ins-loan/product-infos': 5,
                         'v5/ins-loan/ensure-tokens-convert': 5,
@@ -384,6 +387,8 @@ class bybit(Exchange, ImplicitAPI):
                         'v5/user/aff-customer-info': 5,
                         'v5/user/del-submember': 5,
                         'v5/user/submembers': 5,
+                        # affilate
+                        'v5/affiliate/aff-user-list': 5,
                         # spot leverage token
                         'v5/spot-lever-token/order-record': 1,  # 50/s => cost = 50 / 50 = 1
                         # spot margin trade
@@ -393,6 +398,13 @@ class bybit(Exchange, ImplicitAPI):
                         'v5/spot-cross-margin-trade/account': 1,  # 50/s => cost = 50 / 50 = 1
                         'v5/spot-cross-margin-trade/orders': 1,  # 50/s => cost = 50 / 50 = 1
                         'v5/spot-cross-margin-trade/repay-history': 1,  # 50/s => cost = 50 / 50 = 1
+                        # crypto loan
+                        'v5/crypto-loan/borrowable-collateralisable-number': 5,
+                        'v5/crypto-loan/ongoing-orders': 5,
+                        'v5/crypto-loan/repayment-history': 5,
+                        'v5/crypto-loan/borrow-history': 5,
+                        'v5/crypto-loan/max-collateral-amount': 5,
+                        'v5/crypto-loan/adjustment-history': 5,
                         # institutional lending
                         'v5/ins-loan/product-infos': 5,
                         'v5/ins-loan/ensure-tokens-convert': 5,
@@ -404,7 +416,7 @@ class bybit(Exchange, ImplicitAPI):
                         'v5/lending/history-order': 5,
                         'v5/lending/account': 5,
                         # broker
-                        'v5/broker/earning-record': 5,
+                        'v5/broker/earning-record': 5,  # deprecated
                         'v5/broker/earnings-info': 5,
                         'v5/broker/account-info': 5,
                         'v5/broker/asset/query-sub-member-deposit-record': 10,
@@ -525,6 +537,10 @@ class bybit(Exchange, ImplicitAPI):
                         'v5/spot-cross-margin-trade/loan': 2.5,  # 20/s => cost = 50 / 20 = 2.5
                         'v5/spot-cross-margin-trade/repay': 2.5,  # 20/s => cost = 50 / 20 = 2.5
                         'v5/spot-cross-margin-trade/switch': 2.5,  # 20/s => cost = 50 / 20 = 2.5
+                        # crypto loan
+                        'v5/crypto-loan/borrow': 5,
+                        'v5/crypto-loan/repay': 5,
+                        'v5/crypto-loan/adjust-ltv': 5,
                         # institutional lending
                         'v5/ins-loan/association-uid': 5,
                         # c2c lending
@@ -535,6 +551,10 @@ class bybit(Exchange, ImplicitAPI):
                         'v5/account/set-collateral-switch-batch': 5,
                         # demo trading
                         'v5/account/demo-apply-money': 5,
+                        # broker
+                        'v5/broker/award/info': 5,
+                        'v5/broker/award/distribute-award': 5,
+                        'v5/broker/award/distribution-record': 5,
                     },
                 },
             },

ccxt/coinbase.py

@@ -88,6 +88,8 @@ class coinbase(Exchange, ImplicitAPI):
                 'fetchDepositAddress': 'emulated',
                 'fetchDepositAddresses': False,
                 'fetchDepositAddressesByNetwork': True,
+                'fetchDepositMethodId': True,
+                'fetchDepositMethodIds': True,
                 'fetchDeposits': True,
                 'fetchDepositsWithdrawals': True,
                 'fetchFundingHistory': False,
@@ -4102,6 +4104,90 @@ class coinbase(Exchange, ImplicitAPI):
         data = self.safe_dict(response, 'data', {})
         return self.parse_transaction(data)
 
+    def fetch_deposit_method_ids(self, params={}):
+        """
+        fetch the deposit id for a fiat currency associated with self account
+
+        https://docs.cdp.coinbase.com/advanced-trade/reference/retailbrokerageapi_getpaymentmethods
+
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an array of `deposit id structures <https://docs.ccxt.com/#/?id=deposit-id-structure>`
+        """
+        self.load_markets()
+        response = self.v3PrivateGetBrokeragePaymentMethods(params)
+        #
+        #     {
+        #         "payment_methods": [
+        #             {
+        #                 "id": "21b39a5d-f7b46876fb2e",
+        #                 "type": "COINBASE_FIAT_ACCOUNT",
+        #                 "name": "CAD Wallet",
+        #                 "currency": "CAD",
+        #                 "verified": True,
+        #                 "allow_buy": False,
+        #                 "allow_sell": True,
+        #                 "allow_deposit": False,
+        #                 "allow_withdraw": False,
+        #                 "created_at": "2023-06-29T19:58:46Z",
+        #                 "updated_at": "2023-10-30T20:25:01Z"
+        #             }
+        #         ]
+        #     }
+        #
+        result = self.safe_list(response, 'payment_methods', [])
+        return self.parse_deposit_method_ids(result)
+
+    def fetch_deposit_method_id(self, id: str, params={}):
+        """
+        fetch the deposit id for a fiat currency associated with self account
+
+        https://docs.cdp.coinbase.com/advanced-trade/reference/retailbrokerageapi_getpaymentmethod
+
+        :param str id: the deposit payment method id
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `deposit id structure <https://docs.ccxt.com/#/?id=deposit-id-structure>`
+        """
+        self.load_markets()
+        request: dict = {
+            'payment_method_id': id,
+        }
+        response = self.v3PrivateGetBrokeragePaymentMethodsPaymentMethodId(self.extend(request, params))
+        #
+        #     {
+        #         "payment_method": {
+        #             "id": "21b39a5d-f7b46876fb2e",
+        #             "type": "COINBASE_FIAT_ACCOUNT",
+        #             "name": "CAD Wallet",
+        #             "currency": "CAD",
+        #             "verified": True,
+        #             "allow_buy": False,
+        #             "allow_sell": True,
+        #             "allow_deposit": False,
+        #             "allow_withdraw": False,
+        #             "created_at": "2023-06-29T19:58:46Z",
+        #             "updated_at": "2023-10-30T20:25:01Z"
+        #         }
+        #     }
+        #
+        result = self.safe_dict(response, 'payment_method', {})
+        return self.parse_deposit_method_id(result)
+
+    def parse_deposit_method_ids(self, ids, params={}):
+        result = []
+        for i in range(0, len(ids)):
+            id = self.extend(self.parse_deposit_method_id(ids[i]), params)
+            result.append(id)
+        return result
+
+    def parse_deposit_method_id(self, depositId):
+        return {
+            'info': depositId,
+            'id': self.safe_string(depositId, 'id'),
+            'currency': self.safe_string(depositId, 'currency'),
+            'verified': self.safe_bool(depositId, 'verified'),
+            'tag': self.safe_string(depositId, 'name'),
+        }
+
     def fetch_convert_quote(self, fromCode: str, toCode: str, amount: Num = None, params={}) -> Conversion:
         """
         fetch a quote for converting from one currency to another