ccxt 4.1.91__py2.py3-none-any.whl → 4.1.95__py2.py3-none-any.whl

ccxt/coinone.py

@@ -52,6 +52,7 @@ class coinone(Exchange, ImplicitAPI):
                 'fetchClosedOrders': False,  # the endpoint that should return closed orders actually returns trades, https://github.com/ccxt/ccxt/pull/7067
                 'fetchCrossBorrowRate': False,
                 'fetchCrossBorrowRates': False,
+                'fetchCurrencies': True,
                 'fetchDepositAddresses': True,
                 'fetchFundingHistory': False,
                 'fetchFundingRate': False,
@@ -88,6 +89,9 @@ class coinone(Exchange, ImplicitAPI):
                 'logo': 'https://user-images.githubusercontent.com/1294454/38003300-adc12fba-323f-11e8-8525-725f53c4a659.jpg',
                 'api': {
                     'rest': 'https://api.coinone.co.kr',
+                    'v2Public': 'https://api.coinone.co.kr/public/v2',
+                    'v2Private': 'https://api.coinone.co.kr/v2',
+                    'v2_1Private': 'https://api.coinone.co.kr/v2.1',
                 },
                 'www': 'https://coinone.co.kr',
                 'doc': 'https://doc.coinone.co.kr',
@@ -99,31 +103,85 @@ class coinone(Exchange, ImplicitAPI):
             'api': {
                 'public': {
                     'get': [
-                        'orderbook/',
-                        'trades/',
-                        'ticker/',
+                        'orderbook',
+                        'ticker',
+                        'ticker_utc',
+                        'trades',
+                    ],
+                },
+                'v2Public': {
+                    'get': [
+                        'range_units',
+                        'markets/{quote_currency}',
+                        'markets/{quote_currency}/{target_currency}',
+                        'orderbook/{quote_currency}/{target_currency}',
+                        'trades/{quote_currency}/{target_currency}',
+                        'ticker_new/{quote_currency}',
+                        'ticker_new/{quote_currency}/{target_currency}',
+                        'ticker_utc_new/{quote_currency}',
+                        'ticker_utc_new/{quote_currency}/{target_currency}',
+                        'currencies',
+                        'currencies/{currency}',
+                        'chart/{quote_currency}/{target_currency}',
                     ],
                 },
                 'private': {
                     'post': [
-                        'account/deposit_address/',
-                        'account/btc_deposit_address/',
-                        'account/balance/',
-                        'account/daily_balance/',
-                        'account/user_info/',
-                        'account/virtual_account/',
-                        'order/cancel_all/',
-                        'order/cancel/',
-                        'order/limit_buy/',
-                        'order/limit_sell/',
-                        'order/complete_orders/',
-                        'order/limit_orders/',
-                        'order/query_order/',
-                        'transaction/auth_number/',
-                        'transaction/history/',
-                        'transaction/krw/history/',
-                        'transaction/btc/',
-                        'transaction/coin/',
+                        'account/deposit_address',
+                        'account/btc_deposit_address',
+                        'account/balance',
+                        'account/daily_balance',
+                        'account/user_info',
+                        'account/virtual_account',
+                        'order/cancel_all',
+                        'order/cancel',
+                        'order/limit_buy',
+                        'order/limit_sell',
+                        'order/complete_orders',
+                        'order/limit_orders',
+                        'order/order_info',
+                        'transaction/auth_number',
+                        'transaction/history',
+                        'transaction/krw/history',
+                        'transaction/btc',
+                        'transaction/coin',
+                    ],
+                },
+                'v2Private': {
+                    'post': [
+                        'account/balance',
+                        'account/deposit_address',
+                        'account/user_info',
+                        'account/virtual_account',
+                        'order/cancel',
+                        'order/limit_buy',
+                        'order/limit_sell',
+                        'order/limit_orders',
+                        'order/complete_orders',
+                        'order/query_order',
+                        'transaction/auth_number',
+                        'transaction/btc',
+                        'transaction/history',
+                        'transaction/krw/history',
+                    ],
+                },
+                'v2_1Private': {
+                    'post': [
+                        'account/balance/all',
+                        'account/balance',
+                        'account/trade_fee',
+                        'account/trade_fee/{quote_currency}/{target_currency}',
+                        'order/limit',
+                        'order/cancel',
+                        'order/cancel/all',
+                        'order/open_orders',
+                        'order/open_orders/all',
+                        'order/complete_orders',
+                        'order/complete_orders/all',
+                        'order/info',
+                        'transaction/krw/history',
+                        'transaction/coin/history',
+                        'transaction/coin/withdrawal/limit',
                     ],
                 },
             },
@@ -147,50 +205,124 @@ class coinone(Exchange, ImplicitAPI):
             },
         })
 
+    def fetch_currencies(self, params={}):
+        """
+        fetches all available currencies on an exchange
+        :see: https://docs.coinone.co.kr/reference/currencies
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an associative dictionary of currencies
+        """
+        response = self.v2PublicGetCurrencies(params)
+        #
+        #     {
+        #         "result": "success",
+        #         "error_code": "0",
+        #         "server_time": 1701054555578,
+        #         "currencies": [
+        #           {
+        #             "name": "Polygon",
+        #             "symbol": "MATIC",
+        #             "deposit_status": "normal",
+        #             "withdraw_status": "normal",
+        #             "deposit_confirm_count": 150,
+        #             "max_precision": 8,
+        #             "deposit_fee": "0.0",
+        #             "withdrawal_min_amount": "1.0",
+        #             "withdrawal_fee": "3.0"
+        #           }
+        #         ]
+        #     }
+        #
+        result = {}
+        currencies = self.safe_value(response, 'currencies', [])
+        for i in range(0, len(currencies)):
+            entry = currencies[i]
+            id = self.safe_string(entry, 'symbol')
+            name = self.safe_string(entry, 'name')
+            code = self.safe_currency_code(id)
+            withdrawStatus = self.safe_string(entry, 'withdraw_status', '')
+            depositStatus = self.safe_string(entry, 'deposit_status', '')
+            isWithdrawEnabled = withdrawStatus == 'normal'
+            isDepositEnabled = depositStatus == 'normal'
+            result[code] = {
+                'id': id,
+                'code': code,
+                'info': entry,
+                'name': name,
+                'active': isWithdrawEnabled and isDepositEnabled,
+                'deposit': isDepositEnabled,
+                'withdraw': isWithdrawEnabled,
+                'fee': self.safe_number(entry, 'withdrawal_fee'),
+                'precision': self.parse_number(self.parse_precision(self.safe_string(entry, 'max_precision'))),
+                'limits': {
+                    'amount': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'withdraw': {
+                        'min': self.safe_number(entry, 'withdrawal_min_amount'),
+                        'max': None,
+                    },
+                },
+                'networks': {},
+            }
+        return result
+
     def fetch_markets(self, params={}):
         """
         retrieves data on all markets for coinone
+        :see: https://docs.coinone.co.kr/v1.0/reference/tickers
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of objects representing market data
         """
         request = {
-            'currency': 'all',
+            'quote_currency': 'KRW',
         }
-        response = self.publicGetTicker(request)
-        #
-        #    {
-        #        "result": "success",
-        #        "errorCode": "0",
-        #        "timestamp": "1643676668",
-        #        "xec": {
-        #          "currency": "xec",
-        #          "first": "0.0914",
-        #          "low": "0.0894",
-        #          "high": "0.096",
-        #          "last": "0.0937",
-        #          "volume": "1673283662.9797",
-        #          "yesterday_first": "0.0929",
-        #          "yesterday_low": "0.0913",
-        #          "yesterday_high": "0.0978",
-        #          "yesterday_last": "0.0913",
-        #          "yesterday_volume": "1167285865.4571"
-        #        },
-        #        ...
-        #    }
+        response = self.v2PublicGetTickerNewQuoteCurrency(request)
         #
+        #     {
+        #         "result": "success",
+        #         "error_code": "0",
+        #         "server_time": 1701067923060,
+        #         "tickers": [
+        #             {
+        #                 "quote_currency": "krw",
+        #                 "target_currency": "stg",
+        #                 "timestamp": 1701067920001,
+        #                 "high": "667.5",
+        #                 "low": "667.5",
+        #                 "first": "667.5",
+        #                 "last": "667.5",
+        #                 "quote_volume": "0.0",
+        #                 "target_volume": "0.0",
+        #                 "best_asks": [
+        #                     {
+        #                         "price": "777.0",
+        #                         "qty": "73.9098"
+        #                     }
+        #                 ],
+        #                 "best_bids": [
+        #                     {
+        #                         "price": "690.8",
+        #                         "qty": "40.7768"
+        #                     }
+        #                 ],
+        #                 "id": "1701067920001001"
+        #             }
+        #         ]
+        #     }
+        #
+        tickers = self.safe_value(response, 'tickers', [])
         result = []
-        quoteId = 'krw'
-        quote = self.safe_currency_code(quoteId)
-        baseIds = list(response.keys())
-        for i in range(0, len(baseIds)):
-            baseId = baseIds[i]
-            ticker = self.safe_value(response, baseId, {})
-            currency = self.safe_value(ticker, 'currency')
-            if currency is None:
-                continue
+        for i in range(0, len(tickers)):
+            entry = self.safe_value(tickers, i)
+            id = self.safe_string(entry, 'id')
+            baseId = self.safe_string_upper(entry, 'target_currency')
+            quoteId = self.safe_string_upper(entry, 'quote_currency')
             base = self.safe_currency_code(baseId)
+            quote = self.safe_currency_code(quoteId)
             result.append({
-                'id': baseId,
+                'id': id,
                 'symbol': base + '/' + quote,
                 'base': base,
                 'quote': quote,
@@ -237,7 +369,7 @@ class coinone(Exchange, ImplicitAPI):
                     },
                 },
                 'created': None,
-                'info': ticker,
+                'info': entry,
             })
         return result
 
@@ -262,16 +394,18 @@ class coinone(Exchange, ImplicitAPI):
     def fetch_balance(self, params={}) -> Balances:
         """
         query for balance and get the amount of funds available for trading or funds locked in orders
+        :see: https://docs.coinone.co.kr/v1.0/reference/v21
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """
         self.load_markets()
-        response = self.privatePostAccountBalance(params)
+        response = self.v2PrivatePostAccountBalance(params)
         return self.parse_balance(response)
 
     def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :see: https://docs.coinone.co.kr/v1.0/reference/orderbook
         :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 dict [params]: extra parameters specific to the exchange API endpoint
@@ -280,16 +414,43 @@ class coinone(Exchange, ImplicitAPI):
         self.load_markets()
         market = self.market(symbol)
         request = {
-            'currency': market['id'],
-            'format': 'json',
+            'quote_currency': market['quote'],
+            'target_currency': market['base'],
         }
-        response = self.publicGetOrderbook(self.extend(request, params))
-        timestamp = self.safe_timestamp(response, 'timestamp')
-        return self.parse_order_book(response, market['symbol'], timestamp, 'bid', 'ask', 'price', 'qty')
+        if limit is not None:
+            request['size'] = limit  # only support 5, 10, 15, 16
+        response = self.v2PublicGetOrderbookQuoteCurrencyTargetCurrency(self.extend(request, params))
+        #
+        #     {
+        #         "result": "success",
+        #         "error_code": "0",
+        #         "timestamp": 1701071108673,
+        #         "id": "1701071108673001",
+        #         "quote_currency": "KRW",
+        #         "target_currency": "BTC",
+        #         "order_book_unit": "0.0",
+        #         "bids": [
+        #             {
+        #                 "price": "50048000",
+        #                 "qty": "0.01080229"
+        #             }
+        #         ],
+        #         "asks": [
+        #             {
+        #                 "price": "50058000",
+        #                 "qty": "0.00272592"
+        #             }
+        #         ]
+        #     }
+        #
+        timestamp = self.safe_integer(response, 'timestamp')
+        return self.parse_order_book(response, market['symbol'], timestamp, 'bids', 'asks', 'price', 'qty')
 
     def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
+        :see: https://docs.coinone.co.kr/v1.0/reference/tickers
+        :see: https://docs.coinone.co.kr/v1.0/reference/ticker
         :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -297,25 +458,58 @@ class coinone(Exchange, ImplicitAPI):
         self.load_markets()
         symbols = self.market_symbols(symbols)
         request = {
-            'currency': 'all',
-            'format': 'json',
+            'quote_currency': 'KRW',
         }
-        response = self.publicGetTicker(self.extend(request, params))
-        result = {}
-        ids = list(response.keys())
-        timestamp = self.safe_timestamp(response, 'timestamp')
-        for i in range(0, len(ids)):
-            id = ids[i]
-            market = self.safe_market(id)
-            symbol = market['symbol']
-            ticker = response[id]
-            result[symbol] = self.parse_ticker(ticker, market)
-            result[symbol]['timestamp'] = timestamp
-        return self.filter_by_array_tickers(result, 'symbol', symbols)
+        market = None
+        response = None
+        if symbols is not None:
+            first = self.safe_string(symbols, 0)
+            market = self.market(first)
+            request['quote_currency'] = market['quote']
+            request['target_currency'] = market['base']
+            response = self.v2PublicGetTickerNewQuoteCurrencyTargetCurrency(self.extend(request, params))
+        else:
+            response = self.v2PublicGetTickerNewQuoteCurrency(self.extend(request, params))
+        #
+        #     {
+        #         "result": "success",
+        #         "error_code": "0",
+        #         "server_time": 1701073358487,
+        #         "tickers": [
+        #             {
+        #                 "quote_currency": "krw",
+        #                 "target_currency": "btc",
+        #                 "timestamp": 1701073357818,
+        #                 "high": "50543000.0",
+        #                 "low": "49945000.0",
+        #                 "first": "50487000.0",
+        #                 "last": "50062000.0",
+        #                 "quote_volume": "11349804285.3859",
+        #                 "target_volume": "226.07268994",
+        #                 "best_asks": [
+        #                     {
+        #                         "price": "50081000.0",
+        #                         "qty": "0.18471358"
+        #                     }
+        #                 ],
+        #                 "best_bids": [
+        #                     {
+        #                         "price": "50062000.0",
+        #                         "qty": "0.04213455"
+        #                     }
+        #                 ],
+        #                 "id": "1701073357818001"
+        #             }
+        #         ]
+        #     }
+        #
+        data = self.safe_value(response, 'tickers', [])
+        return self.parse_tickers(data, symbols)
 
     def fetch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+        :see: https://docs.coinone.co.kr/v1.0/reference/ticker
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -323,53 +517,102 @@ class coinone(Exchange, ImplicitAPI):
         self.load_markets()
         market = self.market(symbol)
         request = {
-            'currency': market['id'],
-            'format': 'json',
+            'quote_currency': market['quote'],
+            'target_currency': market['base'],
         }
-        response = self.publicGetTicker(self.extend(request, params))
-        return self.parse_ticker(response, market)
+        response = self.v2PublicGetTickerNewQuoteCurrencyTargetCurrency(self.extend(request, params))
+        #
+        #     {
+        #         "result": "success",
+        #         "error_code": "0",
+        #         "server_time": 1701073358487,
+        #         "tickers": [
+        #             {
+        #                 "quote_currency": "krw",
+        #                 "target_currency": "btc",
+        #                 "timestamp": 1701073357818,
+        #                 "high": "50543000.0",
+        #                 "low": "49945000.0",
+        #                 "first": "50487000.0",
+        #                 "last": "50062000.0",
+        #                 "quote_volume": "11349804285.3859",
+        #                 "target_volume": "226.07268994",
+        #                 "best_asks": [
+        #                     {
+        #                         "price": "50081000.0",
+        #                         "qty": "0.18471358"
+        #                     }
+        #                 ],
+        #                 "best_bids": [
+        #                     {
+        #                         "price": "50062000.0",
+        #                         "qty": "0.04213455"
+        #                     }
+        #                 ],
+        #                 "id": "1701073357818001"
+        #             }
+        #         ]
+        #     }
+        #
+        data = self.safe_value(response, 'tickers', [])
+        ticker = self.safe_value(data, 0, {})
+        return self.parse_ticker(ticker, market)
 
     def parse_ticker(self, ticker, market: Market = None) -> Ticker:
         #
         #     {
-        #         "currency":"xec",
-        #         "first":"0.1069",
-        #         "low":"0.09",
-        #         "high":"0.1069",
-        #         "last":"0.0911",
-        #         "volume":"4591217267.4974",
-        #         "yesterday_first":"0.1128",
-        #         "yesterday_low":"0.1035",
-        #         "yesterday_high":"0.1167",
-        #         "yesterday_last":"0.1069",
-        #         "yesterday_volume":"4014832231.5102"
+        #         "quote_currency": "krw",
+        #         "target_currency": "btc",
+        #         "timestamp": 1701073357818,
+        #         "high": "50543000.0",
+        #         "low": "49945000.0",
+        #         "first": "50487000.0",
+        #         "last": "50062000.0",
+        #         "quote_volume": "11349804285.3859",
+        #         "target_volume": "226.07268994",
+        #         "best_asks": [
+        #             {
+        #                 "price": "50081000.0",
+        #                 "qty": "0.18471358"
+        #             }
+        #         ],
+        #         "best_bids": [
+        #             {
+        #                 "price": "50062000.0",
+        #                 "qty": "0.04213455"
+        #             }
+        #         ],
+        #         "id": "1701073357818001"
         #     }
         #
-        timestamp = self.safe_timestamp(ticker, 'timestamp')
-        open = self.safe_string(ticker, 'first')
+        timestamp = self.safe_integer(ticker, 'timestamp')
         last = self.safe_string(ticker, 'last')
-        previousClose = self.safe_string(ticker, 'yesterday_last')
-        symbol = self.safe_symbol(None, market)
+        asks = self.safe_value(ticker, 'best_asks')
+        bids = self.safe_value(ticker, 'best_bids')
+        baseId = self.safe_string(ticker, 'target_currency')
+        quoteId = self.safe_string(ticker, 'quote_currency')
+        base = self.safe_currency_code(baseId)
+        quote = self.safe_currency_code(quoteId)
         return self.safe_ticker({
-            'symbol': symbol,
+            'symbol': base + '/' + quote,
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'high': self.safe_string(ticker, 'high'),
             'low': self.safe_string(ticker, 'low'),
-            'bid': None,
-            'bidVolume': None,
-            'ask': None,
-            'askVolume': None,
+            'bid': self.safe_string(bids, 'price'),
+            'bidVolume': self.safe_string(bids, 'qty'),
+            'ask': self.safe_string(asks, 'price'),
+            'askVolume': self.safe_string(asks, 'qty'),
             'vwap': None,
-            'open': open,
+            'open': self.safe_string(ticker, 'first'),
             'close': last,
             'last': last,
-            'previousClose': previousClose,
+            'previousClose': None,
             'change': None,
             'percentage': None,
             'average': None,
-            'baseVolume': self.safe_string(ticker, 'volume'),
-            'quoteVolume': None,
+            'baseVolume': self.safe_string(ticker, 'target_volume'),
+            'quoteVolume': self.safe_string(ticker, 'quote_volume'),
             'info': ticker,
         }, market)
 
@@ -378,10 +621,11 @@ class coinone(Exchange, ImplicitAPI):
         # fetchTrades(public)
         #
         #     {
-        #         "timestamp": "1416893212",
-        #         "price": "420000.0",
-        #         "qty": "0.1",
-        #         "is_ask": "1"
+        #         "id": "1701075265708001",
+        #         "timestamp": 1701075265708,
+        #         "price": "50020000",
+        #         "qty": "0.00155177",
+        #         "is_seller_maker": False
         #     }
         #
         # fetchMyTrades(private)
@@ -396,20 +640,12 @@ class coinone(Exchange, ImplicitAPI):
         #         "orderId": "E84A1AC2-8088-4FA0-B093-A3BCDB9B3C85"
         #     }
         #
-        timestamp = self.safe_timestamp(trade, 'timestamp')
+        timestamp = self.safe_integer(trade, 'timestamp')
         market = self.safe_market(None, market)
-        is_ask = self.safe_string(trade, 'is_ask')
-        side = self.safe_string(trade, 'type')
-        if is_ask is not None:
-            if is_ask == '1':
-                side = 'sell'
-            elif is_ask == '0':
-                side = 'buy'
-        else:
-            if side == 'ask':
-                side = 'sell'
-            elif side == 'bid':
-                side = 'buy'
+        isSellerMaker = self.safe_value(trade, 'is_seller_maker')
+        side = None
+        if isSellerMaker is not None:
+            side = 'sell' if isSellerMaker else 'buy'
         priceString = self.safe_string(trade, 'price')
         amountString = self.safe_string(trade, 'qty')
         orderId = self.safe_string(trade, 'orderId')
