ccxt 4.3.6__py2.py3-none-any.whl → 4.3.7__py2.py3-none-any.whl

ccxt/async_support/btcmarkets.py

@@ -73,8 +73,11 @@ class btcmarkets(Exchange, ImplicitAPI):
                 'fetchOrderBook': True,
                 'fetchOrders': True,
                 'fetchPosition': False,
+                'fetchPositionHistory': False,
                 'fetchPositionMode': False,
                 'fetchPositions': False,
+                'fetchPositionsForSymbol': False,
+                'fetchPositionsHistory': False,
                 'fetchPositionsRisk': False,
                 'fetchPremiumIndexOHLCV': False,
                 'fetchTicker': True,
@@ -1093,7 +1096,7 @@ class btcmarkets(Exchange, ImplicitAPI):
         #
         return self.parse_trades(response, market, since, limit)
 
-    async def withdraw(self, code: str, amount: float, address, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
         """
         make a withdrawal
         :see: https://docs.btcmarkets.net/v3/#tag/Fund-Management-APIs/paths/~1v3~1withdrawals/post

ccxt/async_support/btcturk.py

@@ -66,8 +66,11 @@ class btcturk(Exchange, ImplicitAPI):
                 'fetchOrderBook': True,
                 'fetchOrders': True,
                 'fetchPosition': False,
+                'fetchPositionHistory': False,
                 'fetchPositionMode': False,
                 'fetchPositions': False,
+                'fetchPositionsForSymbol': False,
+                'fetchPositionsHistory': False,
                 'fetchPositionsRisk': False,
                 'fetchPremiumIndexOHLCV': False,
                 'fetchTicker': True,

ccxt/async_support/bybit.py

@@ -7,7 +7,7 @@ from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.bybit import ImplicitAPI
 import asyncio
 import hashlib
-from ccxt.base.types import Balances, Currencies, Currency, Greeks, Int, Leverage, Market, MarketInterface, Num, Option, OptionChain, Order, OrderBook, OrderRequest, CancellationRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, TradingFees, Transaction, TransferEntry
+from ccxt.base.types import Balances, Currencies, Currency, Greeks, Int, Leverage, Market, MarketInterface, Num, Option, OptionChain, Order, OrderBook, OrderRequest, CancellationRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, TradingFees, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -117,7 +117,9 @@ class bybit(Exchange, ImplicitAPI):
                 'fetchOrders': False,
                 'fetchOrderTrades': True,
                 'fetchPosition': True,
+                'fetchPositionHistory': 'emulated',
                 'fetchPositions': True,
+                'fetchPositionsHistory': True,
                 'fetchPremiumIndexOHLCV': True,
                 'fetchSettlementHistory': True,
                 'fetchTicker': True,
@@ -5614,7 +5616,7 @@ class bybit(Exchange, ImplicitAPI):
         }
         return self.safe_string(types, type, type)
 
-    async def withdraw(self, code: str, amount: float, address, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
         """
         make a withdrawal
         :see: https://bybit-exchange.github.io/docs/v5/asset/withdraw
@@ -6014,31 +6016,57 @@ class bybit(Exchange, ImplicitAPI):
         #         "tradeMode": 0
         #     }
         #
+        # fetchPositionsHistory
+        #
+        #    {
+        #        symbol: 'XRPUSDT',
+        #        orderType: 'Market',
+        #        leverage: '10',
+        #        updatedTime: '1712717265572',
+        #        side: 'Sell',
+        #        orderId: '071749f3-a9fa-427b-b5ca-27b2f52b81de',
+        #        closedPnl: '-0.00049568',
+        #        avgEntryPrice: '0.6045',
+        #        qty: '3',
+        #        cumEntryValue: '1.8135',
+        #        createdTime: '1712717265566',
+        #        orderPrice: '0.5744',
+        #        closedSize: '3',
+        #        avgExitPrice: '0.605',
+        #        execType: 'Trade',
+        #        fillCount: '1',
+        #        cumExitValue: '1.815'
+        #    }
+        #
+        closedSize = self.safe_string(position, 'closedSize')
+        isHistory = (closedSize is not None)
         contract = self.safe_string(position, 'symbol')
         market = self.safe_market(contract, market, None, 'contract')
-        size = Precise.string_abs(self.safe_string(position, 'size'))
+        size = Precise.string_abs(self.safe_string_2(position, 'size', 'qty'))
         side = self.safe_string(position, 'side')
         if side is not None:
             if side == 'Buy':
-                side = 'long'
+                side = 'short' if isHistory else 'long'
             elif side == 'Sell':
-                side = 'short'
+                side = 'long' if isHistory else 'short'
             else:
                 side = None
-        notional = self.safe_string(position, 'positionValue')
+        notional = self.safe_string_2(position, 'positionValue', 'cumExitValue')
         unrealisedPnl = self.omit_zero(self.safe_string(position, 'unrealisedPnl'))
-        initialMarginString = self.safe_string(position, 'positionIM')
+        initialMarginString = self.safe_string_n(position, ['positionIM', 'cumEntryValue'])
         maintenanceMarginString = self.safe_string(position, 'positionMM')
-        timestamp = self.parse8601(self.safe_string(position, 'updated_at'))
-        if timestamp is None:
-            timestamp = self.safe_integer_n(position, ['updatedTime', 'updatedAt'])
+        timestamp = self.safe_integer_n(position, ['createdTime', 'createdAt'])
+        lastUpdateTimestamp = self.parse8601(self.safe_string(position, 'updated_at'))
+        if lastUpdateTimestamp is None:
+            lastUpdateTimestamp = self.safe_integer_n(position, ['updatedTime', 'updatedAt', 'updatedTime'])
         tradeMode = self.safe_integer(position, 'tradeMode', 0)
         marginMode = None
         if (not self.options['enableUnifiedAccount']) or (self.options['enableUnifiedAccount'] and market['inverse']):
             # tradeMode would work for classic and UTA(inverse)
-            marginMode = 'isolated' if (tradeMode == 1) else 'cross'
+            if not isHistory:     # cannot tell marginMode for fetchPositionsHistory, and closedSize will only be defined for fetchPositionsHistory response
+                marginMode = 'isolated' if (tradeMode == 1) else 'cross'
         collateralString = self.safe_string(position, 'positionBalance')
-        entryPrice = self.omit_zero(self.safe_string_2(position, 'entryPrice', 'avgPrice'))
+        entryPrice = self.omit_zero(self.safe_string_n(position, ['entryPrice', 'avgPrice', 'avgEntryPrice']))
         liquidationPrice = self.omit_zero(self.safe_string(position, 'liqPrice'))
         leverage = self.safe_string(position, 'leverage')
         if liquidationPrice is not None:
@@ -6077,7 +6105,7 @@ class bybit(Exchange, ImplicitAPI):
             'symbol': market['symbol'],
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
-            'lastUpdateTimestamp': None,
+            'lastUpdateTimestamp': lastUpdateTimestamp,
             'initialMargin': self.parse_number(initialMarginString),
             'initialMarginPercentage': self.parse_number(Precise.string_div(initialMarginString, notional)),
             'maintenanceMargin': self.parse_number(maintenanceMarginString),
@@ -6086,12 +6114,13 @@ class bybit(Exchange, ImplicitAPI):
             'notional': self.parse_number(notional),
             'leverage': self.parse_number(leverage),
             'unrealizedPnl': self.parse_number(unrealisedPnl),
+            'realizedPnl': self.safe_number(position, 'closedPnl'),
             'contracts': self.parse_number(size),  # in USD for inverse swaps
             'contractSize': self.safe_number(market, 'contractSize'),
             'marginRatio': self.parse_number(marginRatio),
             'liquidationPrice': self.parse_number(liquidationPrice),
             'markPrice': self.safe_number(position, 'markPrice'),
-            'lastPrice': None,
+            'lastPrice': self.safe_number(position, 'avgExitPrice'),
             'collateral': self.parse_number(collateralString),
             'marginMode': marginMode,
             'side': side,
@@ -7885,6 +7914,79 @@ class bybit(Exchange, ImplicitAPI):
             'quoteVolume': None,
         }
 
