ccxt 4.3.23__py2.py3-none-any.whl → 4.3.27__py2.py3-none-any.whl

ccxt/coinex.py

@@ -457,8 +457,15 @@ class coinex(Exchange, ImplicitAPI):
                 'fetchDepositAddress': {
                     'fillResponseFromRequest': True,
                 },
+                'accountsByType': {
+                    'spot': 'SPOT',
+                    'margin': 'MARGIN',
+                    'swap': 'FUTURES',
+                },
                 'accountsById': {
-                    'spot': '0',
+                    'SPOT': 'spot',
+                    'MARGIN': 'margin',
+                    'FUTURES': 'swap',
                 },
                 'networks': {
                     'BEP20': 'BSC',
@@ -3453,7 +3460,10 @@ class coinex(Exchange, ImplicitAPI):
         :param str [params.marginMode]: 'cross' or 'isolated' for fetching spot margin orders
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        return self.fetch_orders_by_status('pending', symbol, since, limit, params)
+        openOrders = self.fetch_orders_by_status('pending', symbol, since, limit, params)
+        for i in range(0, len(openOrders)):
+            openOrders[i]['status'] = 'open'
+        return openOrders
 
     def fetch_closed_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
@@ -4598,40 +4608,42 @@ class coinex(Exchange, ImplicitAPI):
     def transfer(self, code: str, amount: float, fromAccount: str, toAccount: str, params={}) -> TransferEntry:
         """
         transfer currency internally between wallets on the same account
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot002_account014_balance_contract_transfer
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot002_account013_margin_transfer
+        :see: https://docs.coinex.com/api/v2/assets/transfer/http/transfer
         :param str code: unified currency code
         :param float amount: amount to transfer
         :param str fromAccount: account to transfer from
         :param str toAccount: account to transfer to
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.symbol]: unified ccxt symbol, required when either the fromAccount or toAccount is margin
         :returns dict: a `transfer structure <https://docs.ccxt.com/#/?id=transfer-structure>`
         """
         self.load_markets()
         currency = self.currency(code)
         amountToPrecision = self.currency_to_precision(code, amount)
+        accountsByType = self.safe_dict(self.options, 'accountsById', {})
+        fromId = self.safe_string(accountsByType, fromAccount, fromAccount)
+        toId = self.safe_string(accountsByType, toAccount, toAccount)
         request = {
+            'ccy': currency['id'],
             'amount': amountToPrecision,
-            'coin_type': currency['id'],
+            'from_account_type': fromId,
+            'to_account_type': toId,
         }
-        response = None
-        if (fromAccount == 'spot') and (toAccount == 'swap'):
-            request['transfer_side'] = 'in'  # 'in' spot to swap, 'out' swap to spot
-            response = self.v1PrivatePostContractBalanceTransfer(self.extend(request, params))
-        elif (fromAccount == 'swap') and (toAccount == 'spot'):
-            request['transfer_side'] = 'out'  # 'in' spot to swap, 'out' swap to spot
-            response = self.v1PrivatePostContractBalanceTransfer(self.extend(request, params))
-        else:
-            accountsById = self.safe_value(self.options, 'accountsById', {})
-            fromId = self.safe_string(accountsById, fromAccount, fromAccount)
-            toId = self.safe_string(accountsById, toAccount, toAccount)
-            # fromAccount and toAccount must be integers for margin transfers
-            # spot is 0, use fetchBalance() to find the margin account id
-            request['from_account'] = int(fromId)
-            request['to_account'] = int(toId)
-            response = self.v1PrivatePostMarginTransfer(self.extend(request, params))
+        if (fromAccount == 'margin') or (toAccount == 'margin'):
+            symbol = self.safe_string(params, 'symbol')
+            if symbol is None:
+                raise ArgumentsRequired(self.id + ' transfer() the symbol parameter must be defined for a margin account')
+            params = self.omit(params, 'symbol')
+            request['market'] = self.market_id(symbol)
+        if (fromAccount != 'spot') and (toAccount != 'spot'):
+            raise BadRequest(self.id + ' transfer() can only be between spot and swap, or spot and margin, either the fromAccount or toAccount must be spot')
+        response = self.v2PrivatePostAssetsTransfer(self.extend(request, params))
         #
-        #     {"code": 0, "data": null, "message": "Success"}
+        #     {
+        #         "code": 0,
+        #         "data": {},
+        #         "message": "OK"
+        #     }
         #
         return self.extend(self.parse_transfer(response, currency), {
             'amount': self.parse_number(amountToPrecision),
@@ -4639,158 +4651,85 @@ class coinex(Exchange, ImplicitAPI):
             'toAccount': toAccount,
         })
 
-    def parse_transfer_status(self, status: Str) -> Str:
+    def parse_transfer_status(self, status):
         statuses = {
             '0': 'ok',
             'SUCCESS': 'ok',
+            'OK': 'ok',
+            'finished': 'ok',
+            'FINISHED': 'ok',
         }
         return self.safe_string(statuses, status, status)
 
     def parse_transfer(self, transfer: dict, currency: Currency = None) -> TransferEntry:
-        #
-        # fetchTransfers Swap
-        #
-        #     {
-        #         "amount": "10",
-        #         "asset": "USDT",
-        #         "transfer_type": "transfer_out",  # from swap to spot
-        #         "created_at": 1651633422
-        #     },
-        #
-        # fetchTransfers Margin
-        #
-        #     {
-        #         "id": 7580062,
-        #         "updated_at": 1653684379,
-        #         "user_id": 3620173,
-        #         "from_account_id": 0,
-        #         "to_account_id": 1,
-        #         "asset": "BTC",
-        #         "amount": "0.00160829",
-        #         "balance": "0.00160829",
-        #         "transfer_type": "IN",
-        #         "status": "SUCCESS",
-        #         "created_at": 1653684379
-        #     },
-        #
-        timestamp = self.safe_timestamp(transfer, 'created_at')
-        transferType = self.safe_string(transfer, 'transfer_type')
-        fromAccount = None
-        toAccount = None
-        if transferType == 'transfer_out':
-            fromAccount = 'swap'
-            toAccount = 'spot'
-        elif transferType == 'transfer_in':
-            fromAccount = 'spot'
-            toAccount = 'swap'
-        elif transferType == 'IN':
-            fromAccount = 'spot'
-            toAccount = 'margin'
-        elif transferType == 'OUT':
-            fromAccount = 'margin'
-            toAccount = 'spot'
-        currencyId = self.safe_string(transfer, 'asset')
-        currencyCode = self.safe_currency_code(currencyId, currency)
+        timestamp = self.safe_integer(transfer, 'created_at')
+        currencyId = self.safe_string(transfer, 'ccy')
+        fromId = self.safe_string(transfer, 'from_account_type')
+        toId = self.safe_string(transfer, 'to_account_type')
+        accountsById = self.safe_value(self.options, 'accountsById', {})
         return {
-            'info': transfer,
-            'id': self.safe_string(transfer, 'id'),
+            'id': None,
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
-            'currency': currencyCode,
+            'currency': self.safe_currency_code(currencyId, currency),
             'amount': self.safe_number(transfer, 'amount'),
-            'fromAccount': fromAccount,
-            'toAccount': toAccount,
+            'fromAccount': self.safe_string(accountsById, fromId, fromId),
+            'toAccount': self.safe_string(accountsById, toId, toId),
             'status': self.parse_transfer_status(self.safe_string_2(transfer, 'code', 'status')),
         }
 
     def fetch_transfers(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> TransferEntries:
         """
         fetch a history of internal transfers made on an account
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot002_account025_margin_transfer_history
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot002_account024_contract_transfer_history
+        :see: https://docs.coinex.com/api/v2/assets/transfer/http/list-transfer-history
         :param str code: unified currency code of the currency transferred
         :param int [since]: the earliest time in ms to fetch transfers for
-        :param int [limit]: the maximum number of  transfers structures to retrieve
+        :param int [limit]: the maximum number of transfer structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.marginMode]: 'cross' or 'isolated' for fetching transfers to and from your margin account
         :returns dict[]: a list of `transfer structures <https://docs.ccxt.com/#/?id=transfer-structure>`
         """
         self.load_markets()
-        currency = None
+        if code is None:
+            raise ArgumentsRequired(self.id + ' fetchTransfers() requires a code argument')
+        currency = self.currency(code)
         request = {
-            'page': 1,
-            # 'limit': limit,
-            # 'asset': 'USDT',
-            # 'start_time': since,
-            # 'end_time': 1515806440,
-            # 'transfer_type': 'transfer_in',  # transfer_in: from Spot to Swap Account, transfer_out: from Swap to Spot Account
+            'ccy': currency['id'],
         }
-        page = self.safe_integer(params, 'page')
-        if page is not None:
-            request['page'] = page
-        if code is not None:
-            currency = self.currency(code)
-            request['asset'] = currency['id']
-        if since is not None:
-            request['start_time'] = since
-        if limit is not None:
-            request['limit'] = limit
-        else:
-            request['limit'] = 100
-        params = self.omit(params, 'page')
         marginMode = None
         marginMode, params = self.handle_margin_mode_and_params('fetchTransfers', params)
-        response = None
         if marginMode is not None:
-            response = self.v1PrivateGetMarginTransferHistory(self.extend(request, params))
+            request['transfer_type'] = 'MARGIN'
         else:
-            response = self.v1PrivateGetContractTransferHistory(self.extend(request, params))
-        #
-        # Swap
+            request['transfer_type'] = 'FUTURES'
+        if since is not None:
+            request['start_time'] = since
+        if limit is not None:
+            request['limit'] = limit
+        request, params = self.handle_until_option('end_time', request, params)
+        response = self.v2PrivateGetAssetsTransferHistory(self.extend(request, params))
         #
         #     {
-        #         "code": 0,
-        #         "data": {
-        #             "records": [
-        #                 {
-        #                     "amount": "10",
-        #                     "asset": "USDT",
-        #                     "transfer_type": "transfer_out",
-        #                     "created_at": 1651633422
-        #                 },
-        #             ],
-        #             "total": 5
+        #         "data": [
+        #             {
+        #                 "created_at": 1715848480646,
+        #                 "from_account_type": "SPOT",
+        #                 "to_account_type": "FUTURES",
+        #                 "ccy": "USDT",
+        #                 "amount": "10",
+        #                 "status": "finished"
+        #             },
+        #         ],
+        #         "pagination": {
+        #             "total": 8,
+        #             "has_next": False
         #         },
-        #         "message": "Success"
-        #     }
-        #
-        # Margin
-        #
-        #     {
         #         "code": 0,
-        #         "data": {
-        #             "records": [
-        #                 {
-        #                     "id": 7580062,
-        #                     "updated_at": 1653684379,
-        #                     "user_id": 3620173,
-        #                     "from_account_id": 0,
-        #                     "to_account_id": 1,
-        #                     "asset": "BTC",
-        #                     "amount": "0.00160829",
-        #                     "balance": "0.00160829",
-        #                     "transfer_type": "IN",
-        #                     "status": "SUCCESS",
-        #                     "created_at": 1653684379
-        #                 }
-        #             ],
-        #             "total": 1
-        #         },
-        #         "message": "Success"
+        #         "message": "OK"
         #     }
         #
-        data = self.safe_value(response, 'data', {})
-        transfers = self.safe_list(data, 'records', [])
-        return self.parse_transfers(transfers, currency, since, limit)
+        data = self.safe_list(response, 'data', [])
+        return self.parse_transfers(data, currency, since, limit)
 
     def fetch_withdrawals(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
         """

ccxt/kraken.py

@@ -58,6 +58,9 @@ class kraken(Exchange, ImplicitAPI):
                 'cancelOrder': True,
                 'cancelOrders': True,
                 'createDepositAddress': True,
+                'createMarketBuyOrderWithCost': True,
+                'createMarketOrderWithCost': False,
+                'createMarketSellOrderWithCost': False,
                 'createOrder': True,
                 'createStopLimitOrder': True,
                 'createStopMarketOrder': True,
@@ -1308,6 +1311,33 @@ class kraken(Exchange, ImplicitAPI):
         #
         return self.parse_balance(response)
 
+    def create_market_order_with_cost(self, symbol: str, side: OrderSide, cost: float, params={}):
+        """
+        create a market order by providing the symbol, side and cost
+        :see: https://docs.kraken.com/rest/#tag/Trading/operation/addOrder
+        :param str symbol: unified symbol of the market to create an order in(only USD markets are supported)
+        :param str side: 'buy' or 'sell'
+        :param float cost: how much you want to trade in units of the quote currency
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.load_markets()
+        # only buy orders are supported by the endpoint
+        params['cost'] = cost
+        return self.create_order(symbol, 'market', side, cost, None, params)
+
+    def create_market_buy_order_with_cost(self, symbol: str, cost: float, params={}):
+        """
+        create a market buy order by providing the symbol, side and cost
+        :see: https://docs.kraken.com/rest/#tag/Trading/operation/addOrder
+        :param str symbol: unified symbol of the market to create an order in
+        :param float cost: how much you want to trade in units of the quote currency
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.load_markets()
+        return self.create_market_order_with_cost(symbol, 'buy', cost, params)
+
     def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
         """
         :see: https://docs.kraken.com/rest/#tag/Trading/operation/addOrder
@@ -1336,7 +1366,7 @@ class kraken(Exchange, ImplicitAPI):
             'ordertype': type,
             'volume': self.amount_to_precision(symbol, amount),
         }
-        orderRequest = self.order_request('createOrder', symbol, type, request, price, params)
+        orderRequest = self.order_request('createOrder', symbol, type, request, amount, price, params)
         response = self.privatePostAddOrder(self.extend(orderRequest[0], orderRequest[1]))
         #
         #     {
@@ -1616,7 +1646,7 @@ class kraken(Exchange, ImplicitAPI):
             'trades': trades,
         }, market)
 
-    def order_request(self, method, symbol, type, request, price=None, params={}):
+    def order_request(self, method: str, symbol: str, type: str, request: dict, amount: Num, price: Num = None, params={}):
         clientOrderId = self.safe_string_2(params, 'userref', 'clientOrderId')
         params = self.omit(params, ['userref', 'clientOrderId'])
         if clientOrderId is not None:
@@ -1630,9 +1660,21 @@ class kraken(Exchange, ImplicitAPI):
         trailingLimitAmount = self.safe_string(params, 'trailingLimitAmount')
         isTrailingAmountOrder = trailingAmount is not None
         isLimitOrder = type.endswith('limit')  # supporting limit, stop-loss-limit, take-profit-limit, etc
-        if isLimitOrder and not isTrailingAmountOrder:
+        isMarketOrder = type == 'market'
+        cost = self.safe_string(params, 'cost')
+        flags = self.safe_string(params, 'oflags')
+        params = self.omit(params, ['cost', 'oflags'])
+        isViqcOrder = (flags is not None) and (flags.find('viqc') > -1)  # volume in quote currency
+        if isMarketOrder and (cost is not None or isViqcOrder):
+            if cost is None and (amount is not None):
+                request['volume'] = self.cost_to_precision(symbol, self.number_to_string(amount))
+            else:
+                request['volume'] = self.cost_to_precision(symbol, cost)
+            extendedOflags = flags + ',viqc' if (flags is not None) else 'viqc'
+            request['oflags'] = extendedOflags
+        elif isLimitOrder and not isTrailingAmountOrder:
             request['price'] = self.price_to_precision(symbol, price)
-        reduceOnly = self.safe_value_2(params, 'reduceOnly', 'reduce_only')
+        reduceOnly = self.safe_bool_2(params, 'reduceOnly', 'reduce_only')
         if isStopLossOrTakeProfitTrigger:
             if isStopLossTriggerOrder:
                 request['price'] = self.price_to_precision(symbol, stopLossTriggerPrice)
@@ -1666,7 +1708,7 @@ class kraken(Exchange, ImplicitAPI):
                 request['reduce_only'] = True  # ws request can't have stringified bool
             else:
                 request['reduce_only'] = 'true'  # not using hasattr(self, boolean) case, because the urlencodedNested transforms it into 'True' string
-        close = self.safe_value(params, 'close')
+        close = self.safe_dict(params, 'close')
         if close is not None:
             close = self.extend({}, close)
             closePrice = self.safe_value(close, 'price')
@@ -1683,7 +1725,8 @@ class kraken(Exchange, ImplicitAPI):
         postOnly = None
         postOnly, params = self.handle_post_only(isMarket, False, params)
         if postOnly:
-            request['oflags'] = 'post'
+            extendedPostFlags = flags + ',post' if (flags is not None) else 'post'
+            request['oflags'] = extendedPostFlags
         params = self.omit(params, ['timeInForce', 'reduceOnly', 'stopLossPrice', 'takeProfitPrice', 'trailingAmount', 'trailingLimitAmount', 'offset'])
         return [request, params]
 
@@ -1716,7 +1759,7 @@ class kraken(Exchange, ImplicitAPI):
         }
         if amount is not None:
             request['volume'] = self.amount_to_precision(symbol, amount)
-        orderRequest = self.order_request('editOrder', symbol, type, request, price, params)
+        orderRequest = self.order_request('editOrder', symbol, type, request, amount, price, params)
         response = self.privatePostEditOrder(self.extend(orderRequest[0], orderRequest[1]))
         #
         #     {
@@ -2808,6 +2851,8 @@ class kraken(Exchange, ImplicitAPI):
             raise CancelPending(self.id + ' ' + body)
         if body.find('Invalid arguments:volume') >= 0:
             raise InvalidOrder(self.id + ' ' + body)
+        if body.find('Invalid arguments:viqc') >= 0:
+            raise InvalidOrder(self.id + ' ' + body)
         if body.find('Rate limit exceeded') >= 0:
             raise RateLimitExceeded(self.id + ' ' + body)
         if response is None:

ccxt/kucoin.py

@@ -4489,6 +4489,7 @@ class kucoin(Exchange, ImplicitAPI):
                 partnerSignature = self.hmac(self.encode(partnerPayload), self.encode(partnerSecret), hashlib.sha256, 'base64')
                 headers['KC-API-PARTNER-SIGN'] = partnerSignature
                 headers['KC-API-PARTNER'] = partnerId
+                headers['KC-API-PARTNER-VERIFY'] = 'true'
             if isBroker:
                 brokerName = self.safe_string(partner, 'name')
                 if brokerName is not None:

ccxt/phemex.py

@@ -2168,7 +2168,7 @@ class phemex(Exchange, ImplicitAPI):
         if feeCost is not None:
             fee = {
                 'cost': feeCost,
-                'currency': None,
+                'currency': self.safe_currency_code(self.safe_string(order, 'feeCurrency')),
             }
         timeInForce = self.parse_time_in_force(self.safe_string(order, 'timeInForce'))
         stopPrice = self.parse_number(self.omit_zero(self.from_ep(self.safe_string(order, 'stopPxEp'))))
@@ -2313,6 +2313,7 @@ class phemex(Exchange, ImplicitAPI):
             clientOrderId = None
         marketId = self.safe_string(order, 'symbol')
         symbol = self.safe_symbol(marketId, market)
+        market = self.safe_market(marketId, market)
         status = self.parse_order_status(self.safe_string(order, 'ordStatus'))
         side = self.parse_order_side(self.safe_string_lower(order, 'side'))
         type = self.parse_order_type(self.safe_string(order, 'orderType'))
@@ -2338,6 +2339,19 @@ class phemex(Exchange, ImplicitAPI):
             reduceOnly = True
         takeProfit = self.safe_string(order, 'takeProfitRp')
         stopLoss = self.safe_string(order, 'stopLossRp')
+        feeValue = self.omit_zero(self.safe_string(order, 'execFeeRv'))
+        ptFeeRv = self.omit_zero(self.safe_string(order, 'ptFeeRv'))
+        fee = None
+        if feeValue is not None:
+            fee = {
+                'cost': feeValue,
+                'currency': market['quote'],
+            }
+        elif ptFeeRv is not None:
+            fee = {
+                'cost': ptFeeRv,
+                'currency': 'PT',
+            }
         return self.safe_order({
             'info': order,
             'id': id,
@@ -2362,7 +2376,7 @@ class phemex(Exchange, ImplicitAPI):
             'cost': cost,
             'average': None,
             'status': status,
-            'fee': None,
+            'fee': fee,
             'trades': None,
         })
 

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.23'
+__version__ = '4.3.27'
 
 # ----------------------------------------------------------------------------
 
@@ -36,8 +36,8 @@ from ccxt.pro.blockchaincom import blockchaincom                          # noqa
 from ccxt.pro.bybit import bybit                                          # noqa: F401
 from ccxt.pro.cex import cex                                              # noqa: F401
 from ccxt.pro.coinbase import coinbase                                    # noqa: F401
+from ccxt.pro.coinbaseexchange import coinbaseexchange                    # noqa: F401
 from ccxt.pro.coinbaseinternational import coinbaseinternational          # noqa: F401
-from ccxt.pro.coinbasepro import coinbasepro                              # noqa: F401
 from ccxt.pro.coincheck import coincheck                                  # noqa: F401
 from ccxt.pro.coinex import coinex                                        # noqa: F401
 from ccxt.pro.coinone import coinone                                      # noqa: F401
