ccxt 4.3.39__py2.py3-none-any.whl → 4.3.41__py2.py3-none-any.whl

ccxt/bitstamp.py

@@ -1376,7 +1376,17 @@ class bitstamp(Exchange, ImplicitAPI):
         request: dict = {
             'id': id,
         }
-        return self.privatePostCancelOrder(self.extend(request, params))
+        response = self.privatePostCancelOrder(self.extend(request, params))
+        #
+        #    {
+        #        "id": 1453282316578816,
+        #        "amount": "0.02035278",
+        #        "price": "2100.45",
+        #        "type": 0,
+        #        "market": "BTC/USD"
+        #    }
+        #
+        return self.parse_order(response)
 
     def cancel_all_orders(self, symbol: Str = None, params={}):
         """
@@ -1397,7 +1407,23 @@ class bitstamp(Exchange, ImplicitAPI):
             response = self.privatePostCancelAllOrdersPair(self.extend(request, params))
         else:
             response = self.privatePostCancelAllOrders(self.extend(request, params))
-        return response
+        #
+        #    {
+        #        "canceled": [
+        #            {
+        #                "id": 1453282316578816,
+        #                "amount": "0.02035278",
+        #                "price": "2100.45",
+        #                "type": 0,
+        #                "currency_pair": "BTC/USD",
+        #                "market": "BTC/USD"
+        #            }
+        #        ],
+        #        "success": True
+        #    }
+        #
+        canceled = self.safe_list(response, 'canceled')
+        return self.parse_orders(canceled)
 
     def parse_order_status(self, status: Str):
         statuses: dict = {
@@ -1743,6 +1769,16 @@ class bitstamp(Exchange, ImplicitAPI):
         #           "id": "2814205012"
         #       }
         #
+        # cancelOrder
+        #
+        #    {
+        #        "id": 1453282316578816,
+        #        "amount": "0.02035278",
+        #        "price": "2100.45",
+        #        "type": 0,
+        #        "market": "BTC/USD"
+        #    }
+        #
         id = self.safe_string(order, 'id')
         clientOrderId = self.safe_string(order, 'client_order_id')
         side = self.safe_string(order, 'type')

ccxt/coinlist.py

@@ -1397,7 +1397,25 @@ class coinlist(Exchange, ImplicitAPI):
         self.load_markets()
         params = ids
         response = self.privateDeleteV1OrdersBulk(params)
-        return response
+        #
+        #    {
+        #        "message": "Cancel order requests received.",
+        #        "order_ids": [
+        #            "ff132955-43bc-4fe5-9d9c-5ba226cc89a0"
+        #        ],
+        #        "timestamp": "2024-06-01T02:32:30.305Z"
+        #    }
+        #
+        orderIds = self.safe_list(response, 'order_ids', [])
+        orders = []
+        datetime = self.safe_string(response, 'timestamp')
+        for i in range(0, len(orderIds)):
+            orders.append(self.safe_order({
+                'info': orderIds[i],
+                'id': orderIds[i],
+                'lastUpdateTimestamp': self.parse8601(datetime),
+            }))
+        return orders
 
     def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
         """

ccxt/coinmate.py

@@ -895,6 +895,13 @@ class coinmate(Exchange, ImplicitAPI):
         #         "trailing": False,
         #     }
         #
+        # cancelOrder
+        #
+        #    {
+        #        "success": True,
+        #        "remainingAmount": 0.1
+        #    }
+        #
         id = self.safe_string(order, 'id')
         timestamp = self.safe_integer(order, 'timestamp')
         side = self.safe_string_lower(order, 'type')
@@ -1003,9 +1010,18 @@ class coinmate(Exchange, ImplicitAPI):
         #   {"error":false,"errorMessage":null,"data":{"success":true,"remainingAmount":0.01}}
         request: dict = {'orderId': id}
         response = self.privatePostCancelOrderWithInfo(self.extend(request, params))
-        return {
-            'info': response,
-        }
+        #
+        #    {
+        #        "error": False,
+        #        "errorMessage": null,
+        #        "data": {
+        #          "success": True,
+        #          "remainingAmount": 0.1
+        #        }
+        #    }
+        #
+        data = self.safe_dict(response, 'data')
+        return self.parse_order(data)
 
     def nonce(self):
         return self.milliseconds()

ccxt/coinone.py

@@ -1020,7 +1020,7 @@ class coinone(Exchange, ImplicitAPI):
         #         "errorCode": "0"
         #     }
         #
