ccxt 4.4.63__py2.py3-none-any.whl → 4.4.68__py2.py3-none-any.whl

ccxt/async_support/tradeogre.py

@@ -5,7 +5,7 @@
 
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.tradeogre import ImplicitAPI
-from ccxt.base.types import Any, IndexType, Int, Market, Num, Order, OrderSide, OrderType, Str, Ticker
+from ccxt.base.types import Any, IndexType, Int, Market, Num, Order, OrderSide, OrderType, Str, Strings, Ticker, Tickers
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -74,7 +74,7 @@ class tradeogre(Exchange, ImplicitAPI):
                 'fetchMarkets': True,
                 'fetchMarkOHLCV': False,
                 'fetchMyTrades': False,
-                'fetchOHLCV': False,
+                'fetchOHLCV': True,
                 'fetchOpenInterest': False,
                 'fetchOpenInterestHistory': False,
                 'fetchOpenOrders': True,
@@ -92,7 +92,7 @@ class tradeogre(Exchange, ImplicitAPI):
                 'fetchPositionsRisk': False,
                 'fetchPremiumIndexOHLCV': False,
                 'fetchTicker': True,
-                'fetchTickers': False,
+                'fetchTickers': True,
                 'fetchTrades': True,
                 'fetchTradingLimits': False,
                 'fetchTransactionFee': False,
@@ -134,6 +134,7 @@ class tradeogre(Exchange, ImplicitAPI):
                         'orders/{market}': 1,
                         'ticker/{market}': 1,
                         'history/{market}': 1,
+                        'chart/{interval}/{market}': 1,
                     },
                 },
                 'private': {
@@ -162,6 +163,14 @@ class tradeogre(Exchange, ImplicitAPI):
                     'Order not found': BadRequest,
                 },
             },
+            'timeframes': {
+                '1m': '1m',
+                '15m': '15m',
+                '1h': '1h',
+                '4h': '4h',
+                '1d': '1d',
+                '1w': '1w',
+            },
             'options': {
             },
             'features': {
@@ -335,18 +344,72 @@ class tradeogre(Exchange, ImplicitAPI):
         #
         return self.parse_ticker(response, market)
 
+    async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        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>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols)
+        request: dict = {}
+        response = await self.publicGetMarkets(self.extend(request, params))
+        #
+        #     [
+        #         {
+        #             "AAVE-USDT": {
+        #                 "initialprice": "177.20325711",
+        #                 "price": "177.20325711",
+        #                 "high": "177.20325711",
+        #                 "low": "177.20325711",
+        #                 "volume": "0.00000000",
+        #                 "bid": "160.72768581",
+        #                 "ask": "348.99999999",
+        #                 "basename": "Aave"
+        #             }
+        #         },
+        #         ...
+        #     ]
+        #
+        result: dict = {}
+        for i in range(0, len(response)):
+            entry = response[i]
+            marketIdArray = list(entry.keys())
+            marketId = self.safe_string(marketIdArray, 0)
+            market = self.safe_market(marketId)
+            data = entry[marketId]
+            ticker = self.parse_ticker(data, market)
+            symbol = ticker['symbol']
+            result[symbol] = ticker
+        return self.filter_by_array_tickers(result, 'symbol', symbols)
+
     def parse_ticker(self, ticker, market: Market = None):
         #
-        #  {
-        #       "success":true,
-        #       "initialprice":"0.02502002",
-        #       "price":"0.02500000",
-        #       "high":"0.03102001",
-        #       "low":"0.02500000",
-        #       "volume":"0.15549958",
-        #       "bid":"0.02420000",
-        #       "ask":"0.02625000"
-        #   }
+        #  fetchTicker:
+        #     {
+        #         "success":true,
+        #         "initialprice":"0.02502002",
+        #         "price":"0.02500000",
+        #         "high":"0.03102001",
+        #         "low":"0.02500000",
+        #         "volume":"0.15549958",
+        #         "bid":"0.02420000",
+        #         "ask":"0.02625000"
+        #     }
+        #
+        #  fetchTickers:
+        #     {
+        #         "initialprice": "177.20325711",
+        #         "price": "177.20325711",
+        #         "high": "177.20325711",
+        #         "low": "177.20325711",
+        #         "volume": "0.00000000",
+        #         "bid": "160.72768581",
+        #         "ask": "348.99999999",
+        #         "basename": "Aave"
+        #     },
+        #     ...
         #
         return self.safe_ticker({
             'symbol': self.safe_string(market, 'symbol'),
@@ -371,6 +434,62 @@ class tradeogre(Exchange, ImplicitAPI):
             'info': ticker,
         }, market)
 
+    async def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
+        """
+        fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :param str symbol: unified symbol of the market to fetch OHLCV data for
+        :param str timeframe: the length of time each candle represents
+        :param int [since]: timestamp in ms of the earliest candle to fetch
+        :param int [limit]: the maximum amount of candles to fetch
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.until]: timestamp of the latest candle in ms
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        request: dict = {
+            'market': market['id'],
+            'interval': self.safe_string(self.timeframes, timeframe, timeframe),
+        }
+        until = self.safe_integer(params, 'until')
+        if until is not None:
+            params = self.omit(params, 'until')
+            request['timestamp'] = until
+        response = await self.publicGetChartIntervalMarket(self.extend(request, params))
+        #
+        #     [
+        #         [
+        #             1729130040,
+        #             67581.47235999,
+        #             67581.47235999,
+        #             67338.01,
+        #             67338.01,
+        #             6.72168016
+        #         ],
+        #     ]
+        #
+        return self.parse_ohlcvs(response, market, timeframe, since, limit)
+
+    def parse_ohlcv(self, ohlcv, market: Market = None) -> list:
+        #
+        #     [
+        #         1729130040,
+        #         67581.47235999,
+        #         67581.47235999,
+        #         67338.01,
+        #         67338.01,
+        #         6.72168016
+        #     ]
+        #
+        return [
+            self.safe_timestamp(ohlcv, 0),
+            self.safe_number(ohlcv, 1),
+            self.safe_number(ohlcv, 3),
+            self.safe_number(ohlcv, 4),
+            self.safe_number(ohlcv, 2),
+            self.safe_number(ohlcv, 5),
+        ]
+
     async def fetch_order_book(self, symbol: str, limit: Int = None, params={}):
         """
         fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data

ccxt/async_support/whitebit.py

@@ -6,7 +6,7 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.whitebit import ImplicitAPI
 import hashlib
-from ccxt.base.types import Any, Balances, BorrowInterest, Bool, Currencies, Currency, DepositAddress, Int, Market, MarketType, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFees, Transaction, TransferEntry
+from ccxt.base.types import Any, Balances, BorrowInterest, Bool, Conversion, Currencies, Currency, DepositAddress, FundingHistory, Int, Market, MarketType, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFees, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -45,6 +45,7 @@ class whitebit(Exchange, ImplicitAPI):
                 'cancelAllOrdersAfter': True,
                 'cancelOrder': True,
                 'cancelOrders': False,
+                'createConvertTrade': True,
                 'createMarketBuyOrderWithCost': True,
                 'createMarketOrderWithCost': False,
                 'createMarketSellOrderWithCost': False,
@@ -57,6 +58,9 @@ class whitebit(Exchange, ImplicitAPI):
                 'fetchBorrowRateHistories': False,
                 'fetchBorrowRateHistory': False,
                 'fetchClosedOrders': True,
+                'fetchConvertQuote': True,
+                'fetchConvertTrade': False,
+                'fetchConvertTradeHistory': True,
                 'fetchCrossBorrowRate': False,
                 'fetchCrossBorrowRates': False,
                 'fetchCurrencies': True,
@@ -68,7 +72,7 @@ class whitebit(Exchange, ImplicitAPI):
                 'fetchDepositsWithdrawals': True,
                 'fetchDepositWithdrawFee': 'emulated',
                 'fetchDepositWithdrawFees': True,
-                'fetchFundingHistory': False,
+                'fetchFundingHistory': True,
                 'fetchFundingRate': True,
                 'fetchFundingRateHistory': False,
                 'fetchFundingRates': True,
@@ -186,6 +190,7 @@ class whitebit(Exchange, ImplicitAPI):
                             'assets',
                             'collateral/markets',
                             'fee',
+                            'orderbook/depth/{market}',
                             'orderbook/{market}',
                             'ticker',
                             'trades/{market}',
@@ -194,6 +199,7 @@ class whitebit(Exchange, ImplicitAPI):
                             'markets',
                             'futures',
                             'platform/status',
+                            'mining-pool',
                         ],
                     },
                     'private': {
@@ -204,6 +210,7 @@ class whitebit(Exchange, ImplicitAPI):
                             'collateral-account/leverage',
                             'collateral-account/positions/open',
                             'collateral-account/summary',
+                            'collateral-account/funding-history',
                             'main-account/address',
                             'main-account/balance',
                             'main-account/create-new-address',
@@ -230,6 +237,7 @@ class whitebit(Exchange, ImplicitAPI):
                             'order/collateral/market',
                             'order/collateral/stop-limit',
                             'order/collateral/trigger-market',
+                            'order/collateral/bulk',
                             'order/new',
                             'order/market',
                             'order/stock_market',
@@ -241,6 +249,7 @@ class whitebit(Exchange, ImplicitAPI):
                             'order/kill-switch/status',
                             'order/bulk',
                             'order/modify',
+                            'order/conditional-cancel',
                             'orders',
                             'oco-orders',
                             'order/collateral/oco',
@@ -259,6 +268,17 @@ class whitebit(Exchange, ImplicitAPI):
                             'sub-account/unblock',
                             'sub-account/balances',
                             'sub-account/transfer/history',
+                            'sub-account/api-key/create',
+                            'sub-account/api-key/edit',
+                            'sub-account/api-key/delete',
+                            'sub-account/api-key/list',
+                            'sub-account/api-key/reset',
+                            'sub-account/api-key/ip-address/list',
+                            'sub-account/api-key/ip-address/create',
+                            'sub-account/api-key/ip-address/delete',
+                            'mining/rewards',
+                            'market/fee',
+                            'conditional-orders',
                         ],
                     },
                 },
@@ -2515,6 +2535,84 @@ class whitebit(Exchange, ImplicitAPI):
             'interval': None,
         }
 
+    async def fetch_funding_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[FundingHistory]:
+        """
+        fetch the history of funding payments paid and received on self account
+
+        https://docs.whitebit.com/private/http-trade-v4/#funding-history
+
+        :param str [symbol]: unified market symbol
+        :param int [since]: the starting timestamp in milliseconds
+        :param int [limit]: the number of entries to return
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.until]: the latest time in ms to fetch funding history for
+        :returns dict[]: a list of `funding history structures <https://docs.ccxt.com/#/?id=funding-history-structure>`
+        """
+        await self.load_markets()
+        if symbol is None:
+            raise ArgumentsRequired(self.id + ' fetchFundingHistory() requires a symbol argument')
+        market = self.market(symbol)
+        request: dict = {
+            'market': market['id'],
+        }
+        if since is not None:
+            request['startDate'] = since
+        if limit is not None:
+            request['limit'] = since
+        request, params = self.handle_until_option('endDate', request, params)
+        response = await self.v4PrivatePostCollateralAccountFundingHistory(request)
+        #
+        #     {
+        #         "records": [
+        #             {
+        #                 "market": "BTC_PERP",
+        #                 "fundingTime": "1708704000000",
+        #                 "fundingRate": "0.00017674",
+        #                 "fundingAmount": "-0.171053531892",
+        #                 "positionAmount": "0.019",
+        #                 "settlementPrice": "50938.2",
+        #                 "rateCalculatedTime": "1708675200000"
+        #             },
+        #         ],
+        #         "limit": 100,
+        #         "offset": 0
+        #     }
+        #
+        data = self.safe_list(response, 'records', [])
+        return self.parse_funding_histories(data, market, since, limit)
+
+    def parse_funding_history(self, contract, market: Market = None):
+        #
+        #     {
+        #         "market": "BTC_PERP",
+        #         "fundingTime": "1708704000000",
+        #         "fundingRate": "0.00017674",
+        #         "fundingAmount": "-0.171053531892",
+        #         "positionAmount": "0.019",
+        #         "settlementPrice": "50938.2",
+        #         "rateCalculatedTime": "1708675200000"
+        #     }
+        #
+        marketId = self.safe_string(contract, 'market')
+        timestamp = self.safe_integer(contract, 'fundingTime')
+        return {
+            'info': contract,
+            'symbol': self.safe_symbol(marketId, market, None, 'swap'),
+            'code': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'id': None,
+            'amount': self.safe_number(contract, 'fundingAmount'),
+        }
+
+    def parse_funding_histories(self, contracts, market=None, since: Int = None, limit: Int = None) -> List[FundingHistory]:
+        result = []
+        for i in range(0, len(contracts)):
+            contract = contracts[i]
+            result.append(self.parse_funding_history(contract, market))
+        sorted = self.sort_by(result, 'timestamp')
+        return self.filter_by_since_limit(sorted, since, limit)
+
     async def fetch_deposits_withdrawals(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
         """
         fetch history of deposits and withdrawals
@@ -2585,6 +2683,182 @@ class whitebit(Exchange, ImplicitAPI):
         records = self.safe_list(response, 'records')
         return self.parse_transactions(records, currency, since, limit)
 
+    async def fetch_convert_quote(self, fromCode: str, toCode: str, amount: Num = None, params={}) -> Conversion:
+        """
+        fetch a quote for converting from one currency to another
+
+        https://docs.whitebit.com/private/http-trade-v4/#convert-estimate
+
+        :param str fromCode: the currency that you want to sell and convert from
+        :param str toCode: the currency that you want to buy and convert into
+        :param float amount: how much you want to trade in units of the from currency
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `conversion structure <https://docs.ccxt.com/#/?id=conversion-structure>`
+        """
+        await self.load_markets()
+        fromCurrency = self.currency(fromCode)
+        toCurrency = self.currency(toCode)
+        request: dict = {
+            'from': fromCode,
+            'to': toCode,
+            'amount': self.number_to_string(amount),
+            'direction': 'from',
+        }
+        response = await self.v4PrivatePostConvertEstimate(self.extend(request, params))
+        #
+        #     {
+        #         "give": "4",
+        #         "receive": "0.00004762",
+        #         "rate": "0.0000119",
+        #         "id": "1740889",
+        #         "expireAt": 1741090147,
+        #         "from": "USDT",
+        #         "to": "BTC"
+        #     }
+        #
+        return self.parse_conversion(response, fromCurrency, toCurrency)
+
+    async def create_convert_trade(self, id: str, fromCode: str, toCode: str, amount: Num = None, params={}) -> Conversion:
+        """
+        convert from one currency to another
+
+        https://docs.whitebit.com/private/http-trade-v4/#convert-confirm
+
+        :param str id: the id of the trade that you want to make
+        :param str fromCode: the currency that you want to sell and convert from
+        :param str toCode: the currency that you want to buy and convert into
+        :param float [amount]: how much you want to trade in units of the from currency
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `conversion structure <https://docs.ccxt.com/#/?id=conversion-structure>`
+        """
+        await self.load_markets()
+        fromCurrency = self.currency(fromCode)
+        toCurrency = self.currency(toCode)
+        request: dict = {
+            'quoteId': id,
+        }
+        response = await self.v4PrivatePostConvertConfirm(self.extend(request, params))
+        #
+        #     {
+        #         "finalGive": "4",
+        #         "finalReceive": "0.00004772"
+        #     }
+        #
+        return self.parse_conversion(response, fromCurrency, toCurrency)
+
+    async def fetch_convert_trade_history(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Conversion]:
+        """
+        fetch the users history of conversion trades
+
+        https://docs.whitebit.com/private/http-trade-v4/#convert-history
+
+        :param str [code]: the unified currency code
+        :param int [since]: the earliest time in ms to fetch conversions for
+        :param int [limit]: the maximum number of conversion structures to retrieve, default 20, max 200
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.until]: the end time in ms
+        :param str [params.fromTicker]: the currency that you sold and converted from
+        :param str [params.toTicker]: the currency that you bought and converted into
+        :param str [params.quoteId]: the quote id of the conversion
+        :returns dict[]: a list of `conversion structures <https://docs.ccxt.com/#/?id=conversion-structure>`
+        """
+        await self.load_markets()
+        request: dict = {}
+        if code is not None:
+            request['fromTicker'] = code
+        if since is not None:
+            start = self.parse_to_int(since / 1000)
+            request['from'] = self.number_to_string(start)
+        if limit is not None:
+            request['limit'] = limit
+        request, params = self.handle_until_option('to', request, params, 0.001)
+        response = await self.v4PrivatePostConvertHistory(self.extend(request, params))
+        #
+        #     {
+        #         "records": [
+        #             {
+        #                 "id": "1741105",
+        #                 "path": [
+        #                     {
+        #                         "from": "USDT",
+        #                         "to": "BTC",
+        #                         "rate": "0.00001193"
+        #                     }
+        #                 ],
+        #                 "date": 1741090757,
+        #                 "give": "4",
+        #                 "receive": "0.00004772",
+        #                 "rate": "0.00001193"
+        #             }
+        #         ],
+        #         "total": 1,
+        #         "limit": 100,
+        #         "offset": 0
+        #     }
+        #
+        rows = self.safe_list(response, 'records', [])
+        return self.parse_conversions(rows, code, 'fromCurrency', 'toCurrency', since, limit)
+
+    def parse_conversion(self, conversion: dict, fromCurrency: Currency = None, toCurrency: Currency = None) -> Conversion:
+        #
+        # fetchConvertQuote
+        #
+        #     {
+        #         "give": "4",
+        #         "receive": "0.00004762",
+        #         "rate": "0.0000119",
+        #         "id": "1740889",
+        #         "expireAt": 1741090147,
+        #         "from": "USDT",
+        #         "to": "BTC"
+        #     }
+        #
+        # createConvertTrade
+        #
+        #     {
+        #         "finalGive": "4",
+        #         "finalReceive": "0.00004772"
+        #     }
+        #
+        # fetchConvertTradeHistory
+        #
+        #     {
+        #         "id": "1741105",
+        #         "path": [
+        #             {
+        #                 "from": "USDT",
+        #                 "to": "BTC",
+        #                 "rate": "0.00001193"
+        #             }
+        #         ],
+        #         "date": 1741090757,
+        #         "give": "4",
+        #         "receive": "0.00004772",
+        #         "rate": "0.00001193"
+        #     }
+        #
+        path = self.safe_list(conversion, 'path', [])
+        first = self.safe_dict(path, 0, {})
+        fromPath = self.safe_string(first, 'from')
+        toPath = self.safe_string(first, 'to')
+        timestamp = self.safe_timestamp_2(conversion, 'date', 'expireAt')
+        fromCoin = self.safe_string(conversion, 'from', fromPath)
+        fromCode = self.safe_currency_code(fromCoin, fromCurrency)
+        toCoin = self.safe_string(conversion, 'to', toPath)
+        toCode = self.safe_currency_code(toCoin, toCurrency)
+        return {
+            'info': conversion,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'id': self.safe_string(conversion, 'id'),
+            'fromCurrency': fromCode,
+            'fromAmount': self.safe_number_2(conversion, 'give', 'finalGive'),
+            'toCurrency': toCode,
+            'toAmount': self.safe_number_2(conversion, 'receive', 'finalReceive'),
+            'price': self.safe_number(conversion, 'rate'),
+            'fee': None,
+        }
+
     def is_fiat(self, currency: str) -> bool:
         fiatCurrencies = self.safe_value(self.options, 'fiatCurrencies', [])
         return self.in_array(currency, fiatCurrencies)

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.63'
+__version__ = '4.4.68'
 
 # -----------------------------------------------------------------------------
 
@@ -21,6 +21,7 @@ from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadSymbol
 from ccxt.base.errors import NullResponse
 from ccxt.base.errors import RateLimitExceeded
+from ccxt.base.errors import OperationFailed
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import BadResponse
 from ccxt.base.errors import InvalidProxySettings
@@ -1742,9 +1743,15 @@ class Exchange(object):
     def create_safe_dictionary(self):
         return {}
 
+    def convert_to_safe_dictionary(self, dictionary):
+        return dictionary
+
     def rand_number(self, size):
         return int(''.join([str(random.randint(0, 9)) for _ in range(size)]))
 
+    def binary_length(self, binary):
+        return len(binary)
+
     # ########################################################################
     # ########################################################################
     # ########################################################################
@@ -2001,6 +2008,7 @@ class Exchange(object):
                 'watchOHLCV': None,
                 'watchOHLCVForSymbols': None,
                 'watchOrderBook': None,
+                'watchBidsAsks': None,
                 'watchOrderBookForSymbols': None,
                 'watchOrders': None,
                 'watchOrdersForSymbols': None,
@@ -4344,14 +4352,15 @@ class Exchange(object):
             try:
                 return self.fetch(request['url'], request['method'], request['headers'], request['body'])
             except Exception as e:
-                if isinstance(e, NetworkError):
+                if isinstance(e, OperationFailed):
                     if i < retries:
                         if self.verbose:
                             self.log('Request failed with the error: ' + str(e) + ', retrying ' + (i + str(1)) + ' of ' + str(retries) + '...')
                         if (retryDelay is not None) and (retryDelay != 0):
                             self.sleep(retryDelay)
-                        # continue  #check self
-                if i >= retries:
+                    else:
+                        raise e
+                else:
                     raise e
         return None  # self line is never reached, but exists for c# value return requirement
 

ccxt/binance.py

@@ -503,6 +503,7 @@ class binance(Exchange, ImplicitAPI):
                         'portfolio/margin-asset-leverage': 5,  # Weight(IP): 50 => cost = 0.1 * 50 = 5
                         'portfolio/balance': 2,
                         'portfolio/negative-balance-exchange-record': 2,
+                        'portfolio/pmloan-history': 5,
                         # staking
                         'staking/productList': 0.1,
                         'staking/position': 0.1,
@@ -6163,11 +6164,11 @@ class binance(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
+        # don't handle/omit params here, omitting happens inside createOrderRequest
         marketType = self.safe_string(params, 'type', market['type'])
-        marginMode = None
-        marginMode, params = self.handle_margin_mode_and_params('createOrder', params)
-        isPortfolioMargin = None
-        isPortfolioMargin, params = self.handle_option_and_params_2(params, 'createOrder', 'papi', 'portfolioMargin', False)
+        marginMode = self.safe_string(params, 'marginMode')
+        porfolioOptionsValue = self.safe_bool_2(self.options, 'papi', 'portfolioMargin', False)
+        isPortfolioMargin = self.safe_bool_2(params, 'papi', 'portfolioMargin', porfolioOptionsValue)
         triggerPrice = self.safe_string_2(params, 'triggerPrice', 'stopPrice')
         stopLossPrice = self.safe_string(params, 'stopLossPrice')
         takeProfitPrice = self.safe_string(params, 'takeProfitPrice')
@@ -6179,8 +6180,9 @@ class binance(Exchange, ImplicitAPI):
         sor = self.safe_bool_2(params, 'sor', 'SOR', False)
         test = self.safe_bool(params, 'test', False)
         params = self.omit(params, ['sor', 'SOR', 'test'])
-        if isPortfolioMargin:
-            params['portfolioMargin'] = isPortfolioMargin
+        # if isPortfolioMargin:
+        #     params['portfolioMargin'] = isPortfolioMargin
+        # }
         request = self.create_order_request(symbol, type, side, amount, price, params)
         response = None
         if market['option']: