ccxt 4.2.70__py2.py3-none-any.whl → 4.2.71__py2.py3-none-any.whl

ccxt/async_support/coinbase.py

@@ -237,6 +237,8 @@ class coinbase(Exchange, ImplicitAPI):
                             'brokerage/intx/portfolio/{portfolio_uuid}': 1,
                             'brokerage/intx/positions/{portfolio_uuid}': 1,
                             'brokerage/intx/positions/{portfolio_uuid}/{symbol}': 1,
+                            'brokerage/payment_methods': 1,
+                            'brokerage/payment_methods/{payment_method_id}': 1,
                         },
                         'post': {
                             'brokerage/orders': 1,
@@ -387,7 +389,7 @@ class coinbase(Exchange, ImplicitAPI):
             #         }
             #     }
             #
-            response = self.safe_value(response, 'data', {})
+            response = self.safe_dict(response, 'data', {})
         else:
             response = await self.v3PublicGetBrokerageTime(params)
             #
@@ -473,7 +475,7 @@ class coinbase(Exchange, ImplicitAPI):
         accounts = self.safe_list(response, 'data', [])
         length = len(accounts)
         lastIndex = length - 1
-        last = self.safe_value(accounts, lastIndex)
+        last = self.safe_dict(accounts, lastIndex)
         if (cursor is not None) and (cursor != ''):
             last['next_starting_after'] = cursor
             accounts[lastIndex] = last
@@ -522,7 +524,7 @@ class coinbase(Exchange, ImplicitAPI):
         accounts = self.safe_list(response, 'accounts', [])
         length = len(accounts)
         lastIndex = length - 1
-        last = self.safe_value(accounts, lastIndex)
+        last = self.safe_dict(accounts, lastIndex)
         cursor = self.safe_string(response, 'cursor')
         if (cursor is not None) and (cursor != ''):
             last['cursor'] = cursor
@@ -585,9 +587,9 @@ class coinbase(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        active = self.safe_value(account, 'active')
+        active = self.safe_bool(account, 'active')
         currencyIdV3 = self.safe_string(account, 'currency')
-        currency = self.safe_value(account, 'currency', {})
+        currency = self.safe_dict(account, 'currency', {})
         currencyId = self.safe_string(currency, 'code', currencyIdV3)
         typeV3 = self.safe_string(account, 'name')
         typeV2 = self.safe_string(account, 'type')
@@ -658,7 +660,7 @@ class coinbase(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         tag = self.safe_string(data, 'destination_tag')
         address = self.safe_string(data, 'address')
         return {
@@ -864,21 +866,21 @@ class coinbase(Exchange, ImplicitAPI):
         amountAndCurrencyObject = None
         feeObject = None
         if transactionType == 'send':
-            network = self.safe_value(transaction, 'network', {})
-            amountAndCurrencyObject = self.safe_value(network, 'transaction_amount', {})
-            feeObject = self.safe_value(network, 'transaction_fee', {})
+            network = self.safe_dict(transaction, 'network', {})
+            amountAndCurrencyObject = self.safe_dict(network, 'transaction_amount', {})
+            feeObject = self.safe_dict(network, 'transaction_fee', {})
         else:
-            amountAndCurrencyObject = self.safe_value(transaction, 'subtotal', {})
-            feeObject = self.safe_value(transaction, 'fee', {})
+            amountAndCurrencyObject = self.safe_dict(transaction, 'subtotal', {})
+            feeObject = self.safe_dict(transaction, 'fee', {})
         status = self.parse_transaction_status(self.safe_string(transaction, 'status'))
         if status is None:
-            committed = self.safe_value(transaction, 'committed')
+            committed = self.safe_bool(transaction, 'committed')
             status = 'ok' if committed else 'pending'
         id = self.safe_string(transaction, 'id')
         currencyId = self.safe_string(amountAndCurrencyObject, 'currency')
         feeCurrencyId = self.safe_string(feeObject, 'currency')
-        datetime = self.safe_value(transaction, 'created_at')
-        toObject = self.safe_value(transaction, 'to', {})
+        datetime = self.safe_string(transaction, 'created_at')
+        toObject = self.safe_dict(transaction, 'to', {})
         toAddress = self.safe_string(toObject, 'address')
         return {
             'info': transaction,
@@ -897,7 +899,7 @@ class coinbase(Exchange, ImplicitAPI):
             'amount': self.safe_number(amountAndCurrencyObject, 'amount'),
             'currency': self.safe_currency_code(currencyId, currency),
             'status': status,
-            'updated': self.parse8601(self.safe_value(transaction, 'updated_at')),
+            'updated': self.parse8601(self.safe_string(transaction, 'updated_at')),
             'fee': {
                 'cost': self.safe_number(feeObject, 'amount'),
                 'currency': self.safe_currency_code(feeCurrencyId),
@@ -967,10 +969,10 @@ class coinbase(Exchange, ImplicitAPI):
         #     }
         #
         symbol = None
-        totalObject = self.safe_value(trade, 'total', {})
-        amountObject = self.safe_value(trade, 'amount', {})
-        subtotalObject = self.safe_value(trade, 'subtotal', {})
-        feeObject = self.safe_value(trade, 'fee', {})
+        totalObject = self.safe_dict(trade, 'total', {})
+        amountObject = self.safe_dict(trade, 'amount', {})
+        subtotalObject = self.safe_dict(trade, 'subtotal', {})
+        feeObject = self.safe_dict(trade, 'fee', {})
         marketId = self.safe_string(trade, 'product_id')
         market = self.safe_market(marketId, market, '-')
         if market is not None:
@@ -982,7 +984,7 @@ class coinbase(Exchange, ImplicitAPI):
                 base = self.safe_currency_code(baseId)
                 quote = self.safe_currency_code(quoteId)
                 symbol = base + '/' + quote
-        sizeInQuote = self.safe_value(trade, 'size_in_quote')
+        sizeInQuote = self.safe_bool(trade, 'size_in_quote')
         v3Price = self.safe_string(trade, 'price')
         v3Cost = None
         v3Amount = self.safe_string(trade, 'size')
@@ -1043,11 +1045,11 @@ class coinbase(Exchange, ImplicitAPI):
 
     async def fetch_markets_v2(self, params={}):
         response = await self.fetch_currencies_from_cache(params)
-        currencies = self.safe_value(response, 'currencies', {})
-        exchangeRates = self.safe_value(response, 'exchangeRates', {})
-        data = self.safe_value(currencies, 'data', [])
+        currencies = self.safe_dict(response, 'currencies', {})
+        exchangeRates = self.safe_dict(response, 'exchangeRates', {})
+        data = self.safe_list(currencies, 'data', [])
         dataById = self.index_by(data, 'id')
-        rates = self.safe_value(self.safe_value(exchangeRates, 'data', {}), 'rates', {})
+        rates = self.safe_dict(self.safe_dict(exchangeRates, 'data', {}), 'rates', {})
         baseIds = list(rates.keys())
         result = []
         for i in range(0, len(baseIds)):
@@ -1166,8 +1168,8 @@ class coinbase(Exchange, ImplicitAPI):
         #         "coinbase_pro_fees": 0
         #     }
         #
-        feeTier = self.safe_value(fees, 'fee_tier', {})
-        data = self.safe_value(response, 'products', [])
+        feeTier = self.safe_dict(fees, 'fee_tier', {})
+        data = self.safe_list(response, 'products', [])
         result = []
         for i in range(0, len(data)):
             market = data[i]
@@ -1177,8 +1179,8 @@ class coinbase(Exchange, ImplicitAPI):
             base = self.safe_currency_code(baseId)
             quote = self.safe_currency_code(quoteId)
             marketType = self.safe_string_lower(market, 'product_type')
-            tradingDisabled = self.safe_value(market, 'trading_disabled')
-            stablePairs = self.safe_value(self.options, 'stablePairs', [])
+            tradingDisabled = self.safe_bool(market, 'trading_disabled')
+            stablePairs = self.safe_list(self.options, 'stablePairs', [])
             result.append({
                 'id': id,
                 'symbol': base + '/' + quote,
@@ -1233,7 +1235,7 @@ class coinbase(Exchange, ImplicitAPI):
         return result
 
     async def fetch_currencies_from_cache(self, params={}):
-        options = self.safe_value(self.options, 'fetchCurrencies', {})
+        options = self.safe_dict(self.options, 'fetchCurrencies', {})
         timestamp = self.safe_integer(options, 'timestamp')
         expires = self.safe_integer(options, 'expires', 1000)
         now = self.milliseconds()
@@ -1286,7 +1288,7 @@ class coinbase(Exchange, ImplicitAPI):
         :returns dict: an associative dictionary of currencies
         """
         response = await self.fetch_currencies_from_cache(params)
-        currencies = self.safe_value(response, 'currencies', {})
+        currencies = self.safe_dict(response, 'currencies', {})
         #
         # fiat
         #
@@ -1398,8 +1400,8 @@ class coinbase(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
-        rates = self.safe_value(data, 'rates', {})
+        data = self.safe_dict(response, 'data', {})
+        rates = self.safe_dict(data, 'rates', {})
         quoteId = self.safe_string(data, 'currency')
         result = {}
         baseIds = list(rates.keys())
@@ -1456,7 +1458,7 @@ class coinbase(Exchange, ImplicitAPI):
         #         "num_products": 549
         #     }
         #
-        data = self.safe_value(response, 'products', [])
+        data = self.safe_list(response, 'products', [])
         result = {}
         for i in range(0, len(data)):
             entry = data[i]
@@ -1500,9 +1502,9 @@ class coinbase(Exchange, ImplicitAPI):
         #
         #     {"data":{"base":"BTC","currency":"USD","amount":"48691.23"}}
         #
-        spotData = self.safe_value(spot, 'data', {})
-        askData = self.safe_value(ask, 'data', {})
-        bidData = self.safe_value(bid, 'data', {})
+        spotData = self.safe_dict(spot, 'data', {})
+        askData = self.safe_dict(ask, 'data', {})
+        bidData = self.safe_dict(bid, 'data', {})
         bidAskLast = {
             'bid': self.safe_number(bidData, 'amount'),
             'ask': self.safe_number(askData, 'amount'),
@@ -1536,7 +1538,7 @@ class coinbase(Exchange, ImplicitAPI):
         #         "best_ask": "28208.62"
         #     }
         #
-        data = self.safe_value(response, 'trades', [])
+        data = self.safe_list(response, 'trades', [])
         ticker = self.parse_ticker(data[0], market)
         ticker['bid'] = self.safe_number(response, 'best_bid')
         ticker['ask'] = self.safe_number(response, 'best_ask')
@@ -1628,8 +1630,8 @@ class coinbase(Exchange, ImplicitAPI):
         bidVolume = None
         askVolume = None
         if ('bids' in ticker):
-            bids = self.safe_value(ticker, 'bids', [])
-            asks = self.safe_value(ticker, 'asks', [])
+            bids = self.safe_list(ticker, 'bids', [])
+            asks = self.safe_list(ticker, 'asks', [])
             bid = self.safe_number(bids[0], 'price')
             bidVolume = self.safe_number(bids[0], 'size')
             ask = self.safe_number(asks[0], 'price')
@@ -1661,21 +1663,21 @@ class coinbase(Exchange, ImplicitAPI):
         }, market)
 
     def parse_custom_balance(self, response, params={}):
-        balances = self.safe_value_2(response, 'data', 'accounts', [])
-        accounts = self.safe_value(params, 'type', self.options['accounts'])
-        v3Accounts = self.safe_value(params, 'type', self.options['v3Accounts'])
+        balances = self.safe_list_2(response, 'data', 'accounts', [])
+        accounts = self.safe_list(params, 'type', self.options['accounts'])
+        v3Accounts = self.safe_list(params, 'type', self.options['v3Accounts'])
         result = {'info': response}
         for b in range(0, len(balances)):
             balance = balances[b]
             type = self.safe_string(balance, 'type')
             if self.in_array(type, accounts):
-                value = self.safe_value(balance, 'balance')
+                value = self.safe_dict(balance, 'balance')
                 if value is not None:
                     currencyId = self.safe_string(value, 'currency')
                     code = self.safe_currency_code(currencyId)
                     total = self.safe_string(value, 'amount')
                     free = total
-                    account = self.safe_value(result, code)
+                    account = self.safe_dict(result, code)
                     if account is None:
                         account = self.account()
                         account['free'] = free
@@ -1685,15 +1687,15 @@ class coinbase(Exchange, ImplicitAPI):
                         account['total'] = Precise.string_add(account['total'], total)
                     result[code] = account
             elif self.in_array(type, v3Accounts):
-                available = self.safe_value(balance, 'available_balance')
-                hold = self.safe_value(balance, 'hold')
+                available = self.safe_dict(balance, 'available_balance')
+                hold = self.safe_dict(balance, 'hold')
                 if available is not None and hold is not None:
                     currencyId = self.safe_string(available, 'currency')
                     code = self.safe_currency_code(currencyId)
                     used = self.safe_string(hold, 'value')
                     free = self.safe_string(available, 'value')
                     total = Precise.string_add(used, free)
-                    account = self.safe_value(result, code)
+                    account = self.safe_dict(result, code)
                     if account is None:
                         account = self.account()
                         account['free'] = free
@@ -2089,7 +2091,7 @@ class coinbase(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        amountInfo = self.safe_value(item, 'amount', {})
+        amountInfo = self.safe_dict(item, 'amount', {})
         amount = self.safe_string(amountInfo, 'amount')
         direction = None
         if Precise.string_lt(amount, '0'):
@@ -2109,9 +2111,9 @@ class coinbase(Exchange, ImplicitAPI):
         #     txid = None
         #
         fee = None
-        networkInfo = self.safe_value(item, 'network', {})
+        networkInfo = self.safe_dict(item, 'network', {})
         # txid = network['hash']  # txid does not belong to the unified ledger structure
-        feeInfo = self.safe_value(networkInfo, 'transaction_fee')
+        feeInfo = self.safe_dict(networkInfo, 'transaction_fee')
         if feeInfo is not None:
             feeCurrencyId = self.safe_string(feeInfo, 'currency')
             feeCurrencyCode = self.safe_currency_code(feeCurrencyId, currency)
@@ -2120,7 +2122,7 @@ class coinbase(Exchange, ImplicitAPI):
                 'cost': feeAmount,
                 'currency': feeCurrencyCode,
             }
-        timestamp = self.parse8601(self.safe_value(item, 'created_at'))
+        timestamp = self.parse8601(self.safe_string(item, 'created_at'))
         id = self.safe_string(item, 'id')
         type = self.parse_ledger_entry_type(self.safe_string(item, 'type'))
         status = self.parse_ledger_entry_status(self.safe_string(item, 'status'))
@@ -2237,7 +2239,7 @@ class coinbase(Exchange, ImplicitAPI):
         isStopLoss = stopLossPrice is not None
         isTakeProfit = takeProfitPrice is not None
         timeInForce = self.safe_string(params, 'timeInForce')
-        postOnly = True if (timeInForce == 'PO') else self.safe_value_2(params, 'postOnly', 'post_only', False)
+        postOnly = True if (timeInForce == 'PO') else self.safe_bool_2(params, 'postOnly', 'post_only', False)
         endTime = self.safe_string(params, 'end_time')
         stopDirection = self.safe_string(params, 'stop_direction')
         if type == 'limit':
@@ -2295,6 +2297,13 @@ class coinbase(Exchange, ImplicitAPI):
                             'post_only': postOnly,
                         },
                     }
+                elif timeInForce == 'IOC':
+                    request['order_configuration'] = {
+                        'sor_limit_ioc': {
+                            'base_size': self.amount_to_precision(symbol, amount),
+                            'limit_price': self.price_to_precision(symbol, price),
+                        },
+                    }
                 else:
                     request['order_configuration'] = {
                         'limit_limit_gtc': {
@@ -2336,7 +2345,7 @@ class coinbase(Exchange, ImplicitAPI):
                     },
                 }
         params = self.omit(params, ['timeInForce', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'stopPrice', 'stop_price', 'stopDirection', 'stop_direction', 'clientOrderId', 'postOnly', 'post_only', 'end_time'])
-        preview = self.safe_value_2(params, 'preview', 'test', False)
+        preview = self.safe_bool_2(params, 'preview', 'test', False)
         response = None
         if preview:
             params = self.omit(params, ['preview', 'test'])
@@ -2381,16 +2390,16 @@ class coinbase(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        success = self.safe_value(response, 'success')
+        success = self.safe_bool(response, 'success')
         if success is not True:
-            errorResponse = self.safe_value(response, 'error_response')
+            errorResponse = self.safe_dict(response, 'error_response')
             errorTitle = self.safe_string(errorResponse, 'error')
             errorMessage = self.safe_string(errorResponse, 'message')
             if errorResponse is not None:
                 self.throw_exactly_matched_exception(self.exceptions['exact'], errorTitle, errorMessage)
                 self.throw_broadly_matched_exception(self.exceptions['broad'], errorTitle, errorMessage)
                 raise ExchangeError(errorMessage)
-        data = self.safe_value(response, 'success_response', {})
+        data = self.safe_dict(response, 'success_response', {})
         return self.parse_order(data, market)
 
     def parse_order(self, order, market: Market = None) -> Order:
@@ -2460,28 +2469,35 @@ class coinbase(Exchange, ImplicitAPI):
         symbol = self.safe_symbol(marketId, market, '-')
         if symbol is not None:
             market = self.market(symbol)
-        orderConfiguration = self.safe_value(order, 'order_configuration', {})
-        limitGTC = self.safe_value(orderConfiguration, 'limit_limit_gtc')
-        limitGTD = self.safe_value(orderConfiguration, 'limit_limit_gtd')
-        stopLimitGTC = self.safe_value(orderConfiguration, 'stop_limit_stop_limit_gtc')
-        stopLimitGTD = self.safe_value(orderConfiguration, 'stop_limit_stop_limit_gtd')
-        marketIOC = self.safe_value(orderConfiguration, 'market_market_ioc')
-        isLimit = ((limitGTC is not None) or (limitGTD is not None))
+        orderConfiguration = self.safe_dict(order, 'order_configuration', {})
+        limitGTC = self.safe_dict(orderConfiguration, 'limit_limit_gtc')
+        limitGTD = self.safe_dict(orderConfiguration, 'limit_limit_gtd')
+        limitIOC = self.safe_dict(orderConfiguration, 'sor_limit_ioc')
+        stopLimitGTC = self.safe_dict(orderConfiguration, 'stop_limit_stop_limit_gtc')
+        stopLimitGTD = self.safe_dict(orderConfiguration, 'stop_limit_stop_limit_gtd')
+        marketIOC = self.safe_dict(orderConfiguration, 'market_market_ioc')
+        isLimit = ((limitGTC is not None) or (limitGTD is not None) or (limitIOC is not None))
         isStop = ((stopLimitGTC is not None) or (stopLimitGTD is not None))
         price = None
         amount = None
         postOnly = None
         triggerPrice = None
         if isLimit:
-            target = limitGTC if (limitGTC is not None) else limitGTD
+            target = None
+            if limitGTC is not None:
+                target = limitGTC
+            elif limitGTD is not None:
+                target = limitGTD
+            else:
+                target = limitIOC
             price = self.safe_string(target, 'limit_price')
             amount = self.safe_string(target, 'base_size')
-            postOnly = self.safe_value(target, 'post_only')
+            postOnly = self.safe_bool(target, 'post_only')
         elif isStop:
             stopTarget = stopLimitGTC if (stopLimitGTC is not None) else stopLimitGTD
             price = self.safe_string(stopTarget, 'limit_price')
             amount = self.safe_string(stopTarget, 'base_size')
-            postOnly = self.safe_value(stopTarget, 'post_only')
+            postOnly = self.safe_bool(stopTarget, 'post_only')
             triggerPrice = self.safe_string(stopTarget, 'stop_price')
         else:
             amount = self.safe_string(marketIOC, 'base_size')
@@ -2561,7 +2577,7 @@ class coinbase(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         orders = await self.cancel_orders([id], symbol, params)
-        return self.safe_value(orders, 0, {})
+        return self.safe_dict(orders, 0, {})
 
     async def cancel_orders(self, ids, symbol: Str = None, params={}):
         """
@@ -2591,9 +2607,9 @@ class coinbase(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        orders = self.safe_value(response, 'results', [])
+        orders = self.safe_list(response, 'results', [])
         for i in range(0, len(orders)):
-            success = self.safe_value(orders[i], 'success')
+            success = self.safe_bool(orders[i], 'success')
             if success is not True:
                 raise BadRequest(self.id + ' cancelOrders() has failed, check your arguments and parameters')
         return self.parse_orders(orders, market)
@@ -2621,7 +2637,7 @@ class coinbase(Exchange, ImplicitAPI):
             request['size'] = self.amount_to_precision(symbol, amount)
         if price is not None:
             request['price'] = self.price_to_precision(symbol, price)
-        preview = self.safe_value_2(params, 'preview', 'test', False)
+        preview = self.safe_bool_2(params, 'preview', 'test', False)
         response = None
         if preview:
             params = self.omit(params, ['preview', 'test'])
@@ -2695,7 +2711,7 @@ class coinbase(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        order = self.safe_value(response, 'order', {})
+        order = self.safe_dict(response, 'order', {})
         return self.parse_order(order, market)
 
     async def fetch_orders(self, symbol: Str = None, since: Int = None, limit: Int = 100, params={}) -> List[Order]:
@@ -2725,7 +2741,7 @@ class coinbase(Exchange, ImplicitAPI):
             request['limit'] = limit
         if since is not None:
             request['start_date'] = self.iso8601(since)
-        until = self.safe_value_n(params, ['until', 'till'])
+        until = self.safe_integer_n(params, ['until', 'till'])
         if until is not None:
             params = self.omit(params, ['until', 'till'])
             request['end_date'] = self.iso8601(until)
@@ -2772,8 +2788,8 @@ class coinbase(Exchange, ImplicitAPI):
         #         "cursor": ""
         #     }
         #
-        orders = self.safe_value(response, 'orders', [])
-        first = self.safe_value(orders, 0)
+        orders = self.safe_list(response, 'orders', [])
+        first = self.safe_dict(orders, 0)
         cursor = self.safe_string(response, 'cursor')
         if (cursor is not None) and (cursor != ''):
             first['cursor'] = cursor
@@ -2795,7 +2811,7 @@ class coinbase(Exchange, ImplicitAPI):
         request['limit'] = limit
         if since is not None:
             request['start_date'] = self.iso8601(since)
-        until = self.safe_value_n(params, ['until', 'till'])
+        until = self.safe_integer_n(params, ['until', 'till'])
         if until is not None:
             params = self.omit(params, ['until', 'till'])
             request['end_date'] = self.iso8601(until)
@@ -2842,8 +2858,8 @@ class coinbase(Exchange, ImplicitAPI):
         #         "cursor": ""
         #     }
         #
-        orders = self.safe_value(response, 'orders', [])
-        first = self.safe_value(orders, 0)
+        orders = self.safe_list(response, 'orders', [])
+        first = self.safe_dict(orders, 0)
         cursor = self.safe_string(response, 'cursor')
         if (cursor is not None) and (cursor != ''):
             first['cursor'] = cursor
@@ -2925,7 +2941,7 @@ class coinbase(Exchange, ImplicitAPI):
             'product_id': market['id'],
             'granularity': self.safe_string(self.timeframes, timeframe, timeframe),
         }
-        until = self.safe_value_n(params, ['until', 'till', 'end'])
+        until = self.safe_integer_n(params, ['until', 'till', 'end'])
         params = self.omit(params, ['until', 'till'])
         duration = self.parse_timeframe(timeframe)
         requestedDuration = limit * duration
@@ -2956,7 +2972,7 @@ class coinbase(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        candles = self.safe_value(response, 'candles', [])
+        candles = self.safe_list(response, 'candles', [])
         return self.parse_ohlcvs(candles, market, timeframe, since, limit)
 
     def parse_ohlcv(self, ohlcv, market: Market = None) -> list:
@@ -3023,7 +3039,7 @@ class coinbase(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        trades = self.safe_value(response, 'trades', [])
+        trades = self.safe_list(response, 'trades', [])
         return self.parse_trades(trades, market, since, limit)
 
     async def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
@@ -3053,7 +3069,7 @@ class coinbase(Exchange, ImplicitAPI):
             request['limit'] = limit
         if since is not None:
             request['start_sequence_timestamp'] = self.iso8601(since)
-        until = self.safe_value_n(params, ['until', 'till'])
+        until = self.safe_integer_n(params, ['until', 'till'])
         if until is not None:
             params = self.omit(params, ['until', 'till'])
             request['end_sequence_timestamp'] = self.iso8601(until)
@@ -3081,8 +3097,8 @@ class coinbase(Exchange, ImplicitAPI):
         #         "cursor": ""
         #     }
         #
-        trades = self.safe_value(response, 'fills', [])
-        first = self.safe_value(trades, 0)
+        trades = self.safe_list(response, 'fills', [])
+        first = self.safe_dict(trades, 0)
         cursor = self.safe_string(response, 'cursor')
         if (cursor is not None) and (cursor != ''):
             first['cursor'] = cursor
@@ -3167,7 +3183,7 @@ class coinbase(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        tickers = self.safe_value(response, 'pricebooks', [])
+        tickers = self.safe_list(response, 'pricebooks', [])
         return self.parse_tickers(tickers, symbols)
 
     async def withdraw(self, code: str, amount: float, address, tag=None, params={}):
@@ -3255,7 +3271,7 @@ class coinbase(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_transaction(data, currency)
 
     async def fetch_deposit_addresses_by_network(self, code: str, params={}):
@@ -3516,7 +3532,7 @@ class coinbase(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_transaction(data)
 
     def sign(self, path, api=[], method='GET', params={}, headers=None, body=None):
@@ -3599,7 +3615,7 @@ class coinbase(Exchange, ImplicitAPI):
             self.throw_exactly_matched_exception(self.exceptions['exact'], errorCode, feedback)
             self.throw_broadly_matched_exception(self.exceptions['broad'], errorMessage, feedback)
             raise ExchangeError(feedback)
-        errors = self.safe_value(response, 'errors')
+        errors = self.safe_list(response, 'errors')
         if errors is not None:
             if isinstance(errors, list):
                 numErrors = len(errors)
@@ -3611,7 +3627,6 @@ class coinbase(Exchange, ImplicitAPI):
                         self.throw_broadly_matched_exception(self.exceptions['broad'], errorMessage, feedback)
                         raise ExchangeError(feedback)
         advancedTrade = self.options['advanced']
-        data = self.safe_value(response, 'data')
-        if (data is None) and (not advancedTrade):
+        if not ('data' in response) and (not advancedTrade):
             raise ExchangeError(self.id + ' failed due to a malformed response ' + self.json(response))
         return None

ccxt/async_support/coinex.py

@@ -6,7 +6,7 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.coinex import ImplicitAPI
 import asyncio
-from ccxt.base.types import Balances, Currency, Int, Leverage, Leverages, Market, Order, TransferEntry, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, Leverage, Leverages, Market, Order, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied

ccxt/async_support/coinlist.py

@@ -7,7 +7,7 @@ from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.coinlist import ImplicitAPI
 import hashlib
 import math
-from ccxt.base.types import Balances, Currency, Int, Market, Order, TransferEntry, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, Market, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied

ccxt/async_support/coinmetro.py

@@ -5,7 +5,7 @@
 
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.coinmetro import ImplicitAPI
-from ccxt.base.types import Balances, Currency, Int, Market, Order, OrderBook, OrderSide, OrderType, IndexType, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Balances, Currency, IndexType, Int, Market, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied

ccxt/async_support/deribit.py

@@ -6,7 +6,7 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.deribit import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, Currency, Greeks, Int, Market, Order, TransferEntry, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Greeks, Int, Market, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied

ccxt/async_support/digifinex.py

@@ -8,7 +8,7 @@ from ccxt.abstract.digifinex import ImplicitAPI
 import asyncio
 import hashlib
 import json
-from ccxt.base.types import Balances, Currency, Int, Market, Order, TransferEntry, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, Market, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -1464,7 +1464,8 @@ class digifinex(Exchange, ImplicitAPI):
             elif limit is not None:
                 endTime = self.seconds()
                 duration = self.parse_timeframe(timeframe)
-                request['start_time'] = self.sum(endTime, -limit * duration)
+                auxLimit = limit  # in c# -limit is mutating the arg
+                request['start_time'] = self.sum(endTime, -auxLimit * duration)
             response = await self.publicSpotGetKline(self.extend(request, params))
         #
         # spot

ccxt/async_support/gate.py

@@ -7,7 +7,7 @@ from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.gate import ImplicitAPI
 import asyncio
 import hashlib
-from ccxt.base.types import Balances, Currency, Greeks, Int, Leverage, Leverages, Market, Order, TransferEntry, OrderBook, OrderRequest, OrderSide, OrderType, FundingHistory, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, FundingHistory, Greeks, Int, Leverage, Leverages, Market, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied

ccxt/async_support/hitbtc.py

@@ -6,7 +6,7 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.hitbtc import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, Currency, Int, Leverage, MarginMode, MarginModes, Market, Order, TransferEntry, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, Leverage, MarginMode, MarginModes, Market, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied

ccxt/async_support/htx.py

@@ -7,7 +7,7 @@ from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.htx import ImplicitAPI
 import asyncio
 import hashlib
-from ccxt.base.types import Balances, Currency, Int, Market, Order, TransferEntry, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, Market, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied