ccxt 4.3.22__py2.py3-none-any.whl → 4.3.24__py2.py3-none-any.whl

ccxt/coinex.py

@@ -10,6 +10,7 @@ from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import PermissionDenied
+from ccxt.base.errors import AccountSuspended
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import BadSymbol
@@ -457,7 +458,9 @@ class coinex(Exchange, ImplicitAPI):
                     'fillResponseFromRequest': True,
                 },
                 'accountsById': {
-                    'spot': '0',
+                    'spot': 'SPOT',
+                    'margin': 'MARGIN',
+                    'swap': 'FUTURES',
                 },
                 'networks': {
                     'BEP20': 'BSC',
@@ -480,10 +483,53 @@ class coinex(Exchange, ImplicitAPI):
                     '36': RequestTimeout,  # Service timeout
                     '213': RateLimitExceeded,  # Too many requests
                     '107': InsufficientFunds,
+                    '158': PermissionDenied,  # {"code":158,"data":{},"message":"API permission is not allowed"}
                     '600': OrderNotFound,
                     '601': InvalidOrder,
                     '602': InvalidOrder,
                     '606': InvalidOrder,
+                    '3008': RequestTimeout,  # Service busy, please try again later.
+                    '3109': InsufficientFunds,  # {"code":3109,"data":{},"message":"balance not enough"}
+                    '3127': InvalidOrder,  # The order quantity is below the minimum requirement. Please adjust the order quantity.
+                    '3606': InvalidOrder,  # The price difference between the order price and the latest price is too large. Please adjust the order amount accordingly.
+                    '3610': ExchangeError,  # Order cancellation prohibited during the Call Auction period.
+                    '3612': InvalidOrder,  # The est. ask price is lower than the current bottom ask price. Please reduce the amount.
+                    '3613': InvalidOrder,  # The est. bid price is higher than the current top bid price. Please reduce the amount.
+                    '3614': InvalidOrder,  # The deviation between your est. filled price and the index price. Please reduce the amount.
+                    '3615': InvalidOrder,  # The deviation between your order price and the index price is too high. Please adjust your order price and try again.
+                    '3616': InvalidOrder,  # The order price exceeds the current top bid price. Please adjust the order price and try again.
+                    '3617': InvalidOrder,  # The order price exceeds the current bottom ask price. Please adjust the order price and try again.
+                    '3618': InvalidOrder,  # The deviation between your order price and the index price is too high. Please adjust your order price and try again.
+                    '3619': InvalidOrder,  # The deviation between your order price and the trigger price is too high. Please adjust your order price and try again.
+                    '3620': InvalidOrder,  # Market order submission is temporarily unavailable due to insufficient depth in the current market
+                    '3621': InvalidOrder,  # This order can't be completely executed and has been canceled.
+                    '3622': InvalidOrder,  # This order can't be set Only and has been canceled.
+                    '3627': InvalidOrder,  # The current market depth is low, please reduce your order amount and try again.
+                    '3628': InvalidOrder,  # The current market depth is low, please reduce your order amount and try again.
+                    '3629': InvalidOrder,  # The current market depth is low, please reduce your order amount and try again.
+                    '3632': InvalidOrder,  # The order price exceeds the current top bid price. Please adjust the order price and try again.
+                    '3633': InvalidOrder,  # The order price exceeds the current bottom ask price. Please adjust the order price and try again.
+                    '3634': InvalidOrder,  # The deviation between your est. filled price and the index price is too high. Please reduce the amount and try again.
+                    '3635': InvalidOrder,  # The deviation between your est. filled price and the index price is too high. Please reduce the amount and try again.
+                    '4001': ExchangeNotAvailable,  # Service unavailable, please try again later.
+                    '4002': RequestTimeout,  # Service request timed out, please try again later.
+                    '4003': ExchangeError,  # Internal error, please contact customer service for help.
+                    '4004': BadRequest,  # Parameter error, please check whether the request parameters are abnormal.
+                    '4005': AuthenticationError,  # Abnormal access_id, please check whether the value passed by X-COINEX-KEY is normal.
+                    '4006': AuthenticationError,  # Signature verification failed, please check the signature according to the documentation instructions.
+                    '4007': PermissionDenied,  # IP address prohibited, please check whether the whitelist or export IP is normal.
+                    '4008': AuthenticationError,  # Abnormal X-COIN-SIGN value, please check.
+                    '4009': ExchangeError,  # Abnormal request method, please check.
+                    '4010': ExchangeError,  # Expired request, please try again later.
+                    '4011': PermissionDenied,  # User prohibited from accessing, please contact customer service for help.
+                    '4017': ExchangeError,  # Signature expired, please try again later.
+                    '4115': AccountSuspended,  # User prohibited from trading, please contact customer service for help.
+                    '4117': BadSymbol,  # Trading hasattr(self, prohibited) market, please try again later.
+                    '4123': RateLimitExceeded,  # Rate limit triggered. Please adjust your strategy and reduce the request rate.
+                    '4130': ExchangeError,  # Futures trading prohibited, please try again later.
+                    '4158': ExchangeError,  # Trading prohibited, please try again later.
+                    '4213': RateLimitExceeded,  # The request is too frequent, please try again later.
+                    '4512': PermissionDenied,  # Insufficient sub-account permissions, please check.
                 },
                 'broad': {
                     'ip not allow visit': PermissionDenied,
@@ -3409,7 +3455,10 @@ class coinex(Exchange, ImplicitAPI):
         :param str [params.marginMode]: 'cross' or 'isolated' for fetching spot margin orders
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        return self.fetch_orders_by_status('pending', symbol, since, limit, params)
+        openOrders = self.fetch_orders_by_status('pending', symbol, since, limit, params)
+        for i in range(0, len(openOrders)):
+            openOrders[i]['status'] = 'open'
+        return openOrders
 
     def fetch_closed_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
@@ -4138,8 +4187,8 @@ class coinex(Exchange, ImplicitAPI):
 
     def fetch_funding_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
-        fetch the history of funding payments paid and received on self account
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http034_funding_position
+        fetch the history of funding fee payments paid and received on self account
+        :see: https://docs.coinex.com/api/v2/futures/position/http/list-position-funding-history
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch funding history for
         :param int [limit]: the maximum number of funding history structures to retrieve
@@ -4148,53 +4197,45 @@ class coinex(Exchange, ImplicitAPI):
         """
         if symbol is None:
             raise ArgumentsRequired(self.id + ' fetchFundingHistory() requires a symbol argument')
-        limit = 100 if (limit is None) else limit
         self.load_markets()
         market = self.market(symbol)
         request = {
             'market': market['id'],
-            'limit': limit,
-            # 'offset': 0,
-            # 'end_time': 1638990636000,
-            # 'windowtime': 1638990636000,
+            'market_type': 'FUTURES',
         }
+        request, params = self.handle_until_option('end_time', request, params)
         if since is not None:
             request['start_time'] = since
-        response = self.v1PerpetualPrivateGetPositionFunding(self.extend(request, params))
+        if limit is not None:
+            request['limit'] = limit
+        response = self.v2PrivateGetFuturesPositionFundingHistory(self.extend(request, params))
         #
         #     {
         #         "code": 0,
-        #         "data": {
-        #             "limit": 100,
-        #             "offset": 0,
-        #             "records": [
-        #                 {
-        #                     "amount": "0.0012",
-        #                     "asset": "USDT",
-        #                     "funding": "-0.0095688273996",
-        #                     "funding_rate": "0.00020034",
-        #                     "market": "BTCUSDT",
-        #                     "position_id": 62052321,
-        #                     "price": "39802.45",
-        #                     "real_funding_rate": "0.00020034",
-        #                     "side": 2,
-        #                     "time": 1650729623.933885,
-        #                     "type": 1,
-        #                     "user_id": 3620173,
-        #                     "value": "47.76294"
-        #                 },
-        #             ]
-        #         },
-        #         "message": "OK"
+        #         "data": [
+        #             {
+        #                 "ccy": "USDT",
+        #                 "created_at": 1715673620183,
+        #                 "funding_rate": "0",
+        #                 "funding_value": "0",
+        #                 "market": "BTCUSDT",
+        #                 "market_type": "FUTURES",
+        #                 "position_id": 306458800,
+        #                 "side": "long"
+        #             },
+        #         ],
+        #         "message": "OK",
+        #         "pagination": {
+        #             "has_next": True
+        #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
-        resultList = self.safe_value(data, 'records', [])
+        data = self.safe_list(response, 'data', [])
         result = []
-        for i in range(0, len(resultList)):
-            entry = resultList[i]
-            timestamp = self.safe_timestamp(entry, 'time')
-            currencyId = self.safe_string(entry, 'asset')
+        for i in range(0, len(data)):
+            entry = data[i]
+            timestamp = self.safe_integer(entry, 'created_at')
+            currencyId = self.safe_string(entry, 'ccy')
             code = self.safe_currency_code(currencyId)
             result.append({
                 'info': entry,
@@ -4203,14 +4244,14 @@ class coinex(Exchange, ImplicitAPI):
                 'timestamp': timestamp,
                 'datetime': self.iso8601(timestamp),
                 'id': self.safe_number(entry, 'position_id'),
-                'amount': self.safe_number(entry, 'funding'),
+                'amount': self.safe_number(entry, 'funding_value'),
             })
         return result
 
     def fetch_funding_rate(self, symbol: str, params={}):
         """
         fetch the current funding rate
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http008_market_ticker
+        :see: https://docs.coinex.com/api/v2/futures/market/http/list-market-funding-rate
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `funding rate structure <https://docs.ccxt.com/#/?id=funding-rate-structure>`
@@ -4222,93 +4263,63 @@ class coinex(Exchange, ImplicitAPI):
         request = {
             'market': market['id'],
         }
-        response = self.v1PerpetualPublicGetMarketTicker(self.extend(request, params))
+        response = self.v2PublicGetFuturesFundingRate(self.extend(request, params))
         #
         #     {
-        #          "code": 0,
-        #         "data":
-        #         {
-        #             "date": 1650678472474,
-        #             "ticker": {
-        #                 "vol": "6090.9430",
-        #                 "low": "39180.30",
-        #                 "open": "40474.97",
-        #                 "high": "40798.01",
-        #                 "last": "39659.30",
-        #                 "buy": "39663.79",
-        #                 "period": 86400,
-        #                 "funding_time": 372,
-        #                 "position_amount": "270.1956",
-        #                 "funding_rate_last": "0.00022913",
-        #                 "funding_rate_next": "0.00013158",
-        #                 "funding_rate_predict": "0.00016552",
-        #                 "insurance": "16045554.83969682659674035672",
-        #                 "sign_price": "39652.48",
-        #                 "index_price": "39648.44250000",
-        #                 "sell_total": "22.3913",
-        #                 "buy_total": "19.4498",
-        #                 "buy_amount": "12.8942",
-        #                 "sell": "39663.80",
-        #                 "sell_amount": "0.9388"
+        #         "code": 0,
+        #         "data": [
+        #             {
+        #                 "latest_funding_rate": "0",
+        #                 "latest_funding_time": 1715731200000,
+        #                 "mark_price": "61602.22",
+        #                 "market": "BTCUSDT",
+        #                 "max_funding_rate": "0.00375",
+        #                 "min_funding_rate": "-0.00375",
+        #                 "next_funding_rate": "0.00021074",
+        #                 "next_funding_time": 1715760000000
         #             }
-        #         },
+        #         ],
         #         "message": "OK"
         #     }
         #
-        data = self.safe_value(response, 'data', {})
-        ticker = self.safe_value(data, 'ticker', {})
-        timestamp = self.safe_integer(data, 'date')
-        ticker['timestamp'] = timestamp  # avoid changing parseFundingRate signature
-        return self.parse_funding_rate(ticker, market)
+        data = self.safe_list(response, 'data', [])
+        first = self.safe_dict(data, 0, {})
+        return self.parse_funding_rate(first, market)
 
     def parse_funding_rate(self, contract, market: Market = None):
         #
-        # fetchFundingRate
+        # fetchFundingRate, fetchFundingRates
         #
         #     {
-        #         "vol": "6090.9430",
-        #         "low": "39180.30",
-        #         "open": "40474.97",
-        #         "high": "40798.01",
-        #         "last": "39659.30",
-        #         "buy": "39663.79",
-        #         "period": 86400,
-        #         "funding_time": 372,
-        #         "position_amount": "270.1956",
-        #         "funding_rate_last": "0.00022913",
-        #         "funding_rate_next": "0.00013158",
-        #         "funding_rate_predict": "0.00016552",
-        #         "insurance": "16045554.83969682659674035672",
-        #         "sign_price": "39652.48",
-        #         "index_price": "39648.44250000",
-        #         "sell_total": "22.3913",
-        #         "buy_total": "19.4498",
-        #         "buy_amount": "12.8942",
-        #         "sell": "39663.80",
-        #         "sell_amount": "0.9388"
+        #         "latest_funding_rate": "0",
+        #         "latest_funding_time": 1715731200000,
+        #         "mark_price": "61602.22",
+        #         "market": "BTCUSDT",
+        #         "max_funding_rate": "0.00375",
+        #         "min_funding_rate": "-0.00375",
+        #         "next_funding_rate": "0.00021074",
+        #         "next_funding_time": 1715760000000
         #     }
         #
-        timestamp = self.safe_integer(contract, 'timestamp')
-        contract = self.omit(contract, 'timestamp')
-        fundingDelta = self.safe_integer(contract, 'funding_time') * 60 * 1000
-        fundingHour = (timestamp + fundingDelta) / 3600000
-        fundingTimestamp = int(round(fundingHour)) * 3600000
+        currentFundingTimestamp = self.safe_integer(contract, 'latest_funding_time')
+        futureFundingTimestamp = self.safe_integer(contract, 'next_funding_time')
+        marketId = self.safe_string(contract, 'market')
         return {
             'info': contract,
-            'symbol': self.safe_symbol(None, market),
-            'markPrice': self.safe_number(contract, 'sign_price'),
-            'indexPrice': self.safe_number(contract, 'index_price'),
+            'symbol': self.safe_symbol(marketId, market, None, 'swap'),
+            'markPrice': self.safe_number(contract, 'mark_price'),
+            'indexPrice': None,
             'interestRate': None,
             'estimatedSettlePrice': None,
-            'timestamp': timestamp,
-            'datetime': self.iso8601(timestamp),
-            'fundingRate': self.safe_number(contract, 'funding_rate_next'),
-            'fundingTimestamp': fundingTimestamp,
-            'fundingDatetime': self.iso8601(fundingTimestamp),
-            'nextFundingRate': self.safe_number(contract, 'funding_rate_predict'),
-            'nextFundingTimestamp': None,
-            'nextFundingDatetime': None,
-            'previousFundingRate': self.safe_number(contract, 'funding_rate_last'),
+            'timestamp': None,
+            'datetime': None,
+            'fundingRate': self.safe_number(contract, 'latest_funding_rate'),
+            'fundingTimestamp': currentFundingTimestamp,
+            'fundingDatetime': self.iso8601(currentFundingTimestamp),
+            'nextFundingRate': self.safe_number(contract, 'next_funding_rate'),
+            'nextFundingTimestamp': futureFundingTimestamp,
+            'nextFundingDatetime': self.iso8601(futureFundingTimestamp),
+            'previousFundingRate': None,
             'previousFundingTimestamp': None,
             'previousFundingDatetime': None,
         }
@@ -4316,65 +4327,43 @@ class coinex(Exchange, ImplicitAPI):
     def fetch_funding_rates(self, symbols: Strings = None, params={}):
         """
         fetch the current funding rates
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http009_market_ticker_all
+        :see: https://docs.coinex.com/api/v2/futures/market/http/list-market-funding-rate
         :param str[] symbols: unified market symbols
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of `funding rate structures <https://docs.ccxt.com/#/?id=funding-rate-structure>`
         """
         self.load_markets()
         symbols = self.market_symbols(symbols)
+        request = {}
         market = None
         if symbols is not None:
             symbol = self.safe_value(symbols, 0)
             market = self.market(symbol)
             if not market['swap']:
                 raise BadSymbol(self.id + ' fetchFundingRates() supports swap contracts only')
-        response = self.v1PerpetualPublicGetMarketTickerAll(params)
+            marketIds = self.market_ids(symbols)
+            request['market'] = ','.join(marketIds)
+        response = self.v2PublicGetFuturesFundingRate(self.extend(request, params))
         #
         #     {
         #         "code": 0,
-        #         "data":
-        #         {
-        #             "date": 1650678472474,
-        #             "ticker": {
-        #                 "BTCUSDT": {
-        #                     "vol": "6090.9430",
-        #                     "low": "39180.30",
-        #                     "open": "40474.97",
-        #                     "high": "40798.01",
-        #                     "last": "39659.30",
-        #                     "buy": "39663.79",
-        #                     "period": 86400,
-        #                     "funding_time": 372,
-        #                     "position_amount": "270.1956",
-        #                     "funding_rate_last": "0.00022913",
-        #                     "funding_rate_next": "0.00013158",
-        #                     "funding_rate_predict": "0.00016552",
-        #                     "insurance": "16045554.83969682659674035672",
-        #                     "sign_price": "39652.48",
-        #                     "index_price": "39648.44250000",
-        #                     "sell_total": "22.3913",
-        #                     "buy_total": "19.4498",
-        #                     "buy_amount": "12.8942",
-        #                     "sell": "39663.80",
-        #                     "sell_amount": "0.9388"
-        #                 }
+        #         "data": [
+        #             {
+        #                 "latest_funding_rate": "0",
+        #                 "latest_funding_time": 1715731200000,
+        #                 "mark_price": "61602.22",
+        #                 "market": "BTCUSDT",
+        #                 "max_funding_rate": "0.00375",
+        #                 "min_funding_rate": "-0.00375",
+        #                 "next_funding_rate": "0.00021074",
+        #                 "next_funding_time": 1715760000000
         #             }
-        #         },
+        #         ],
         #         "message": "OK"
         #     }
-        data = self.safe_value(response, 'data', {})
-        tickers = self.safe_value(data, 'ticker', {})
-        timestamp = self.safe_integer(data, 'date')
-        result = []
-        marketIds = list(tickers.keys())
-        for i in range(0, len(marketIds)):
-            marketId = marketIds[i]
-            if marketId.find('_') == -1:  # skip _signprice and _indexprice
-                marketInner = self.safe_market(marketId, None, None, 'swap')
-                ticker = tickers[marketId]
-                ticker['timestamp'] = timestamp
-                result.append(self.parse_funding_rate(ticker, marketInner))
+        #
+        data = self.safe_list(response, 'data', [])
+        result = self.parse_funding_rates(data, market)
         return self.filter_by_array(result, 'symbol', symbols)
 
     def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
@@ -4442,13 +4431,13 @@ class coinex(Exchange, ImplicitAPI):
 
     def fetch_funding_rate_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http038_funding_history
         fetches historical funding rate prices
+        :see: https://docs.coinex.com/api/v2/futures/market/http/list-market-funding-rate-history
         :param str symbol: unified symbol of the market to fetch the funding rate history for
         :param int [since]: timestamp in ms of the earliest funding rate to fetch
         :param int [limit]: the maximum amount of `funding rate structures <https://docs.ccxt.com/#/?id=funding-rate-history-structure>` to fetch
         :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]: timestamp in ms of the latest funding rate
         :returns dict[]: a list of `funding rate structures <https://docs.ccxt.com/#/?id=funding-rate-history-structure>`
         """
@@ -4459,50 +4448,44 @@ class coinex(Exchange, ImplicitAPI):
         paginate, params = self.handle_option_and_params(params, 'fetchFundingRateHistory', 'paginate')
         if paginate:
             return self.fetch_paginated_call_deterministic('fetchFundingRateHistory', symbol, since, limit, '8h', params, 1000)
-        if limit is None:
-            limit = 100
         market = self.market(symbol)
         request = {
             'market': market['id'],
-            'limit': limit,
-            'offset': 0,
-            # 'end_time': 1638990636,
         }
         if since is not None:
             request['start_time'] = since
+        if limit is not None:
+            request['limit'] = limit
         request, params = self.handle_until_option('end_time', request, params)
-        response = self.v1PerpetualPublicGetMarketFundingHistory(self.extend(request, params))
+        response = self.v2PublicGetFuturesFundingRateHistory(self.extend(request, params))
         #
         #     {
         #         "code": 0,
-        #         "data": {
-        #             "offset": 0,
-        #             "limit": 3,
-        #             "records": [
-        #                 {
-        #                     "time": 1650672021.6230309,
-        #                     "market": "BTCUSDT",
-        #                     "asset": "USDT",
-        #                     "funding_rate": "0.00022913",
-        #                     "funding_rate_real": "0.00022913"
-        #                 },
-        #             ]
-        #         },
-        #         "message": "OK"
+        #         "data": [
+        #             {
+        #                 "actual_funding_rate": "0",
+        #                 "funding_time": 1715731221761,
+        #                 "market": "BTCUSDT",
+        #                 "theoretical_funding_rate": "0"
+        #             },
+        #         ],
+        #         "message": "OK",
+        #         "pagination": {
+        #             "has_next": True
+        #         }
         #     }
         #
-        data = self.safe_value(response, 'data')
-        result = self.safe_value(data, 'records', [])
+        data = self.safe_list(response, 'data', [])
         rates = []
-        for i in range(0, len(result)):
-            entry = result[i]
+        for i in range(0, len(data)):
+            entry = data[i]
             marketId = self.safe_string(entry, 'market')
             symbolInner = self.safe_symbol(marketId, market, None, 'swap')
-            timestamp = self.safe_timestamp(entry, 'time')
+            timestamp = self.safe_integer(entry, 'funding_time')
             rates.append({
                 'info': entry,
                 'symbol': symbolInner,
-                'fundingRate': self.safe_number(entry, 'funding_rate'),
+                'fundingRate': self.safe_number(entry, 'actual_funding_rate'),
                 'timestamp': timestamp,
                 'datetime': self.iso8601(timestamp),
             })
@@ -4620,40 +4603,42 @@ class coinex(Exchange, ImplicitAPI):
     def transfer(self, code: str, amount: float, fromAccount: str, toAccount: str, params={}) -> TransferEntry:
         """
         transfer currency internally between wallets on the same account
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot002_account014_balance_contract_transfer
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot002_account013_margin_transfer
+        :see: https://docs.coinex.com/api/v2/assets/transfer/http/transfer
         :param str code: unified currency code
         :param float amount: amount to transfer
         :param str fromAccount: account to transfer from
         :param str toAccount: account to transfer to
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.symbol]: unified ccxt symbol, required when either the fromAccount or toAccount is margin
         :returns dict: a `transfer structure <https://docs.ccxt.com/#/?id=transfer-structure>`
         """
         self.load_markets()
         currency = self.currency(code)
         amountToPrecision = self.currency_to_precision(code, amount)
+        accountsById = self.safe_dict(self.options, 'accountsById', {})
+        fromId = self.safe_string(accountsById, fromAccount, fromAccount)
+        toId = self.safe_string(accountsById, toAccount, toAccount)
         request = {
+            'ccy': currency['id'],
             'amount': amountToPrecision,
-            'coin_type': currency['id'],
+            'from_account_type': fromId,
+            'to_account_type': toId,
         }
-        response = None
-        if (fromAccount == 'spot') and (toAccount == 'swap'):
-            request['transfer_side'] = 'in'  # 'in' spot to swap, 'out' swap to spot
-            response = self.v1PrivatePostContractBalanceTransfer(self.extend(request, params))
-        elif (fromAccount == 'swap') and (toAccount == 'spot'):
-            request['transfer_side'] = 'out'  # 'in' spot to swap, 'out' swap to spot
-            response = self.v1PrivatePostContractBalanceTransfer(self.extend(request, params))
-        else:
-            accountsById = self.safe_value(self.options, 'accountsById', {})
-            fromId = self.safe_string(accountsById, fromAccount, fromAccount)
-            toId = self.safe_string(accountsById, toAccount, toAccount)
-            # fromAccount and toAccount must be integers for margin transfers
-            # spot is 0, use fetchBalance() to find the margin account id
-            request['from_account'] = int(fromId)
-            request['to_account'] = int(toId)
-            response = self.v1PrivatePostMarginTransfer(self.extend(request, params))
+        if (fromAccount == 'margin') or (toAccount == 'margin'):
+            symbol = self.safe_string(params, 'symbol')
+            if symbol is None:
+                raise ArgumentsRequired(self.id + ' transfer() the symbol parameter must be defined for a margin account')
+            params = self.omit(params, 'symbol')
+            request['market'] = self.market_id(symbol)
+        if (fromAccount != 'spot') and (toAccount != 'spot'):
+            raise BadRequest(self.id + ' transfer() can only be between spot and swap, or spot and margin, either the fromAccount or toAccount must be spot')
+        response = self.v2PrivatePostAssetsTransfer(self.extend(request, params))
         #
-        #     {"code": 0, "data": null, "message": "Success"}
+        #     {
+        #         "code": 0,
+        #         "data": {},
+        #         "message": "OK"
+        #     }
         #
         return self.extend(self.parse_transfer(response, currency), {
             'amount': self.parse_number(amountToPrecision),
@@ -4661,67 +4646,28 @@ class coinex(Exchange, ImplicitAPI):
             'toAccount': toAccount,
         })
 
-    def parse_transfer_status(self, status: Str) -> Str:
+    def parse_transfer_status(self, status):
         statuses = {
             '0': 'ok',
             'SUCCESS': 'ok',
+            'OK': 'ok',
         }
         return self.safe_string(statuses, status, status)
 
     def parse_transfer(self, transfer: dict, currency: Currency = None) -> TransferEntry:
-        #
-        # fetchTransfers Swap
-        #
-        #     {
-        #         "amount": "10",
-        #         "asset": "USDT",
-        #         "transfer_type": "transfer_out",  # from swap to spot
-        #         "created_at": 1651633422
-        #     },
-        #
-        # fetchTransfers Margin
-        #
-        #     {
-        #         "id": 7580062,
-        #         "updated_at": 1653684379,
-        #         "user_id": 3620173,
-        #         "from_account_id": 0,
-        #         "to_account_id": 1,
-        #         "asset": "BTC",
-        #         "amount": "0.00160829",
-        #         "balance": "0.00160829",
-        #         "transfer_type": "IN",
-        #         "status": "SUCCESS",
-        #         "created_at": 1653684379
-        #     },
-        #
-        timestamp = self.safe_timestamp(transfer, 'created_at')
-        transferType = self.safe_string(transfer, 'transfer_type')
-        fromAccount = None
-        toAccount = None
-        if transferType == 'transfer_out':
-            fromAccount = 'swap'
-            toAccount = 'spot'
-        elif transferType == 'transfer_in':
-            fromAccount = 'spot'
-            toAccount = 'swap'
-        elif transferType == 'IN':
-            fromAccount = 'spot'
-            toAccount = 'margin'
-        elif transferType == 'OUT':
-            fromAccount = 'margin'
-            toAccount = 'spot'
-        currencyId = self.safe_string(transfer, 'asset')
-        currencyCode = self.safe_currency_code(currencyId, currency)
+        timestamp = self.safe_integer(transfer, 'created_at')
+        currencyId = self.safe_string(transfer, 'ccy')
+        fromId = self.safe_string(transfer, 'from_account_type')
+        toId = self.safe_string(transfer, 'to_account_type')
+        accountsById = self.safe_value(self.options, 'accountsById', {})
         return {
-            'info': transfer,
-            'id': self.safe_string(transfer, 'id'),
+            'id': None,
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
-            'currency': currencyCode,
+            'currency': self.safe_currency_code(currencyId, currency),
             'amount': self.safe_number(transfer, 'amount'),
-            'fromAccount': fromAccount,
-            'toAccount': toAccount,
+            'fromAccount': self.safe_string(accountsById, fromId, fromId),
+            'toAccount': self.safe_string(accountsById, toId, toId),
             'status': self.parse_transfer_status(self.safe_string_2(transfer, 'code', 'status')),
         }