ccxt 4.2.58__py2.py3-none-any.whl → 4.2.60__py2.py3-none-any.whl

ccxt/async_support/woo.py

@@ -93,10 +93,10 @@ class woo(Exchange, ImplicitAPI):
                 'fetchPositionMode': False,
                 'fetchPositions': True,
                 'fetchPremiumIndexOHLCV': False,
-                'fetchStatus': False,
+                'fetchStatus': True,
                 'fetchTicker': False,
                 'fetchTickers': False,
-                'fetchTime': False,
+                'fetchTime': True,
                 'fetchTrades': True,
                 'fetchTradingFee': False,
                 'fetchTradingFees': True,
@@ -333,6 +333,60 @@ class woo(Exchange, ImplicitAPI):
             'precisionMode': TICK_SIZE,
         })
 
+    async def fetch_status(self, params={}):
+        """
+        the latest known information on the availability of the exchange API
+        :see: https://docs.woo.org/#get-system-maintenance-status-public
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `status structure <https://docs.ccxt.com/#/?id=exchange-status-structure>`
+        """
+        response = await self.v1PublicGetSystemInfo(params)
+        #
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "status": "0",
+        #             "msg": "System is functioning properly."
+        #         },
+        #         "timestamp": "1709274106602"
+        #     }
+        #
+        data = self.safe_dict(response, 'data', {})
+        status = self.safe_string(data, 'status')
+        if status is None:
+            status = 'error'
+        elif status == '0':
+            status = 'ok'
+        else:
+            status = 'maintenance'
+        return {
+            'status': status,
+            'updated': None,
+            'eta': None,
+            'url': None,
+            'info': response,
+        }
+
+    async def fetch_time(self, params={}):
+        """
+        fetches the current integer timestamp in milliseconds from the exchange server
+        :see: https://docs.woo.org/#get-system-maintenance-status-public
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns int: the current integer timestamp in milliseconds from the exchange server
+        """
+        response = await self.v1PublicGetSystemInfo(params)
+        #
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "status": "0",
+        #             "msg": "System is functioning properly."
+        #         },
+        #         "timestamp": "1709274106602"
+        #     }
+        #
+        return self.safe_integer(response, 'timestamp')
+
     async def fetch_markets(self, params={}):
         """
         retrieves data on all markets for woo
@@ -361,7 +415,7 @@ class woo(Exchange, ImplicitAPI):
         #     "success": True
         # }
         #
-        data = self.safe_value(response, 'rows', [])
+        data = self.safe_list(response, 'rows', [])
         return self.parse_markets(data)
 
     def parse_market(self, market) -> Market:
@@ -491,7 +545,7 @@ class woo(Exchange, ImplicitAPI):
         #      ]
         # }
         #
-        resultResponse = self.safe_value(response, 'rows', {})
+        resultResponse = self.safe_list(response, 'rows', [])
         return self.parse_trades(resultResponse, market, since, limit)
 
     def parse_trade(self, trade, market: Market = None) -> Trade:
@@ -603,7 +657,7 @@ class woo(Exchange, ImplicitAPI):
         #         "timestamp": 1673323685109
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         maker = self.safe_string(data, 'makerFeeRate')
         taker = self.safe_string(data, 'takerFeeRate')
         result = {}
@@ -687,7 +741,7 @@ class woo(Exchange, ImplicitAPI):
         #     "success": True
         # }
         #
-        tokenRows = self.safe_value(tokenResponse, 'rows', [])
+        tokenRows = self.safe_list(tokenResponse, 'rows', [])
         networksByCurrencyId = self.group_by(tokenRows, 'balance_token')
         currencyIds = list(networksByCurrencyId.keys())
         for i in range(0, len(currencyIds)):
@@ -831,7 +885,7 @@ class woo(Exchange, ImplicitAPI):
         :param str [params.trailingTriggerPrice]: the price to trigger a trailing order, default uses the price argument
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        reduceOnly = self.safe_value_2(params, 'reduceOnly', 'reduce_only')
+        reduceOnly = self.safe_bool_2(params, 'reduceOnly', 'reduce_only')
         params = self.omit(params, ['reduceOnly', 'reduce_only'])
         orderType = type.upper()
         await self.load_markets()
@@ -975,9 +1029,9 @@ class woo(Exchange, ImplicitAPI):
         #     },
         #     "timestamp": "1686149372216"
         # }
-        data = self.safe_value(response, 'data')
+        data = self.safe_dict(response, 'data')
         if data is not None:
-            rows = self.safe_value(data, 'rows', [])
+            rows = self.safe_list(data, 'rows', [])
             return self.parse_order(rows[0], market)
         order = self.parse_order(response, market)
         order['type'] = type
@@ -1062,7 +1116,7 @@ class woo(Exchange, ImplicitAPI):
         #         "timestamp": 0
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_order(data, market)
 
     async def cancel_order(self, id: str, symbol: Str = None, params={}):
@@ -1124,8 +1178,8 @@ class woo(Exchange, ImplicitAPI):
         :returns dict: an list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        stop = self.safe_value(params, 'stop')
-        params = self.omit(params, 'stop')
+        stop = self.safe_bool_2(params, 'stop', 'trigger')
+        params = self.omit(params, ['stop', 'trigger'])
         if stop:
             return await self.v3PrivateDeleteAlgoOrdersPending(params)
         if symbol is None:
@@ -1155,8 +1209,8 @@ class woo(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol) if (symbol is not None) else None
-        stop = self.safe_value(params, 'stop')
-        params = self.omit(params, 'stop')
+        stop = self.safe_bool_2(params, 'stop', 'trigger')
+        params = self.omit(params, ['stop', 'trigger'])
         request = {}
         clientOrderId = self.safe_string_2(params, 'clOrdID', 'clientOrderId')
         response = None
@@ -1225,9 +1279,9 @@ class woo(Exchange, ImplicitAPI):
         await self.load_markets()
         request = {}
         market: Market = None
-        stop = self.safe_value(params, 'stop')
+        stop = self.safe_bool_2(params, 'stop', 'trigger')
         trailing = self.safe_bool(params, 'trailing', False)
-        params = self.omit(params, ['stop', 'trailing'])
+        params = self.omit(params, ['stop', 'trailing', 'trigger'])
         if symbol is not None:
             market = self.market(symbol)
             request['symbol'] = market['id']
@@ -1277,7 +1331,7 @@ class woo(Exchange, ImplicitAPI):
         #     }
         #
         data = self.safe_value(response, 'data', response)
-        orders = self.safe_value(data, 'rows')
+        orders = self.safe_list(data, 'rows')
         return self.parse_orders(orders, market, since, limit, params)
 
     def parse_time_in_force(self, timeInForce):
@@ -1377,7 +1431,7 @@ class woo(Exchange, ImplicitAPI):
             'type': orderType,
             'timeInForce': self.parse_time_in_force(orderType),
             'postOnly': None,  # TO_DO
-            'reduceOnly': self.safe_value(order, 'reduce_only'),
+            'reduceOnly': self.safe_bool(order, 'reduce_only'),
             'side': side,
             'price': price,
             'stopPrice': stopPrice,
@@ -1524,7 +1578,7 @@ class woo(Exchange, ImplicitAPI):
             #        }
             #    }
             #
-        rows = self.safe_value(response, 'rows', [])
+        rows = self.safe_list(response, 'rows', [])
         return self.parse_ohlcvs(rows, market, timeframe, since, limit)
 
     def parse_ohlcv(self, ohlcv, market: Market = None) -> list:
@@ -1574,7 +1628,7 @@ class woo(Exchange, ImplicitAPI):
         #       }
         #     ]
         # }
-        trades = self.safe_value(response, 'rows', [])
+        trades = self.safe_list(response, 'rows', [])
         return self.parse_trades(trades, market, since, limit, params)
 
     async def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
@@ -1618,7 +1672,7 @@ class woo(Exchange, ImplicitAPI):
         #         ...
         #     ]
         # }
-        trades = self.safe_value(response, 'rows', [])
+        trades = self.safe_list(response, 'rows', [])
         return self.parse_trades(trades, market, since, limit, params)
 
     async def fetch_accounts(self, params={}):
@@ -1644,7 +1698,7 @@ class woo(Exchange, ImplicitAPI):
         #         "success": True
         #     }
         #
-        rows = self.safe_value(response, 'rows', [])
+        rows = self.safe_list(response, 'rows', [])
         return self.parse_accounts(rows, params)
 
     def parse_account(self, account):
@@ -1696,14 +1750,14 @@ class woo(Exchange, ImplicitAPI):
         #         "timestamp": 1673323746259
         #     }
         #
-        data = self.safe_value(response, 'data')
+        data = self.safe_dict(response, 'data')
         return self.parse_balance(data)
 
     def parse_balance(self, response) -> Balances:
         result = {
             'info': response,
         }
-        balances = self.safe_value(response, 'holding', [])
+        balances = self.safe_list(response, 'holding', [])
         for i in range(0, len(balances)):
             balance = balances[i]
             code = self.safe_currency_code(self.safe_string(balance, 'token'))
@@ -1959,6 +2013,7 @@ class woo(Exchange, ImplicitAPI):
 
     async def transfer(self, code: str, amount: float, fromAccount: str, toAccount: str, params={}) -> TransferEntry:
         """
+        :see: https://docs.woo.org/#get-transfer-history
         transfer currency internally between wallets on the same account
         :param str code: unified currency code
         :param float amount: amount to transfer
@@ -1971,7 +2026,7 @@ class woo(Exchange, ImplicitAPI):
         currency = self.currency(code)
         request = {
             'token': currency['id'],
-            'amount': self.parse_number(amount),
+            'amount': self.parse_to_numeric(amount),
             'from_application_id': fromAccount,
             'to_application_id': toAccount,
         }
@@ -1983,7 +2038,7 @@ class woo(Exchange, ImplicitAPI):
         #     }
         #
         transfer = self.parse_transfer(response, currency)
-        transferOptions = self.safe_value(self.options, 'transfer', {})
+        transferOptions = self.safe_dict(self.options, 'transfer', {})
         fillResponseFromRequest = self.safe_bool(transferOptions, 'fillResponseFromRequest', True)
         if fillResponseFromRequest:
             transfer['amount'] = amount
@@ -1994,41 +2049,68 @@ class woo(Exchange, ImplicitAPI):
     async def fetch_transfers(self, code: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetch a history of internal transfers made on an account
+        :see: https://docs.woo.org/#get-transfer-history
         :param str code: unified currency code of the currency transferred
         :param int [since]: the earliest time in ms to fetch transfers for
         :param int [limit]: the maximum number of  transfers structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.until]: the latest time in ms to fetch entries for
         :returns dict[]: a list of `transfer structures <https://docs.ccxt.com/#/?id=transfer-structure>`
         """
-        request = {
-            'type': 'COLLATERAL',
-        }
-        currency, rows = await self.get_asset_history_rows(code, since, limit, self.extend(request, params))
-        return self.parse_transfers(rows, currency, since, limit, params)
+        request = {}
+        if limit is not None:
+            request['size'] = limit
+        if since is not None:
+            request['start_t'] = since
+        until = self.safe_integer_2(params, 'until', 'till')  # unified in milliseconds
+        params = self.omit(params, ['until', 'till'])
+        if until is not None:
+            request['end_t'] = until
+        response = await self.v1PrivateGetAssetMainSubTransferHistory(self.extend(request, params))
+        #
+        #     {
+        #         "rows": [
+        #             {
+        #                 "id": 46704,
+        #                 "token": "USDT",
+        #                 "amount": 30000.00000000,
+        #                 "status": "COMPLETED",
+        #                 "from_application_id": "0f1bd3cd-dba2-4563-b8bb-0adb1bfb83a3",
+        #                 "to_application_id": "c01e6940-a735-4022-9b6c-9d3971cdfdfa",
+        #                 "from_user": "LeverageLow",
+        #                 "to_user": "dev",
+        #                 "created_time": "1709022325.427",
+        #                 "updated_time": "1709022325.542"
+        #             }
+        #         ],
+        #         "meta": {
+        #             "total": 50,
+        #             "records_per_page": 25,
+        #             "current_page": 1
+        #         },
+        #         "success": True
+        #     }
+        #
+        data = self.safe_list(response, 'rows', [])
+        return self.parse_transfers(data, None, since, limit, params)
 
     def parse_transfer(self, transfer, currency: Currency = None):
         #
-        #    getAssetHistoryRows
-        #        {
-        #            "created_time": "1579399877.041",  # Unix epoch time in seconds
-        #            "updated_time": "1579399877.041",  # Unix epoch time in seconds
-        #            "id": "202029292829292",
-        #            "external_id": "202029292829292",
-        #            "application_id": null,
-        #            "token": "ETH",
-        #            "target_address": "0x31d64B3230f8baDD91dE1710A65DF536aF8f7cDa",
-        #            "source_address": "0x70fd25717f769c7f9a46b319f0f9103c0d887af0",
-        #            "extra": "",
-        #            "type": "BALANCE",
-        #            "token_side": "DEPOSIT",
-        #            "amount": 1000,
-        #            "tx_id": "0x8a74c517bc104c8ebad0c3c3f64b1f302ed5f8bca598ae4459c63419038106b6",
-        #            "fee_token": null,
-        #            "fee_amount": null,
-        #            "status": "CONFIRMING"
-        #        }
+        #    fetchTransfers
+        #     {
+        #         "id": 46704,
+        #         "token": "USDT",
+        #         "amount": 30000.00000000,
+        #         "status": "COMPLETED",
+        #         "from_application_id": "0f1bd3cd-dba2-4563-b8bb-0adb1bfb83a3",
+        #         "to_application_id": "c01e6940-a735-4022-9b6c-9d3971cdfdfa",
+        #         "from_user": "LeverageLow",
+        #         "to_user": "dev",
+        #         "created_time": "1709022325.427",
+        #         "updated_time": "1709022325.542"
+        #     }
         #
-        #    v1PrivatePostAssetMainSubTransfer
+        #    transfer
         #        {
         #            "success": True,
         #            "id": 200
@@ -2037,19 +2119,8 @@ class woo(Exchange, ImplicitAPI):
         networkizedCode = self.safe_string(transfer, 'token')
         currencyDefined = self.get_currency_from_chaincode(networkizedCode, currency)
         code = currencyDefined['code']
-        movementDirection = self.safe_string_lower(transfer, 'token_side')
-        if movementDirection == 'withdraw':
-            movementDirection = 'withdrawal'
-        fromAccount: Str = None
-        toAccount: Str = None
-        if movementDirection == 'withdraw':
-            fromAccount = None
-            toAccount = 'spot'
-        elif movementDirection == 'deposit':
-            fromAccount = 'spot'
-            toAccount = None
         timestamp = self.safe_timestamp(transfer, 'created_time')
-        success = self.safe_value(transfer, 'success')
+        success = self.safe_bool(transfer, 'success')
         status: Str = None
         if success is not None:
             status = 'ok' if success else 'failed'
@@ -2059,8 +2130,8 @@ class woo(Exchange, ImplicitAPI):
             'datetime': self.iso8601(timestamp),
             'currency': code,
             'amount': self.safe_number(transfer, 'amount'),
-            'fromAccount': fromAccount,
-            'toAccount': toAccount,
+            'fromAccount': self.safe_string(transfer, 'from_application_id'),
+            'toAccount': self.safe_string(transfer, 'to_application_id'),
             'status': self.parse_transfer_status(self.safe_string(transfer, 'status', status)),
             'info': transfer,
         }
@@ -2095,11 +2166,11 @@ class woo(Exchange, ImplicitAPI):
         }
         if tag is not None:
             request['extra'] = tag
-        networks = self.safe_value(self.options, 'networks', {})
-        currencyNetworks = self.safe_value(currency, 'networks', {})
+        networks = self.safe_dict(self.options, 'networks', {})
+        currencyNetworks = self.safe_dict(currency, 'networks', {})
         network = self.safe_string_upper(params, 'network')
         networkId = self.safe_string(networks, network, network)
-        coinNetwork = self.safe_value(currencyNetworks, networkId, {})
+        coinNetwork = self.safe_dict(currencyNetworks, networkId, {})
         coinNetworkId = self.safe_string(coinNetwork, 'id')
         if coinNetworkId is None:
             raise BadRequest(self.id + ' withdraw() require network parameter')
@@ -2179,7 +2250,7 @@ class woo(Exchange, ImplicitAPI):
         else:
             self.check_required_credentials()
             if method == 'POST' and (path == 'algo/order' or path == 'order'):
-                isSandboxMode = self.safe_value(self.options, 'sandboxMode', False)
+                isSandboxMode = self.safe_bool(self.options, 'sandboxMode', False)
                 if not isSandboxMode:
                     applicationId = 'bc830de7-50f3-460b-9ee0-f430f83f9dad'
                     brokerId = self.safe_string(self.options, 'brokerId', applicationId)
@@ -2212,7 +2283,8 @@ class woo(Exchange, ImplicitAPI):
                 if method == 'POST' or method == 'PUT' or method == 'DELETE':
                     body = auth
                 else:
-                    url += '?' + auth
+                    if params:
+                        url += '?' + auth
                 auth += '|' + ts
                 headers['content-type'] = 'application/x-www-form-urlencoded'
             headers['x-api-signature'] = self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256)
@@ -2225,7 +2297,7 @@ class woo(Exchange, ImplicitAPI):
         #     400 Bad Request {"success":false,"code":-1012,"message":"Amount is required for buy market orders when margin disabled."}
         #                     {"code":"-1011","message":"The system is under maintenance.","success":false}
         #
-        success = self.safe_value(response, 'success')
+        success = self.safe_bool(response, 'success')
         errorCode = self.safe_string(response, 'code')
         if not success:
             feedback = self.id + ' ' + self.json(response)
@@ -2298,7 +2370,7 @@ class woo(Exchange, ImplicitAPI):
         #         "success":true
         #     }
         #
-        result = self.safe_value(response, 'rows', [])
+        result = self.safe_list(response, 'rows', [])
         return self.parse_incomes(result, market, since, limit)
 
     def parse_funding_rate(self, fundingRate, market: Market = None):
@@ -2379,7 +2451,7 @@ class woo(Exchange, ImplicitAPI):
         #         "timestamp":1653633985646
         #     }
         #
-        rows = self.safe_value(response, 'rows', {})
+        rows = self.safe_list(response, 'rows', [])
         result = self.parse_funding_rates(rows)
         return self.filter_by_array(result, 'symbol', symbols)
 
@@ -2428,7 +2500,7 @@ class woo(Exchange, ImplicitAPI):
         #         "timestamp":1653640814885
         #     }
         #
-        result = self.safe_value(response, 'rows')
+        result = self.safe_list(response, 'rows')
         rates = []
         for i in range(0, len(result)):
             entry = result[i]
@@ -2582,8 +2654,8 @@ class woo(Exchange, ImplicitAPI):
         #         "timestamp": 1673323880342
         #     }
         #
-        result = self.safe_value(response, 'data', {})
-        positions = self.safe_value(result, 'positions', [])
+        result = self.safe_dict(response, 'data', {})
+        positions = self.safe_list(result, 'positions', [])
         return self.parse_positions(positions, symbols)
 
     def parse_position(self, position, market: Market = None):

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.2.58'
+__version__ = '4.2.60'
 
 # -----------------------------------------------------------------------------
 
@@ -3825,6 +3825,8 @@ class Exchange(object):
         if value is not None:
             params = self.omit(params, [optionName, defaultOptionName])
         else:
+            # handle routed methods like "watchTrades > watchTradesForSymbols"(or "watchTicker > watchTickers")
+            methodName, params = self.handleParamString(params, 'callerMethodName', methodName)
             # check if exchange has properties for self method
             exchangeWideMethodOptions = self.safe_value(self.options, methodName)
             if exchangeWideMethodOptions is not None:

ccxt/binance.py

@@ -4626,7 +4626,7 @@ class binance(Exchange, ImplicitAPI):
         stopPriceIsRequired = False
         quantityIsRequired = False
         if uppercaseType == 'MARKET':
-            quoteOrderQty = self.safe_value(self.options, 'quoteOrderQty', True)
+            quoteOrderQty = self.safe_bool(self.options, 'quoteOrderQty', True)
             if quoteOrderQty:
                 quoteOrderQtyNew = self.safe_value_2(params, 'quoteOrderQty', 'cost')
                 precision = market['precision']['price']
@@ -9546,7 +9546,7 @@ class binance(Exchange, ImplicitAPI):
             # POST https://fapi.binance.com/fapi/v1/marginType 400 Bad Request
             # binanceusdm
             if isinstance(e, MarginModeAlreadySet):
-                throwMarginModeAlreadySet = self.safe_value(self.options, 'throwMarginModeAlreadySet', False)
+                throwMarginModeAlreadySet = self.safe_bool(self.options, 'throwMarginModeAlreadySet', False)
                 if throwMarginModeAlreadySet:
                     raise e
                 else:

ccxt/bingx.py

@@ -7,7 +7,7 @@ from ccxt.base.exchange import Exchange
 from ccxt.abstract.bingx import ImplicitAPI
 import hashlib
 import numbers
-from ccxt.base.types import Balances, Currency, Int, Leverage, Market, Order, TransferEntry, OrderBook, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, Leverage, MarginMode, Market, Order, TransferEntry, OrderBook, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -72,6 +72,7 @@ class bingx(Exchange, ImplicitAPI):
                 'fetchFundingRates': True,
                 'fetchLeverage': True,
                 'fetchLiquidations': False,
+                'fetchMarginMode': True,
                 'fetchMarkets': True,
                 'fetchMarkOHLCV': True,
                 'fetchMyLiquidations': True,
@@ -457,7 +458,7 @@ class bingx(Exchange, ImplicitAPI):
         """
         if not self.check_required_credentials(False):
             return None
