ccxt 4.0.100__py2.py3-none-any.whl → 4.0.102__py2.py3-none-any.whl

ccxt/async_support/kucoinfutures.py

@@ -850,58 +850,53 @@ class kucoinfutures(kucoin, ImplicitAPI):
         request = {
             'symbol': market['id'],
         }
-        response = await self.futuresPrivateGetPositions(self.extend(request, params))
+        response = await self.futuresPrivateGetPosition(self.extend(request, params))
         #
-        #     {
-        #         "code": "200000",
-        #         "data": [
-        #             {
-        #                 "id": "63b3599e6c41f50001c47d44",
-        #                 "symbol": "XBTUSDTM",
-        #                 "autoDeposit": False,
-        #                 "maintMarginReq": 0.004,
-        #                 "riskLimit": 25000,
-        #                 "realLeverage": 5.0,
-        #                 "crossMode": False,
-        #                 "delevPercentage": 0.57,
-        #                 "openingTimestamp": 1684000025528,
-        #                 "currentTimestamp": 1684000052160,
-        #                 "currentQty": 1,
-        #                 "currentCost": 26.821,
-        #                 "currentComm": 0.0160926,
-        #                 "unrealisedCost": 26.821,
-        #                 "realisedGrossCost": 0.0,
-        #                 "realisedCost": 0.0160926,
-        #                 "isOpen": True,
-        #                 "markPrice": 26821.13,
-        #                 "markValue": 26.82113,
-        #                 "posCost": 26.821,
-        #                 "posCross": 0.0,
-        #                 "posCrossMargin": 0.0,
-        #                 "posInit": 5.3642,
-        #                 "posComm": 0.01931112,
-        #                 "posCommCommon": 0.01931112,
-        #                 "posLoss": 0.0,
-        #                 "posMargin": 5.38351112,
-        #                 "posMaint": 0.12927722,
-        #                 "maintMargin": 5.38364112,
-        #                 "realisedGrossPnl": 0.0,
-        #                 "realisedPnl": -0.0160926,
-        #                 "unrealisedPnl": 1.3E-4,
-        #                 "unrealisedPnlPcnt": 0.0,
-        #                 "unrealisedRoePcnt": 0.0,
-        #                 "avgEntryPrice": 26821.0,
-        #                 "liquidationPrice": 21567.0,
-        #                 "bankruptPrice": 21456.0,
-        #                 "settleCurrency": "USDT",
-        #                 "isInverse": False,
-        #                 "maintainMargin": 0.004
-        #             }
-        #         ]
-        #     }
+        #    {
+        #        "code": "200000",
+        #        "data": {
+        #            "id": "6505ee6eaff4070001f651c4",
+        #            "symbol": "XBTUSDTM",
+        #            "autoDeposit": False,
+        #            "maintMarginReq": 0,
+        #            "riskLimit": 200,
+        #            "realLeverage": 0.0,
+        #            "crossMode": False,
+        #            "delevPercentage": 0.0,
+        #            "currentTimestamp": 1694887534594,
+        #            "currentQty": 0,
+        #            "currentCost": 0.0,
+        #            "currentComm": 0.0,
+        #            "unrealisedCost": 0.0,
+        #            "realisedGrossCost": 0.0,
+        #            "realisedCost": 0.0,
+        #            "isOpen": False,
+        #            "markPrice": 26611.71,
+        #            "markValue": 0.0,
+        #            "posCost": 0.0,
+        #            "posCross": 0,
+        #            "posInit": 0.0,
+        #            "posComm": 0.0,
+        #            "posLoss": 0.0,
+        #            "posMargin": 0.0,
+        #            "posMaint": 0.0,
+        #            "maintMargin": 0.0,
+        #            "realisedGrossPnl": 0.0,
+        #            "realisedPnl": 0.0,
+        #            "unrealisedPnl": 0.0,
+        #            "unrealisedPnlPcnt": 0,
+        #            "unrealisedRoePcnt": 0,
+        #            "avgEntryPrice": 0.0,
+        #            "liquidationPrice": 0.0,
+        #            "bankruptPrice": 0.0,
+        #            "settleCurrency": "USDT",
+        #            "maintainMargin": 0,
+        #            "riskLimitLevel": 1
+        #        }
+        #    }
         #
-        data = self.safe_value(response, 'data', [])
-        return self.parse_position(data[0], market)
+        data = self.safe_value(response, 'data', {})
+        return self.parse_position(data, market)
 
     async def fetch_positions(self, symbols: Optional[List[str]] = None, params={}):
         """
@@ -1043,7 +1038,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
             'unrealizedPnl': self.parse_number(unrealisedPnl),
             'contracts': self.parse_number(Precise.string_abs(size)),
             'contractSize': self.safe_value(market, 'contractSize'),
-            'realizedPnl': self.safe_number(position, 'realised_pnl'),
+            'realizedPnl': self.safe_number(position, 'realisedPnl'),
             'marginRatio': None,
             'liquidationPrice': self.safe_number(position, 'liquidationPrice'),
             'markPrice': self.safe_number(position, 'markPrice'),

ccxt/async_support/lbank.py

@@ -394,7 +394,7 @@ class lbank(Exchange, ImplicitAPI):
         if since is not None:
             request['time'] = since
         if limit is not None:
-            request['size'] = limit
+            request['size'] = min(limit, 600)
         response = await self.publicGetTrades(self.extend(request, params))
         return self.parse_trades(response, market, since, limit)
 

ccxt/async_support/lbank2.py

@@ -895,7 +895,7 @@ class lbank2(Exchange, ImplicitAPI):
         if since is not None:
             request['time'] = since
         if limit is not None:
-            request['size'] = limit
+            request['size'] = min(limit, 600)
         else:
             request['size'] = 600  # max
         method = self.safe_string(params, 'method')

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.0.100'
+__version__ = '4.0.102'
 
 # -----------------------------------------------------------------------------
 

ccxt/binance.py

@@ -425,6 +425,7 @@ class binance(Exchange, ImplicitAPI):
                         'portfolio/interest-history': 0.6667,
                         'portfolio/asset-index-price': 0.1,
                         'portfolio/repay-futures-switch': 3,  # Weight(IP): 30 => cost = 0.1 * 30 = 3
+                        'portfolio/margin-asset-leverage': 5,  # Weight(IP): 50 => cost = 0.1 * 50 = 5
                         # staking
                         'staking/productList': 0.1,
                         'staking/position': 0.1,
@@ -437,6 +438,11 @@ class binance(Exchange, ImplicitAPI):
                         'lending/auto-invest/plan/list': 0.1,
                         'lending/auto-invest/plan/id': 0.1,
                         'lending/auto-invest/history/list': 0.1,
+                        'lending/auto-invest/index/info': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
+                        'lending/auto-invest/index/user-summary': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
+                        'lending/auto-invest/one-off/status': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
+                        'lending/auto-invest/redeem/history': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
+                        'lending/auto-invest/rebalance/history': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
                         # simple earn
                         'simple-earn/flexible/list': 15,
                         'simple-earn/locked/list': 15,
@@ -564,6 +570,8 @@ class binance(Exchange, ImplicitAPI):
                         'lending/auto-invest/plan/add': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
                         'lending/auto-invest/plan/edit': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
                         'lending/auto-invest/plan/edit-status': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
+                        'lending/auto-invest/one-off': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
+                        'lending/auto-invest/redeem': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
                         # simple earn
                         'simple-earn/flexible/subscribe': 0.1,
                         'simple-earn/locked/subscribe': 0.1,
@@ -3298,6 +3306,18 @@ class binance(Exchange, ImplicitAPI):
         #         "M": True           # Was the trade the best price match?
         #     }
         #
+        # REST: aggregate trades for swap & future(both linear and inverse)
+        #
+        #     {
+        #         "a": "269772814",
+        #         "p": "25864.1",
+        #         "q": "3",
+        #         "f": "662149354",
+        #         "l": "662149355",
+        #         "T": "1694209776022",
+        #         "m": False,
+        #     }
+        #
         # recent public trades and old public trades
         # https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#recent-trades-list
         # https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#old-trade-lookup-market_data
@@ -3529,7 +3549,8 @@ class binance(Exchange, ImplicitAPI):
             if until is not None:
                 request['endTime'] = until
         if limit is not None:
-            request['limit'] = limit  # default = 500, maximum = 1000
+            isFutureOrSwap = (market['swap'] or market['future'])
+            request['limit'] = min(limit, 1000) if isFutureOrSwap else limit  # default = 500, maximum = 1000
         params = self.omit(params, ['until', 'fetchTradesMethod'])
         #
         # Caveats:
@@ -3557,6 +3578,20 @@ class binance(Exchange, ImplicitAPI):
         #         }
         #     ]
         #
+        # inverse(swap & future)
+        #
+        #     [
+        #      {
+        #         "a": "269772814",
+        #         "p": "25864.1",
+        #         "q": "3",
+        #         "f": "662149354",
+        #         "l": "662149355",
+        #         "T": "1694209776022",
+        #         "m": False,
+        #      },
+        #     ]
+        #
         # recent public trades and historical public trades
         #
         #     [

ccxt/bingx.py

@@ -153,6 +153,7 @@ class bingx(Exchange, ImplicitAPI):
                                 'quote/klines': 1,
                                 'quote/openInterest': 1,
                                 'quote/ticker': 1,
+                                'quote/bookTicker': 1,
                             },
                         },
                         'private': {
@@ -204,11 +205,17 @@ class bingx(Exchange, ImplicitAPI):
                         'private': {
                             'get': {
                                 'capital/config/getall': 3,
+                                'capital/deposit/address': 1,
+                                'capital/innerTransfer/records': 1,
+                                'capital/subAccount/deposit/address': 1,
+                                'capital/deposit/subHisrec': 1,
+                                'capital/subAccount/innerTransfer/records': 1,
                             },
                             'post': {
                                 'capital/withdraw/apply': 3,
                                 'capital/innerTransfer/apply': 3,
                                 'capital/subAccountInnerTransfer/apply': 3,
+                                'capital/deposit/createSubAddress': 1,
                             },
                         },
                     },
@@ -219,6 +226,7 @@ class bingx(Exchange, ImplicitAPI):
                             'get': {
                                 'list': 3,
                                 'assets': 3,
+                                'apiKey/query': 1,
                             },
                             'post': {
                                 'create': 3,
@@ -233,13 +241,42 @@ class bingx(Exchange, ImplicitAPI):
                 'account': {
                     'v1': {
                         'private': {
+                            'get': {
+                                'uid': 1,
+                            },
                             'post': {
-                                'uid': 3,
                                 'innerTransfer/authorizeSubAccount': 3,
                             },
                         },
                     },
                 },
+                'copyTrading': {
+                    'v1': {
+                        'private': {
+                            'get': {
+                                'swap/trace/currentTrack': 1,
+                            },
+                            'post': {
+                                'swap/trace/closeTrackOrder': 1,
+                                'swap/trace/setTPSL': 1,
+                            },
+                        },
+                    },
+                },
+                'api': {
+                    'v3': {
+                        'private': {
+                            'get': {
+                                'asset/transfer': 1,
+                                'capital/deposit/hisrec': 1,
+                                'capital/withdraw/history': 1,
+                            },
+                            'post': {
+                                'post/asset/transfer': 1,
+                            },
+                        },
+                    },
+                },
             },
             'timeframes': {
                 '1m': '1m',
@@ -1437,9 +1474,9 @@ class bingx(Exchange, ImplicitAPI):
         :param float [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the bingx api endpoint
         :param bool [params.postOnly]: True to place a post only order
-        :param dict [params.triggerPrice]: triggerPrice at which the attached take profit / stop loss order will be triggered(swap markets only)
-        :param float [params.stopLossPrice]: stop loss trigger price(swap markets only)
-        :param float [params.takeProfitPrice]: take profit trigger price(swap markets only)
+        :param float [params.triggerPrice]: *swap only* triggerPrice at which the attached take profit / stop loss order will be triggered
+        :param float [params.stopLossPrice]: *swap only* stop loss trigger price
+        :param float [params.takeProfitPrice]: *swap only* take profit trigger price
         :returns dict: an `order structure <https://github.com/ccxt/ccxt/wiki/Manual#order-structure>`
         """
         self.load_markets()

ccxt/bitbank.py

@@ -318,6 +318,17 @@ class bitbank(Exchange, ImplicitAPI):
         return self.parse_order_book(orderbook, market['symbol'], timestamp)
 
     def parse_trade(self, trade, market=None):
+        #
+        # fetchTrades
+        #
+        #    {
+        #        "transaction_id": "1143247037",
+        #        "side": "buy",
+        #        "price": "3836025",
+        #        "amount": "0.0005",
+        #        "executed_at": "1694249441593"
+        #    }
+        #
         timestamp = self.safe_integer(trade, 'executed_at')
         market = self.safe_market(None, market)
         priceString = self.safe_string(trade, 'price')

ccxt/bitfinex.py

@@ -899,14 +899,6 @@ class bitfinex(Exchange, ImplicitAPI):
         #          "type":"sell"
         #     }
         #
-        #     {   "timestamp":1637258238,
-        #          "tid":894452800,
-        #          "price":"0.99958",
-        #          "amount":"261.90514",
-        #          "exchange":"bitfinex",
-        #          "type":"buy"
-        #     }
-        #
         # fetchMyTrades(private) v1
         #
         #     {
@@ -981,6 +973,18 @@ class bitfinex(Exchange, ImplicitAPI):
         if since is not None:
             request['timestamp'] = self.parse_to_int(since / 1000)
         response = self.publicGetTradesSymbol(self.extend(request, params))
+        #
+        #    [
+        #        {
+        #            "timestamp": "1694284565",
+        #            "tid": "1415415034",
+        #            "price": "25862.0",
+        #            "amount": "0.00020685",
+        #            "exchange": "bitfinex",
+        #            "type": "buy"
+        #        },
+        #    ]
+        #
         return self.parse_trades(response, market, since, limit)
 
     def fetch_my_trades(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):

ccxt/bitflyer.py

@@ -395,7 +395,7 @@ class bitflyer(Exchange, ImplicitAPI):
         #
         # fetchTrades(public) v1
         #
-        #     {
+        #      {
         #          "id":2278466664,
         #          "side":"SELL",
         #          "price":56810.7,
@@ -405,16 +405,18 @@ class bitflyer(Exchange, ImplicitAPI):
         #          "sell_child_order_acceptance_id":"JRF20211119-114639-236919"
         #      }
         #
-        #      {
-        #          "id":2278463423,
-        #          "side":"BUY",
-        #          "price":56757.83,
-        #          "size":0.6003,"exec_date":"2021-11-19T11:28:00.523",
-        #          "buy_child_order_acceptance_id":"JRF20211119-112800-236526",
-        #          "sell_child_order_acceptance_id":"JRF20211119-112734-062017"
-        #      }
-        #
+        # fetchMyTrades
         #
+        #      {
+        #          "id": 37233,
+        #          "side": "BUY",
+        #          "price": 33470,
+        #          "size": 0.01,
+        #          "exec_date": "2015-07-07T09:57:40.397",
+        #          "child_order_id": "JOR20150707-060559-021935",
+        #          "child_order_acceptance_id": "JRF20150707-060559-396699"
+        #          "commission": 0,
+        #      },
         #
         side = self.safe_string_lower(trade, 'side')
         if side is not None:
@@ -465,6 +467,19 @@ class bitflyer(Exchange, ImplicitAPI):
         if limit is not None:
             request['count'] = limit
         response = self.publicGetGetexecutions(self.extend(request, params))
+        #
+        #    [
+        #     {
+        #       "id": 39287,
+        #       "side": "BUY",
+        #       "price": 31690,
+        #       "size": 27.04,
+        #       "exec_date": "2015-07-08T02:43:34.823",
+        #       "buy_child_order_acceptance_id": "JRF20150707-200203-452209",
+        #       "sell_child_order_acceptance_id": "JRF20150708-024334-060234"
+        #     },
+        #    ]
+        #
         return self.parse_trades(response, market, since, limit)
 
     def fetch_trading_fee(self, symbol: str, params={}):
@@ -677,6 +692,20 @@ class bitflyer(Exchange, ImplicitAPI):
         if limit is not None:
             request['count'] = limit
         response = self.privateGetGetexecutions(self.extend(request, params))
+        #
+        #    [
+        #     {
+        #       "id": 37233,
+        #       "side": "BUY",
+        #       "price": 33470,
+        #       "size": 0.01,
+        #       "exec_date": "2015-07-07T09:57:40.397",
+        #       "child_order_id": "JOR20150707-060559-021935",
+        #       "child_order_acceptance_id": "JRF20150707-060559-396699"
+        #       "commission": 0,
+        #     },
+        #    ]
+        #
         return self.parse_trades(response, market, since, limit)
 
     def fetch_positions(self, symbols: Optional[List[str]] = None, params={}):

ccxt/bitforex.py

@@ -254,14 +254,6 @@ class bitforex(Exchange, ImplicitAPI):
         #          "tid":"1131019666"
         #      }
         #
-        #      {
-        #          "price":57591.33,
-        #          "amount":0.002,
-        #          "time":1637329685322,
-        #          "direction":1,
-        #          "tid":"1131019639"
-        #      }
-        #
         # fetchMyTrades(private)
         #
         #     {

ccxt/bitget.py

@@ -2106,7 +2106,7 @@ class bitget(Exchange, ImplicitAPI):
         #         "fillTime": "1692073691000"
         #     }
         #
-        # swap
+        # swap(public trades)
         #
         #     {
         #         "tradeId": "1075199767891652609",
@@ -2228,6 +2228,16 @@ class bitget(Exchange, ImplicitAPI):
             params = self.omit(params, 'method')
             if swapMethod == 'publicMixGetMarketFillsHistory':
                 response = self.publicMixGetMarketFillsHistory(self.extend(request, params))
+                #
+                #     {
+                #         "tradeId": "1084459062491590657",
+                #         "price": "25874",
+                #         "size": "1.624",
+                #         "side": "Buy",
+                #         "timestamp": "1694281109000",
+                #         "symbol": "BTCUSDT_UMCBL",
+                #     }
+                #
             elif swapMethod == 'publicMixGetMarketFills':
                 response = self.publicMixGetMarketFills(self.extend(request, params))
         #
@@ -2860,11 +2870,11 @@ class bitget(Exchange, ImplicitAPI):
                 method = 'privateMixPostPlanPlacePositionsTPSL'
             elif isStopLossOrTakeProfit:
                 if isStopLoss:
-                    stopLossTriggerPrice = self.safe_value_2(stopLoss, 'triggerPrice', 'stopPrice')
-                    request['presetStopLossPrice'] = self.price_to_precision(symbol, stopLossTriggerPrice)
+                    slTriggerPrice = self.safe_value_2(stopLoss, 'triggerPrice', 'stopPrice')
+                    request['presetStopLossPrice'] = self.price_to_precision(symbol, slTriggerPrice)
                 if isTakeProfit:
-                    takeProfitTriggerPrice = self.safe_value_2(takeProfit, 'triggerPrice', 'stopPrice')
-                    request['presetTakeProfitPrice'] = self.price_to_precision(symbol, takeProfitTriggerPrice)
+                    tpTriggerPrice = self.safe_value_2(takeProfit, 'triggerPrice', 'stopPrice')
+                    request['presetTakeProfitPrice'] = self.price_to_precision(symbol, tpTriggerPrice)
         if postOnly:
             request[timeInForceKey] = 'post_only'
         elif timeInForce == 'gtc':

ccxt/bitmart.py

@@ -76,6 +76,9 @@ class bitmart(Exchange, ImplicitAPI):
                 'fetchDepositWithdrawFee': True,
                 'fetchDepositWithdrawFees': False,
                 'fetchFundingHistory': None,
+                'fetchFundingRate': True,
+                'fetchFundingRateHistory': False,
+                'fetchFundingRates': False,
                 'fetchMarginMode': False,
                 'fetchMarkets': True,
                 'fetchMyTrades': True,
@@ -3084,6 +3087,69 @@ class bitmart(Exchange, ImplicitAPI):
         }
         return self.privatePostContractPrivateSubmitLeverage(self.extend(request, params))
 
+    def fetch_funding_rate(self, symbol: str, params={}):
+        """
+        fetch the current funding rate
+        see https://developer-pro.bitmart.com/en/futures/#get-current-funding-rate
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the bitmart api endpoint
+        :returns dict: a `funding rate structure <https://github.com/ccxt/ccxt/wiki/Manual#funding-rate-structure>`
+        """
+        self.load_markets()
+        market = self.market(symbol)
+        if not market['swap']:
+            raise BadSymbol(self.id + ' fetchFundingRate() supports swap contracts only')
+        request = {
+            'symbol': market['id'],
+        }
+        response = self.publicGetContractPublicFundingRate(self.extend(request, params))
+        #
+        #     {
+        #         "code": 1000,
+        #         "message": "Ok",
+        #         "data": {
+        #             "timestamp": 1695184410697,
+        #             "symbol": "BTCUSDT",
+        #             "rate_value": "-0.00002614",
+        #             "expected_rate": "-0.00002"
+        #         },
+        #         "trace": "4cad855074654097ac7ba5257c47305d.54.16951844206655589"
+        #     }
+        #
+        data = self.safe_value(response, 'data', {})
+        return self.parse_funding_rate(data, market)
+
+    def parse_funding_rate(self, contract, market=None):
+        #
+        #     {
+        #         "timestamp": 1695184410697,
+        #         "symbol": "BTCUSDT",
+        #         "rate_value": "-0.00002614",
+        #         "expected_rate": "-0.00002"
+        #     }
+        #
+        marketId = self.safe_string(contract, 'symbol')
+        timestamp = self.safe_integer(contract, 'timestamp')
+        return {
+            'info': contract,
+            'symbol': self.safe_symbol(marketId, market),
+            'markPrice': None,
+            'indexPrice': None,
+            'interestRate': None,
+            'estimatedSettlePrice': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'fundingRate': self.safe_number(contract, 'expected_rate'),
+            'fundingTimestamp': None,
+            'fundingDatetime': None,
+            'nextFundingRate': None,
+            'nextFundingTimestamp': None,
+            'nextFundingDatetime': None,
+            'previousFundingRate': self.safe_number(contract, 'rate_value'),
+            'previousFundingTimestamp': None,
+            'previousFundingDatetime': None,
+        }
+
     def nonce(self):
         return self.milliseconds()
 

ccxt/bitstamp1.py

@@ -213,6 +213,17 @@ class bitstamp1(Exchange, ImplicitAPI):
         return self.parse_ticker(ticker, market)
 
     def parse_trade(self, trade, market=None):
+        #
+        # public trade
+        #
+        #        {
+        #            "amount": "0.00114000",
+        #            "date": "1694287856",
+        #            "price": "25865",
+        #            "tid": 298730788,
+        #            "type": 0
+        #        }
+        #
         timestamp = self.safe_timestamp_2(trade, 'date', 'datetime')
         side = 'buy' if (trade['type'] == 0) else 'sell'
         orderId = self.safe_string(trade, 'order_id')
@@ -254,6 +265,17 @@ class bitstamp1(Exchange, ImplicitAPI):
             'time': 'minute',
         }
         response = self.publicGetTransactions(self.extend(request, params))
+        #
+        #    [
+        #        {
+        #            "amount": "0.00114000",
+        #            "date": "1694287856",
+        #            "price": "25865",
+        #            "tid": 298730788,
+        #            "type": 0
+        #        },
+        #    ]
+        #
         return self.parse_trades(response, market, since, limit)
 
     def parse_balance(self, response):