ccxt 4.3.72__py2.py3-none-any.whl → 4.3.74__py2.py3-none-any.whl

ccxt/async_support/bybit.py

@@ -6739,8 +6739,8 @@ class bybit(Exchange, ImplicitAPI):
         currency = None
         request: dict = {}
         if code is not None:
-            currency = self.safe_currency_code(code)
-            request['coin'] = currency
+            currency = self.safe_currency(code)
+            request['coin'] = currency['id']
         if since is not None:
             request['startTime'] = since
         if limit is not None:

ccxt/async_support/woo.py

@@ -155,7 +155,7 @@ class woo(Exchange, ImplicitAPI):
                     'https://support.woo.org/hc/en-001/articles/4404611795353--Trading-Fees',
                 ],
                 'referral': {
-                    'url': 'https://x.woo.org/register?ref=YWOWC96B',
+                    'url': 'https://x.woo.org/register?ref=DIJT0CNL',
                     'discount': 0.35,
                 },
             },

ccxt/async_support/yobit.py

@@ -5,6 +5,7 @@
 
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.yobit import ImplicitAPI
+import asyncio
 import hashlib
 from ccxt.base.types import Balances, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFees
 from typing import List
@@ -541,31 +542,7 @@ class yobit(Exchange, ImplicitAPI):
             'info': ticker,
         }, market)
 
-    async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
-        """
-        :see: https://yobit.net/en/api
-        fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
-        :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
-        :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
-        """
-        if symbols is None:
-            raise ArgumentsRequired(self.id + ' fetchTickers() requires "symbols" argument')
-        await self.load_markets()
-        symbols = self.market_symbols(symbols)
-        ids = None
-        if symbols is None:
-            ids = self.ids
-        else:
-            ids = self.market_ids(symbols)
-        idsLength: number = len(ids)
-        idsString = '-'.join(ids)
-        maxLength = self.safe_integer(self.options, 'maxUrlLength', 2048)
-        # max URL length is 2048 symbols, including http schema, hostname, tld, etc...
-        lenghtOfBaseUrl = 30  # the url including api-base and endpoint dir is 30 chars
-        actualLength = len(idsString) + lenghtOfBaseUrl
-        if actualLength > maxLength:
-            raise ArgumentsRequired(self.id + ' fetchTickers() is being requested for ' + str(idsLength) + ' markets(which has an URL length of ' + str(actualLength) + ' characters), but it exceedes max URL length(' + str(maxLength) + '), please pass limisted symbols array to fetchTickers to fit in one request')
+    async def fetch_tickers_helper(self, idsString: str, params={}) -> Tickers:
         request: dict = {
             'pair': idsString,
         }
@@ -578,7 +555,53 @@ class yobit(Exchange, ImplicitAPI):
             market = self.safe_market(id)
             symbol = market['symbol']
             result[symbol] = self.parse_ticker(ticker, market)