-        isSandbox = self.safe_value(self.options, 'sandboxMode', False)
+        isSandbox = self.safe_bool(self.options, 'sandboxMode', False)
         if isSandbox:
             return None
         response = self.walletsV1PrivateGetCapitalConfigGetall(params)
@@ -692,7 +693,7 @@ class bingx(Exchange, ImplicitAPI):
         :returns dict[]: an array of objects representing market data
         """
         requests = [self.fetch_swap_markets(params)]
-        isSandbox = self.safe_value(self.options, 'sandboxMode', False)
+        isSandbox = self.safe_bool(self.options, 'sandboxMode', False)
         if not isSandbox:
             requests.append(self.fetch_spot_markets(params))  # sandbox is swap only
         promises = requests
@@ -3898,11 +3899,46 @@ class bingx(Exchange, ImplicitAPI):
         data = self.safe_dict(response, 'data')
         return self.parse_order(data, market)
 
+    def fetch_margin_mode(self, symbol: str, params={}) -> MarginMode:
+        """
+        fetches the margin mode of the trading pair
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Margin%20Mode
+        :param str symbol: unified symbol of the market to fetch the margin mode for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: Struct of MarginMode
+        """
+        self.load_markets()
+        market = self.market(symbol)
+        request: dict = {
+            'symbol': market['id'],
+        }
+        response = self.swapV2PrivateGetTradeMarginType(self.extend(request, params))
+        #
+        #     {
+        #         "code": 0,
+        #         "msg": "",
+        #         "data": {
+        #             "marginType": "CROSSED"
+        #         }
+        #     }
+        #
+        data = self.safe_dict(response, 'data', {})
+        return self.parse_margin_mode(data, market)
+
+    def parse_margin_mode(self, marginMode, market=None) -> MarginMode:
+        marginType = self.safe_string_lower(marginMode, 'marginType')
+        marginType = 'cross' if (marginType == 'crossed') else marginType
+        return {
+            'info': marginMode,
+            'symbol': market['symbol'],
+            'marginMode': marginType,
+        }
+
     def sign(self, path, section='public', method='GET', params={}, headers=None, body=None):
         type = section[0]
         version = section[1]
         access = section[2]
-        isSandbox = self.safe_value(self.options, 'sandboxMode', False)
+        isSandbox = self.safe_bool(self.options, 'sandboxMode', False)
         if isSandbox and (type != 'swap'):
             raise NotSupported(self.id + ' does not have a testnet/sandbox URL for ' + type + ' endpoints')
         url = self.implode_hostname(self.urls['api'][type])

ccxt/bitfinex2.py

@@ -46,8 +46,8 @@ class bitfinex2(Exchange, ImplicitAPI):
                 'spot': True,
                 'margin': True,
                 'swap': True,
-                'future': None,
-                'option': None,
+                'future': False,
+                'option': False,
                 'addMargin': False,
                 'borrowCrossMargin': False,
                 'borrowIsolatedMargin': False,
@@ -58,6 +58,7 @@ class bitfinex2(Exchange, ImplicitAPI):
                 'createLimitOrder': True,
                 'createMarketOrder': True,
                 'createOrder': True,
+                'createPostOnlyOrder': True,
                 'createReduceOnlyOrder': True,
                 'createStopLimitOrder': True,
                 'createStopMarketOrder': True,
@@ -68,8 +69,11 @@ class bitfinex2(Exchange, ImplicitAPI):
                 'editOrder': True,
                 'fetchBalance': True,
                 'fetchBorrowInterest': False,
+                'fetchBorrowRate': False,
                 'fetchBorrowRateHistories': False,
                 'fetchBorrowRateHistory': False,
+                'fetchBorrowRates': False,
+                'fetchBorrowRatesPerSymbol': False,
                 'fetchClosedOrder': True,
                 'fetchClosedOrders': True,
                 'fetchCrossBorrowRate': False,
@@ -98,6 +102,8 @@ class bitfinex2(Exchange, ImplicitAPI):
                 'fetchOpenOrder': True,
                 'fetchOpenOrders': True,
                 'fetchOrder': True,
+                'fetchOrderBook': True,
+                'fetchOrderBooks': False,
                 'fetchOrderTrades': True,
                 'fetchPosition': False,
                 'fetchPositionMode': False,
@@ -117,6 +123,8 @@ class bitfinex2(Exchange, ImplicitAPI):
                 'setMargin': True,
                 'setMarginMode': False,
                 'setPositionMode': False,
+                'signIn': False,
+                'transfer': True,
                 'withdraw': True,
             },
             'timeframes': {
@@ -1484,7 +1492,16 @@ class bitfinex2(Exchange, ImplicitAPI):
         :param float amount: how much you want to trade in units of the base currency
         :param float [price]: the price of the order, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict: request to be sent to the exchange
+        :param float [params.stopPrice]: The price at which a trigger order is triggered at
+        :param str [params.timeInForce]: "GTC", "IOC", "FOK", or "PO"
+        :param bool [params.postOnly]:
+        :param bool [params.reduceOnly]: Ensures that the executed order does not flip the opened position.
+        :param int [params.flags]: additional order parameters: 4096(Post Only), 1024(Reduce Only), 16384(OCO), 64(Hidden), 512(Close), 524288(No Var Rates)
+        :param int [params.lev]: leverage for a derivative order, supported by derivative symbol orders only. The value should be between 1 and 100 inclusive.
+        :param str [params.price_traling]: The trailing price for a trailing stop order
+        :param str [params.price_aux_limit]: Order price for stop limit orders
+        :param str [params.price_oco_stop]: OCO stop price
+        :returns dict: an `order structure <https://github.com/ccxt/ccxt/wiki/Manual#order-structure>`
         """
         market = self.market(symbol)
         amountString = self.amount_to_precision(symbol, amount)