-        return response
+        return self.safe_order(response)
 
     def fetch_deposit_addresses(self, codes: Strings = None, params={}):
         """

ccxt/coinspot.py

@@ -505,11 +505,20 @@ class coinspot(Exchange, ImplicitAPI):
         if side != 'buy' and side != 'sell':
             raise ArgumentsRequired(self.id + ' cancelOrder() requires a side parameter, "buy" or "sell"')
         params = self.omit(params, 'side')
-        method = 'privatePostMy' + self.capitalize(side) + 'Cancel'
         request: dict = {
             'id': id,
         }
-        return getattr(self, method)(self.extend(request, params))
+        response = None
+        if side == 'buy':
+            response = self.privatePostMyBuyCancel(self.extend(request, params))
+        else:
+            response = self.privatePostMySellCancel(self.extend(request, params))
+        #
+        # status - ok, error
+        #
+        return self.safe_order({
+            'info': response,
+        })
 
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
         url = self.urls['api'][api] + '/' + path

ccxt/hitbtc.py

@@ -860,8 +860,8 @@ class hitbtc(Exchange, ImplicitAPI):
                 network = self.safe_network(networkId)
                 fee = self.safe_number(rawNetwork, 'payout_fee')
                 networkPrecision = self.safe_number(rawNetwork, 'precision_payout')
-                payinEnabledNetwork = self.safe_bool(entry, 'payin_enabled', False)
-                payoutEnabledNetwork = self.safe_bool(entry, 'payout_enabled', False)
+                payinEnabledNetwork = self.safe_bool(rawNetwork, 'payin_enabled', False)
+                payoutEnabledNetwork = self.safe_bool(rawNetwork, 'payout_enabled', False)
                 activeNetwork = payinEnabledNetwork and payoutEnabledNetwork
                 if payinEnabledNetwork and not depositEnabled:
                     depositEnabled = True

ccxt/independentreserve.py

@@ -375,6 +375,21 @@ class independentreserve(Exchange, ImplicitAPI):
         #         "FeePercent": 0.005,
         #     }
         #
+        # cancelOrder
+        #
+        #    {
+        #        "AvgPrice": 455.48,
+        #        "CreatedTimestampUtc": "2022-08-05T06:42:11.3032208Z",
+        #        "OrderGuid": "719c495c-a39e-4884-93ac-280b37245037",
+        #        "Price": 485.76,
+        #        "PrimaryCurrencyCode": "Xbt",
+        #        "ReservedAmount": 0.358,
+        #        "SecondaryCurrencyCode": "Usd",
+        #        "Status": "Cancelled",
+        #        "Type": "LimitOffer",
+        #        "VolumeFilled": 0,
+        #        "VolumeOrdered": 0.358
+        #    }
         symbol = None
         baseId = self.safe_string(order, 'PrimaryCurrencyCode')
         quoteId = self.safe_string(order, 'SecondaryCurrencyCode')
@@ -666,6 +681,7 @@ class independentreserve(Exchange, ImplicitAPI):
     def cancel_order(self, id: str, symbol: Str = None, params={}):
         """
         cancels an open order
+        :see: https://www.independentreserve.com/features/api#CancelOrder
         :param str id: order id
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -675,7 +691,23 @@ class independentreserve(Exchange, ImplicitAPI):
         request: dict = {
             'orderGuid': id,
         }
-        return self.privatePostCancelOrder(self.extend(request, params))
+        response = self.privatePostCancelOrder(self.extend(request, params))
+        #
+        #    {
+        #        "AvgPrice": 455.48,
+        #        "CreatedTimestampUtc": "2022-08-05T06:42:11.3032208Z",
+        #        "OrderGuid": "719c495c-a39e-4884-93ac-280b37245037",
+        #        "Price": 485.76,
+        #        "PrimaryCurrencyCode": "Xbt",
+        #        "ReservedAmount": 0.358,
+        #        "SecondaryCurrencyCode": "Usd",
+        #        "Status": "Cancelled",
+        #        "Type": "LimitOffer",
+        #        "VolumeFilled": 0,
+        #        "VolumeOrdered": 0.358
+        #    }
+        #
+        return self.parse_order(response)
 
     def fetch_deposit_address(self, code: str, params={}):
         """

ccxt/indodax.py

@@ -641,6 +641,24 @@ class indodax(Exchange, ImplicitAPI):
         #       "order_xrp": "30.45000000",
         #       "remain_xrp": "0.00000000"
         #     }
+        #
+        # cancelOrder
+        #
+        #    {
+        #        "order_id": 666883,
+        #        "client_order_id": "clientx-sj82ks82j",
+        #        "type": "sell",
+        #        "pair": "btc_idr",
+        #        "balance": {
+        #            "idr": "33605800",
+        #            "btc": "0.00000000",
+        #            ...
+        #            "frozen_idr": "0",
+        #            "frozen_btc": "0.00000000",
+        #            ...
+        #        }
+        #    }
+        #
         side = None
         if 'type' in order:
             side = order['type']
@@ -650,6 +668,8 @@ class indodax(Exchange, ImplicitAPI):
         price = self.safe_string(order, 'price')
         amount = None
         remaining = None
+        marketId = self.safe_string(order, 'pair')
+        market = self.safe_market(marketId, market)
         if market is not None:
             symbol = market['symbol']
             quoteId = market['quoteId']
@@ -668,7 +688,7 @@ class indodax(Exchange, ImplicitAPI):
         return self.safe_order({
             'info': order,
             'id': id,
-            'clientOrderId': None,
+            'clientOrderId': self.safe_string(order, 'client_order_id'),
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'lastTradeTimestamp': None,
@@ -825,7 +845,28 @@ class indodax(Exchange, ImplicitAPI):
             'pair': market['id'],
             'type': side,
         }
-        return self.privatePostCancelOrder(self.extend(request, params))
+        response = self.privatePostCancelOrder(self.extend(request, params))
+        #
+        #    {
+        #        "success": 1,
+        #        "return": {
+        #            "order_id": 666883,
+        #            "client_order_id": "clientx-sj82ks82j",
+        #            "type": "sell",
+        #            "pair": "btc_idr",
+        #            "balance": {
+        #                "idr": "33605800",
+        #                "btc": "0.00000000",
+        #                ...
+        #                "frozen_idr": "0",
+        #                "frozen_btc": "0.00000000",
+        #                ...
+        #            }
+        #        }
+        #    }
+        #
+        data = self.safe_dict(response, 'return')
+        return self.parse_order(data)
 
     def fetch_transaction_fee(self, code: str, params={}):
         """

ccxt/okx.py

@@ -369,6 +369,9 @@ class okx(Exchange, ImplicitAPI):
                         'account/greeks': 2,
                         'account/position-tiers': 2,
                         'account/mmp-config': 4,
+                        'account/fixed-loan/borrowing-limit': 4,
+                        'account/fixed-loan/borrowing-quote': 5,
+                        'account/fixed-loan/borrowing-orders-list': 5,
                         # subaccount
                         'users/subaccount/list': 10,
                         'account/subaccount/balances': 10 / 3,
@@ -494,6 +497,10 @@ class okx(Exchange, ImplicitAPI):
                         'account/set-account-level': 4,
                         'account/mmp-reset': 4,
                         'account/mmp-config': 100,
+                        'account/fixed-loan/borrowing-order': 5,
+                        'account/fixed-loan/amend-borrowing-order': 5,
+                        'account/fixed-loan/manual-reborrow': 5,
+                        'account/fixed-loan/repay-borrowing-order': 5,
                         # subaccount
                         'users/subaccount/modify-apikey': 10,
                         'asset/subaccount/transfer': 10,

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.39'
+__version__ = '4.3.41'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/alpaca.py

@@ -226,15 +226,15 @@ class alpaca(ccxt.async_support.alpaca):
         datetime = self.safe_string(message, 't')
         timestamp = self.parse8601(datetime)
         isSnapshot = self.safe_bool(message, 'r', False)
-        orderbook = self.safe_value(self.orderbooks, symbol)
-        if orderbook is None:
-            orderbook = self.order_book()
+        if not (symbol in self.orderbooks):
+            self.orderbooks[symbol] = self.order_book()
+        orderbook = self.orderbooks[symbol]
         if isSnapshot:
             snapshot = self.parse_order_book(message, symbol, timestamp, 'b', 'a', 'p', 's')
             orderbook.reset(snapshot)
         else:
-            asks = self.safe_value(message, 'a', [])
-            bids = self.safe_value(message, 'b', [])
+            asks = self.safe_list(message, 'a', [])
+            bids = self.safe_list(message, 'b', [])
             self.handle_deltas(orderbook['asks'], asks)
             self.handle_deltas(orderbook['bids'], bids)
             orderbook['timestamp'] = timestamp

ccxt/pro/ascendex.py

@@ -285,9 +285,9 @@ class ascendex(ccxt.async_support.ascendex):
         marketId = self.safe_string(message, 'symbol')
         symbol = self.safe_symbol(marketId)
         messageHash = channel + ':' + marketId
-        orderbook = self.safe_value(self.orderbooks, symbol)
-        if orderbook is None:
-            orderbook = self.order_book({})
+        if not (symbol in self.orderbooks):
+            self.orderbooks[symbol] = self.order_book({})
+        orderbook = self.orderbooks[symbol]
         if orderbook['nonce'] is None:
             orderbook.cache.append(message)
         else: