ccxt 4.3.89__py2.py3-none-any.whl → 4.3.90__py2.py3-none-any.whl

ccxt/async_support/bingx.py

@@ -1036,8 +1036,7 @@ class bingx(Exchange, ImplicitAPI):
 
     def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
-        # spot
-        # fetchTrades
+        # spot fetchTrades
         #
         #    {
         #        "id": 43148253,
@@ -1047,8 +1046,8 @@ class bingx(Exchange, ImplicitAPI):
         #        "buyerMaker": False
         #    }
         #
-        # spot
-        # fetchMyTrades
+        # spot fetchMyTrades
+        #
         #     {
         #         "symbol": "LTC-USDT",
         #         "id": 36237072,
@@ -1063,8 +1062,7 @@ class bingx(Exchange, ImplicitAPI):
         #         "isMaker": False
         #     }
         #
-        # swap
-        # fetchTrades
+        # swap fetchTrades
         #
         #    {
         #        "time": 1672025549368,
@@ -1074,8 +1072,7 @@ class bingx(Exchange, ImplicitAPI):
         #        "quoteQty": "55723.87"
         #    }
         #
-        # swap
-        # fetchMyTrades
+        # swap fetchMyTrades
         #
         #    {
         #        "volume": "0.1",
@@ -1089,10 +1086,7 @@ class bingx(Exchange, ImplicitAPI):
         #        "filledTime": "2023-07-04T20:56:01.000+0800"
         #    }
         #
-        #
-        # ws
-        #
-        # spot
+        # ws spot
         #
         #    {
         #        "E": 1690214529432,
@@ -1105,7 +1099,7 @@ class bingx(Exchange, ImplicitAPI):
         #        "t": "57903921"
         #    }
         #
-        # swap
+        # ws linear swap
         #
         #    {
         #        "q": "0.0421",
@@ -1115,6 +1109,19 @@ class bingx(Exchange, ImplicitAPI):
         #        "s": "BTC-USDT"
         #    }
         #
+        # ws inverse swap
+        #
+        #     {
+        #         "e": "trade",
+        #         "E": 1722920589665,
+        #         "s": "BTC-USD",
+        #         "t": "39125001",
+        #         "p": "55360.0",
+        #         "q": "1",
+        #         "T": 1722920589582,
+        #         "m": False
+        #     }
+        #
         # inverse swap fetchMyTrades
         #
         #     {
@@ -2399,13 +2406,17 @@ class bingx(Exchange, ImplicitAPI):
                     tpRequest['quantity'] = self.parse_to_numeric(self.amount_to_precision(symbol, tkQuantity))
                     request['takeProfit'] = self.json(tpRequest)
             positionSide = None
-            if reduceOnly:
-                positionSide = 'SHORT' if (side == 'buy') else 'LONG'
+            hedged = self.safe_bool(params, 'hedged', False)
+            if hedged:
+                if reduceOnly:
+                    positionSide = 'SHORT' if (side == 'buy') else 'LONG'
+                else:
+                    positionSide = 'LONG' if (side == 'buy') else 'SHORT'
             else:
-                positionSide = 'LONG' if (side == 'buy') else 'SHORT'
+                positionSide = 'BOTH'
             request['positionSide'] = positionSide
             request['quantity'] = amount if (market['inverse']) else self.parse_to_numeric(self.amount_to_precision(symbol, amount))  # precision not available for inverse contracts
-        params = self.omit(params, ['reduceOnly', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'trailingAmount', 'trailingPercent', 'trailingType', 'takeProfit', 'stopLoss', 'clientOrderId'])
+        params = self.omit(params, ['hedged', 'reduceOnly', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'trailingAmount', 'trailingPercent', 'trailingType', 'takeProfit', 'stopLoss', 'clientOrderId'])
         return self.extend(request, params)
 
     async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