@@ -444,6 +680,7 @@ class coinone(Exchange, ImplicitAPI):
     def fetch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
+        :see: https://docs.coinone.co.kr/v1.0/reference/recent-completed-orders
         :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
@@ -453,28 +690,32 @@ class coinone(Exchange, ImplicitAPI):
         self.load_markets()
         market = self.market(symbol)
         request = {
-            'currency': market['id'],
-            'format': 'json',
+            'quote_currency': market['quote'],
+            'target_currency': market['base'],
         }
-        response = self.publicGetTrades(self.extend(request, params))
+        if limit is not None:
+            request['size'] = limit  # only support 10, 50, 100, 150, 200
+        response = self.v2PublicGetTradesQuoteCurrencyTargetCurrency(self.extend(request, params))
         #
         #     {
         #         "result": "success",
-        #         "errorCode": "0",
-        #         "timestamp": "1416895635",
-        #         "currency": "btc",
-        #         "completeOrders": [
+        #         "error_code": "0",
+        #         "server_time": 1701075315771,
+        #         "quote_currency": "KRW",
+        #         "target_currency": "BTC",
+        #         "transactions": [
         #             {
-        #                 "timestamp": "1416893212",
-        #                 "price": "420000.0",
-        #                 "qty": "0.1",
-        #                 "is_ask": "1"
+        #                 "id": "1701075265708001",
+        #                 "timestamp": 1701075265708,
+        #                 "price": "50020000",
+        #                 "qty": "0.00155177",
+        #                 "is_seller_maker": False
         #             }
         #         ]
         #     }
         #
-        completeOrders = self.safe_value(response, 'completeOrders', [])
-        return self.parse_trades(completeOrders, market, since, limit)
+        data = self.safe_value(response, 'transactions', [])
+        return self.parse_trades(data, market, since, limit)
 
     def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
         """
@@ -524,7 +765,7 @@ class coinone(Exchange, ImplicitAPI):
             'order_id': id,
             'currency': market['id'],
         }
-        response = self.privatePostOrderQueryOrder(self.extend(request, params))
+        response = self.v2PrivatePostOrderQueryOrder(self.extend(request, params))
         #
         #     {
         #         "result": "success",
@@ -720,7 +961,7 @@ class coinone(Exchange, ImplicitAPI):
         request = {
             'currency': market['id'],
         }
-        response = self.privatePostOrderCompleteOrders(self.extend(request, params))
+        response = self.v2PrivatePostOrderCompleteOrders(self.extend(request, params))
         #
         # despite the name of the endpoint it returns trades which may have a duplicate orderId
         # https://github.com/ccxt/ccxt/pull/7067
@@ -769,7 +1010,7 @@ class coinone(Exchange, ImplicitAPI):
             'is_ask': isAsk,
             'currency': self.market_id(symbol),
         }
-        response = self.privatePostOrderCancel(self.extend(request, params))
+        response = self.v2PrivatePostOrderCancel(self.extend(request, params))
         #
         #     {
         #         "result": "success",
@@ -786,7 +1027,7 @@ class coinone(Exchange, ImplicitAPI):
         :returns dict: a list of `address structures <https://docs.ccxt.com/#/?id=address-structure>`
         """
         self.load_markets()
-        response = self.privatePostAccountDepositAddress(params)
+        response = self.v2PrivatePostAccountDepositAddress(params)
         #
         #     {
         #         "result": "success",
@@ -835,13 +1076,20 @@ class coinone(Exchange, ImplicitAPI):
         request = self.implode_params(path, params)
         query = self.omit(params, self.extract_params(path))
         url = self.urls['api']['rest'] + '/'
+        if api == 'v2Public':
+            url = self.urls['api']['v2Public'] + '/'
+            api = 'public'
+        elif api == 'v2Private':
+            url = self.urls['api']['v2Private'] + '/'
+        elif api == 'v2_1Private':
+            url = self.urls['api']['v2_1Private'] + '/'
         if api == 'public':
             url += request
             if query:
                 url += '?' + self.urlencode(query)
         else:
             self.check_required_credentials()
-            url += self.version + '/' + request
+            url += request
             nonce = str(self.nonce())
             json = self.json(self.extend({
                 'access_token': self.apiKey,