+    async def fetch_positions_history(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}) -> List[Position]:
+        """
+        fetches historical positions
+        :see: https://bybit-exchange.github.io/docs/v5/position/close-pnl
+        :param str [symbol]: unified market symbols, symbols must have the same subType(must all be linear or all be inverse)
+        :param int [since]: timestamp in ms of the earliest position to fetch, params["until"] - since <= 7 days
+        :param int [limit]: the maximum amount of records to fetch, default=50, max=100
+        :param dict params: extra parameters specific to the exchange api endpoint
+        :param int [params.until]: timestamp in ms of the latest position to fetch, params["until"] - since <= 7 days
+        :param str [params.subType]: 'linear' or 'inverse'
+        :returns dict[]: a list of `position structures <https://docs.ccxt.com/#/?id=position-structure>`
+        """
+        await self.load_markets()
+        market = None
+        subType = None
+        symbolsLength = 0
+        if symbols is not None:
+            symbolsLength = len(symbols)
+            if symbolsLength > 0:
+                market = self.market(symbols[0])
+        until = self.safe_integer(params, 'until')
+        subType, params = self.handle_sub_type_and_params('fetchPositionsHistory', market, params, 'linear')
+        params = self.omit(params, 'until')
+        request = {
+            'category': subType,
+        }
+        if (symbols is not None) and (symbolsLength == 1):
+            request['symbol'] = market['id']
+        if since is not None:
+            request['startTime'] = since
+        if limit is not None:
+            request['limit'] = limit
+        if until is not None:
+            request['endTime'] = until
+        response = await self.privateGetV5PositionClosedPnl(self.extend(request, params))
+        #
+        #    {
+        #        retCode: '0',
+        #        retMsg: 'OK',
+        #        result: {
+        #            nextPageCursor: '071749f3-a9fa-427b-b5ca-27b2f52b81de%3A1712717265566520788%2C071749f3-a9fa-427b-b5ca-27b2f52b81de%3A1712717265566520788',
+        #            category: 'linear',
+        #            list: [
+        #                {
+        #                    symbol: 'XRPUSDT',
+        #                    orderType: 'Market',
+        #                    leverage: '10',
+        #                    updatedTime: '1712717265572',
+        #                    side: 'Sell',
+        #                    orderId: '071749f3-a9fa-427b-b5ca-27b2f52b81de',
+        #                    closedPnl: '-0.00049568',
+        #                    avgEntryPrice: '0.6045',
+        #                    qty: '3',
+        #                    cumEntryValue: '1.8135',
+        #                    createdTime: '1712717265566',
+        #                    orderPrice: '0.5744',
+        #                    closedSize: '3',
+        #                    avgExitPrice: '0.605',
+        #                    execType: 'Trade',
+        #                    fillCount: '1',
+        #                    cumExitValue: '1.815'
+        #                }
+        #            ]
+        #        },
+        #        retExtInfo: {},
+        #        time: '1712717286073'
+        #    }
+        #
+        result = self.safe_dict(response, 'result')
+        rawPositions = self.safe_list(result, 'list')
+        positions = self.parse_positions(rawPositions, symbols, params)
+        return self.filter_by_since_limit(positions, since, limit)
+
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
         url = self.implode_hostname(self.urls['api'][api]) + '/' + path
         if api == 'public':