@@ -2435,6 +2446,7 @@ class bingx(Exchange, ImplicitAPI):
         :param dict [params.stopLoss]: *stopLoss object in params* containing the triggerPrice at which the attached stop loss order will be triggered
         :param float [params.stopLoss.triggerPrice]: stop loss trigger price
         :param boolean [params.test]: *swap only* whether to use the test endpoint or not, default is False
+        :param boolean [params.hedged]: *swap only* whether the order is in hedged mode or one way mode
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()

ccxt/async_support/bitfinex2.py

@@ -397,6 +397,25 @@ class bitfinex2(Exchange, ImplicitAPI):
                 'withdraw': {
                     'includeFee': False,
                 },
+                'networks': {
+                    'BTC': 'BITCOIN',
+                    'LTC': 'LITECOIN',
+                    'ERC20': 'ETHEREUM',
+                    'OMNI': 'TETHERUSO',
+                    'LIQUID': 'TETHERUSL',
+                    'TRC20': 'TETHERUSX',
+                    'EOS': 'TETHERUSS',
+                    'AVAX': 'TETHERUSDTAVAX',
+                    'SOL': 'TETHERUSDTSOL',
+                    'ALGO': 'TETHERUSDTALG',
+                    'BCH': 'TETHERUSDTBCH',
+                    'KSM': 'TETHERUSDTKSM',
+                    'DVF': 'TETHERUSDTDVF',
+                    'OMG': 'TETHERUSDTOMG',
+                },
+                'networksById': {
+                    'TETHERUSE': 'ERC20',
+                },
             },
             'exceptions': {
                 'exact': {
@@ -791,7 +810,7 @@ class bitfinex2(Exchange, ImplicitAPI):
                 networkId = self.safe_string(pair, 0)
                 currencyId = self.safe_string(self.safe_value(pair, 1, []), 0)
                 if currencyId == cleanId:
-                    network = self.safe_network(networkId)
+                    network = self.network_id_to_code(networkId)
                     networks[network] = {
                         'info': networkId,
                         'id': networkId.lower(),
@@ -814,26 +833,6 @@ class bitfinex2(Exchange, ImplicitAPI):
                 result[code]['networks'] = networks
         return result
 
-    def safe_network(self, networkId):
-        networksById: dict = {
-            'BITCOIN': 'BTC',
-            'LITECOIN': 'LTC',
-            'ETHEREUM': 'ERC20',
-            'TETHERUSE': 'ERC20',
-            'TETHERUSO': 'OMNI',
-            'TETHERUSL': 'LIQUID',
-            'TETHERUSX': 'TRC20',
-            'TETHERUSS': 'EOS',
-            'TETHERUSDTAVAX': 'AVAX',
-            'TETHERUSDTSOL': 'SOL',
-            'TETHERUSDTALG': 'ALGO',
-            'TETHERUSDTBCH': 'BCH',
-            'TETHERUSDTKSM': 'KSM',
-            'TETHERUSDTDVF': 'DVF',
-            'TETHERUSDTOMG': 'OMG',
-        }
-        return self.safe_string(networksById, networkId, networkId)
-
     async def fetch_balance(self, params={}) -> Balances:
         """
         query for balance and get the amount of funds available for trading or funds locked in orders
@@ -2249,7 +2248,7 @@ class bitfinex2(Exchange, ImplicitAPI):
             currencyId = self.safe_string(transaction, 1)
             code = self.safe_currency_code(currencyId, currency)
             networkId = self.safe_string(transaction, 2)
-            network = self.safe_network(networkId)
+            network = self.network_id_to_code(networkId)
             timestamp = self.safe_integer(transaction, 5)
             updated = self.safe_integer(transaction, 6)
             status = self.parse_transaction_status(self.safe_string(transaction, 9))

ccxt/async_support/bitget.py

@@ -3847,7 +3847,7 @@ class bitget(Exchange, ImplicitAPI):
         if feeCostString is not None:
             # swap
             fee = {
-                'cost': self.parse_number(Precise.string_abs(feeCostString)),
+                'cost': self.parse_number(Precise.string_neg(feeCostString)),
                 'currency': market['settle'],
             }
         feeDetail = self.safe_value(order, 'feeDetail')
@@ -3861,7 +3861,7 @@ class bitget(Exchange, ImplicitAPI):
                     feeObject = feeValue
                     break
             fee = {
-                'cost': self.parse_number(Precise.string_abs(self.safe_string(feeObject, 'totalFee'))),
+                'cost': self.parse_number(Precise.string_neg(self.safe_string(feeObject, 'totalFee'))),
                 'currency': self.safe_currency_code(self.safe_string(feeObject, 'feeCoinCode')),
             }
         postOnly = None

ccxt/async_support/bitmart.py

@@ -3209,7 +3209,10 @@ class bitmart(Exchange, ImplicitAPI):
             parts = chain.split('-')
             partsLength = len(parts)
             networkId = self.safe_string(parts, partsLength - 1)
-            network = self.safe_network_code(networkId, currency)
+            if networkId == self.safe_string(currency, 'name'):
+                network = self.safe_string(currency, 'code')
+            else:
+                network = self.network_id_to_code(networkId)
         self.check_address(address)
         return {
             'info': depositAddress,
@@ -3219,13 +3222,6 @@ class bitmart(Exchange, ImplicitAPI):
             'network': network,
         }
 
-    def safe_network_code(self, networkId, currency=None):
-        name = self.safe_string(currency, 'name')
-        if networkId == name:
-            code = self.safe_string(currency, 'code')
-            return code
-        return self.network_id_to_code(networkId)
-
     async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
         """
         make a withdrawal

ccxt/async_support/coinbaseinternational.py

@@ -754,11 +754,12 @@ class coinbaseinternational(Exchange, ImplicitAPI):
         currencyId = self.safe_string(network, 'asset_name')
         currencyCode = self.safe_currency_code(currencyId)
         networkId = self.safe_string(network, 'network_arn_id')
+        networkIdForCode = self.safe_string_n(network, ['network_name', 'display_name', 'network_arn_id'], '')
         return self.safe_network({
             'info': network,
             'id': networkId,
             'name': self.safe_string(network, 'display_name'),
-            'network': self.network_id_to_code(self.safe_string_n(network, ['network_name', 'display_name', 'network_arn_id'], ''), currencyCode),
+            'network': self.network_id_to_code(networkIdForCode, currencyCode),
             'active': None,
             'deposit': None,
             'withdraw': None,

ccxt/async_support/coinex.py

@@ -3559,24 +3559,9 @@ class coinex(Exchange, ImplicitAPI):
         options = self.safe_dict(self.options, 'fetchDepositAddress', {})
         fillResponseFromRequest = self.safe_bool(options, 'fillResponseFromRequest', True)
         if fillResponseFromRequest:
-            depositAddress['network'] = self.safe_network_code(network, currency)
+            depositAddress['network'] = self.network_id_to_code(network, currency).upper()
         return depositAddress
 
-    def safe_network(self, networkId, currency: Currency = None):
-        networks = self.safe_value(currency, 'networks', {})
-        networksCodes = list(networks.keys())
-        networksCodesLength = len(networksCodes)
-        if networkId is None and networksCodesLength == 1:
-            return networks[networksCodes[0]]
-        return {
-            'id': networkId,
-            'network': None if (networkId is None) else networkId.upper(),
-        }
-
-    def safe_network_code(self, networkId, currency: Currency = None):
-        network = self.safe_network(networkId, currency)
-        return network['network']
-
     def parse_deposit_address(self, depositAddress, currency: Currency = None):
         #
         #     {

ccxt/async_support/hitbtc.py

@@ -1371,6 +1371,7 @@ class hitbtc(Exchange, ImplicitAPI):
         statuses: dict = {
             'PENDING': 'pending',
             'FAILED': 'failed',
+            'ROLLED_BACK': 'failed',
             'SUCCESS': 'ok',
         }
         return self.safe_string(statuses, status, status)

ccxt/async_support/huobijp.py

@@ -1564,14 +1564,6 @@ class huobijp(Exchange, ImplicitAPI):
     def currency_to_precision(self, code, fee, networkCode=None):
         return self.decimal_to_precision(fee, 0, self.currencies[code]['precision'], self.precisionMode)
 
-    def safe_network(self, networkId):
-        lastCharacterIndex = len(networkId) - 1
-        lastCharacter = networkId[lastCharacterIndex]
-        if lastCharacter == '1':
-            networkId = networkId[0:lastCharacterIndex]
-        networksById: dict = {}
-        return self.safe_string(networksById, networkId, networkId)
-
     def parse_deposit_address(self, depositAddress, currency: Currency = None):
         #
         #     {

ccxt/async_support/latoken.py

@@ -1465,6 +1465,7 @@ class latoken(Exchange, ImplicitAPI):
         statuses: dict = {
             'TRANSACTION_STATUS_CONFIRMED': 'ok',
             'TRANSACTION_STATUS_EXECUTED': 'ok',
+            'TRANSACTION_STATUS_CHECKING': 'pending',
             'TRANSACTION_STATUS_CANCELLED': 'canceled',
         }
         return self.safe_string(statuses, status, status)

ccxt/async_support/okx.py

@@ -1063,6 +1063,7 @@ class okx(Exchange, ImplicitAPI):
                     'ZEC': 'Zcash',
                     'ZIL': 'Zilliqa',
                     'ZKSYNC': 'ZKSYNC',
+                    'OMNI': 'Omni',
                     # 'NEON3': 'N3',  # tbd
                     # undetermined : "CELO-TOKEN", "Digital Cash", Khala
                     # todo: uncomment below after consensus
@@ -1589,14 +1590,6 @@ class okx(Exchange, ImplicitAPI):
         dataResponse = self.safe_list(response, 'data', [])
         return self.parse_markets(dataResponse)
 
-    def safe_network(self, networkId):
-        networksById: dict = {
-            'Bitcoin': 'BTC',
-            'Omni': 'OMNI',
-            'TRON': 'TRC20',
-        }
-        return self.safe_string(networksById, networkId, networkId)
-
     async def fetch_currencies(self, params={}) -> Currencies:
         """
         fetches all available currencies on an exchange

ccxt/async_support/whitebit.py

@@ -2472,9 +2472,11 @@ class whitebit(Exchange, ImplicitAPI):
                 if hasErrorStatus:
                     errorInfo = status
                 else:
-                    errorObject = self.safe_value(response, 'errors')
-                    if errorObject is not None:
-                        errorKey = list(errorObject.keys())[0]
+                    errorObject = self.safe_dict(response, 'errors', {})
+                    errorKeys = list(errorObject.keys())
+                    errorsLength = len(errorKeys)
+                    if errorsLength > 0:
+                        errorKey = errorKeys[0]
                         errorMessageArray = self.safe_value(errorObject, errorKey, [])
                         errorMessageLength = len(errorMessageArray)
                         errorInfo = errorMessageArray[0] if (errorMessageLength > 0) else body

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.89'
+__version__ = '4.3.90'
 
 # -----------------------------------------------------------------------------
 

ccxt/bingx.py

@@ -1035,8 +1035,7 @@ class bingx(Exchange, ImplicitAPI):
 
     def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
-        # spot
-        # fetchTrades
+        # spot fetchTrades
         #
         #    {
         #        "id": 43148253,
@@ -1046,8 +1045,8 @@ class bingx(Exchange, ImplicitAPI):
         #        "buyerMaker": False
         #    }
         #
-        # spot
-        # fetchMyTrades
+        # spot fetchMyTrades
+        #
         #     {
         #         "symbol": "LTC-USDT",
         #         "id": 36237072,
@@ -1062,8 +1061,7 @@ class bingx(Exchange, ImplicitAPI):
         #         "isMaker": False
         #     }
         #
-        # swap
-        # fetchTrades
+        # swap fetchTrades
         #
         #    {
         #        "time": 1672025549368,
@@ -1073,8 +1071,7 @@ class bingx(Exchange, ImplicitAPI):
         #        "quoteQty": "55723.87"
         #    }
         #
-        # swap
-        # fetchMyTrades
+        # swap fetchMyTrades
         #
         #    {
         #        "volume": "0.1",
@@ -1088,10 +1085,7 @@ class bingx(Exchange, ImplicitAPI):
         #        "filledTime": "2023-07-04T20:56:01.000+0800"
         #    }
         #
-        #
-        # ws
-        #
-        # spot
+        # ws spot
         #
         #    {
         #        "E": 1690214529432,
@@ -1104,7 +1098,7 @@ class bingx(Exchange, ImplicitAPI):
         #        "t": "57903921"
         #    }
         #
-        # swap
+        # ws linear swap
         #
         #    {
         #        "q": "0.0421",
@@ -1114,6 +1108,19 @@ class bingx(Exchange, ImplicitAPI):
         #        "s": "BTC-USDT"
         #    }
         #
+        # ws inverse swap
+        #
+        #     {
+        #         "e": "trade",
+        #         "E": 1722920589665,
+        #         "s": "BTC-USD",
+        #         "t": "39125001",
+        #         "p": "55360.0",
+        #         "q": "1",
+        #         "T": 1722920589582,
+        #         "m": False
+        #     }
+        #
         # inverse swap fetchMyTrades
         #
         #     {
@@ -2398,13 +2405,17 @@ class bingx(Exchange, ImplicitAPI):
                     tpRequest['quantity'] = self.parse_to_numeric(self.amount_to_precision(symbol, tkQuantity))
                     request['takeProfit'] = self.json(tpRequest)
             positionSide = None
-            if reduceOnly:
-                positionSide = 'SHORT' if (side == 'buy') else 'LONG'
+            hedged = self.safe_bool(params, 'hedged', False)
+            if hedged:
+                if reduceOnly:
+                    positionSide = 'SHORT' if (side == 'buy') else 'LONG'
+                else:
+                    positionSide = 'LONG' if (side == 'buy') else 'SHORT'
             else:
-                positionSide = 'LONG' if (side == 'buy') else 'SHORT'
+                positionSide = 'BOTH'
             request['positionSide'] = positionSide
             request['quantity'] = amount if (market['inverse']) else self.parse_to_numeric(self.amount_to_precision(symbol, amount))  # precision not available for inverse contracts
-        params = self.omit(params, ['reduceOnly', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'trailingAmount', 'trailingPercent', 'trailingType', 'takeProfit', 'stopLoss', 'clientOrderId'])
+        params = self.omit(params, ['hedged', 'reduceOnly', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'trailingAmount', 'trailingPercent', 'trailingType', 'takeProfit', 'stopLoss', 'clientOrderId'])
         return self.extend(request, params)
 
     def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
@@ -2434,6 +2445,7 @@ class bingx(Exchange, ImplicitAPI):
         :param dict [params.stopLoss]: *stopLoss object in params* containing the triggerPrice at which the attached stop loss order will be triggered
         :param float [params.stopLoss.triggerPrice]: stop loss trigger price
         :param boolean [params.test]: *swap only* whether to use the test endpoint or not, default is False
+        :param boolean [params.hedged]: *swap only* whether the order is in hedged mode or one way mode
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()

ccxt/bitfinex2.py

@@ -397,6 +397,25 @@ class bitfinex2(Exchange, ImplicitAPI):
                 'withdraw': {
                     'includeFee': False,
                 },
+                'networks': {
+                    'BTC': 'BITCOIN',
+                    'LTC': 'LITECOIN',
+                    'ERC20': 'ETHEREUM',
+                    'OMNI': 'TETHERUSO',
+                    'LIQUID': 'TETHERUSL',
+                    'TRC20': 'TETHERUSX',
+                    'EOS': 'TETHERUSS',
+                    'AVAX': 'TETHERUSDTAVAX',
+                    'SOL': 'TETHERUSDTSOL',
+                    'ALGO': 'TETHERUSDTALG',
+                    'BCH': 'TETHERUSDTBCH',
+                    'KSM': 'TETHERUSDTKSM',
+                    'DVF': 'TETHERUSDTDVF',
+                    'OMG': 'TETHERUSDTOMG',
+                },
+                'networksById': {
+                    'TETHERUSE': 'ERC20',
+                },
             },
             'exceptions': {
                 'exact': {
@@ -791,7 +810,7 @@ class bitfinex2(Exchange, ImplicitAPI):
                 networkId = self.safe_string(pair, 0)
                 currencyId = self.safe_string(self.safe_value(pair, 1, []), 0)
                 if currencyId == cleanId:
-                    network = self.safe_network(networkId)
+                    network = self.network_id_to_code(networkId)
                     networks[network] = {
                         'info': networkId,
                         'id': networkId.lower(),
@@ -814,26 +833,6 @@ class bitfinex2(Exchange, ImplicitAPI):
                 result[code]['networks'] = networks
         return result
 
-    def safe_network(self, networkId):
-        networksById: dict = {
-            'BITCOIN': 'BTC',
-            'LITECOIN': 'LTC',
-            'ETHEREUM': 'ERC20',
-            'TETHERUSE': 'ERC20',
-            'TETHERUSO': 'OMNI',
-            'TETHERUSL': 'LIQUID',
-            'TETHERUSX': 'TRC20',
-            'TETHERUSS': 'EOS',
-            'TETHERUSDTAVAX': 'AVAX',
-            'TETHERUSDTSOL': 'SOL',
-            'TETHERUSDTALG': 'ALGO',
-            'TETHERUSDTBCH': 'BCH',
-            'TETHERUSDTKSM': 'KSM',
-            'TETHERUSDTDVF': 'DVF',
-            'TETHERUSDTOMG': 'OMG',
-        }
-        return self.safe_string(networksById, networkId, networkId)
-
     def fetch_balance(self, params={}) -> Balances:
         """
         query for balance and get the amount of funds available for trading or funds locked in orders
@@ -2249,7 +2248,7 @@ class bitfinex2(Exchange, ImplicitAPI):
             currencyId = self.safe_string(transaction, 1)
             code = self.safe_currency_code(currencyId, currency)
             networkId = self.safe_string(transaction, 2)
-            network = self.safe_network(networkId)
+            network = self.network_id_to_code(networkId)
             timestamp = self.safe_integer(transaction, 5)
             updated = self.safe_integer(transaction, 6)
             status = self.parse_transaction_status(self.safe_string(transaction, 9))

ccxt/bitget.py

@@ -3846,7 +3846,7 @@ class bitget(Exchange, ImplicitAPI):
         if feeCostString is not None:
             # swap
             fee = {
-                'cost': self.parse_number(Precise.string_abs(feeCostString)),
+                'cost': self.parse_number(Precise.string_neg(feeCostString)),
                 'currency': market['settle'],
             }
         feeDetail = self.safe_value(order, 'feeDetail')
@@ -3860,7 +3860,7 @@ class bitget(Exchange, ImplicitAPI):
                     feeObject = feeValue
                     break
             fee = {
-                'cost': self.parse_number(Precise.string_abs(self.safe_string(feeObject, 'totalFee'))),
+                'cost': self.parse_number(Precise.string_neg(self.safe_string(feeObject, 'totalFee'))),
                 'currency': self.safe_currency_code(self.safe_string(feeObject, 'feeCoinCode')),
             }
         postOnly = None

ccxt/bitmart.py

@@ -3209,7 +3209,10 @@ class bitmart(Exchange, ImplicitAPI):
             parts = chain.split('-')
             partsLength = len(parts)
             networkId = self.safe_string(parts, partsLength - 1)
-            network = self.safe_network_code(networkId, currency)
+            if networkId == self.safe_string(currency, 'name'):
+                network = self.safe_string(currency, 'code')
+            else:
+                network = self.network_id_to_code(networkId)
         self.check_address(address)
         return {
             'info': depositAddress,
@@ -3219,13 +3222,6 @@ class bitmart(Exchange, ImplicitAPI):
             'network': network,
         }
 
-    def safe_network_code(self, networkId, currency=None):
-        name = self.safe_string(currency, 'name')
-        if networkId == name:
-            code = self.safe_string(currency, 'code')
-            return code
-        return self.network_id_to_code(networkId)
-
     def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
         """
         make a withdrawal

ccxt/coinbaseinternational.py

@@ -754,11 +754,12 @@ class coinbaseinternational(Exchange, ImplicitAPI):
         currencyId = self.safe_string(network, 'asset_name')
         currencyCode = self.safe_currency_code(currencyId)
         networkId = self.safe_string(network, 'network_arn_id')
+        networkIdForCode = self.safe_string_n(network, ['network_name', 'display_name', 'network_arn_id'], '')
         return self.safe_network({
             'info': network,
             'id': networkId,
             'name': self.safe_string(network, 'display_name'),
-            'network': self.network_id_to_code(self.safe_string_n(network, ['network_name', 'display_name', 'network_arn_id'], ''), currencyCode),
+            'network': self.network_id_to_code(networkIdForCode, currencyCode),
             'active': None,
             'deposit': None,
             'withdraw': None,

ccxt/coinex.py

@@ -3558,24 +3558,9 @@ class coinex(Exchange, ImplicitAPI):
         options = self.safe_dict(self.options, 'fetchDepositAddress', {})
         fillResponseFromRequest = self.safe_bool(options, 'fillResponseFromRequest', True)
         if fillResponseFromRequest:
-            depositAddress['network'] = self.safe_network_code(network, currency)
+            depositAddress['network'] = self.network_id_to_code(network, currency).upper()
         return depositAddress
 
-    def safe_network(self, networkId, currency: Currency = None):
-        networks = self.safe_value(currency, 'networks', {})
-        networksCodes = list(networks.keys())
-        networksCodesLength = len(networksCodes)
-        if networkId is None and networksCodesLength == 1:
-            return networks[networksCodes[0]]
-        return {
-            'id': networkId,
-            'network': None if (networkId is None) else networkId.upper(),
-        }
-
-    def safe_network_code(self, networkId, currency: Currency = None):
-        network = self.safe_network(networkId, currency)
-        return network['network']
-
     def parse_deposit_address(self, depositAddress, currency: Currency = None):
         #
         #     {

ccxt/hitbtc.py

@@ -1371,6 +1371,7 @@ class hitbtc(Exchange, ImplicitAPI):
         statuses: dict = {
             'PENDING': 'pending',
             'FAILED': 'failed',
+            'ROLLED_BACK': 'failed',
             'SUCCESS': 'ok',
         }
         return self.safe_string(statuses, status, status)

ccxt/huobijp.py

@@ -1564,14 +1564,6 @@ class huobijp(Exchange, ImplicitAPI):
     def currency_to_precision(self, code, fee, networkCode=None):
         return self.decimal_to_precision(fee, 0, self.currencies[code]['precision'], self.precisionMode)
 
-    def safe_network(self, networkId):
-        lastCharacterIndex = len(networkId) - 1
-        lastCharacter = networkId[lastCharacterIndex]
-        if lastCharacter == '1':
-            networkId = networkId[0:lastCharacterIndex]
-        networksById: dict = {}
-        return self.safe_string(networksById, networkId, networkId)
-
     def parse_deposit_address(self, depositAddress, currency: Currency = None):
         #
         #     {

ccxt/latoken.py

@@ -1465,6 +1465,7 @@ class latoken(Exchange, ImplicitAPI):
         statuses: dict = {
             'TRANSACTION_STATUS_CONFIRMED': 'ok',
             'TRANSACTION_STATUS_EXECUTED': 'ok',
+            'TRANSACTION_STATUS_CHECKING': 'pending',
             'TRANSACTION_STATUS_CANCELLED': 'canceled',
         }
         return self.safe_string(statuses, status, status)