-        return self.filter_by_array_tickers(result, 'symbol', symbols)
+        return result
+
+    async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        :see: https://yobit.net/en/api
+        fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
+        :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param dict [params.all]: you can set to `true` for convenience to fetch all tickers from self exchange by sending multiple requests
+        :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        allSymbols = None
+        allSymbols, params = self.handle_param_bool(params, 'all', False)
+        if symbols is None and not allSymbols:
+            raise ArgumentsRequired(self.id + ' fetchTickers() requires "symbols" argument or use `params["all"] = True` to send multiple requests for all markets')
+        await self.load_markets()
+        promises = []
+        maxLength = self.safe_integer(self.options, 'maxUrlLength', 2048)
+        # max URL length is 2048 symbols, including http schema, hostname, tld, etc...
+        lenghtOfBaseUrl = 40  # safe space for the url including api-base and endpoint dir is 30 chars
+        if allSymbols:
+            symbols = self.symbols
+            ids = ''
+            for i in range(0, len(self.ids)):
+                id = self.ids[i]
+                prefix = '' if (ids == '') else '-'
+                ids += prefix + id
+                if len(ids) > maxLength:
+                    promises.append(self.fetch_tickers_helper(ids, params))
+                    ids = ''
+            if ids != '':
+                promises.append(self.fetch_tickers_helper(ids, params))
+        else:
+            symbols = self.market_symbols(symbols)
+            ids = self.market_ids(symbols)
+            idsLength: number = len(ids)
+            idsString = '-'.join(ids)
+            actualLength = len(idsString) + lenghtOfBaseUrl
+            if actualLength > maxLength:
+                raise ArgumentsRequired(self.id + ' fetchTickers() is being requested for ' + str(idsLength) + ' markets(which has an URL length of ' + str(actualLength) + ' characters), but it exceedes max URL length(' + str(maxLength) + '), please pass limisted symbols array to fetchTickers to fit in one request')
+            promises.append(self.fetch_tickers_helper(idsString, params))
+        resultAll = await asyncio.gather(*promises)
+        finalResult = {}
+        for i in range(0, len(resultAll)):
+            result = self.filter_by_array_tickers(resultAll[i], 'symbol', symbols)
+            finalResult = self.extend(finalResult, result)
+        return finalResult
 
     async def fetch_ticker(self, symbol: str, params={}) -> Ticker:
         """

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.72'
+__version__ = '4.3.74'
 
 # -----------------------------------------------------------------------------
 

ccxt/binance.py

@@ -212,8 +212,10 @@ class binance(Exchange, ImplicitAPI):
                     'dapiPrivateV2': 'https://testnet.binancefuture.com/dapi/v2',
                     'fapiPublic': 'https://testnet.binancefuture.com/fapi/v1',
                     'fapiPublicV2': 'https://testnet.binancefuture.com/fapi/v2',
+                    'fapiPublicV3': 'https://testnet.binancefuture.com/fapi/v3',
                     'fapiPrivate': 'https://testnet.binancefuture.com/fapi/v1',
                     'fapiPrivateV2': 'https://testnet.binancefuture.com/fapi/v2',
+                    'fapiPrivateV3': 'https://testnet.binancefuture.com/fapi/v3',
                     'public': 'https://testnet.binance.vision/api/v3',
                     'private': 'https://testnet.binance.vision/api/v3',
                     'v1': 'https://testnet.binance.vision/api/v1',
@@ -231,9 +233,11 @@ class binance(Exchange, ImplicitAPI):
                     'dapiData': 'https://dapi.binance.com/futures/data',
                     'fapiPublic': 'https://fapi.binance.com/fapi/v1',
                     'fapiPublicV2': 'https://fapi.binance.com/fapi/v2',
+                    'fapiPublicV3': 'https://fapi.binance.com/fapi/v3',
                     'fapiPrivate': 'https://fapi.binance.com/fapi/v1',
-                    'fapiData': 'https://fapi.binance.com/futures/data',
                     'fapiPrivateV2': 'https://fapi.binance.com/fapi/v2',
+                    'fapiPrivateV3': 'https://fapi.binance.com/fapi/v3',
+                    'fapiData': 'https://fapi.binance.com/futures/data',
                     'public': 'https://api.binance.com/api/v3',
                     'private': 'https://api.binance.com/api/v3',
                     'v1': 'https://api.binance.com/api/v1',
@@ -869,6 +873,8 @@ class binance(Exchange, ImplicitAPI):
                         'trade/asyn': 1000,
                         'trade/asyn/id': 10,
                         'feeBurn': 1,
+                        'symbolConfig': 5,
+                        'accountConfig': 5,
                     },
                     'post': {
                         'batchOrders': 5,
@@ -909,6 +915,16 @@ class binance(Exchange, ImplicitAPI):
                         'positionRisk': 1,
                     },
                 },
+                'fapiPublicV3': {
+                    'get': {},
+                },
+                'fapiPrivateV3': {
+                    'get': {
+                        'account': 1,
+                        'balance': 1,
+                        'positionRisk': 1,
+                    },
+                },
                 'eapiPublic': {
                     'get': {
                         'ping': 1,
@@ -3347,7 +3363,7 @@ class binance(Exchange, ImplicitAPI):
             response = self.papiGetBalance(self.extend(request, query))
         elif self.is_linear(type, subType):
             type = 'linear'
-            response = self.fapiPrivateV2GetAccount(self.extend(request, query))
+            response = self.fapiPrivateV3GetAccount(self.extend(request, query))
         elif self.is_inverse(type, subType):
             type = 'inverse'
             response = self.dapiPrivateGetAccount(self.extend(request, query))
@@ -8765,24 +8781,29 @@ class binance(Exchange, ImplicitAPI):
         #
         # usdm
         #
+        # v3(similar for cross & isolated)
+        #
         #    {
-        #       "symbol": "BTCBUSD",
-        #       "initialMargin": "0",
-        #       "maintMargin": "0",
-        #       "unrealizedProfit": "0.00000000",
-        #       "positionInitialMargin": "0",
-        #       "openOrderInitialMargin": "0",
-        #       "leverage": "20",
-        #       "isolated": False,
-        #       "entryPrice": "0.0000",
-        #       "maxNotional": "100000",
-        #       "positionSide": "BOTH",
-        #       "positionAmt": "0.000",
-        #       "notional": "0",
-        #       "isolatedWallet": "0",
-        #       "updateTime": "0",
-        #       "crossMargin": "100.93634809",
-        #     }
+        #        "symbol": "WLDUSDT",
+        #        "positionSide": "BOTH",
+        #        "positionAmt": "-849",
+        #        "unrealizedProfit": "11.17920750",
+        #        "notional": "-1992.46079250",
+        #        "isolatedMargin": "0",
+        #        "isolatedWallet": "0",
+        #        "initialMargin": "99.62303962",
+        #        "maintMargin": "11.95476475",
+        #        "updateTime": "1721995760449"
+        #        "leverage": "50",                        # in v2
+        #        "entryPrice": "2.34",                    # in v2
+        #        "positionInitialMargin": "118.82116614",  # in v2
+        #        "openOrderInitialMargin": "0",           # in v2
+        #        "isolated": False,                       # in v2
+        #        "breakEvenPrice": "2.3395788",           # in v2
+        #        "maxNotional": "25000",                  # in v2
+        #        "bidNotional": "0",                      # in v2
+        #        "askNotional": "0"                       # in v2
+        #    }
         #
         # coinm
         #
@@ -8848,13 +8869,15 @@ class binance(Exchange, ImplicitAPI):
         market = self.safe_market(marketId, market, None, 'contract')
         symbol = self.safe_string(market, 'symbol')
         leverageString = self.safe_string(position, 'leverage')
-        leverage = int(leverageString)
+        leverage = int(leverageString) if (leverageString is not None) else None
         initialMarginString = self.safe_string(position, 'initialMargin')
         initialMargin = self.parse_number(initialMarginString)
-        initialMarginPercentageString = Precise.string_div('1', leverageString, 8)
-        rational = self.is_round_number(1000 % leverage)
-        if not rational:
-            initialMarginPercentageString = Precise.string_div(Precise.string_add(initialMarginPercentageString, '1e-8'), '1', 8)
+        initialMarginPercentageString = None
+        if leverageString is not None:
+            initialMarginPercentageString = Precise.string_div('1', leverageString, 8)
+            rational = self.is_round_number(1000 % leverage)
+            if not rational:
+                initialMarginPercentageString = Precise.string_div(Precise.string_add(initialMarginPercentageString, '1e-8'), '1', 8)
         # to notionalValue
         usdm = ('notional' in position)
         maintenanceMarginString = self.safe_string(position, 'maintMargin')
@@ -8887,6 +8910,9 @@ class binance(Exchange, ImplicitAPI):
         if timestamp == 0:
             timestamp = None
         isolated = self.safe_bool(position, 'isolated')
+        if isolated is None:
+            isolatedMarginRaw = self.safe_string(position, 'isolatedMargin')
+            isolated = not Precise.string_eq(isolatedMarginRaw, '0')
         marginMode = None
         collateralString = None
         walletBalance = None
@@ -8991,23 +9017,34 @@ class binance(Exchange, ImplicitAPI):
         #
         # usdm
         #
-        #     {
-        #       "symbol": "BTCUSDT",
-        #       "positionAmt": "0.001",
-        #       "entryPrice": "43578.07000",
-        #       "markPrice": "43532.30000000",
-        #       "unRealizedProfit": "-0.04577000",
-        #       "liquidationPrice": "21841.24993976",
-        #       "leverage": "2",
-        #       "maxNotionalValue": "300000000",
-        #       "marginType": "isolated",
-        #       "isolatedMargin": "21.77841506",
-        #       "isAutoAddMargin": "false",
-        #       "positionSide": "BOTH",
-        #       "notional": "43.53230000",
-        #       "isolatedWallet": "21.82418506",
-        #       "updateTime": "1621358023886"
-        #     }
+        #  {
+        #     symbol: "WLDUSDT",
+        #     positionSide: "BOTH",
+        #     positionAmt: "5",
+        #     entryPrice: "2.3483",
+        #     breakEvenPrice: "2.349356735",
+        #     markPrice: "2.39560000",
+        #     unRealizedProfit: "0.23650000",
+        #     liquidationPrice: "0",
+        #     isolatedMargin: "0",
+        #     notional: "11.97800000",
+        #     isolatedWallet: "0",
+        #     updateTime: "1722062678998",
+        #     initialMargin: "2.39560000",         # not in v2
+        #     maintMargin: "0.07186800",           # not in v2
+        #     positionInitialMargin: "2.39560000",  # not in v2
+        #     openOrderInitialMargin: "0",         # not in v2
+        #     adl: "2",                            # not in v2
+        #     bidNotional: "0",                    # not in v2
+        #     askNotional: "0",                    # not in v2
+        #     marginAsset: "USDT",                 # not in v2
+        #     # the below fields are only in v2
+        #     leverage: "5",
+        #     maxNotionalValue: "6000000",
+        #     marginType: "cross",
+        #     isAutoAddMargin: "false",
+        #     isolated: False,
+        #     adlQuantile: "2",
         #
         # coinm
         #
@@ -9065,6 +9102,7 @@ class binance(Exchange, ImplicitAPI):
         marketId = self.safe_string(position, 'symbol')
         market = self.safe_market(marketId, market, None, 'contract')
         symbol = self.safe_string(market, 'symbol')
+        isolatedMarginString = self.safe_string(position, 'isolatedMargin')
         leverageBrackets = self.safe_dict(self.options, 'leverageBrackets', {})
         leverageBracket = self.safe_list(leverageBrackets, symbol, [])
         notionalString = self.safe_string_2(position, 'notional', 'notionalValue')
@@ -9080,12 +9118,12 @@ class binance(Exchange, ImplicitAPI):
         contracts = self.parse_number(contractsAbs)
         unrealizedPnlString = self.safe_string(position, 'unRealizedProfit')
         unrealizedPnl = self.parse_number(unrealizedPnlString)
-        leverageString = self.safe_string(position, 'leverage')
-        leverage = int(leverageString)
         liquidationPriceString = self.omit_zero(self.safe_string(position, 'liquidationPrice'))
         liquidationPrice = self.parse_number(liquidationPriceString)
         collateralString = None
         marginMode = self.safe_string(position, 'marginType')
+        if marginMode is None and isolatedMarginString:
+            marginMode = 'cross' if Precise.string_eq(isolatedMarginString, '0') else 'isolated'
         side = None
         if Precise.string_gt(notionalString, '0'):
             side = 'long'
@@ -9142,13 +9180,25 @@ class binance(Exchange, ImplicitAPI):
             timestamp = None
         maintenanceMarginPercentage = self.parse_number(maintenanceMarginPercentageString)
         maintenanceMarginString = Precise.string_mul(maintenanceMarginPercentageString, notionalStringAbs)
+        if maintenanceMarginString is None:
+            # for a while, self new value was a backup to the existing calculations, but in future we might prioritize self
+            maintenanceMarginString = self.safe_string(position, 'maintMargin')
         maintenanceMargin = self.parse_number(maintenanceMarginString)
-        initialMarginPercentageString = Precise.string_div('1', leverageString, 8)
-        rational = self.is_round_number(1000 % leverage)
-        if not rational:
-            initialMarginPercentageString = Precise.string_add(initialMarginPercentageString, '1e-8')
-        initialMarginString = Precise.string_div(Precise.string_mul(notionalStringAbs, initialMarginPercentageString), '1', 8)
-        initialMargin = self.parse_number(initialMarginString)
+        initialMarginString = None
+        initialMarginPercentageString = None
+        leverageString = self.safe_string(position, 'leverage')
+        if leverageString is not None:
+            leverage = int(leverageString)
+            rational = self.is_round_number(1000 % leverage)
+            initialMarginPercentageString = Precise.string_div('1', leverageString, 8)
+            if not rational:
+                initialMarginPercentageString = Precise.string_add(initialMarginPercentageString, '1e-8')
+            unrounded = Precise.string_mul(notionalStringAbs, initialMarginPercentageString)
+            initialMarginString = Precise.string_div(unrounded, '1', 8)
+        else:
+            initialMarginString = self.safe_string(position, 'initialMargin')
+            unrounded = Precise.string_mul(initialMarginString, '1')
+            initialMarginPercentageString = Precise.string_div(unrounded, notionalStringAbs, 8)
         marginRatio = None
         percentage = None
         if not Precise.string_equals(collateralString, '0'):
@@ -9170,7 +9220,7 @@ class binance(Exchange, ImplicitAPI):
             'markPrice': markPrice,
             'entryPrice': entryPrice,
             'timestamp': timestamp,
-            'initialMargin': initialMargin,
+            'initialMargin': self.parse_number(initialMarginString),
             'initialMarginPercentage': self.parse_number(initialMarginPercentageString),
             'maintenanceMargin': maintenanceMargin,
             'maintenanceMarginPercentage': maintenanceMarginPercentage,
@@ -9500,9 +9550,14 @@ class binance(Exchange, ImplicitAPI):
         :param str [method]: method name to call, "positionRisk", "account" or "option", default is "positionRisk"
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/#/?id=position-structure>`
         """
-        defaultValue = self.safe_string(self.options, 'fetchPositions', 'positionRisk')
         defaultMethod = None
-        defaultMethod, params = self.handle_option_and_params(params, 'fetchPositions', 'method', defaultValue)
+        defaultMethod, params = self.handle_option_and_params(params, 'fetchPositions', 'method')
+        if defaultMethod is None:
+            options = self.safe_dict(self.options, 'fetchPositions')
+            if options is None:
+                defaultMethod = self.safe_string(self.options, 'fetchPositions', 'positionRisk')
+            else:
+                defaultMethod = 'positionRisk'
         if defaultMethod == 'positionRisk':
             return self.fetch_positions_risk(symbols, params)
         elif defaultMethod == 'account':
@@ -9510,7 +9565,7 @@ class binance(Exchange, ImplicitAPI):
         elif defaultMethod == 'option':
             return self.fetch_option_positions(symbols, params)
         else:
-            raise NotSupported(self.id + '.options["fetchPositions"]/params["method"] = "' + defaultMethod + '" is invalid, please choose between "account", "positionRisk" and "option"')
+            raise NotSupported(self.id + '.options["fetchPositions"]["method"] or params["method"] = "' + defaultMethod + '" is invalid, please choose between "account", "positionRisk" and "option"')
 
     def fetch_account_positions(self, symbols: Strings = None, params={}):
         """
@@ -9525,6 +9580,7 @@ class binance(Exchange, ImplicitAPI):
         :param boolean [params.portfolioMargin]: set to True if you would like to fetch positions in a portfolio margin account
         :param str [params.subType]: "linear" or "inverse"
         :param boolean [params.filterClosed]: set to True if you would like to filter out closed positions, default is False
+        :param boolean [params.useV2]: set to True if you want to use obsolete endpoint, where some more additional fields were provided
         :returns dict: data on account positions
         """
         if symbols is not None:
