ccxt 4.2.38__py2.py3-none-any.whl → 4.2.40__py2.py3-none-any.whl

ccxt/async_support/binance.py

@@ -2362,7 +2362,7 @@ class binance(Exchange, ImplicitAPI):
         reconstructedDate = '20' + year + '-' + month + '-' + day + 'T00:00:00Z'
         return reconstructedDate
 
-    def create_expired_option_market(self, symbol):
+    def create_expired_option_market(self, symbol: str):
         # support expired option contracts
         settle = 'USDT'
         optionParts = symbol.split('-')
@@ -2638,7 +2638,7 @@ class binance(Exchange, ImplicitAPI):
             minPrecision = None
             isWithdrawEnabled = True
             isDepositEnabled = True
-            networkList = self.safe_value(entry, 'networkList', [])
+            networkList = self.safe_list(entry, 'networkList', [])
             fees = {}
             fee = None
             for j in range(0, len(networkList)):
@@ -2646,12 +2646,12 @@ class binance(Exchange, ImplicitAPI):
                 network = self.safe_string(networkItem, 'network')
                 # name = self.safe_string(networkItem, 'name')
                 withdrawFee = self.safe_number(networkItem, 'withdrawFee')
-                depositEnable = self.safe_value(networkItem, 'depositEnable')
-                withdrawEnable = self.safe_value(networkItem, 'withdrawEnable')
+                depositEnable = self.safe_bool(networkItem, 'depositEnable')
+                withdrawEnable = self.safe_bool(networkItem, 'withdrawEnable')
                 isDepositEnabled = isDepositEnabled or depositEnable
                 isWithdrawEnabled = isWithdrawEnabled or withdrawEnable
                 fees[network] = withdrawFee
-                isDefault = self.safe_value(networkItem, 'isDefault')
+                isDefault = self.safe_bool(networkItem, 'isDefault')
                 if isDefault or (fee is None):
                     fee = withdrawFee
                 precisionTick = self.safe_string(networkItem, 'withdrawIntegerMultiple')
@@ -2659,7 +2659,7 @@ class binance(Exchange, ImplicitAPI):
                 # so, when there is zero instead of i.e. 0.001, then we skip those cases, because we don't know the precision - it might be because of network is suspended or other reasons
                 if not Precise.string_eq(precisionTick, '0'):
                     minPrecision = precisionTick if (minPrecision is None) else Precise.string_min(minPrecision, precisionTick)
-            trading = self.safe_value(entry, 'trading')
+            trading = self.safe_bool(entry, 'trading')
             active = (isWithdrawEnabled and isDepositEnabled and trading)
             maxDecimalPlaces = None
             if minPrecision is not None:
@@ -2691,8 +2691,8 @@ class binance(Exchange, ImplicitAPI):
         :returns dict[]: an array of objects representing market data
         """
         promisesRaw = []
-        rawFetchMarkets = self.safe_value(self.options, 'fetchMarkets', ['spot', 'linear', 'inverse'])
-        sandboxMode = self.safe_value(self.options, 'sandboxMode', False)
+        rawFetchMarkets = self.safe_list(self.options, 'fetchMarkets', ['spot', 'linear', 'inverse'])
+        sandboxMode = self.safe_bool(self.options, 'sandboxMode', False)
         fetchMarkets = []
         for i in range(0, len(rawFetchMarkets)):
             type = rawFetchMarkets[i]
@@ -2957,7 +2957,7 @@ class binance(Exchange, ImplicitAPI):
             future = True
         settle = self.safe_currency_code(settleId)
         spot = not contract
-        filters = self.safe_value(market, 'filters', [])
+        filters = self.safe_list(market, 'filters', [])
         filtersByType = self.index_by(filters, 'filterType')
         status = self.safe_string_2(market, 'status', 'contractStatus')
         contractSize = None
@@ -2977,10 +2977,10 @@ class binance(Exchange, ImplicitAPI):
             linear = settle == quote
             inverse = settle == base
             feesType = 'linear' if linear else 'inverse'
-            fees = self.safe_value(self.fees, feesType, {})
+            fees = self.safe_dict(self.fees, feesType, {})
         active = (status == 'TRADING')
         if spot:
-            permissions = self.safe_value(market, 'permissions', [])
+            permissions = self.safe_list(market, 'permissions', [])
             for j in range(0, len(permissions)):
                 if permissions[j] == 'TRD_GRP_003':
                     active = False
@@ -3051,7 +3051,7 @@ class binance(Exchange, ImplicitAPI):
             'created': self.safe_integer(market, 'onboardDate'),  # present in inverse & linear apis
         }
         if 'PRICE_FILTER' in filtersByType:
-            filter = self.safe_value(filtersByType, 'PRICE_FILTER', {})
+            filter = self.safe_dict(filtersByType, 'PRICE_FILTER', {})
             # PRICE_FILTER reports zero values for maxPrice
             # since they updated filter types in November 2018
             # https://github.com/ccxt/ccxt/issues/4286
@@ -3062,7 +3062,7 @@ class binance(Exchange, ImplicitAPI):
             }
             entry['precision']['price'] = self.precision_from_string(filter['tickSize'])
         if 'LOT_SIZE' in filtersByType:
-            filter = self.safe_value(filtersByType, 'LOT_SIZE', {})
+            filter = self.safe_dict(filtersByType, 'LOT_SIZE', {})
             stepSize = self.safe_string(filter, 'stepSize')
             entry['precision']['amount'] = self.precision_from_string(stepSize)
             entry['limits']['amount'] = {
@@ -3070,13 +3070,13 @@ class binance(Exchange, ImplicitAPI):
                 'max': self.safe_number(filter, 'maxQty'),
             }
         if 'MARKET_LOT_SIZE' in filtersByType:
-            filter = self.safe_value(filtersByType, 'MARKET_LOT_SIZE', {})
+            filter = self.safe_dict(filtersByType, 'MARKET_LOT_SIZE', {})
             entry['limits']['market'] = {
                 'min': self.safe_number(filter, 'minQty'),
                 'max': self.safe_number(filter, 'maxQty'),
             }
         if ('MIN_NOTIONAL' in filtersByType) or ('NOTIONAL' in filtersByType):  # notional added in 12/04/23 to spot testnet
-            filter = self.safe_value_2(filtersByType, 'MIN_NOTIONAL', 'NOTIONAL', {})
+            filter = self.safe_dict_2(filtersByType, 'MIN_NOTIONAL', 'NOTIONAL', {})
             entry['limits']['cost']['min'] = self.safe_number_2(filter, 'minNotional', 'notional')
             entry['limits']['cost']['max'] = self.safe_number(filter, 'maxNotional')
         return entry
@@ -3720,7 +3720,7 @@ class binance(Exchange, ImplicitAPI):
             else:
                 response = await self.publicGetTicker24hr(self.extend(request, params))
         if isinstance(response, list):
-            firstTicker = self.safe_value(response, 0, {})
+            firstTicker = self.safe_dict(response, 0, {})
             return self.parse_ticker(firstTicker, market)
         return self.parse_ticker(response, market)
 
@@ -4627,7 +4627,7 @@ class binance(Exchange, ImplicitAPI):
         #
         return self.parse_order(response, market)
 
-    async def edit_order(self, id: str, symbol, type, side, amount=None, price=None, params={}):
+    async def edit_order(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: float = None, price: float = None, params={}):
         """
         edit a trade order
         :see: https://binance-docs.github.io/apidocs/spot/en/#cancel-an-existing-order-and-send-a-new-order-trade
@@ -4841,7 +4841,7 @@ class binance(Exchange, ImplicitAPI):
         #         "msg": "Quantity greater than max quantity."
         #     }
         #
-        # createOrder, fetchOpenOrders: portfolio margin linear swap and future
+        # createOrder, fetchOpenOrders, fetchOrder, cancelOrder: portfolio margin linear swap and future
         #
         #     {
         #         "symbol": "BTCUSDT",
@@ -4864,7 +4864,7 @@ class binance(Exchange, ImplicitAPI):
         #         "status": "NEW"
         #     }
         #
-        # createOrder, fetchOpenOrders: portfolio margin inverse swap and future
+        # createOrder, fetchOpenOrders, fetchOrder, cancelOrder: portfolio margin inverse swap and future
         #
         #     {
         #         "symbol": "ETHUSD_PERP",
@@ -4930,7 +4930,7 @@ class binance(Exchange, ImplicitAPI):
         #         "priceProtect": False
         #     }
         #
-        # createOrder, cancelAllOrders: portfolio margin spot margin
+        # createOrder, cancelAllOrders, cancelOrder: portfolio margin spot margin
         #
         #     {
         #         "clientOrderId": "x-R4BD3S82e9ef29d8346440f0b28b86",
@@ -4949,7 +4949,7 @@ class binance(Exchange, ImplicitAPI):
         #         "type": "LIMIT"
         #     }
         #
-        # fetchOpenOrders: portfolio margin spot margin
+        # fetchOpenOrders, fetchOrder: portfolio margin spot margin
         #
         #     {
         #         "symbol": "BTCUSDT",
@@ -4974,6 +4974,31 @@ class binance(Exchange, ImplicitAPI):
         #         "preventedQuantity": null
         #     }
         #
+        # cancelOrder: portfolio margin linear and inverse swap conditional
+        #
+        #     {
+        #         "strategyId": 3733211,
+        #         "newClientStrategyId": "x-xcKtGhcuaf166172ed504cd1bc0396",
+        #         "strategyType": "STOP",
+        #         "strategyStatus": "CANCELED",
+        #         "origQty": "0.010",
+        #         "price": "35000.00",
+        #         "reduceOnly": False,
+        #         "side": "BUY",
+        #         "positionSide": "BOTH",
+        #         "stopPrice": "50000.00",  # ignored with trailing orders
+        #         "symbol": "BTCUSDT",
+        #         "timeInForce": "GTC",
+        #         "activatePrice": null,  # only return with trailing orders
+        #         "priceRate": null,      # only return with trailing orders
+        #         "bookTime": 1707270098774,
+        #         "updateTime": 1707270119261,
+        #         "workingType": "CONTRACT_PRICE",
+        #         "priceProtect": False,
+        #         "goodTillDate": 0,
+        #         "selfTradePreventionMode": "NONE"
+        #     }
+        #
         code = self.safe_string(order, 'code')
         if code is not None:
             # cancelOrders/createOrders might have a partial success
@@ -5004,7 +5029,7 @@ class binance(Exchange, ImplicitAPI):
         cost = self.safe_string(order, 'cumBase', cost)
         type = self.safe_string_lower(order, 'type')
         side = self.safe_string_lower(order, 'side')
-        fills = self.safe_value(order, 'fills', [])
+        fills = self.safe_list(order, 'fills', [])
         timeInForce = self.safe_string(order, 'timeInForce')
         if timeInForce == 'GTX':
             # GTX means "Good Till Crossing" and is an equivalent way of saying Post Only
@@ -5034,7 +5059,7 @@ class binance(Exchange, ImplicitAPI):
             'type': type,
             'timeInForce': timeInForce,
             'postOnly': postOnly,
-            'reduceOnly': self.safe_value(order, 'reduceOnly'),
+            'reduceOnly': self.safe_bool(order, 'reduceOnly'),
             'side': side,
             'price': price,
             'triggerPrice': stopPrice,
@@ -5066,7 +5091,7 @@ class binance(Exchange, ImplicitAPI):
             side = self.safe_string(rawOrder, 'side')
             amount = self.safe_value(rawOrder, 'amount')
             price = self.safe_value(rawOrder, 'price')
-            orderParams = self.safe_value(rawOrder, 'params', {})
+            orderParams = self.safe_dict(rawOrder, 'params', {})
             orderRequest = self.create_order_request(marketId, type, side, amount, price, orderParams)
             ordersRequests.append(orderRequest)
         orderSymbols = self.market_symbols(orderSymbols, None, False, True, True)
@@ -5417,7 +5442,7 @@ class binance(Exchange, ImplicitAPI):
         requestParams = self.omit(params, ['type', 'newClientOrderId', 'clientOrderId', 'postOnly', 'stopLossPrice', 'takeProfitPrice', 'stopPrice', 'triggerPrice', 'trailingTriggerPrice', 'trailingPercent', 'quoteOrderQty', 'cost', 'test'])
         return self.extend(request, requestParams)
 
-    async def create_market_order_with_cost(self, symbol: str, side: OrderSide, cost, params={}):
+    async def create_market_order_with_cost(self, symbol: str, side: OrderSide, cost: float, params={}):
         """
         create a market order by providing the symbol, side and cost
         :see: https://binance-docs.github.io/apidocs/spot/en/#new-order-trade
@@ -5434,7 +5459,7 @@ class binance(Exchange, ImplicitAPI):
         params['quoteOrderQty'] = cost
         return await self.create_order(symbol, 'market', side, cost, None, params)
 
-    async def create_market_buy_order_with_cost(self, symbol: str, cost, params={}):
+    async def create_market_buy_order_with_cost(self, symbol: str, cost: float, params={}):
         """
         create a market buy order by providing the symbol and cost
         :see: https://binance-docs.github.io/apidocs/spot/en/#new-order-trade
@@ -5450,7 +5475,7 @@ class binance(Exchange, ImplicitAPI):
         params['quoteOrderQty'] = cost
         return await self.create_order(symbol, 'market', 'buy', cost, None, params)
 