@@ -103,8 +103,8 @@ exchanges = [
     'bybit',
     'cex',
     'coinbase',
+    'coinbaseexchange',
     'coinbaseinternational',
-    'coinbasepro',
     'coincheck',
     'coinex',
     'coinone',

ccxt/pro/binance.py

@@ -1951,7 +1951,7 @@ class binance(ccxt.async_support.binance):
         orders = self.parse_orders(result)
         client.resolve(orders, messageHash)
 
-    async def edit_order_ws(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}) -> Order:
+    async def edit_order_ws(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}) -> Order:
         """
         edit a trade order
         :see: https://binance-docs.github.io/apidocs/websocket_api/en/#cancel-and-replace-order-trade

ccxt/pro/bitget.py

@@ -1060,7 +1060,7 @@ class bitget(ccxt.async_support.bitget):
         #         "executePrice": "35123",  # self is limit price
         #         "triggerType": "fill_price",
         #         "planType": "amount",
-        #                   #### in case order had fill:  ####
+        #                   #### in case order had a partial fill:  ####
         #         fillPrice: '35123',
         #         tradeId: '1171775539946528779',
         #         baseVolume: '7',  # field present in market order
@@ -1177,13 +1177,19 @@ class bitget(ccxt.async_support.bitget):
         totalAmount = None
         filledAmount = None
         cost = None
+        remaining = None
+        totalFilled = self.safe_string(order, 'accBaseVolume')
         if isSpot:
             if isMargin:
                 filledAmount = self.omit_zero(self.safe_string(order, 'fillTotalAmount'))
                 totalAmount = self.omit_zero(self.safe_string(order, 'baseSize'))  # for margin trading
                 cost = self.safe_string(order, 'quoteSize')
             else:
-                filledAmount = self.omit_zero(self.safe_string_2(order, 'accBaseVolume', 'baseVolume'))
+                partialFillAmount = self.safe_string(order, 'baseVolume')
+                if partialFillAmount is not None:
+                    filledAmount = partialFillAmount
+                else:
+                    filledAmount = totalFilled
                 if isMarketOrder:
                     if isBuy:
                         totalAmount = accBaseVolume
@@ -1199,6 +1205,7 @@ class bitget(ccxt.async_support.bitget):
             filledAmount = self.safe_string(order, 'baseVolume')
             totalAmount = self.safe_string(order, 'size')
             cost = self.safe_string(order, 'fillNotionalUsd')
+        remaining = self.omit_zero(Precise.string_sub(totalAmount, totalFilled))
         return self.safe_order({
             'info': order,
             'symbol': symbol,
@@ -1217,7 +1224,7 @@ class bitget(ccxt.async_support.bitget):
             'cost': cost,
             'average': avgPrice,
             'filled': filledAmount,
-            'remaining': None,
+            'remaining': remaining,
             'status': self.parse_ws_order_status(rawStatus),
             'fee': feeObject,
             'trades': None,

ccxt/pro/{coinbasepro.py → coinbaseexchange.py}

@@ -16,10 +16,10 @@ from ccxt.base.errors import BadRequest
 from ccxt.base.errors import BadSymbol
 
 
-class coinbasepro(ccxt.async_support.coinbasepro):
+class coinbaseexchange(ccxt.async_support.coinbaseexchange):
 
     def describe(self):
-        return self.deep_extend(super(coinbasepro, self).describe(), {
+        return self.deep_extend(super(coinbaseexchange, self).describe(), {
             'has': {
                 'ws': True,
                 'watchOHLCV': False,  # missing on the exchange side
@@ -38,7 +38,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
             },
             'urls': {
                 'api': {
-                    'ws': 'wss://ws-feed.pro.coinbase.com',
+                    'ws': 'wss://ws-feed.exchange.coinbase.com',
                 },
                 'test': {
                     'ws': 'wss://ws-feed-public.sandbox.exchange.coinbase.com',
@@ -437,7 +437,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         #     "side": "buy",
         #     "order_type": "limit"
         # }
-        parsed = super(coinbasepro, self).parse_trade(trade)
+        parsed = super(coinbaseexchange, self).parse_trade(trade)
         feeRate = None
         isMaker = False
         if 'maker_fee_rate' in trade:
@@ -727,7 +727,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         #
         type = self.safe_string(ticker, 'type')
         if type is None:
-            return super(coinbasepro, self).parse_ticker(ticker, market)
+            return super(coinbaseexchange, self).parse_ticker(ticker, market)
         marketId = self.safe_string(ticker, 'product_id')
         symbol = self.safe_symbol(marketId, market, '-')
         timestamp = self.parse8601(self.safe_string(ticker, 'time'))

ccxt/pro/cryptocom.py

@@ -103,13 +103,16 @@ class cryptocom(ccxt.async_support.cryptocom):
         if topicParams is None:
             params['params'] = {}
         bookSubscriptionType = None
-        bookSubscriptionType, params = self.handle_option_and_params_2(params, 'watchOrderBook', 'watchOrderBookForSymbols', 'bookSubscriptionType', 'SNAPSHOT_AND_UPDATE')
-        if bookSubscriptionType is not None:
-            params['params']['bookSubscriptionType'] = bookSubscriptionType
+        bookSubscriptionType2 = None
+        bookSubscriptionType, params = self.handle_option_and_params(params, 'watchOrderBook', 'bookSubscriptionType', 'SNAPSHOT_AND_UPDATE')
+        bookSubscriptionType2, params = self.handle_option_and_params(params, 'watchOrderBookForSymbols', 'bookSubscriptionType', bookSubscriptionType)
+        params['params']['bookSubscriptionType'] = bookSubscriptionType2
         bookUpdateFrequency = None
-        bookUpdateFrequency, params = self.handle_option_and_params_2(params, 'watchOrderBook', 'watchOrderBookForSymbols', 'bookUpdateFrequency')
-        if bookUpdateFrequency is not None:
-            params['params']['bookSubscriptionType'] = bookSubscriptionType
+        bookUpdateFrequency2 = None
+        bookUpdateFrequency, params = self.handle_option_and_params(params, 'watchOrderBook', 'bookUpdateFrequency')
+        bookUpdateFrequency2, params = self.handle_option_and_params(params, 'watchOrderBookForSymbols', 'bookUpdateFrequency', bookUpdateFrequency)
+        if bookUpdateFrequency2 is not None:
+            params['params']['bookSubscriptionType'] = bookUpdateFrequency2
         for i in range(0, len(symbols)):
             symbol = symbols[i]
             market = self.market(symbol)