@@ -9544,7 +9600,78 @@ class binance(Exchange, ImplicitAPI):
             if isPortfolioMargin:
                 response = self.papiGetUmAccount(params)
             else:
-                response = self.fapiPrivateV2GetAccount(params)
+                useV2 = None
+                useV2, params = self.handle_option_and_params(params, 'fetchAccountPositions', 'useV2', False)
+                if not useV2:
+                    response = self.fapiPrivateV3GetAccount(params)
+                else:
+                    response = self.fapiPrivateV2GetAccount(params)
+                #
+                #    {
+                #        "totalInitialMargin": "99.62112386",
+                #        "totalMaintMargin": "11.95453485",
+                #        "totalWalletBalance": "99.84331553",
+                #        "totalUnrealizedProfit": "11.17675690",
+                #        "totalMarginBalance": "111.02007243",
+                #        "totalPositionInitialMargin": "99.62112386",
+                #        "totalOpenOrderInitialMargin": "0.00000000",
+                #        "totalCrossWalletBalance": "99.84331553",
+                #        "totalCrossUnPnl": "11.17675690",
+                #        "availableBalance": "11.39894857",
+                #        "maxWithdrawAmount": "11.39894857",
+                #        "feeTier": "0",      # in v2
+                #        "canTrade": True,    # in v2
+                #        "canDeposit": True,  # in v2
+                #        "canWithdraw": True,  # in v2
+                #        "feeBurn": True,     # in v2
+                #        "tradeGroupId": "-1",// in v2
+                #        "updateTime": "0",   # in v2
+                #        "multiAssetsMargin": True  # in v2
+                #        "assets": [
+                #            {
+                #                "asset": "USDT",
+                #                "walletBalance": "72.72317863",
+                #                "unrealizedProfit": "11.17920750",
+                #                "marginBalance": "83.90238613",
+                #                "maintMargin": "11.95476475",
+                #                "initialMargin": "99.62303962",
+                #                "positionInitialMargin": "99.62303962",
+                #                "openOrderInitialMargin": "0.00000000",
+                #                "crossWalletBalance": "72.72317863",
+                #                "crossUnPnl": "11.17920750",
+                #                "availableBalance": "11.39916777",
+                #                "maxWithdrawAmount": "11.39916777",
+                #                "updateTime": "1721995605338",
+                #                "marginAvailable": True  # in v2
+                #            },
+                #            ... and some few supported settle currencies: USDC, BTC, ETH, BNB ..
+                #        ],
+                #        "positions": [
+                #            {
+                #                "symbol": "WLDUSDT",
+                #                "positionSide": "BOTH",
+                #                "positionAmt": "-849",
+                #                "unrealizedProfit": "11.17920750",
+                #                "isolatedMargin": "0",
+                #                "isolatedWallet": "0",
+                #                "notional": "-1992.46079250",
+                #                "initialMargin": "99.62303962",
+                #                "maintMargin": "11.95476475",
+                #                "updateTime": "1721995760449"
+                #                "leverage": "50",                        # in v2
+                #                "entryPrice": "2.34",                    # in v2
+                #                "positionInitialMargin": "118.82116614",  # in v2
+                #                "openOrderInitialMargin": "0",           # in v2
+                #                "isolated": False,                       # in v2
+                #                "breakEvenPrice": "2.3395788",           # in v2
+                #                "maxNotional": "25000",                  # in v2
+                #                "bidNotional": "0",                      # in v2
+                #                "askNotional": "0"                       # in v2
+                #            },
+                #            ...
+                #        ]
+                #    }
+                #
         elif self.is_inverse(type, subType):
             if isPortfolioMargin:
                 response = self.papiGetCmAccount(params)
@@ -9591,7 +9718,33 @@ class binance(Exchange, ImplicitAPI):
             if isPortfolioMargin:
                 response = self.papiGetUmPositionRisk(self.extend(request, params))
             else:
-                response = self.fapiPrivateV2GetPositionRisk(self.extend(request, params))
+                response = self.fapiPrivateV3GetPositionRisk(self.extend(request, params))
+                #
+                # [
+                #  {
+                #     symbol: "WLDUSDT",
+                #     positionSide: "BOTH",
+                #     positionAmt: "5",
+                #     entryPrice: "2.3483",
+                #     breakEvenPrice: "2.349356735",
+                #     markPrice: "2.39560000",
+                #     unRealizedProfit: "0.23650000",
+                #     liquidationPrice: "0",
+                #     isolatedMargin: "0",
+                #     notional: "11.97800000",
+                #     isolatedWallet: "0",
+                #     updateTime: "1722062678998",
+                #     initialMargin: "2.39560000",         # added in v3
+                #     maintMargin: "0.07186800",           # added in v3
+                #     positionInitialMargin: "2.39560000",  # added in v3
+                #     openOrderInitialMargin: "0",         # added in v3
+                #     adl: "2",                            # added in v3
+                #     bidNotional: "0",                    # added in v3
+                #     askNotional: "0",                    # added in v3
+                #     marginAsset: "USDT",                 # added in v3
+                #  },
+                # ]
+                #
         elif self.is_inverse(type, subType):
             if isPortfolioMargin:
                 response = self.papiGetCmPositionRisk(self.extend(request, params))
@@ -9605,18 +9758,18 @@ class binance(Exchange, ImplicitAPI):
         #
         #     [
         #         {
+        #             "symbol": "BTCUSDT",
+        #             "positionSide": "BOTH",
+        #             "positionAmt": "0.000",
         #             "entryPrice": "0.00000",
+        #             "markPrice": "6679.50671178",
+        #             "unRealizedProfit": "0.00000000",
+        #             "liquidationPrice": "0",
+        #             "isolatedMargin": "0.00000000",
         #             "marginType": "isolated",
         #             "isAutoAddMargin": "false",
-        #             "isolatedMargin": "0.00000000",
         #             "leverage": "10",
-        #             "liquidationPrice": "0",
-        #             "markPrice": "6679.50671178",
         #             "maxNotionalValue": "20000000",
-        #             "positionAmt": "0.000",
-        #             "symbol": "BTCUSDT",
-        #             "unRealizedProfit": "0.00000000",
-        #             "positionSide": "BOTH",
         #             "updateTime": 0
         #        }
         #     ]
@@ -9633,27 +9786,13 @@ class binance(Exchange, ImplicitAPI):
         #             "liquidationPrice": "5930.78",
         #             "markPrice": "6679.50671178",
         #             "maxNotionalValue": "20000000",
-        #             "positionAmt": "20.000",
+        #             "positionSide": "LONG",
+        #             "positionAmt": "20.000",  # negative value for 'SHORT'
         #             "symbol": "BTCUSDT",
         #             "unRealizedProfit": "2316.83423560"
-        #             "positionSide": "LONG",
         #             "updateTime": 1625474304765
         #         },
-        #         {
-        #             "entryPrice": "0.00000",
-        #             "marginType": "isolated",
-        #             "isAutoAddMargin": "false",
-        #             "isolatedMargin": "5413.95799991",
-        #             "leverage": "10",
-        #             "liquidationPrice": "7189.95",
-        #             "markPrice": "6679.50671178",
-        #             "maxNotionalValue": "20000000",
-        #             "positionAmt": "-10.000",
-        #             "symbol": "BTCUSDT",
-        #             "unRealizedProfit": "-1156.46711780",
-        #             "positionSide": "SHORT",
-        #             "updateTime": 0
-        #         }
+        #         .. second dict is similar, but with `positionSide: SHORT`
         #     ]
         #
         # inverse portfolio margin:
@@ -9697,10 +9836,9 @@ class binance(Exchange, ImplicitAPI):
         result = []
         for i in range(0, len(response)):
             rawPosition = response[i]
-            entryPrice = self.safe_string(rawPosition, 'entryPrice')
-            if (entryPrice != '0') and (entryPrice != '0.0') and (entryPrice != '0.00000000'):
-                parsed = self.parse_position_risk(response[i])
-                result.append(parsed)
+            entryPriceString = self.safe_string(rawPosition, 'entryPrice')
+            if Precise.string_gt(entryPriceString, '0'):
+                result.append(self.parse_position_risk(response[i]))
         symbols = self.market_symbols(symbols)
         return self.filter_by_array_positions(result, 'symbol', symbols, False)
 
@@ -10335,7 +10473,7 @@ class binance(Exchange, ImplicitAPI):
                     body = self.urlencode(params)
             else:
                 raise AuthenticationError(self.id + ' userDataStream endpoint requires `apiKey` credential')
-        elif (api == 'private') or (api == 'eapiPrivate') or (api == 'sapi' and path != 'system/status') or (api == 'sapiV2') or (api == 'sapiV3') or (api == 'sapiV4') or (api == 'dapiPrivate') or (api == 'dapiPrivateV2') or (api == 'fapiPrivate') or (api == 'fapiPrivateV2') or (api == 'papi' and path != 'ping'):
+        elif (api == 'private') or (api == 'eapiPrivate') or (api == 'sapi' and path != 'system/status') or (api == 'sapiV2') or (api == 'sapiV3') or (api == 'sapiV4') or (api == 'dapiPrivate') or (api == 'dapiPrivateV2') or (api == 'fapiPrivate') or (api == 'fapiPrivateV2') or (api == 'fapiPrivateV3') or (api == 'papi' and path != 'ping'):
             self.check_required_credentials()
             if method == 'POST' and ((path == 'order') or (path == 'sor/order')):
                 # inject in implicit API calls

ccxt/bybit.py

@@ -6738,8 +6738,8 @@ class bybit(Exchange, ImplicitAPI):
         currency = None
         request: dict = {}
         if code is not None:
-            currency = self.safe_currency_code(code)
-            request['coin'] = currency
+            currency = self.safe_currency(code)
+            request['coin'] = currency['id']
         if since is not None:
             request['startTime'] = since
         if limit is not None:

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.72'
+__version__ = '4.3.74'
 
 # ----------------------------------------------------------------------------