-    async def create_market_sell_order_with_cost(self, symbol: str, cost, params={}):
+    async def create_market_sell_order_with_cost(self, symbol: str, cost: float, params={}):
         """
         create a market sell order by providing the symbol and cost
         :see: https://binance-docs.github.io/apidocs/spot/en/#new-order-trade
@@ -5474,9 +5499,14 @@ class binance(Exchange, ImplicitAPI):
         :see: https://binance-docs.github.io/apidocs/delivery/en/#query-order-user_data
         :see: https://binance-docs.github.io/apidocs/voptions/en/#query-single-order-trade
         :see: https://binance-docs.github.io/apidocs/spot/en/#query-margin-account-39-s-order-user_data
+        :see: https://binance-docs.github.io/apidocs/pm/en/#query-um-order-user_data
+        :see: https://binance-docs.github.io/apidocs/pm/en/#query-cm-order-user_data
+        :see: https://binance-docs.github.io/apidocs/pm/en/#query-margin-account-order-user_data
+        :param str id: the order id
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.marginMode]: 'cross' or 'isolated', for spot margin trading
+        :param boolean [params.portfolioMargin]: set to True if you would like to fetch an order in a portfolio margin account
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         if symbol is None:
@@ -5485,11 +5515,14 @@ class binance(Exchange, ImplicitAPI):
         market = self.market(symbol)
         defaultType = self.safe_string_2(self.options, 'fetchOrder', 'defaultType', 'spot')
         type = self.safe_string(params, 'type', defaultType)
-        marginMode, query = self.handle_margin_mode_and_params('fetchOrder', params)
+        marginMode = None
+        marginMode, params = self.handle_margin_mode_and_params('fetchOrder', params)
+        isPortfolioMargin = None
+        isPortfolioMargin, params = self.handle_option_and_params_2(params, 'fetchOrder', 'papi', 'portfolioMargin', False)
         request = {
             'symbol': market['id'],
         }
-        clientOrderId = self.safe_value_2(params, 'origClientOrderId', 'clientOrderId')
+        clientOrderId = self.safe_string_2(params, 'origClientOrderId', 'clientOrderId')
         if clientOrderId is not None:
             if market['option']:
                 request['clientOrderId'] = clientOrderId
@@ -5497,20 +5530,29 @@ class binance(Exchange, ImplicitAPI):
                 request['origClientOrderId'] = clientOrderId
         else:
             request['orderId'] = id
-        requestParams = self.omit(query, ['type', 'clientOrderId', 'origClientOrderId'])
+        params = self.omit(params, ['type', 'clientOrderId', 'origClientOrderId'])
         response = None
         if market['option']:
-            response = await self.eapiPrivateGetOrder(self.extend(request, requestParams))
+            response = await self.eapiPrivateGetOrder(self.extend(request, params))
         elif market['linear']:
-            response = await self.fapiPrivateGetOrder(self.extend(request, requestParams))
+            if isPortfolioMargin:
+                response = await self.papiGetUmOrder(self.extend(request, params))
+            else:
+                response = await self.fapiPrivateGetOrder(self.extend(request, params))
         elif market['inverse']:
-            response = await self.dapiPrivateGetOrder(self.extend(request, requestParams))
-        elif type == 'margin' or marginMode is not None:
-            if marginMode == 'isolated':
-                request['isIsolated'] = True
-            response = await self.sapiGetMarginOrder(self.extend(request, requestParams))
+            if isPortfolioMargin:
+                response = await self.papiGetCmOrder(self.extend(request, params))
+            else:
+                response = await self.dapiPrivateGetOrder(self.extend(request, params))
+        elif (type == 'margin') or (marginMode is not None) or isPortfolioMargin:
+            if isPortfolioMargin:
+                response = await self.papiGetMarginOrder(self.extend(request, params))
+            else:
+                if marginMode == 'isolated':
+                    request['isIsolated'] = True
+                response = await self.sapiGetMarginOrder(self.extend(request, params))
         else:
-            response = await self.privateGetOrder(self.extend(request, requestParams))
+            response = await self.privateGetOrder(self.extend(request, params))
         return self.parse_order(response, market)
 
     async def fetch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
@@ -5779,9 +5821,16 @@ class binance(Exchange, ImplicitAPI):
         :see: https://binance-docs.github.io/apidocs/delivery/en/#cancel-order-trade
         :see: https://binance-docs.github.io/apidocs/voptions/en/#cancel-option-order-trade
         :see: https://binance-docs.github.io/apidocs/spot/en/#margin-account-cancel-order-trade
+        :see: https://binance-docs.github.io/apidocs/pm/en/#cancel-um-order-trade
+        :see: https://binance-docs.github.io/apidocs/pm/en/#cancel-cm-order-trade
+        :see: https://binance-docs.github.io/apidocs/pm/en/#cancel-um-conditional-order-trade
+        :see: https://binance-docs.github.io/apidocs/pm/en/#cancel-cm-conditional-order-trade
+        :see: https://binance-docs.github.io/apidocs/pm/en/#cancel-margin-account-order-trade
         :param str id: order id
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.portfolioMargin]: set to True if you would like to cancel an order in a portfolio margin account
+        :param boolean [params.stop]: set to True if you would like to cancel a portfolio margin account conditional order
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         if symbol is None:
@@ -5790,34 +5839,57 @@ class binance(Exchange, ImplicitAPI):
         market = self.market(symbol)
         defaultType = self.safe_string_2(self.options, 'cancelOrder', 'defaultType', 'spot')
         type = self.safe_string(params, 'type', defaultType)
-        marginMode, query = self.handle_margin_mode_and_params('cancelOrder', params)
+        marginMode = None
+        marginMode, params = self.handle_margin_mode_and_params('cancelOrder', params)
+        isPortfolioMargin = None
+        isPortfolioMargin, params = self.handle_option_and_params_2(params, 'cancelOrder', 'papi', 'portfolioMargin', False)
+        isConditional = self.safe_bool_2(params, 'stop', 'conditional')
         request = {
             'symbol': market['id'],
-            # 'orderId': id,
-            # 'origClientOrderId': id,
         }
-        clientOrderId = self.safe_value_2(params, 'origClientOrderId', 'clientOrderId')
+        clientOrderId = self.safe_string_n(params, ['origClientOrderId', 'clientOrderId', 'newClientStrategyId'])
         if clientOrderId is not None:
             if market['option']:
                 request['clientOrderId'] = clientOrderId
             else:
-                request['origClientOrderId'] = clientOrderId
+                if isPortfolioMargin and isConditional:
+                    request['newClientStrategyId'] = clientOrderId
+                else:
+                    request['origClientOrderId'] = clientOrderId
         else:
-            request['orderId'] = id
-        requestParams = self.omit(query, ['type', 'origClientOrderId', 'clientOrderId'])
+            if isPortfolioMargin and isConditional:
+                request['strategyId'] = id
+            else:
+                request['orderId'] = id
+        params = self.omit(params, ['type', 'origClientOrderId', 'clientOrderId', 'newClientStrategyId', 'stop', 'conditional'])
         response = None
         if market['option']:
-            response = await self.eapiPrivateDeleteOrder(self.extend(request, requestParams))
+            response = await self.eapiPrivateDeleteOrder(self.extend(request, params))
         elif market['linear']:
-            response = await self.fapiPrivateDeleteOrder(self.extend(request, requestParams))
+            if isPortfolioMargin:
+                if isConditional:
+                    response = await self.papiDeleteUmConditionalOrder(self.extend(request, params))
+                else:
+                    response = await self.papiDeleteUmOrder(self.extend(request, params))
+            else:
+                response = await self.fapiPrivateDeleteOrder(self.extend(request, params))
         elif market['inverse']:
-            response = await self.dapiPrivateDeleteOrder(self.extend(request, requestParams))
-        elif type == 'margin' or marginMode is not None:
-            if marginMode == 'isolated':
-                request['isIsolated'] = True
-            response = await self.sapiDeleteMarginOrder(self.extend(request, requestParams))
+            if isPortfolioMargin:
+                if isConditional:
+                    response = await self.papiDeleteCmConditionalOrder(self.extend(request, params))
+                else:
+                    response = await self.papiDeleteCmOrder(self.extend(request, params))
+            else:
+                response = await self.dapiPrivateDeleteOrder(self.extend(request, params))
+        elif (type == 'margin') or (marginMode is not None) or isPortfolioMargin:
+            if isPortfolioMargin:
+                response = await self.papiDeleteMarginOrder(self.extend(request, params))
+            else:
+                if marginMode == 'isolated':
+                    request['isIsolated'] = True
+                response = await self.sapiDeleteMarginOrder(self.extend(request, params))
         else:
-            response = await self.privateDeleteOrder(self.extend(request, requestParams))
+            response = await self.privateDeleteOrder(self.extend(request, params))
         return self.parse_order(response, market)
 
     async def cancel_all_orders(self, symbol: Str = None, params={}):
@@ -6170,11 +6242,11 @@ class binance(Exchange, ImplicitAPI):
         #         },
         #       ]
         #     }
-        results = self.safe_value(response, 'userAssetDribblets', [])
+        results = self.safe_list(response, 'userAssetDribblets', [])
         rows = self.safe_integer(response, 'total', 0)
         data = []
         for i in range(0, rows):
-            logs = self.safe_value(results[i], 'userAssetDribbletDetails', [])
+            logs = self.safe_list(results[i], 'userAssetDribbletDetails', [])
             for j in range(0, len(logs)):
                 logs[j]['isDustTrade'] = True
                 data.append(logs[j])
@@ -6271,7 +6343,7 @@ class binance(Exchange, ImplicitAPI):
         currency = None
         response = None
         request = {}
-        legalMoney = self.safe_value(self.options, 'legalMoney', {})
+        legalMoney = self.safe_dict(self.options, 'legalMoney', {})
         fiatOnly = self.safe_bool(params, 'fiat', False)
         params = self.omit(params, 'fiatOnly')
         until = self.safe_integer(params, 'until')
@@ -6370,7 +6442,7 @@ class binance(Exchange, ImplicitAPI):
         paginate, params = self.handle_option_and_params(params, 'fetchWithdrawals', 'paginate')
         if paginate:
             return await self.fetch_paginated_call_dynamic('fetchWithdrawals', code, since, limit, params)
-        legalMoney = self.safe_value(self.options, 'legalMoney', {})
+        legalMoney = self.safe_dict(self.options, 'legalMoney', {})
         fiatOnly = self.safe_bool(params, 'fiat', False)
         params = self.omit(params, 'fiatOnly')
         request = {}
@@ -6505,7 +6577,7 @@ class binance(Exchange, ImplicitAPI):
                 'Refund Failed': 'failed',
             },
         }
-        statuses = self.safe_value(statusesByType, type, {})
+        statuses = self.safe_dict(statusesByType, type, {})
         return self.safe_string(statuses, status, status)
 
     def parse_transaction(self, transaction, currency: Currency = None) -> Transaction:
@@ -6662,7 +6734,7 @@ class binance(Exchange, ImplicitAPI):
         type = self.safe_string(transfer, 'type')
         fromAccount = None
         toAccount = None
-        accountsById = self.safe_value(self.options, 'accountsById', {})
+        accountsById = self.safe_dict(self.options, 'accountsById', {})
         if type is not None:
             parts = type.split('_')
             fromAccount = self.safe_value(parts, 0)
@@ -6697,23 +6769,19 @@ class binance(Exchange, ImplicitAPI):
         #     }
         #
         marketId = self.safe_string(income, 'symbol')
-        symbol = self.safe_symbol(marketId, market, None, 'swap')
-        amount = self.safe_number(income, 'income')
         currencyId = self.safe_string(income, 'asset')
-        code = self.safe_currency_code(currencyId)
-        id = self.safe_string(income, 'tranId')
         timestamp = self.safe_integer(income, 'time')
         return {
             'info': income,
-            'symbol': symbol,
-            'code': code,
+            'symbol': self.safe_symbol(marketId, market, None, 'swap'),
+            'code': self.safe_currency_code(currencyId),
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
-            'id': id,
-            'amount': amount,
+            'id': self.safe_string(income, 'tranId'),
+            'amount': self.safe_number(income, 'income'),
         }
 
-    async def transfer(self, code: str, amount: float, fromAccount, toAccount, params={}) -> TransferEntry:
+    async def transfer(self, code: str, amount: float, fromAccount: str, toAccount: str, params={}) -> TransferEntry:
         """
         transfer currency internally between wallets on the same account
         :see: https://binance-docs.github.io/apidocs/spot/en/#user-universal-transfer-user_data
@@ -6751,7 +6819,7 @@ class binance(Exchange, ImplicitAPI):
             if toId == 'ISOLATED':
                 if symbol is None:
                     raise ArgumentsRequired(self.id + ' transfer() requires params["symbol"] when toAccount is ' + toAccount)
-            accountsById = self.safe_value(self.options, 'accountsById', {})
+            accountsById = self.safe_dict(self.options, 'accountsById', {})
             fromIsolated = not (fromId in accountsById)
             toIsolated = not (toId in accountsById)
             if fromIsolated and (market is None):
@@ -6824,7 +6892,7 @@ class binance(Exchange, ImplicitAPI):
         defaultTo = 'spot' if (fromAccount == 'future') else 'future'
         toAccount = self.safe_string(params, 'toAccount', defaultTo)
         type = self.safe_string(params, 'type')
-        accountsByType = self.safe_value(self.options, 'accountsByType', {})
+        accountsByType = self.safe_dict(self.options, 'accountsByType', {})
         fromId = self.safe_string(accountsByType, fromAccount)
         toId = self.safe_string(accountsByType, toAccount)
         if type is None:
@@ -6862,7 +6930,7 @@ class binance(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        rows = self.safe_value(response, 'rows', [])
+        rows = self.safe_list(response, 'rows', [])
         return self.parse_transfers(rows, currency, since, limit)
 
     async def fetch_deposit_address(self, code: str, params={}):
@@ -6879,7 +6947,7 @@ class binance(Exchange, ImplicitAPI):
             'coin': currency['id'],
             # 'network': 'ETH',  # 'BSC', 'XMR', you can get network and isDefault in networkList in the response of sapiGetCapitalConfigDetail
         }
-        networks = self.safe_value(self.options, 'networks', {})
+        networks = self.safe_dict(self.options, 'networks', {})
         network = self.safe_string_upper(params, 'network')  # self line allows the user to specify either ERC20 or ETH
         network = self.safe_string(networks, network, network)  # handle ERC20>ETH alias
         if network is not None:
@@ -6905,7 +6973,7 @@ class binance(Exchange, ImplicitAPI):
         url = self.safe_string(response, 'url')
         impliedNetwork = None
         if url is not None:
-            reverseNetworks = self.safe_value(self.options, 'reverseNetworks', {})
+            reverseNetworks = self.safe_dict(self.options, 'reverseNetworks', {})
             parts = url.split('/')
             topLevel = self.safe_string(parts, 2)
             if (topLevel == 'blockchair.com') or (topLevel == 'viewblock.io'):
@@ -6918,7 +6986,7 @@ class binance(Exchange, ImplicitAPI):
                 'TRX': {'TRC20': 'TRX'},
             })
             if code in impliedNetworks:
-                conversion = self.safe_value(impliedNetworks, code, {})
+                conversion = self.safe_dict(impliedNetworks, code, {})
                 impliedNetwork = self.safe_string(conversion, impliedNetwork, impliedNetwork)
         tag = self.safe_string(response, 'tag', '')
         if len(tag) == 0:
@@ -6932,7 +7000,7 @@ class binance(Exchange, ImplicitAPI):
             'info': response,
         }
 
-    async def fetch_transaction_fees(self, codes=None, params={}):
+    async def fetch_transaction_fees(self, codes: List[str] = None, params={}):
         """
          * @deprecated
         please use fetchDepositWithdrawFees instead
@@ -7029,7 +7097,7 @@ class binance(Exchange, ImplicitAPI):
             entry = response[i]
             currencyId = self.safe_string(entry, 'coin')
             code = self.safe_currency_code(currencyId)
-            networkList = self.safe_value(entry, 'networkList', [])
+            networkList = self.safe_list(entry, 'networkList', [])
             withdrawFees[code] = {}
             for j in range(0, len(networkList)):
                 networkEntry = networkList[j]
@@ -7138,14 +7206,14 @@ class binance(Exchange, ImplicitAPI):
         #        ]
         #    }
         #
-        networkList = self.safe_value(fee, 'networkList', [])
+        networkList = self.safe_list(fee, 'networkList', [])
         result = self.deposit_withdraw_fee(fee)
         for j in range(0, len(networkList)):
             networkEntry = networkList[j]
             networkId = self.safe_string(networkEntry, 'network')
             networkCode = self.network_id_to_code(networkId)
             withdrawFee = self.safe_number(networkEntry, 'withdrawFee')
-            isDefault = self.safe_value(networkEntry, 'isDefault')
+            isDefault = self.safe_bool(networkEntry, 'isDefault')
             if isDefault is True:
                 result['withdraw'] = {
                     'fee': withdrawFee,
@@ -7188,7 +7256,7 @@ class binance(Exchange, ImplicitAPI):
         }
         if tag is not None:
             request['addressTag'] = tag
-        networks = self.safe_value(self.options, 'networks', {})
+        networks = self.safe_dict(self.options, 'networks', {})
         network = self.safe_string_upper(params, 'network')  # self line allows the user to specify either ERC20 or ETH
         network = self.safe_string(networks, network, network)  # handle ERC20>ETH alias
         if network is not None:
@@ -7274,7 +7342,7 @@ class binance(Exchange, ImplicitAPI):
         #
         data = response
         if isinstance(data, list):
-            data = self.safe_value(data, 0, {})
+            data = self.safe_dict(data, 0, {})
         return self.parse_trading_fee(data)
 
     async def fetch_trading_fees(self, params={}):
@@ -7648,8 +7716,8 @@ class binance(Exchange, ImplicitAPI):
         }
 
     def parse_account_positions(self, account):
-        positions = self.safe_value(account, 'positions')
-        assets = self.safe_value(account, 'assets', [])
+        positions = self.safe_list(account, 'positions')
+        assets = self.safe_list(account, 'assets', [])
         balances = {}
         for i in range(0, len(assets)):
             entry = assets[i]
@@ -7667,18 +7735,22 @@ class binance(Exchange, ImplicitAPI):
             marketId = self.safe_string(position, 'symbol')
             market = self.safe_market(marketId, None, None, 'contract')
             code = market['quote'] if market['linear'] else market['base']
-            # sometimes not all the codes are correctly returned...
-            if code in balances:
-                parsed = self.parse_account_position(self.extend(position, {
-                    'crossMargin': balances[code]['crossMargin'],
-                    'crossWalletBalance': balances[code]['crossWalletBalance'],
-                }), market)
-                result.append(parsed)
+            maintenanceMargin = self.safe_string(position, 'maintMargin')
+            # check for maintenance margin so empty positions are not returned
+            if (maintenanceMargin != '0') and (maintenanceMargin != '0.00000000'):
+                # sometimes not all the codes are correctly returned...
+                if code in balances:
+                    parsed = self.parse_account_position(self.extend(position, {
+                        'crossMargin': balances[code]['crossMargin'],
+                        'crossWalletBalance': balances[code]['crossWalletBalance'],
+                    }), market)
+                    result.append(parsed)
         return result
 
     def parse_account_position(self, position, market: Market = None):
         #
         # usdm
+        #
         #    {
         #       "symbol": "BTCBUSD",
         #       "initialMargin": "0",
@@ -7699,6 +7771,7 @@ class binance(Exchange, ImplicitAPI):
         #     }
         #
         # coinm
+        #
         #     {
         #       "symbol": "BTCUSD_210625",
         #       "initialMargin": "0.00024393",
@@ -7717,6 +7790,46 @@ class binance(Exchange, ImplicitAPI):
         #       "crossWalletBalance": "34",
         #     }
         #
+        # linear portfolio margin
+        #
+        #     {
+        #         "symbol": "CTSIUSDT",
+        #         "initialMargin": "0",
+        #         "maintMargin": "0",
+        #         "unrealizedProfit": "0.00000000",
+        #         "positionInitialMargin": "0",
+        #         "openOrderInitialMargin": "0",
+        #         "leverage": "20",
+        #         "entryPrice": "0.0",
+        #         "maxNotional": "25000",
+        #         "bidNotional": "0",
+        #         "askNotional": "0",
+        #         "positionSide": "SHORT",
+        #         "positionAmt": "0",
+        #         "updateTime": 0,
+        #         "notional": "0",
+        #         "breakEvenPrice": "0.0"
+        #     }
+        #
+        # inverse portoflio margin
+        #
+        #     {
+        #         "symbol": "TRXUSD_PERP",
+        #         "initialMargin": "0",
+        #         "maintMargin": "0",
+        #         "unrealizedProfit": "0.00000000",
+        #         "positionInitialMargin": "0",
+        #         "openOrderInitialMargin": "0",
+        #         "leverage": "20",
+        #         "entryPrice": "0.00000000",
+        #         "positionSide": "SHORT",
+        #         "positionAmt": "0",
+        #         "maxQty": "5000000",
+        #         "updateTime": 0,
+        #         "notionalValue": "0",
+        #         "breakEvenPrice": "0.00000000"
+        #     }
+        #
         marketId = self.safe_string(position, 'symbol')
         market = self.safe_market(marketId, market, None, 'contract')
         symbol = self.safe_string(market, 'symbol')
@@ -7745,8 +7858,8 @@ class binance(Exchange, ImplicitAPI):
             contractsString = Precise.string_div(entryNotional, contractSizeNew)
             contractsStringAbs = Precise.string_div(Precise.string_add(contractsString, '0.5'), '1', 0)
         contracts = self.parse_number(contractsStringAbs)
-        leverageBrackets = self.safe_value(self.options, 'leverageBrackets', {})
-        leverageBracket = self.safe_value(leverageBrackets, symbol, [])
+        leverageBrackets = self.safe_dict(self.options, 'leverageBrackets', {})
+        leverageBracket = self.safe_list(leverageBrackets, symbol, [])
         maintenanceMarginPercentageString = None
         for i in range(0, len(leverageBracket)):
             bracket = leverageBracket[i]
@@ -7759,7 +7872,7 @@ class binance(Exchange, ImplicitAPI):
         timestamp = self.safe_integer(position, 'updateTime')
         if timestamp == 0:
             timestamp = None
-        isolated = self.safe_value(position, 'isolated')
+        isolated = self.safe_bool(position, 'isolated')
         marginMode = None
         collateralString = None
         walletBalance = None
@@ -7901,11 +8014,45 @@ class binance(Exchange, ImplicitAPI):
         #       "isolatedWallet": "0.00268058"
         #     }
         #
+        # inverse portfolio margin
+        #
+        #     {
+        #         "symbol": "ETHUSD_PERP",
+        #         "positionAmt": "1",
+        #         "entryPrice": "2422.400000007",
+        #         "markPrice": "2424.51267823",
+        #         "unRealizedProfit": "0.0000036",
+        #         "liquidationPrice": "293.57678898",
+        #         "leverage": "100",
+        #         "positionSide": "LONG",
+        #         "updateTime": 1707371941861,
+        #         "maxQty": "15",
+        #         "notionalValue": "0.00412454",
+        #         "breakEvenPrice": "2423.368960034"
+        #     }
+        #
+        # linear portfolio margin
+        #
+        #     {
+        #         "symbol": "BTCUSDT",
+        #         "positionAmt": "0.01",
+        #         "entryPrice": "44525.0",
+        #         "markPrice": "45464.1735922",
+        #         "unRealizedProfit": "9.39173592",
+        #         "liquidationPrice": "38007.16308568",
+        #         "leverage": "100",
+        #         "positionSide": "LONG",
+        #         "updateTime": 1707371879042,
+        #         "maxNotionalValue": "500000.0",
+        #         "notional": "454.64173592",
+        #         "breakEvenPrice": "44542.81"
+        #     }
+        #
         marketId = self.safe_string(position, 'symbol')
         market = self.safe_market(marketId, market, None, 'contract')
         symbol = self.safe_string(market, 'symbol')
-        leverageBrackets = self.safe_value(self.options, 'leverageBrackets', {})
-        leverageBracket = self.safe_value(leverageBrackets, symbol, [])
+        leverageBrackets = self.safe_dict(self.options, 'leverageBrackets', {})
+        leverageBracket = self.safe_list(leverageBrackets, symbol, [])
         notionalString = self.safe_string_2(position, 'notional', 'notionalValue')
         notionalStringAbs = Precise.string_abs(notionalString)
         maintenanceMarginPercentageString = None
@@ -7938,7 +8085,7 @@ class binance(Exchange, ImplicitAPI):
         linear = ('notional' in position)
         if marginMode == 'cross':
             # calculate collateral
-            precision = self.safe_value(market, 'precision', {})
+            precision = self.safe_dict(market, 'precision', {})
             if linear:
                 # walletBalance = (liquidationPrice * (±1 + mmp) ± entryPrice) * contracts
                 onePlusMaintenanceMarginPercentageString = None
@@ -8032,11 +8179,19 @@ class binance(Exchange, ImplicitAPI):
             query = self.omit(params, 'type')
             subType = None
             subType, params = self.handle_sub_type_and_params('loadLeverageBrackets', None, params, 'linear')
+            isPortfolioMargin = None
+            isPortfolioMargin, params = self.handle_option_and_params_2(params, 'loadLeverageBrackets', 'papi', 'portfolioMargin', False)
             response = None
             if self.is_linear(type, subType):
-                response = await self.fapiPrivateGetLeverageBracket(query)
+                if isPortfolioMargin:
+                    response = await self.papiGetUmLeverageBracket(query)
+                else:
+                    response = await self.fapiPrivateGetLeverageBracket(query)
             elif self.is_inverse(type, subType):
-                response = await self.dapiPrivateV2GetLeverageBracket(query)
+                if isPortfolioMargin:
+                    response = await self.papiGetCmLeverageBracket(query)
+                else:
+                    response = await self.dapiPrivateV2GetLeverageBracket(query)
             else:
                 raise NotSupported(self.id + ' loadLeverageBrackets() supports linear and inverse contracts only')
             self.options['leverageBrackets'] = {}
@@ -8044,7 +8199,7 @@ class binance(Exchange, ImplicitAPI):
                 entry = response[i]
                 marketId = self.safe_string(entry, 'symbol')
                 symbol = self.safe_symbol(marketId, None, None, 'contract')
-                brackets = self.safe_value(entry, 'brackets', [])
+                brackets = self.safe_list(entry, 'brackets', [])
                 result = []
                 for j in range(0, len(brackets)):
                     bracket = brackets[j]
@@ -8059,8 +8214,11 @@ class binance(Exchange, ImplicitAPI):
         retrieve information on the maximum leverage, and maintenance margin for trades of varying trade sizes
         :see: https://binance-docs.github.io/apidocs/futures/en/#notional-and-leverage-brackets-user_data
         :see: https://binance-docs.github.io/apidocs/delivery/en/#notional-bracket-for-symbol-user_data
+        :see: https://binance-docs.github.io/apidocs/pm/en/#um-notional-and-leverage-brackets-user_data
+        :see: https://binance-docs.github.io/apidocs/pm/en/#cm-notional-and-leverage-brackets-user_data
         :param str[]|None symbols: list of unified market symbols
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.portfolioMargin]: set to True if you would like to fetch the leverage tiers for a portfolio margin account
         :returns dict: a dictionary of `leverage tiers structures <https://docs.ccxt.com/#/?id=leverage-tiers-structure>`, indexed by market symbols
         """
         await self.load_markets()
@@ -8068,11 +8226,19 @@ class binance(Exchange, ImplicitAPI):
         type, params = self.handle_market_type_and_params('fetchLeverageTiers', None, params)
         subType = None
         subType, params = self.handle_sub_type_and_params('fetchLeverageTiers', None, params, 'linear')
+        isPortfolioMargin = None
+        isPortfolioMargin, params = self.handle_option_and_params_2(params, 'fetchLeverageTiers', 'papi', 'portfolioMargin', False)
         response = None
         if self.is_linear(type, subType):
-            response = await self.fapiPrivateGetLeverageBracket(params)
+            if isPortfolioMargin:
+                response = await self.papiGetUmLeverageBracket(params)
+            else:
+                response = await self.fapiPrivateGetLeverageBracket(params)
         elif self.is_inverse(type, subType):
-            response = await self.dapiPrivateV2GetLeverageBracket(params)
+            if isPortfolioMargin:
+                response = await self.papiGetCmLeverageBracket(params)
+            else:
+                response = await self.dapiPrivateV2GetLeverageBracket(params)
         else:
             raise NotSupported(self.id + ' fetchLeverageTiers() supports linear and inverse contracts only')
         #
@@ -8139,7 +8305,7 @@ class binance(Exchange, ImplicitAPI):
         #
         marketId = self.safe_string(info, 'symbol')
         market = self.safe_market(marketId, market, None, 'contract')
-        brackets = self.safe_value(info, 'brackets', [])
+        brackets = self.safe_list(info, 'brackets', [])
         tiers = []
         for j in range(0, len(brackets)):
             bracket = brackets[j]
@@ -8334,8 +8500,11 @@ class binance(Exchange, ImplicitAPI):
         fetch account positions
         :see: https://binance-docs.github.io/apidocs/futures/en/#account-information-v2-user_data
         :see: https://binance-docs.github.io/apidocs/delivery/en/#account-information-user_data
+        :see: https://binance-docs.github.io/apidocs/pm/en/#get-um-account-detail-user_data
+        :see: https://binance-docs.github.io/apidocs/pm/en/#get-cm-account-detail-user_data
         :param str[]|None symbols: list of unified market symbols
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.portfolioMargin]: set to True if you would like to fetch positions in a portfolio margin account
         :returns dict: data on account positions
         """
         if symbols is not None:
@@ -8345,14 +8514,22 @@ class binance(Exchange, ImplicitAPI):
         await self.load_leverage_brackets(False, params)
         defaultType = self.safe_string(self.options, 'defaultType', 'future')
         type = self.safe_string(params, 'type', defaultType)
-        query = self.omit(params, 'type')
+        params = self.omit(params, 'type')
         subType = None
-        subType, query = self.handle_sub_type_and_params('fetchAccountPositions', None, params, 'linear')
+        subType, params = self.handle_sub_type_and_params('fetchAccountPositions', None, params, 'linear')
+        isPortfolioMargin = None
+        isPortfolioMargin, params = self.handle_option_and_params_2(params, 'fetchAccountPositions', 'papi', 'portfolioMargin', False)
         response = None
         if self.is_linear(type, subType):
-            response = await self.fapiPrivateV2GetAccount(query)
+            if isPortfolioMargin:
+                response = await self.papiGetUmAccount(params)
+            else:
+                response = await self.fapiPrivateV2GetAccount(params)
         elif self.is_inverse(type, subType):
-            response = await self.dapiPrivateGetAccount(query)
+            if isPortfolioMargin:
+                response = await self.papiGetCmAccount(params)
+            else:
+                response = await self.dapiPrivateGetAccount(params)
         else:
             raise NotSupported(self.id + ' fetchPositions() supports linear and inverse contracts only')
         result = self.parse_account_positions(response)
@@ -8365,8 +8542,11 @@ class binance(Exchange, ImplicitAPI):
         fetch positions risk
         :see: https://binance-docs.github.io/apidocs/futures/en/#position-information-v2-user_data
         :see: https://binance-docs.github.io/apidocs/delivery/en/#position-information-user_data
+        :see: https://binance-docs.github.io/apidocs/pm/en/#query-um-position-information-user_data
+        :see: https://binance-docs.github.io/apidocs/pm/en/#query-cm-position-information-user_data
         :param str[]|None symbols: list of unified market symbols
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.portfolioMargin]: set to True if you would like to fetch positions for a portfolio margin account
         :returns dict: data on the positions risk
         """
         if symbols is not None:
@@ -8380,68 +8560,117 @@ class binance(Exchange, ImplicitAPI):
         type = self.safe_string(params, 'type', defaultType)
         subType = None
         subType, params = self.handle_sub_type_and_params('fetchPositionsRisk', None, params, 'linear')
+        isPortfolioMargin = None
+        isPortfolioMargin, params = self.handle_option_and_params_2(params, 'fetchPositionsRisk', 'papi', 'portfolioMargin', False)
         params = self.omit(params, 'type')
         response = None
         if self.is_linear(type, subType):
-            response = await self.fapiPrivateV2GetPositionRisk(self.extend(request, params))
-            #  ### Response examples  ###
-            #
-            # For One-way position mode:
-            #     [
-            #         {
-            #             "entryPrice": "0.00000",
-            #             "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
-            #        }
-            #     ]
-            #
-            # For Hedge position mode:
-            #     [
-            #         {
-            #             "entryPrice": "6563.66500",
-            #             "marginType": "isolated",
-            #             "isAutoAddMargin": "false",
-            #             "isolatedMargin": "15517.54150468",
-            #             "leverage": "10",
-            #             "liquidationPrice": "5930.78",
-            #             "markPrice": "6679.50671178",
-            #             "maxNotionalValue": "20000000",
-            #             "positionAmt": "20.000",
-            #             "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
-            #         }
-            #     ]
+            if isPortfolioMargin:
+                response = await self.papiGetUmPositionRisk(self.extend(request, params))
+            else:
+                response = await self.fapiPrivateV2GetPositionRisk(self.extend(request, params))
         elif self.is_inverse(type, subType):
-            response = await self.dapiPrivateGetPositionRisk(self.extend(request, params))
+            if isPortfolioMargin:
+                response = await self.papiGetCmPositionRisk(self.extend(request, params))
+            else:
+                response = await self.dapiPrivateGetPositionRisk(self.extend(request, params))
         else:
             raise NotSupported(self.id + ' fetchPositionsRisk() supports linear and inverse contracts only')
+        #  ### Response examples  ###
+        #
+        # For One-way position mode:
+        #
+        #     [
+        #         {
+        #             "entryPrice": "0.00000",
+        #             "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
+        #        }
+        #     ]
+        #
+        # For Hedge position mode:
+        #
+        #     [
+        #         {
+        #             "entryPrice": "6563.66500",
+        #             "marginType": "isolated",
+        #             "isAutoAddMargin": "false",
+        #             "isolatedMargin": "15517.54150468",
+        #             "leverage": "10",
+        #             "liquidationPrice": "5930.78",
+        #             "markPrice": "6679.50671178",
+        #             "maxNotionalValue": "20000000",
+        #             "positionAmt": "20.000",
+        #             "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
+        #         }
+        #     ]
+        #
+        # inverse portfolio margin:
+        #
+        #     [
+        #         {
+        #             "symbol": "ETHUSD_PERP",
+        #             "positionAmt": "1",
+        #             "entryPrice": "2422.400000007",
+        #             "markPrice": "2424.51267823",
+        #             "unRealizedProfit": "0.0000036",
+        #             "liquidationPrice": "293.57678898",
+        #             "leverage": "100",
+        #             "positionSide": "LONG",
+        #             "updateTime": 1707371941861,
+        #             "maxQty": "15",
+        #             "notionalValue": "0.00412454",
+        #             "breakEvenPrice": "2423.368960034"
+        #         }
+        #     ]
+        #
+        # linear portfolio margin:
+        #
+        #     [
+        #         {
+        #             "symbol": "BTCUSDT",
+        #             "positionAmt": "0.01",
+        #             "entryPrice": "44525.0",
+        #             "markPrice": "45464.1735922",
+        #             "unRealizedProfit": "9.39173592",
+        #             "liquidationPrice": "38007.16308568",
+        #             "leverage": "100",
+        #             "positionSide": "LONG",
+        #             "updateTime": 1707371879042,
+        #             "maxNotionalValue": "500000.0",
+        #             "notional": "454.64173592",
+        #             "breakEvenPrice": "44542.81"
+        #         }
+        #     ]
+        #
         result = []
         for i in range(0, len(response)):
             parsed = self.parse_position_risk(response[i])
@@ -8454,10 +8683,14 @@ class binance(Exchange, ImplicitAPI):
         fetch the history of funding payments paid and received on self account
         :see: https://binance-docs.github.io/apidocs/futures/en/#get-income-history-user_data
         :see: https://binance-docs.github.io/apidocs/delivery/en/#get-income-history-user_data
+        :see: https://binance-docs.github.io/apidocs/pm/en/#get-um-income-history-user_data
+        :see: https://binance-docs.github.io/apidocs/pm/en/#get-cm-income-history-user_data
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch funding history for
         :param int [limit]: the maximum number of funding history structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.until]: timestamp in ms of the latest funding history entry
+        :param boolean [params.portfolioMargin]: set to True if you would like to fetch the funding history for a portfolio margin account
         :returns dict: a `funding history structure <https://docs.ccxt.com/#/?id=funding-history-structure>`
         """
         await self.load_markets()
@@ -8472,6 +8705,9 @@ class binance(Exchange, ImplicitAPI):
                 raise NotSupported(self.id + ' fetchFundingHistory() supports swap contracts only')
         subType = None
         subType, params = self.handle_sub_type_and_params('fetchFundingHistory', market, params, 'linear')
+        isPortfolioMargin = None
+        isPortfolioMargin, params = self.handle_option_and_params_2(params, 'fetchFundingHistory', 'papi', 'portfolioMargin', False)
+        request, params = self.handle_until_option('endTime', request, params)
         if since is not None:
             request['startTime'] = since
         if limit is not None:
@@ -8481,9 +8717,15 @@ class binance(Exchange, ImplicitAPI):
         params = self.omit(params, 'type')
         response = None
         if self.is_linear(type, subType):
-            response = await self.fapiPrivateGetIncome(self.extend(request, params))
+            if isPortfolioMargin:
+                response = await self.papiGetUmIncome(self.extend(request, params))
+            else:
+                response = await self.fapiPrivateGetIncome(self.extend(request, params))
         elif self.is_inverse(type, subType):
-            response = await self.dapiPrivateGetIncome(self.extend(request, params))
+            if isPortfolioMargin:
+                response = await self.papiGetCmIncome(self.extend(request, params))
+            else:
+                response = await self.dapiPrivateGetIncome(self.extend(request, params))
         else:
             raise NotSupported(self.id + ' fetchFundingHistory() supports linear and inverse contracts only')
         return self.parse_incomes(response, market, since, limit)
@@ -8493,9 +8735,12 @@ class binance(Exchange, ImplicitAPI):
         set the level of leverage for a market
         :see: https://binance-docs.github.io/apidocs/futures/en/#change-initial-leverage-trade
         :see: https://binance-docs.github.io/apidocs/delivery/en/#change-initial-leverage-trade
+        :see: https://binance-docs.github.io/apidocs/pm/en/#change-um-initial-leverage-trade
+        :see: https://binance-docs.github.io/apidocs/pm/en/#change-cm-initial-leverage-trade
         :param float leverage: the rate of leverage
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.portfolioMargin]: set to True if you would like to set the leverage for a trading pair in a portfolio margin account
         :returns dict: response from the exchange
         """
         if symbol is None:
@@ -8510,11 +8755,19 @@ class binance(Exchange, ImplicitAPI):
             'symbol': market['id'],
             'leverage': leverage,
         }
+        isPortfolioMargin = None
+        isPortfolioMargin, params = self.handle_option_and_params_2(params, 'setLeverage', 'papi', 'portfolioMargin', False)
         response = None
         if market['linear']:
-            response = await self.fapiPrivatePostLeverage(self.extend(request, params))
+            if isPortfolioMargin:
+                response = await self.papiPostUmLeverage(self.extend(request, params))
+            else:
+                response = await self.fapiPrivatePostLeverage(self.extend(request, params))
         elif market['inverse']:
-            response = await self.dapiPrivatePostLeverage(self.extend(request, params))
+            if isPortfolioMargin:
+                response = await self.papiPostCmLeverage(self.extend(request, params))
+            else:
+                response = await self.dapiPrivatePostLeverage(self.extend(request, params))
         else:
             raise NotSupported(self.id + ' setLeverage() supports linear and inverse contracts only')
         return response
@@ -8573,14 +8826,17 @@ class binance(Exchange, ImplicitAPI):
                 raise e
         return response
 
-    async def set_position_mode(self, hedged, symbol: Str = None, params={}):
+    async def set_position_mode(self, hedged: bool, symbol: Str = None, params={}):
         """
         set hedged to True or False for a market
         :see: https://binance-docs.github.io/apidocs/futures/en/#change-position-mode-trade
         :see: https://binance-docs.github.io/apidocs/delivery/en/#change-position-mode-trade
+        :see: https://binance-docs.github.io/apidocs/pm/en/#change-um-position-mode-trade
+        :see: https://binance-docs.github.io/apidocs/pm/en/#change-cm-position-mode-trade
         :param bool hedged: set to True to use dualSidePosition
         :param str symbol: not used by binance setPositionMode()
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.portfolioMargin]: set to True if you would like to set the position mode for a portfolio margin account
         :returns dict: response from the exchange
         """
         defaultType = self.safe_string(self.options, 'defaultType', 'future')
@@ -8588,6 +8844,8 @@ class binance(Exchange, ImplicitAPI):
         params = self.omit(params, ['type'])
         subType = None
         subType, params = self.handle_sub_type_and_params('setPositionMode', None, params)
+        isPortfolioMargin = None
+        isPortfolioMargin, params = self.handle_option_and_params_2(params, 'setPositionMode', 'papi', 'portfolioMargin', False)
         dualSidePosition = None
         if hedged:
             dualSidePosition = 'true'
@@ -8598,10 +8856,15 @@ class binance(Exchange, ImplicitAPI):
         }
         response = None
         if self.is_inverse(type, subType):
-            response = await self.dapiPrivatePostPositionSideDual(self.extend(request, params))
+            if isPortfolioMargin:
+                response = await self.papiPostCmPositionSideDual(self.extend(request, params))
+            else:
+                response = await self.dapiPrivatePostPositionSideDual(self.extend(request, params))
         else:
-            # default to future
-            response = await self.fapiPrivatePostPositionSideDual(self.extend(request, params))
+            if isPortfolioMargin:
+                response = await self.papiPostUmPositionSideDual(self.extend(request, params))
+            else:
+                response = await self.fapiPrivatePostPositionSideDual(self.extend(request, params))
         #
         #     {
         #       "code": 200,
@@ -8785,12 +9048,15 @@ class binance(Exchange, ImplicitAPI):
         :see: https://binance-docs.github.io/apidocs/voptions/en/#account-funding-flow-user_data
         :see: https://binance-docs.github.io/apidocs/futures/en/#get-income-history-user_data
         :see: https://binance-docs.github.io/apidocs/delivery/en/#get-income-history-user_data
+        :see: https://binance-docs.github.io/apidocs/pm/en/#get-um-income-history-user_data
+        :see: https://binance-docs.github.io/apidocs/pm/en/#get-cm-income-history-user_data
         :param str code: unified currency code
         :param int [since]: timestamp in ms of the earliest ledger entry
         :param int [limit]: max number of ledger entrys to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param int [params.until]: timestamp in ms of the latest ledger entry
-        :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
+        :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
+        :param boolean [params.portfolioMargin]: set to True if you would like to fetch the ledger for a portfolio margin account
         :returns dict: a `ledger structure <https://docs.ccxt.com/#/?id=ledger-structure>`
         """
         await self.load_markets()
@@ -8814,15 +9080,23 @@ class binance(Exchange, ImplicitAPI):
         if until is not None:
             params = self.omit(params, 'until')
             request['endTime'] = until
+        isPortfolioMargin = None
+        isPortfolioMargin, params = self.handle_option_and_params_2(params, 'fetchLedger', 'papi', 'portfolioMargin', False)
         response = None
         if type == 'option':
             self.check_required_argument('fetchLedger', code, 'code')
             request['currency'] = currency['id']
             response = await self.eapiPrivateGetBill(self.extend(request, params))
         elif self.is_linear(type, subType):
-            response = await self.fapiPrivateGetIncome(self.extend(request, params))
+            if isPortfolioMargin:
+                response = await self.papiGetUmIncome(self.extend(request, params))
+            else:
+                response = await self.fapiPrivateGetIncome(self.extend(request, params))
         elif self.is_inverse(type, subType):
-            response = await self.dapiPrivateGetIncome(self.extend(request, params))
+            if isPortfolioMargin:
+                response = await self.papiGetCmIncome(self.extend(request, params))
+            else:
+                response = await self.dapiPrivateGetIncome(self.extend(request, params))
         else:
             raise NotSupported(self.id + ' fetchLedger() supports contract wallets only')
         #
@@ -8838,7 +9112,7 @@ class binance(Exchange, ImplicitAPI):
         #         }
         #     ]
         #
-        # futures(fapi, dapi)
+        # futures(fapi, dapi, papi)
         #
         #     [
         #         {
@@ -8867,7 +9141,7 @@ class binance(Exchange, ImplicitAPI):
         #         "createDate": 1676621042489
         #     }
         #
-        # futures(fapi, dapi)
+        # futures(fapi, dapi, papi)
         #
         #     {
         #         "symbol": "",
@@ -8966,7 +9240,7 @@ class binance(Exchange, ImplicitAPI):
                     isSpotOrMargin = (api.find('sapi') > -1 or api == 'private')
                     marketType = 'spot' if isSpotOrMargin else 'future'
                     defaultId = 'x-xcKtGhcu' if (not isSpotOrMargin) else 'x-R4BD3S82'
-                    broker = self.safe_value(self.options, 'broker', {})
+                    broker = self.safe_dict(self.options, 'broker', {})
                     brokerId = self.safe_string(broker, marketType, defaultId)
                     params['newClientOrderId'] = brokerId + self.uuid22()
             query = None
@@ -8988,8 +9262,8 @@ class binance(Exchange, ImplicitAPI):
                 query = self.urlencode_with_array_repeat(extendedParams)
             elif (path == 'batchOrders') or (path.find('sub-account') >= 0) or (path == 'capital/withdraw/apply') or (path.find('staking') >= 0):
                 if (method == 'DELETE') and (path == 'batchOrders'):
-                    orderidlist = self.safe_value(extendedParams, 'orderidlist', [])
-                    origclientorderidlist = self.safe_value(extendedParams, 'origclientorderidlist', [])
+                    orderidlist = self.safe_list(extendedParams, 'orderidlist', [])
+                    origclientorderidlist = self.safe_list(extendedParams, 'origclientorderidlist', [])
                     extendedParams = self.omit(extendedParams, ['orderidlist', 'origclientorderidlist'])
                     query = self.rawencode(extendedParams)
                     orderidlistLength = len(orderidlist)
@@ -9038,8 +9312,8 @@ class binance(Exchange, ImplicitAPI):
         elif url.startswith('https://papi.' + hostname + '/'):
             marketType = 'portfoliomargin'
         if marketType is not None:
-            exceptionsForMarketType = self.safe_value(self.exceptions, marketType, {})
-            return self.safe_value(exceptionsForMarketType, exactOrBroad, {})
+            exceptionsForMarketType = self.safe_dict(self.exceptions, marketType, {})
+            return self.safe_dict(exceptionsForMarketType, exactOrBroad, {})
         return {}
 
     def handle_errors(self, code, reason, url, method, headers, body, response, requestHeaders, requestBody):
@@ -9235,7 +9509,7 @@ class binance(Exchange, ImplicitAPI):
         #         },
         #     ]
         #
-        rate = self.safe_value(response, 0)
+        rate = self.safe_dict(response, 0)
         return self.parse_borrow_rate(rate)
 
     async def fetch_borrow_rate_history(self, code: str, since: Int = None, limit: Int = None, params={}):
@@ -9331,7 +9605,7 @@ class binance(Exchange, ImplicitAPI):
         #         "success": True
         #     }
         #
-        data = self.safe_value(response, 'data')
+        data = self.safe_dict(response, 'data')
         giftcardCode = self.safe_string(data, 'code')
         id = self.safe_string(data, 'referenceNo')
         return {
@@ -9430,7 +9704,7 @@ class binance(Exchange, ImplicitAPI):
         #         "total": 1
         #     }
         #
-        rows = self.safe_value(response, 'rows')
+        rows = self.safe_list(response, 'rows')
         interest = self.parse_borrow_interests(rows, market)
         return self.filter_by_currency_since_limit(interest, code, since, limit)
 
@@ -9455,9 +9729,11 @@ class binance(Exchange, ImplicitAPI):
         """
         repay borrowed margin and interest
         :see: https://binance-docs.github.io/apidocs/spot/en/#margin-account-borrow-repay-margin
+        :see: https://binance-docs.github.io/apidocs/pm/en/#margin-account-repay-margin
         :param str code: unified currency code of the currency to repay
         :param float amount: the amount to repay
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.portfolioMargin]: set to True if you would like to repay margin in a portfolio margin account
         :returns dict: a `margin loan structure <https://docs.ccxt.com/#/?id=margin-loan-structure>`
         """
         await self.load_markets()
@@ -9465,10 +9741,16 @@ class binance(Exchange, ImplicitAPI):
         request = {
             'asset': currency['id'],
             'amount': self.currency_to_precision(code, amount),
-            'isIsolated': 'FALSE',
-            'type': 'REPAY',
         }
-        response = await self.sapiPostMarginBorrowRepay(self.extend(request, params))
+        response = None
+        isPortfolioMargin = None
+        isPortfolioMargin, params = self.handle_option_and_params_2(params, 'repayCrossMargin', 'papi', 'portfolioMargin', False)
+        if isPortfolioMargin:
+            response = await self.papiPostRepayLoan(self.extend(request, params))
+        else:
+            request['isIsolated'] = 'FALSE'
+            request['type'] = 'REPAY'
+            response = await self.sapiPostMarginBorrowRepay(self.extend(request, params))
         #
         #     {
         #         "tranId": 108988250265,
@@ -9510,9 +9792,11 @@ class binance(Exchange, ImplicitAPI):
         """
         create a loan to borrow margin
         :see: https://binance-docs.github.io/apidocs/spot/en/#margin-account-borrow-repay-margin
+        :see: https://binance-docs.github.io/apidocs/pm/en/#margin-account-borrow-margin
         :param str code: unified currency code of the currency to borrow
         :param float amount: the amount to borrow
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.portfolioMargin]: set to True if you would like to borrow margin in a portfolio margin account
         :returns dict: a `margin loan structure <https://docs.ccxt.com/#/?id=margin-loan-structure>`
         """
         await self.load_markets()
@@ -9520,10 +9804,16 @@ class binance(Exchange, ImplicitAPI):
         request = {
             'asset': currency['id'],
             'amount': self.currency_to_precision(code, amount),
-            'isIsolated': 'FALSE',
-            'type': 'BORROW',
         }
-        response = await self.sapiPostMarginBorrowRepay(self.extend(request, params))
+        response = None
+        isPortfolioMargin = None
+        isPortfolioMargin, params = self.handle_option_and_params_2(params, 'borrowCrossMargin', 'papi', 'portfolioMargin', False)
+        if isPortfolioMargin:
+            response = await self.papiPostMarginLoan(self.extend(request, params))
+        else:
+            request['isIsolated'] = 'FALSE'
+            request['type'] = 'BORROW'
+            response = await self.sapiPostMarginBorrowRepay(self.extend(request, params))
         #
         #     {
         #         "tranId": 108988250265,