ccxt/async_support/cex.py

@@ -75,7 +75,13 @@ class cex(Exchange, ImplicitAPI):
                 'fetchOrder': True,
                 'fetchOrderBook': True,
                 'fetchOrders': True,
+                'fetchPosition': False,
+                'fetchPositionHistory': False,
                 'fetchPositionMode': False,
+                'fetchPositions': False,
+                'fetchPositionsForSymbol': False,
+                'fetchPositionsHistory': False,
+                'fetchPositionsRisk': False,
                 'fetchPremiumIndexOHLCV': False,
                 'fetchTicker': True,
                 'fetchTickers': True,

ccxt/async_support/coinbase.py

@@ -213,6 +213,11 @@ class coinbase(Exchange, ImplicitAPI):
                     'public': {
                         'get': {
                             'brokerage/time': 3,
+                            'brokerage/market/product_book': 3,
+                            'brokerage/market/products': 3,
+                            'brokerage/market/products/{product_id}': 3,
+                            'brokerage/market/products/{product_id}/candles': 3,
+                            'brokerage/market/products/{product_id}/ticker': 3,
                         },
                     },
                     'private': {
@@ -1060,7 +1065,7 @@ class coinbase(Exchange, ImplicitAPI):
 
     async def fetch_markets(self, params={}) -> List[Market]:
         """
-        :see: https://docs.cloud.coinbase.com/advanced-trade-api/reference/retailbrokerageapi_getproducts
+        :see: https://docs.cloud.coinbase.com/advanced-trade-api/reference/retailbrokerageapi_getpublicproducts
         :see: https://docs.cloud.coinbase.com/sign-in-with-coinbase/docs/api-currencies#get-fiat-currencies
         :see: https://docs.cloud.coinbase.com/sign-in-with-coinbase/docs/api-exchange-rates#get-exchange-rates
         retrieves data on all markets for coinbase
@@ -1143,19 +1148,89 @@ class coinbase(Exchange, ImplicitAPI):
 
     async def fetch_markets_v3(self, params={}):
         spotUnresolvedPromises = [
-            self.v3PrivateGetBrokerageProducts(params),
-            self.v3PrivateGetBrokerageTransactionSummary(params),
+            self.v3PublicGetBrokerageMarketProducts(params),
+            #
+            #    {
+            #        products: [
+            #            {
+            #                product_id: 'BTC-USD',
+            #                price: '67060',
+            #                price_percentage_change_24h: '3.30054960636883',
+            #                volume_24h: '10967.87426597',
+            #                volume_percentage_change_24h: '141.73048325503036',
+            #                base_increment: '0.00000001',
+            #                quote_increment: '0.01',
+            #                quote_min_size: '1',
+            #                quote_max_size: '150000000',
+            #                base_min_size: '0.00000001',
+            #                base_max_size: '3400',
+            #                base_name: 'Bitcoin',
+            #                quote_name: 'US Dollar',
+            #                watched: False,
+            #                is_disabled: False,
+            #                new: False,
+            #                status: 'online',
+            #                cancel_only: False,
+            #                limit_only: False,
+            #                post_only: False,
+            #                trading_disabled: False,
+            #                auction_mode: False,
+            #                product_type: 'SPOT',
+            #                quote_currency_id: 'USD',
+            #                base_currency_id: 'BTC',
+            #                fcm_trading_session_details: null,
+            #                mid_market_price: '',
+            #                alias: '',
+            #                alias_to: ['BTC-USDC'],
+            #                base_display_symbol: 'BTC',
+            #                quote_display_symbol: 'USD',
+            #                view_only: False,
+            #                price_increment: '0.01',
+            #                display_name: 'BTC-USD',
+            #                product_venue: 'CBE'
+            #            },
+            #            ...
+            #        ],
+            #        num_products: '646'
+            #    }
+            #
         ]
+        if self.check_required_credentials(False):
+            spotUnresolvedPromises.append(self.v3PrivateGetBrokerageTransactionSummary(params))
+        #
+        #    {
+        #        total_volume: '9.995989116664404',
+        #        total_fees: '0.07996791093331522',
+        #        fee_tier: {
+        #            pricing_tier: 'Advanced 1',
+        #            usd_from: '0',
+        #            usd_to: '1000',
+        #            taker_fee_rate: '0.008',
+        #            maker_fee_rate: '0.006',
+        #            aop_from: '',
+        #            aop_to: ''
+        #        },
+        #        margin_rate: null,
+        #        goods_and_services_tax: null,
+        #        advanced_trade_only_volume: '9.995989116664404',
+        #        advanced_trade_only_fees: '0.07996791093331522',
+        #        coinbase_pro_volume: '0',
+        #        coinbase_pro_fees: '0',
+        #        total_balance: '',
+        #        has_promo_fee: False
+        #    }
+        #
         unresolvedContractPromises = []
         try:
             unresolvedContractPromises = [
-                self.v3PrivateGetBrokerageProducts(self.extend(params, {'product_type': 'FUTURE'})),
-                self.v3PrivateGetBrokerageProducts(self.extend(params, {'product_type': 'FUTURE', 'contract_expiry_type': 'PERPETUAL'})),
-                self.v3PrivateGetBrokerageTransactionSummary(self.extend(params, {'product_type': 'FUTURE'})),
-                self.v3PrivateGetBrokerageTransactionSummary(self.extend(params, {'product_type': 'FUTURE', 'contract_expiry_type': 'PERPETUAL'})),
+                self.v3PublicGetBrokerageMarketProducts(self.extend(params, {'product_type': 'FUTURE'})),
+                self.v3PublicGetBrokerageMarketProducts(self.extend(params, {'product_type': 'FUTURE', 'contract_expiry_type': 'PERPETUAL'})),
             ]
+            if self.check_required_credentials(False):
+                unresolvedContractPromises.append(self.extend(params, {'product_type': 'FUTURE'}))
+                unresolvedContractPromises.append(self.extend(params, {'product_type': 'FUTURE', 'contract_expiry_type': 'PERPETUAL'}))
         except Exception as e:
-            unresolvedContractPromises = []  # the sync version of ccxt won't have the promise.all line so the request is made here
+            unresolvedContractPromises = []  # the sync version of ccxt won't have the promise.all line so the request is made here. Some users can't access perpetual products
         promises = await asyncio.gather(*spotUnresolvedPromises)
         contractPromises = None
         try:
@@ -1418,6 +1493,7 @@ class coinbase(Exchange, ImplicitAPI):
         contractSize = self.safe_number(futureProductDetails, 'contract_size')
         contractExpire = self.safe_string(futureProductDetails, 'contract_expiry')
         expireTimestamp = self.parse8601(contractExpire)
+        expireDateTime = self.iso8601(expireTimestamp)
         isSwap = (contractExpiryType == 'PERPETUAL')
         baseId = self.safe_string(futureProductDetails, 'contract_root_unit')
         quoteId = self.safe_string(market, 'quote_currency_id')
@@ -1459,7 +1535,7 @@ class coinbase(Exchange, ImplicitAPI):
             'maker': maker,
             'contractSize': contractSize,
             'expiry': expireTimestamp,
-            'expiryDatetime': contractExpire,
+            'expiryDatetime': expireDateTime,
             'strike': None,
             'optionType': None,
             'precision': {
@@ -1674,7 +1750,7 @@ class coinbase(Exchange, ImplicitAPI):
         request = {}
         if symbols is not None:
             request['product_ids'] = self.market_ids(symbols)
-        response = await self.v3PrivateGetBrokerageProducts(self.extend(request, params))
+        response = await self.v3PublicGetBrokerageMarketProducts(self.extend(request, params))
         #
         #     {
         #         "products": [
@@ -1773,7 +1849,7 @@ class coinbase(Exchange, ImplicitAPI):
             'product_id': market['id'],
             'limit': 1,
         }
-        response = await self.v3PrivateGetBrokerageProductsProductIdTicker(self.extend(request, params))
+        response = await self.v3PublicGetBrokerageMarketProductsProductIdTicker(self.extend(request, params))
         #
         #     {
         #         "trades": [
@@ -3212,7 +3288,7 @@ class coinbase(Exchange, ImplicitAPI):
     async def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
-        :see: https://docs.cloud.coinbase.com/advanced-trade-api/reference/retailbrokerageapi_getcandles
+        :see: https://docs.cloud.coinbase.com/advanced-trade-api/reference/retailbrokerageapi_getpubliccandles
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
         :param int [since]: timestamp in ms of the earliest candle to fetch
@@ -3250,7 +3326,7 @@ class coinbase(Exchange, ImplicitAPI):
         else:
             # 300 candles max
             request['end'] = Precise.string_add(sinceString, str(requestedDuration))
-        response = await self.v3PrivateGetBrokerageProductsProductIdCandles(self.extend(request, params))
+        response = await self.v3PublicGetBrokerageMarketProductsProductIdCandles(self.extend(request, params))
         #
         #     {
         #         "candles": [
@@ -3293,7 +3369,7 @@ class coinbase(Exchange, ImplicitAPI):
     async def fetch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
-        :see: https://docs.cloud.coinbase.com/advanced-trade-api/reference/retailbrokerageapi_getmarkettrades
+        :see: https://docs.cloud.coinbase.com/advanced-trade-api/reference/retailbrokerageapi_getpublicmarkettrades
         :param str symbol: unified market symbol of the trades
         :param int [since]: not used by coinbase fetchTrades
         :param int [limit]: the maximum number of trade structures to fetch
@@ -3315,7 +3391,7 @@ class coinbase(Exchange, ImplicitAPI):
             request['end'] = self.number_to_string(self.parse_to_int(until / 1000))
         elif since is not None:
             raise ArgumentsRequired(self.id + ' fetchTrades() requires a `until` parameter when you use `since` argument')
-        response = await self.v3PrivateGetBrokerageProductsProductIdTicker(self.extend(request, params))
+        response = await self.v3PublicGetBrokerageMarketProductsProductIdTicker(self.extend(request, params))
         #
         #     {
         #         "trades": [
@@ -3401,7 +3477,7 @@ class coinbase(Exchange, ImplicitAPI):
     async def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
-        :see: https://docs.cloud.coinbase.com/advanced-trade-api/reference/retailbrokerageapi_getproductbook
+        :see: https://docs.cloud.coinbase.com/advanced-trade-api/reference/retailbrokerageapi_getpublicproductbook
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -3414,7 +3490,7 @@ class coinbase(Exchange, ImplicitAPI):
         }
         if limit is not None:
             request['limit'] = limit
-        response = await self.v3PrivateGetBrokerageProductBook(self.extend(request, params))
+        response = await self.v3PublicGetBrokerageMarketProductBook(self.extend(request, params))
         #
         #     {
         #         "pricebook": {
@@ -3479,7 +3555,7 @@ class coinbase(Exchange, ImplicitAPI):
         tickers = self.safe_list(response, 'pricebooks', [])
         return self.parse_tickers(tickers, symbols)
 
-    async def withdraw(self, code: str, amount: float, address, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
         """
         make a withdrawal
         :see: https://docs.cloud.coinbase.com/sign-in-with-coinbase/docs/api-transactions#send-money

ccxt/async_support/coinbaseinternational.py

@@ -99,8 +99,10 @@ class coinbaseinternational(Exchange, ImplicitAPI):
                 'fetchOrderBook': False,
                 'fetchOrders': False,
                 'fetchPosition': True,
+                'fetchPositionHistory': False,
                 'fetchPositionMode': False,
                 'fetchPositions': True,
+                'fetchPositionsHistory': False,
                 'fetchPositionsRisk': False,
                 'fetchPremiumIndexOHLCV': False,
                 'fetchTicker': True,
@@ -1771,7 +1773,7 @@ class coinbaseinternational(Exchange, ImplicitAPI):
         trades = self.safe_list(response, 'results', [])
         return self.parse_trades(trades, market, since, limit)
 
-    async def withdraw(self, code: str, amount: float, address, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
         """
         make a withdrawal
         :see: https://docs.cloud.coinbase.com/intx/reference/withdraw

ccxt/async_support/coinbasepro.py

@@ -64,7 +64,13 @@ class coinbasepro(Exchange, ImplicitAPI):
                 'fetchOrderBook': True,
                 'fetchOrders': True,
                 'fetchOrderTrades': True,
+                'fetchPosition': False,
+                'fetchPositionHistory': False,
                 'fetchPositionMode': False,
+                'fetchPositions': False,
+                'fetchPositionsForSymbol': False,
+                'fetchPositionsHistory': False,
+                'fetchPositionsRisk': False,
                 'fetchTicker': True,
                 'fetchTickers': True,
                 'fetchTime': True,
@@ -1274,7 +1280,7 @@ class coinbasepro(Exchange, ImplicitAPI):
     async def fetch_payment_methods(self, params={}):
         return await self.privateGetPaymentMethods(params)
 
-    async def withdraw(self, code: str, amount: float, address, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
         """
         make a withdrawal
         :see: https://docs.cloud.coinbase.com/exchange/reference/exchangerestapi_postwithdrawpaymentmethod

ccxt/async_support/coincheck.py

@@ -56,8 +56,11 @@ class coincheck(Exchange, ImplicitAPI):
                 'fetchOpenOrders': True,
                 'fetchOrderBook': True,
                 'fetchPosition': False,
+                'fetchPositionHistory': False,
                 'fetchPositionMode': False,
                 'fetchPositions': False,
+                'fetchPositionsForSymbol': False,
+                'fetchPositionsHistory': False,
                 'fetchPositionsRisk': False,
                 'fetchPremiumIndexOHLCV': False,
                 'fetchTicker': True,