ccxt 4.2.29__py2.py3-none-any.whl → 4.2.31__py2.py3-none-any.whl

ccxt/bitfinex2.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.bitfinex2 import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, Currency, Int, Market, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, Market, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -45,32 +45,42 @@ class bitfinex2(Exchange, ImplicitAPI):
                 'CORS': None,
                 'spot': True,
                 'margin': None,  # has but unimplemented
-                'swap': None,  # has but unimplemented
+                'swap': True,
                 'future': None,
                 'option': None,
+                'addMargin': False,
                 'cancelAllOrders': True,
                 'cancelOrder': True,
+                'cancelOrders': True,
                 'createDepositAddress': True,
                 'createLimitOrder': True,
                 'createMarketOrder': True,
                 'createOrder': True,
+                'createReduceOnlyOrder': True,
                 'createStopLimitOrder': True,
                 'createStopMarketOrder': True,
                 'createStopOrder': True,
-                'editOrder': False,
+                'createTrailingAmountOrder': True,
+                'createTrailingPercentOrder': False,
+                'createTriggerOrder': True,
+                'editOrder': True,
                 'fetchBalance': True,
                 'fetchClosedOrder': True,
                 'fetchClosedOrders': True,
                 'fetchCurrencies': True,
                 'fetchDepositAddress': True,
                 'fetchDepositsWithdrawals': True,
+                'fetchFundingHistory': False,
                 'fetchFundingRate': True,
                 'fetchFundingRateHistory': True,
                 'fetchFundingRates': True,
                 'fetchIndexOHLCV': False,
                 'fetchLedger': True,
+                'fetchLeverage': False,
+                'fetchLeverageTiers': False,
                 'fetchLiquidations': True,
                 'fetchMarginMode': False,
+                'fetchMarketLeverageTiers': False,
                 'fetchMarkOHLCV': False,
                 'fetchMyTrades': True,
                 'fetchOHLCV': True,
@@ -80,7 +90,10 @@ class bitfinex2(Exchange, ImplicitAPI):
                 'fetchOpenOrders': True,
                 'fetchOrder': True,
                 'fetchOrderTrades': True,
+                'fetchPosition': False,
                 'fetchPositionMode': False,
+                'fetchPositions': True,
+                'fetchPremiumIndexOHLCV': False,
                 'fetchStatus': True,
                 'fetchTickers': True,
                 'fetchTime': False,
@@ -88,7 +101,11 @@ class bitfinex2(Exchange, ImplicitAPI):
                 'fetchTradingFees': True,
                 'fetchTransactionFees': None,
                 'fetchTransactions': 'emulated',
+                'reduceMargin': False,
+                'setLeverage': False,
                 'setMargin': True,
+                'setMarginMode': False,
+                'setPositionMode': False,
                 'withdraw': True,
             },
             'timeframes': {
@@ -356,6 +373,7 @@ class bitfinex2(Exchange, ImplicitAPI):
                     'margin': 'margin',
                     'derivatives': 'margin',
                     'future': 'margin',
+                    'swap': 'margin',
                 },
                 'withdraw': {
                     'includeFee': False,
@@ -977,7 +995,7 @@ class bitfinex2(Exchange, ImplicitAPI):
         fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
         :see: https://docs.bitfinex.com/reference/rest-public-book
         :param str symbol: unified symbol of the market to fetch the order book for
-        :param int [limit]: the maximum amount of order book entries to return
+        :param int [limit]: the maximum amount of order book entries to return, bitfinex only allows 1, 25, or 100
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
         """
@@ -989,7 +1007,7 @@ class bitfinex2(Exchange, ImplicitAPI):
             'precision': precision,
         }
         if limit is not None:
-            request['len'] = limit  # 25 or 100
+            request['len'] = limit
         fullRequest = self.extend(request, params)
         orderbook = self.publicGetBookSymbolPrecision(fullRequest)
         timestamp = self.milliseconds()
@@ -1247,9 +1265,9 @@ class bitfinex2(Exchange, ImplicitAPI):
         :see: https://docs.bitfinex.com/reference/rest-public-trades
         :param str symbol: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
-        :param int [limit]: the maximum amount of trades to fetch
+        :param int [limit]: the maximum amount of trades to fetch, default 120, max 10000
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :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 int [params.until]: the latest time in ms to fetch entries for
         :returns Trade[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
         """
@@ -1291,11 +1309,11 @@ class bitfinex2(Exchange, ImplicitAPI):
         :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 int [limit]: the maximum amount of candles to fetch, default 100 max 10000
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns int[][]: A list of candles ordered, open, high, low, close, volume
         :param int [params.until]: timestamp in ms of the latest candle to fetch
-        :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)
         """
         self.load_markets()
         paginate = False
@@ -1304,7 +1322,7 @@ class bitfinex2(Exchange, ImplicitAPI):
             return self.fetch_paginated_call_deterministic('fetchOHLCV', symbol, since, limit, timeframe, params, 10000)
         market = self.market(symbol)
         if limit is None:
-            limit = 10000  # default 100, max 5000
+            limit = 10000
         request = {
             'symbol': market['id'],
             'timeframe': self.safe_string(self.timeframes, timeframe, timeframe),
@@ -1444,87 +1462,62 @@ class bitfinex2(Exchange, ImplicitAPI):
             'trades': None,
         }, market)
 
-    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+    def create_order_request(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
         """
-        Create an order on the exchange
-        :see: https://docs.bitfinex.com/reference/rest-auth-submit-order
-        :param str symbol: Unified CCXT market symbol
-        :param str type: 'limit' or 'market'
+         * @ignore
+        helper function to build an order request
+        :param str symbol: unified symbol of the market to create an order in
+        :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
-        :param float amount: the amount of currency to trade
-        :param float [price]: price of order
-        :param dict [params]:  extra parameters specific to the exchange API endpoint
-        :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://docs.ccxt.com/#/?id=order-structure>`
+        :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
         """
-        self.load_markets()
         market = self.market(symbol)
-        # order types "limit" and "market" immediatley parsed "EXCHANGE LIMIT" and "EXCHANGE MARKET"
-        # note: same order types exist for margin orders without the EXCHANGE prefix
-        orderTypes = self.safe_value(self.options, 'orderTypes', {})
-        orderType = type.upper()
-        if market['spot']:
-            # although they claim that type needs to be 'exchange limit' or 'exchange market'
-            # in fact that's not the case for swap markets
-            orderType = self.safe_string_upper(orderTypes, type, type)
-        stopPrice = self.safe_string_2(params, 'stopPrice', 'triggerPrice')
-        timeInForce = self.safe_string(params, 'timeInForce')
-        postOnlyParam = self.safe_value(params, 'postOnly', False)
-        reduceOnly = self.safe_value(params, 'reduceOnly', False)
-        clientOrderId = self.safe_value_2(params, 'cid', 'clientOrderId')
-        params = self.omit(params, ['triggerPrice', 'stopPrice', 'timeInForce', 'postOnly', 'reduceOnly', 'price_aux_limit'])
         amountString = self.amount_to_precision(symbol, amount)
         amountString = amountString if (side == 'buy') else Precise.string_neg(amountString)
         request = {
-            # 'gid': 0123456789,  # int32,  optional group id for the order
-            # 'cid': 0123456789,  # int32 client order id
-            'type': orderType,
             'symbol': market['id'],
-            # 'price': self.number_to_string(price),
             'amount': amountString,
-            # 'flags': 0,  # int32, https://docs.bitfinex.com/v2/docs/flag-values
-            # 'lev': 10,  # leverage for a derivative orders, the value should be between 1 and 100 inclusive, optional, 10 by default
-            # 'price_trailing': self.number_to_string(priceTrailing),
-            # 'price_aux_limit': self.number_to_string(stopPrice),
-            # 'price_oco_stop': self.number_to_string(ocoStopPrice),
-            # 'tif': '2020-01-01 10:45:23',  # datetime for automatic order cancellation
-            # 'meta': {
-            #     'aff_code': 'AFF_CODE_HERE'
-            # },
         }
-        stopLimit = ((orderType == 'EXCHANGE STOP LIMIT') or ((orderType == 'EXCHANGE LIMIT') and (stopPrice is not None)))
-        exchangeStop = (orderType == 'EXCHANGE STOP')
-        exchangeMarket = (orderType == 'EXCHANGE MARKET')
-        stopMarket = (exchangeStop or (exchangeMarket and (stopPrice is not None)))
-        ioc = ((orderType == 'EXCHANGE IOC') or (timeInForce == 'IOC'))
-        fok = ((orderType == 'EXCHANGE FOK') or (timeInForce == 'FOK'))
+        stopPrice = self.safe_string_2(params, 'stopPrice', 'triggerPrice')
+        trailingAmount = self.safe_string(params, 'trailingAmount')
+        timeInForce = self.safe_string(params, 'timeInForce')
+        postOnlyParam = self.safe_bool(params, 'postOnly', False)
+        reduceOnly = self.safe_bool(params, 'reduceOnly', False)
+        clientOrderId = self.safe_value_2(params, 'cid', 'clientOrderId')
+        orderType = type.upper()
+        if trailingAmount is not None:
+            orderType = 'TRAILING STOP'
+            request['price_trailing'] = trailingAmount
+        elif stopPrice is not None:
+            # request['price'] is taken for stop orders
+            request['price'] = self.price_to_precision(symbol, stopPrice)
+            if type == 'limit':
+                orderType = 'STOP LIMIT'
+                request['price_aux_limit'] = self.price_to_precision(symbol, price)
+            else:
+                orderType = 'STOP'
+        ioc = (timeInForce == 'IOC')
+        fok = (timeInForce == 'FOK')
         postOnly = (postOnlyParam or (timeInForce == 'PO'))
         if (ioc or fok) and (price is None):
             raise InvalidOrder(self.id + ' createOrder() requires a price argument with IOC and FOK orders')
-        if (ioc or fok) and exchangeMarket:
+        if (ioc or fok) and (type == 'market'):
             raise InvalidOrder(self.id + ' createOrder() does not allow market IOC and FOK orders')
-        if (orderType != 'MARKET') and (not exchangeMarket) and (not exchangeStop):
+        if (type != 'market') and (stopPrice is None):
             request['price'] = self.price_to_precision(symbol, price)
-        if stopLimit or stopMarket:
-            # request['price'] is taken for stop orders
-            request['price'] = self.price_to_precision(symbol, stopPrice)
-            if stopMarket:
-                request['type'] = 'EXCHANGE STOP'
-            elif stopLimit:
-                request['type'] = 'EXCHANGE STOP LIMIT'
-                request['price_aux_limit'] = self.price_to_precision(symbol, price)
         if ioc:
-            request['type'] = 'EXCHANGE IOC'
+            orderType = 'IOC'
         elif fok:
-            request['type'] = 'EXCHANGE FOK'
+            orderType = 'FOK'
+        marginMode = None
+        marginMode, params = self.handle_margin_mode_and_params('createOrder', params)
+        if market['spot'] and (marginMode is None):
+            # The EXCHANGE prefix is only required for non margin spot markets
+            orderType = 'EXCHANGE ' + orderType
+        request['type'] = orderType
         # flag values may be summed to combine flags
         flags = 0
         if postOnly:
@@ -1535,8 +1528,34 @@ class bitfinex2(Exchange, ImplicitAPI):
             request['flags'] = flags
         if clientOrderId is not None:
             request['cid'] = clientOrderId
-            params = self.omit(params, ['cid', 'clientOrderId'])
-        response = self.privatePostAuthWOrderSubmit(self.extend(request, params))
+        params = self.omit(params, ['triggerPrice', 'stopPrice', 'timeInForce', 'postOnly', 'reduceOnly', 'trailingAmount', 'clientOrderId'])
+        return self.extend(request, params)
+
+    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+        """
+        create an order on the exchange
+        :see: https://docs.bitfinex.com/reference/rest-auth-submit-order
+        :param str symbol: unified CCXT market symbol
+        :param str type: 'limit' or 'market'
+        :param str side: 'buy' or 'sell'
+        :param float amount: the amount of currency to trade
+        :param float [price]: price of the order
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param float [params.stopPrice]: the price that triggers a trigger order
+        :param str [params.timeInForce]: "GTC", "IOC", "FOK", or "PO"
+        :param boolean [params.postOnly]: set to True if you want to make a post only order
+        :param boolean [params.reduceOnly]: indicates that the order is to reduce the size of a 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_aux_limit]: order price for stop limit orders
+        :param str [params.price_oco_stop]: OCO stop price
+        :param str [params.trailingAmount]: *swap only* the quote amount to trail away from the current market price
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.load_markets()
+        market = self.market(symbol)
+        request = self.create_order_request(symbol, type, side, amount, price, params)
+        response = self.privatePostAuthWOrderSubmit(request)
         #
         #      [
         #          1653325121,   # Timestamp in milliseconds
@@ -1589,10 +1608,67 @@ class bitfinex2(Exchange, ImplicitAPI):
             errorCode = response[5]
             errorText = response[7]
             raise ExchangeError(self.id + ' ' + response[6] + ': ' + errorText + '(#' + errorCode + ')')
-        orders = self.safe_value(response, 4, [])
-        order = self.safe_value(orders, 0)
+        orders = self.safe_list(response, 4, [])
+        order = self.safe_list(orders, 0)
         return self.parse_order(order, market)
 
+    def create_orders(self, orders: List[OrderRequest], params={}):
+        """
+        create a list of trade orders
+        :see: https://docs.bitfinex.com/reference/rest-auth-order-multi
+        :param Array orders: list of orders to create, each object should contain the parameters required by createOrder, namely symbol, type, side, amount, price and params
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.load_markets()
+        ordersRequests = []
+        for i in range(0, len(orders)):
+            rawOrder = orders[i]
+            symbol = self.safe_string(rawOrder, 'symbol')
+            type = self.safe_string(rawOrder, 'type')
+            side = self.safe_string(rawOrder, 'side')
+            amount = self.safe_number(rawOrder, 'amount')
+            price = self.safe_number(rawOrder, 'price')
+            orderParams = self.safe_dict(rawOrder, 'params', {})
+            orderRequest = self.create_order_request(symbol, type, side, amount, price, orderParams)
+            ordersRequests.append(['on', orderRequest])
+        request = {
+            'ops': ordersRequests,
+        }
+        response = self.privatePostAuthWOrderMulti(request)
+        #
+        #     [
+        #         1706762515553,
+        #         "ox_multi-req",
+        #         null,
+        #         null,
+        #         [
+        #             [
+        #                 1706762515,
+        #                 "on-req",
+        #                 null,
+        #                 null,
+        #                 [
+        #                     [139567428547,null,1706762515551,"tBTCUST",1706762515551,1706762515551,0.0001,0.0001,"EXCHANGE LIMIT",null,null,null,0,"ACTIVE",null,null,35000,0,0,0,null,null,null,0,0,null,null,null,"API>BFX",null,null,{}]
+        #                 ],
+        #                 null,
+        #                 "SUCCESS",
+        #                 "Submitting 1 orders."
+        #             ],
+        #         ],
+        #         null,
+        #         "SUCCESS",
+        #         "Submitting 2 order operations."
+        #     ]
+        #
+        results = []
+        data = self.safe_list(response, 4, [])
+        for i in range(0, len(data)):
+            entry = data[i]
+            individualOrder = entry[4]
+            results.append(individualOrder[0])
+        return self.parse_orders(results)
+
     def cancel_all_orders(self, symbol: Str = None, params={}):
         """
         cancel all open orders
@@ -1601,6 +1677,7 @@ class bitfinex2(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
+        self.load_markets()
         request = {
             'all': 1,
         }
@@ -1617,6 +1694,7 @@ class bitfinex2(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
+        self.load_markets()
         cid = self.safe_value_2(params, 'cid', 'clientOrderId')  # client order id
         request = None
         if cid is not None:
@@ -1636,6 +1714,78 @@ class bitfinex2(Exchange, ImplicitAPI):
         order = self.safe_value(response, 4)
         return self.parse_order(order)
 
+    def cancel_orders(self, ids, symbol: Str = None, params={}):
+        """
+        cancel multiple orders at the same time
+        :see: https://docs.bitfinex.com/reference/rest-auth-cancel-orders-multiple
+        :param str[] ids: order ids
+        :param str symbol: unified market symbol, default is None
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an array of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.load_markets()
+        for i in range(0, len(ids)):
+            ids[i] = self.parse_to_numeric(ids[i])
+        request = {
+            'id': ids,
+        }
+        market = None
+        if symbol is not None:
+            market = self.market(symbol)
+        response = self.privatePostAuthWOrderCancelMulti(self.extend(request, params))
+        #
+        #     [
+        #         1706740198811,
+        #         "oc_multi-req",
+        #         null,
+        #         null,
+        #         [
+        #             [
+        #                 139530205057,
+        #                 null,
+        #                 1706740132275,
+        #                 "tBTCF0:USTF0",
+        #                 1706740132276,
+        #                 1706740132276,
+        #                 0.0001,
+        #                 0.0001,
+        #                 "LIMIT",
+        #                 null,
+        #                 null,
+        #                 null,
+        #                 0,
+        #                 "ACTIVE",
+        #                 null,
+        #                 null,
+        #                 39000,
+        #                 0,
+        #                 0,
+        #                 0,
+        #                 null,
+        #                 null,
+        #                 null,
+        #                 0,
+        #                 0,
+        #                 null,
+        #                 null,
+        #                 null,
+        #                 "API>BFX",
+        #                 null,
+        #                 null,
+        #                 {
+        #                     "lev": 10,
+        #                     "$F33": 10
+        #                 }
+        #             ],
+        #         ],
+        #         null,
+        #         "SUCCESS",
+        #         "Submitting 2 order cancellations."
+        #     ]
+        #
+        orders = self.safe_list(response, 4, [])
+        return self.parse_orders(orders, market)
+
     def fetch_open_order(self, id: str, symbol: Str = None, params={}):
         """
         fetch an open order by it's id
@@ -2275,7 +2425,7 @@ class bitfinex2(Exchange, ImplicitAPI):
         if tag is not None:
             request['payment_id'] = tag
         withdrawOptions = self.safe_value(self.options, 'withdraw', {})
-        includeFee = self.safe_value(withdrawOptions, 'includeFee', False)
+        includeFee = self.safe_bool(withdrawOptions, 'includeFee', False)
         if includeFee:
             request['fee_deduct'] = 1
         response = self.privatePostAuthWWithdraw(self.extend(request, params))
@@ -2563,14 +2713,13 @@ class bitfinex2(Exchange, ImplicitAPI):
         :see: https://docs.bitfinex.com/reference/rest-auth-ledgers
         :param str code: unified currency code, default is None
         :param int [since]: timestamp in ms of the earliest ledger entry, default is None
-        :param int [limit]: max number of ledger entrys to return, default is None
+        :param int [limit]: max number of ledger entrys to return, default is None max is 2500
         :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)
         :returns dict: a `ledger structure <https://docs.ccxt.com/#/?id=ledger-structure>`
         """
         self.load_markets()
-        self.load_markets()
         paginate = False
         paginate, params = self.handle_option_and_params(params, 'fetchLedger', 'paginate')
         if paginate:
@@ -2580,7 +2729,7 @@ class bitfinex2(Exchange, ImplicitAPI):
         if since is not None:
             request['start'] = since
         if limit is not None:
-            request['limit'] = limit  # max 2500
+            request['limit'] = limit
         request, params = self.handle_until_option('end', request, params)
         response = None
         if code is not None:
@@ -2669,9 +2818,11 @@ class bitfinex2(Exchange, ImplicitAPI):
         fetches historical funding rate prices
         :see: https://docs.bitfinex.com/reference/rest-public-derivatives-status-history
         :param str symbol: unified market symbol
+        :param int [since]: timestamp in ms of the earliest funding rate entry
+        :param int [limit]: max number of funding rate entrys to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param int [params.until]: timestamp in ms of the latest funding rate
-        :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)
         :returns dict: a `funding rate structure <https://docs.ccxt.com/#/?id=funding-rate-structure>`
         """
         if symbol is None:
@@ -2724,7 +2875,14 @@ class bitfinex2(Exchange, ImplicitAPI):
             fr = response[i]
             rate = self.parse_funding_rate_history(fr, market)
             rates.append(rate)
-        return self.filter_by_symbol_since_limit(rates, symbol, since, limit)
+        reversedArray = []
+        rawRates = self.filter_by_symbol_since_limit(rates, symbol, since, limit)
+        rawRatesLength = len(rawRates)
+        ratesLength = max(rawRatesLength - 1, 0)
+        for i in range(ratesLength, 0):
+            valueAtIndex = rawRates[i]
+            reversedArray.append(valueAtIndex)
+        return reversedArray
 
     def parse_funding_rate(self, contract, market: Market = None):
         #
@@ -2872,7 +3030,8 @@ class bitfinex2(Exchange, ImplicitAPI):
         #         ]
         #     ]
         #
-        return self.parse_open_interest(response[0], market)
+        oi = self.safe_list(response, 0)
+        return self.parse_open_interest(oi, market)
 
     def fetch_open_interest_history(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}):
         """
@@ -3129,3 +3288,179 @@ class bitfinex2(Exchange, ImplicitAPI):
             'symbol': market['symbol'],
             'status': marginStatus,
         }
+
+    def fetch_order(self, id: str, symbol: str = None, params={}):
+        """
+        fetches information on an order made by the user
+        :see: https://docs.bitfinex.com/reference/rest-auth-retrieve-orders
+        :see: https://docs.bitfinex.com/reference/rest-auth-retrieve-orders-by-symbol
+        :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
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.load_markets()
+        request = {
+            'id': [self.parse_to_numeric(id)],
+        }
+        market = None
+        response = None
+        if symbol is None:
+            response = self.privatePostAuthROrders(self.extend(request, params))
+        else:
+            market = self.market(symbol)
+            request['symbol'] = market['id']
+            response = self.privatePostAuthROrdersSymbol(self.extend(request, params))
+        #
+        #     [
+        #         [
+        #             139658969116,
+        #             null,
+        #             1706843908637,
+        #             "tBTCUST",
+        #             1706843908637,
+        #             1706843908638,
+        #             0.0001,
+        #             0.0001,
+        #             "EXCHANGE LIMIT",
+        #             null,
+        #             null,
+        #             null,
+        #             0,
+        #             "ACTIVE",
+        #             null,
+        #             null,
+        #             35000,
+        #             0,
+        #             0,
+        #             0,
+        #             null,
+        #             null,
+        #             null,
+        #             0,
+        #             0,
+        #             null,
+        #             null,
+        #             null,
+        #             "API>BFX",
+        #             null,
+        #             null,
+        #             {}
+        #         ]
+        #     ]
+        #
+        order = self.safe_list(response, 0)
+        return self.parse_order(order, market)
+
+    def edit_order(self, id: str, symbol, type, side, amount=None, price=None, params={}):
+        """
+        edit a trade order
+        :see: https://docs.bitfinex.com/reference/rest-auth-update-order
+        :param str id: edit order id
+        :param str symbol: unified symbol of the market to edit an order in
+        :param str type: 'market' or 'limit'
+        :param str side: 'buy' or 'sell'
+        :param float amount: how much you want to trade in units of the base currency
+        :param float [price]: the price that the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param float [params.stopPrice]: the price that triggers a trigger order
+        :param boolean [params.postOnly]: set to True if you want to make a post only order
+        :param boolean [params.reduceOnly]: indicates that the order is to reduce the size of a 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.leverage]: leverage for a derivative order, supported by derivative symbol orders only, the value should be between 1 and 100 inclusive
+        :param int [params.clientOrderId]: a unique client order id for the order
+        :param float [params.trailingAmount]: *swap only* the quote amount to trail away from the current market price
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.load_markets()
+        market = self.market(symbol)
+        request = {
+            'id': self.parse_to_numeric(id),
+        }
+        if amount is not None:
+            amountString = self.amount_to_precision(symbol, amount)
+            amountString = amountString if (side == 'buy') else Precise.string_neg(amountString)
+            request['amount'] = amountString
+        stopPrice = self.safe_string_2(params, 'stopPrice', 'triggerPrice')
+        trailingAmount = self.safe_string(params, 'trailingAmount')
+        timeInForce = self.safe_string(params, 'timeInForce')
+        postOnlyParam = self.safe_bool(params, 'postOnly', False)
+        reduceOnly = self.safe_bool(params, 'reduceOnly', False)
+        clientOrderId = self.safe_integer_2(params, 'cid', 'clientOrderId')
+        if trailingAmount is not None:
+            request['price_trailing'] = trailingAmount
+        elif stopPrice is not None:
+            # request['price'] is taken for stop orders
+            request['price'] = self.price_to_precision(symbol, stopPrice)
+            if type == 'limit':
+                request['price_aux_limit'] = self.price_to_precision(symbol, price)
+        postOnly = (postOnlyParam or (timeInForce == 'PO'))
+        if (type != 'market') and (stopPrice is None):
+            request['price'] = self.price_to_precision(symbol, price)
+        # flag values may be summed to combine flags
+        flags = 0
+        if postOnly:
+            flags = self.sum(flags, 4096)
+        if reduceOnly:
+            flags = self.sum(flags, 1024)
+        if flags != 0:
+            request['flags'] = flags
+        if clientOrderId is not None:
+            request['cid'] = clientOrderId
+        leverage = self.safe_integer_2(params, 'leverage', 'lev')
+        if leverage is not None:
+            request['lev'] = leverage
+        params = self.omit(params, ['triggerPrice', 'stopPrice', 'timeInForce', 'postOnly', 'reduceOnly', 'trailingAmount', 'clientOrderId', 'leverage'])
+        response = self.privatePostAuthWOrderUpdate(self.extend(request, params))
+        #
+        #     [
+        #         1706845376402,
+        #         "ou-req",
+        #         null,
+        #         null,
+        #         [
+        #             139658969116,
+        #             null,
+        #             1706843908637,
+        #             "tBTCUST",
+        #             1706843908637,
+        #             1706843908638,
+        #             0.0002,
+        #             0.0002,
+        #             "EXCHANGE LIMIT",
+        #             null,
+        #             null,
+        #             null,
+        #             0,
+        #             "ACTIVE",
+        #             null,
+        #             null,
+        #             35000,
+        #             0,
+        #             0,
+        #             0,
+        #             null,
+        #             null,
+        #             null,
+        #             0,
+        #             0,
+        #             null,
+        #             null,
+        #             null,
+        #             "API>BFX",
+        #             null,
+        #             null,
+        #             {}
+        #         ],
+        #         null,
+        #         "SUCCESS",
+        #         "Submitting update to exchange limit buy order for 0.0002 BTC."
+        #     ]
+        #
+        status = self.safe_string(response, 6)
+        if status != 'SUCCESS':
+            errorCode = response[5]
+            errorText = response[7]
+            raise ExchangeError(self.id + ' ' + response[6] + ': ' + errorText + '(#' + errorCode + ')')
+        order = self.safe_list(response, 4, [])
+        return self.parse_order(order, market)