ccxt 4.3.44__py2.py3-none-any.whl → 4.3.45__py2.py3-none-any.whl

ccxt/async_support/wavesexchange.py

@@ -21,7 +21,7 @@ from ccxt.base.errors import InvalidOrder
 from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import DuplicateOrderId
 from ccxt.base.errors import ExchangeNotAvailable
-from ccxt.base.decimal_to_precision import DECIMAL_PLACES
+from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise
 
 
@@ -329,9 +329,9 @@ class wavesexchange(Exchange, ImplicitAPI):
                 },
             },
             'currencies': {
-                'WX': self.safe_currency_structure({'id': 'EMAMLxDnv3xiz8RXg8Btj33jcEw3wLczL3JKYYmuubpc', 'numericId': None, 'code': 'WX', 'precision': self.parse_to_int('8')}),
+                'WX': self.safe_currency_structure({'id': 'EMAMLxDnv3xiz8RXg8Btj33jcEw3wLczL3JKYYmuubpc', 'numericId': None, 'code': 'WX', 'precision': self.parse_number('1e-8')}),
             },
-            'precisionMode': DECIMAL_PLACES,
+            'precisionMode': TICK_SIZE,
             'options': {
                 'allowedCandles': 1440,
                 'accessToken': None,
@@ -342,7 +342,7 @@ class wavesexchange(Exchange, ImplicitAPI):
                 'wavesAddress': None,
                 'withdrawFeeUSDN': 7420,
                 'withdrawFeeWAVES': 100000,
-                'wavesPrecision': 8,
+                'wavesPrecision': 1e-8,
                 'messagePrefix': 'W',  # W for production, T for testnet
                 'networks': {
                     'ERC20': 'ETH',
@@ -390,8 +390,8 @@ class wavesexchange(Exchange, ImplicitAPI):
     async def get_fees_for_asset(self, symbol: str, side, amount, price, params={}):
         await self.load_markets()
         market = self.market(symbol)
-        amount = self.custom_amount_to_precision(symbol, amount)
-        price = self.custom_price_to_precision(symbol, price)
+        amount = self.to_real_symbol_amount(symbol, amount)
+        price = self.to_real_symbol_price(symbol, price)
         request = self.extend({
             'baseId': market['baseId'],
             'quoteId': market['quoteId'],
@@ -422,7 +422,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         matcherFee = self.safe_string(mode, 'matcherFee')
         feeAssetId = self.safe_string(mode, 'feeAssetId')
         feeAsset = self.safe_currency_code(feeAssetId)
-        adjustedMatcherFee = self.currency_from_precision(feeAsset, matcherFee)
+        adjustedMatcherFee = self.from_real_currency_amount(feeAsset, matcherFee)
         amountAsString = self.number_to_string(amount)
         priceAsString = self.number_to_string(price)
         feeCost = self.fee_to_precision(symbol, self.parse_number(adjustedMatcherFee))
@@ -570,8 +570,8 @@ class wavesexchange(Exchange, ImplicitAPI):
                 'strike': None,
                 'optionType': None,
                 'precision': {
-                    'amount': self.safe_integer(entry, 'amountAssetDecimals'),
-                    'price': self.safe_integer(entry, 'priceAssetDecimals'),
+                    'amount': self.parse_number(self.parse_precision(self.safe_string(entry, 'amountAssetDecimals'))),
+                    'price': self.parse_number(self.parse_precision(self.safe_string(entry, 'priceAssetDecimals'))),
                 },
                 'limits': {
                     'leverage': {
@@ -625,12 +625,11 @@ class wavesexchange(Exchange, ImplicitAPI):
 
     def parse_order_book_side(self, bookSide, market=None, limit: Int = None):
         precision = market['precision']
-        wavesPrecision = self.safe_string(self.options, 'wavesPrecision', '8')
-        amountPrecision = '1e' + self.number_to_string(precision['amount'])
-        amountPrecisionString = self.number_to_string(precision['amount'])
-        pricePrecisionString = self.number_to_string(precision['price'])
-        difference = Precise.string_sub(amountPrecisionString, pricePrecisionString)
-        pricePrecision = '1e' + Precise.string_sub(wavesPrecision, difference)
+        wavesPrecision = self.safe_string(self.options, 'wavesPrecision', '1e-8')
+        amountPrecisionString = self.safe_string(precision, 'amount')
+        pricePrecisionString = self.safe_string(precision, 'price')
+        difference = Precise.string_div(amountPrecisionString, pricePrecisionString)
+        pricePrecision = Precise.string_div(wavesPrecision, difference)
         result = []
         for i in range(0, len(bookSide)):
             entry = bookSide[i]
@@ -639,9 +638,9 @@ class wavesexchange(Exchange, ImplicitAPI):
             price = None
             amount = None
             if (pricePrecision is not None) and (entryPrice is not None):
-                price = Precise.string_div(entryPrice, pricePrecision)
-            if (amountPrecision is not None) and (entryAmount is not None):
-                amount = Precise.string_div(entryAmount, amountPrecision)
+                price = Precise.string_mul(entryPrice, pricePrecision)
+            if (amountPrecisionString is not None) and (entryAmount is not None):
+                amount = Precise.string_mul(entryAmount, amountPrecisionString)
             if (limit is not None) and (i > limit):
                 break
             result.append([
@@ -1171,50 +1170,35 @@ class wavesexchange(Exchange, ImplicitAPI):
             return ''
         return currencyId
 
-    def custom_price_to_precision(self, symbol, price):
-        market = self.markets[symbol]
-        wavesPrecision = self.safe_string(self.options, 'wavesPrecision', '8')
-        amount = self.number_to_string(market['precision']['amount'])
-        precisionPrice = self.number_to_string(market['precision']['price'])
-        difference = Precise.string_sub(amount, precisionPrice)
-        precision = Precise.string_sub(wavesPrecision, difference)
-        pricePrecision = self.to_precision(price, str(precision))
-        return self.parse_to_int(float(pricePrecision))
-
-    def custom_amount_to_precision(self, symbol, amount):
-        amountPrecision = self.number_to_string(self.to_precision(amount, self.number_to_string(self.markets[symbol]['precision']['amount'])))
-        return self.parse_to_int(float(amountPrecision))
+    def to_real_currency_amount(self, code: str, amount: float, networkCode=None):
+        currency = self.currency(code)
+        stringValue = Precise.string_div(self.number_to_string(amount), self.safe_string(currency, 'precision'))
+        return int(stringValue)
 
-    def custom_currency_to_precision(self, code, amount, networkCode=None):
-        amountPrecision = self.number_to_string(self.to_precision(amount, self.currencies[code]['precision']))
-        return self.parse_to_int(float(amountPrecision))
+    def from_real_currency_amount(self, code: str, amountString: str):
+        if not (code in self.currencies):
+            return amountString
+        currency = self.currency(code)
+        precisionAmount = self.safe_string(currency, 'precision')
+        return Precise.string_mul(amountString, precisionAmount)
 
-    def from_precision(self, amount, scale):
-        if amount is None:
-            return None
-        precise = Precise(amount)
-        precise.decimals = self.sum(precise.decimals, scale)
-        precise.reduce()
-        return str(precise)
+    def to_real_symbol_price(self, symbol: str, price: float):
+        market = self.market(symbol)
+        stringValue = Precise.string_div(self.number_to_string(price), self.safe_string(market['precision'], 'price'))
+        return int(stringValue)
 
-    def to_precision(self, amount, scale):
-        amountString = self.number_to_string(amount)
-        precise = Precise(amountString)
-        # precise.decimals should be integer
-        precise.decimals = self.parse_to_int(Precise.string_sub(self.number_to_string(precise.decimals), self.number_to_string(scale)))
-        precise.reduce()
-        stringValue = str(precise)
-        return stringValue
+    def from_real_symbol_price(self, symbol: str, priceString: str):
+        market = self.markets[symbol]
+        return Precise.string_mul(priceString, self.safe_string(market['precision'], 'price'))
 
-    def currency_from_precision(self, currency, amount):
-        scale = self.currencies[currency]['precision']
-        return self.from_precision(amount, scale)
+    def to_real_symbol_amount(self, symbol: str, amount: float):
+        market = self.market(symbol)
+        stringValue = Precise.string_div(self.number_to_string(amount), self.safe_string(market['precision'], 'amount'))
+        return int(stringValue)
 
-    def price_from_precision(self, symbol, price):
+    def from_real_symbol_amount(self, symbol: str, amountString: str):
         market = self.markets[symbol]
-        wavesPrecision = self.safe_integer(self.options, 'wavesPrecision', 8)
-        scale = self.sum(wavesPrecision, market['precision']['price']) - market['precision']['amount']
-        return self.from_precision(price, scale)
+        return Precise.string_mul(amountString, market['precision']['amount'])
 
     def safe_get_dynamic(self, settings):
         orderFee = self.safe_value(settings, 'orderFee')
@@ -1288,26 +1272,26 @@ class wavesexchange(Exchange, ImplicitAPI):
                 raise InvalidOrder(self.id + ' asset fee must be ' + baseFeeAsset + ' or ' + discountFeeAsset)
             matcherFeeAsset = self.safe_currency_code(matcherFeeAssetId)
             rawMatcherFee = baseMatcherFee if (matcherFeeAssetId == baseFeeAssetId) else discountMatcherFee
-            floatMatcherFee = float(self.currency_from_precision(matcherFeeAsset, rawMatcherFee))
+            floatMatcherFee = float(self.from_real_currency_amount(matcherFeeAsset, rawMatcherFee))
             if (matcherFeeAsset in balances) and (balances[matcherFeeAsset]['free'] >= floatMatcherFee):
                 matcherFee = int(rawMatcherFee)
             else:
                 raise InsufficientFunds(self.id + ' not enough funds of the selected asset fee')
+        floatBaseMatcherFee = self.from_real_currency_amount(baseFeeAsset, baseMatcherFee)
+        floatDiscountMatcherFee = self.from_real_currency_amount(discountFeeAsset, discountMatcherFee)
         if matcherFeeAssetId is None:
             # try to the pay the fee using the base first then discount asset
-            floatBaseMatcherFee = float(self.currency_from_precision(baseFeeAsset, baseMatcherFee))
-            if (baseFeeAsset in balances) and (balances[baseFeeAsset]['free'] >= floatBaseMatcherFee):
+            if (baseFeeAsset in balances) and (balances[baseFeeAsset]['free'] >= float(floatBaseMatcherFee)):
                 matcherFeeAssetId = baseFeeAssetId
                 matcherFee = int(baseMatcherFee)
             else:
-                floatDiscountMatcherFee = float(self.currency_from_precision(discountFeeAsset, discountMatcherFee))
-                if (discountFeeAsset in balances) and (balances[discountFeeAsset]['free'] >= floatDiscountMatcherFee):
+                if (discountFeeAsset in balances) and (balances[discountFeeAsset]['free'] >= float(floatDiscountMatcherFee)):
                     matcherFeeAssetId = discountFeeAssetId
                     matcherFee = int(discountMatcherFee)
         if matcherFeeAssetId is None:
-            raise InsufficientFunds(self.id + ' not enough funds on none of the eligible asset fees')
-        amount = self.custom_amount_to_precision(symbol, amount)
-        price = self.custom_price_to_precision(symbol, price)
+            raise InsufficientFunds(self.id + ' not enough funds on none of the eligible asset fees: ' + baseFeeAsset + ' ' + floatBaseMatcherFee + ' or ' + discountFeeAsset + ' ' + floatDiscountMatcherFee)
+        amount = self.to_real_symbol_amount(symbol, amount)
+        price = self.to_real_symbol_price(symbol, price)
         assetPair: dict = {
             'amountAsset': amountAsset,
             'priceAsset': priceAsset,
@@ -1345,7 +1329,7 @@ class wavesexchange(Exchange, ImplicitAPI):
                 'c': {
                     't': 'sp',
                     'v': {
-                        'p': self.custom_price_to_precision(symbol, stopPrice),
+                        'p': self.to_real_symbol_price(symbol, stopPrice),
                     },
                 },
             }
@@ -1671,23 +1655,23 @@ class wavesexchange(Exchange, ImplicitAPI):
         elif market is not None:
             symbol = market['symbol']
         amountCurrency = self.safe_currency_code(self.safe_string(assetPair, 'amountAsset', 'WAVES'))
-        price = self.price_from_precision(symbol, priceString)
-        amount = self.currency_from_precision(amountCurrency, amountString)
-        filled = self.currency_from_precision(amountCurrency, filledString)
-        average = self.price_from_precision(symbol, self.safe_string(order, 'avgWeighedPrice'))
+        price = self.from_real_symbol_price(symbol, priceString)
+        amount = self.from_real_currency_amount(amountCurrency, amountString)
+        filled = self.from_real_currency_amount(amountCurrency, filledString)
+        average = self.from_real_symbol_price(symbol, self.safe_string(order, 'avgWeighedPrice'))
         status = self.parse_order_status(self.safe_string(order, 'status'))
         fee = None
         if 'type' in order:
-            currency = self.safe_currency_code(self.safe_string(order, 'feeAsset'))
+            code = self.safe_currency_code(self.safe_string(order, 'feeAsset'))
             fee = {
-                'currency': currency,
-                'fee': self.parse_number(self.currency_from_precision(currency, self.safe_string(order, 'filledFee'))),
+                'currency': code,
+                'fee': self.parse_number(self.from_real_currency_amount(code, self.safe_string(order, 'filledFee'))),
             }
         else:
-            currency = self.safe_currency_code(self.safe_string(order, 'matcherFeeAssetId', 'WAVES'))
+            code = self.safe_currency_code(self.safe_string(order, 'matcherFeeAssetId', 'WAVES'))
             fee = {
-                'currency': currency,
-                'fee': self.parse_number(self.currency_from_precision(currency, self.safe_string(order, 'matcherFee'))),
+                'currency': code,
+                'fee': self.parse_number(self.from_real_currency_amount(code, self.safe_string(order, 'matcherFee'))),
             }
         triggerPrice = None
         attachment = self.safe_string(order, 'attachment')
@@ -1802,16 +1786,14 @@ class wavesexchange(Exchange, ImplicitAPI):
             issueTransaction = self.safe_value(entry, 'issueTransaction')
             currencyId = self.safe_string(entry, 'assetId')
             balance = self.safe_string(entry, 'balance')
-            if issueTransaction is None:
-                assetIds.append(currencyId)
-                nonStandardBalances.append(balance)
-                continue
-            decimals = self.safe_integer(issueTransaction, 'decimals')
-            code = None
-            if currencyId in self.currencies_by_id:
+            currencyExists = (currencyId in self.currencies_by_id)
+            if currencyExists:
                 code = self.safe_currency_code(currencyId)
                 result[code] = self.account()
-                result[code]['total'] = self.from_precision(balance, decimals)
+                result[code]['total'] = self.from_real_currency_amount(code, balance)
+            elif issueTransaction is None:
+                assetIds.append(currencyId)
+                nonStandardBalances.append(balance)
         nonStandardAssets = len(assetIds)
         if nonStandardAssets:
             requestInner: dict = {
@@ -1823,11 +1805,11 @@ class wavesexchange(Exchange, ImplicitAPI):
                 entry = data[i]
                 balance = nonStandardBalances[i]
                 inner = self.safe_value(entry, 'data')
-                decimals = self.safe_integer(inner, 'precision')
+                precision = self.parse_precision(self.safe_string(inner, 'precision'))
                 ticker = self.safe_string(inner, 'ticker')
                 code = self.safe_currency_code(ticker)
                 result[code] = self.account()
-                result[code]['total'] = self.from_precision(balance, decimals)
+                result[code]['total'] = Precise.string_mul(balance, precision)
         currentTimestamp = self.milliseconds()
         byteArray = [
             self.base58_to_binary(self.apiKey),
@@ -1850,10 +1832,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             if not (code in result):
                 result[code] = self.account()
             amount = self.safe_string(reservedBalance, currencyId)
-            if code in self.currencies:
-                result[code]['used'] = self.currency_from_precision(code, amount)
-            else:
-                result[code]['used'] = amount
+            result[code]['used'] = self.from_real_currency_amount(code, amount)
         wavesRequest: dict = {
             'address': wavesAddress,
         }
@@ -1863,17 +1842,21 @@ class wavesexchange(Exchange, ImplicitAPI):
         #   "confirmations": 0,
         #   "balance": 909085978
         # }
-        result['WAVES'] = self.safe_value(result, 'WAVES', {})
-        result['WAVES']['total'] = self.currency_from_precision('WAVES', self.safe_string(wavesTotal, 'balance'))
-        codes = list(result.keys())
-        for i in range(0, len(codes)):
-            code = codes[i]
-            if self.safe_value(result[code], 'used') is None:
-                result[code]['used'] = '0'
+        result['WAVES'] = self.safe_value(result, 'WAVES', self.account())
+        result['WAVES']['total'] = self.from_real_currency_amount('WAVES', self.safe_string(wavesTotal, 'balance'))
+        result = self.set_undefined_balances_to_zero(result)
         result['timestamp'] = timestamp
         result['datetime'] = self.iso8601(timestamp)
         return self.safe_balance(result)
 
+    def set_undefined_balances_to_zero(self, balances, key='used'):
+        codes = list(balances.keys())
+        for i in range(0, len(codes)):
+            code = codes[i]
+            if self.safe_value(balances[code], 'used') is None:
+                balances[code][key] = '0'
+        return balances
+
     async def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetch all trades made by the user
@@ -2374,7 +2357,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         feeAssetId = 'WAVES'
         type = 4  # transfer
         version = 2
-        amountInteger = self.custom_currency_to_precision(code, amount)
+        amountInteger = self.to_real_currency_amount(code, amount)
         currency = self.currency(code)
         timestamp = self.milliseconds()
         byteArray = [
@@ -2434,18 +2417,45 @@ class wavesexchange(Exchange, ImplicitAPI):
         #         "amount": 0
         #     }
         #
+        # withdraw new:
+        #     {
+        #         type: "4",
+        #         id: "2xnWTqG9ar7jEDrLxfbVyyspPZ6XZNrrw9ai9sQ81Eya",
+        #         fee: "100000",
+        #         feeAssetId: null,
+        #         timestamp: "1715786263807",
+        #         version: "2",
+        #         sender: "3P81LLX1kk2CSJC9L8C2enxdHB7XvnSGAEE",
+        #         senderPublicKey: "DdmzmXf9mty1FBE8AdVGnrncVLEAzP4gR4nWoTFAJoXz",
+        #         proofs: ["RyoKwdSYv3EqotJCYftfFM9JE2j1ZpDRxKwYfiRhLAFeyNp6VfJUXNDS884XfeCeHeNypNmTCZt5NYR1ekyjCX3",],
+        #         recipient: "3P9tXxu38a8tgewNEKFzourVxeqHd11ppOc",
+        #         assetId: null,
+        #         feeAsset: null,
+        #         amount: "2000000",
+        #         attachment: "",
+        #     }
+        #
         currency = self.safe_currency(None, currency)
+        code = currency['code']
+        typeRaw = self.safe_string(transaction, 'type')
+        type = 'withdraw' if (typeRaw == '4') else 'deposit'
+        amount = self.parse_number(self.from_real_currency_amount(code, self.safe_string(transaction, 'amount')))
+        feeString = self.safe_string(transaction, 'fee')
+        feeAssetId = self.safe_string(transaction, 'feeAssetId', 'WAVES')
+        feeCode = self.safe_currency_code(feeAssetId)
+        feeAmount = self.parse_number(self.from_real_currency_amount(feeCode, feeString))
+        timestamp = self.safe_integer(transaction, 'timestamp')
         return {
-            'id': None,
+            'id': self.safe_string(transaction, 'id'),
             'txid': None,
-            'timestamp': None,
-            'datetime': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
             'network': None,
-            'addressFrom': None,
+            'addressFrom': self.safe_string(transaction, 'sender'),
             'address': None,
-            'addressTo': None,
-            'amount': None,
-            'type': None,
+            'addressTo': self.safe_string(transaction, 'recipient'),
+            'amount': amount,
+            'type': type,
             'currency': currency['code'],
             'status': None,
             'updated': None,
@@ -2454,6 +2464,9 @@ class wavesexchange(Exchange, ImplicitAPI):
             'tagTo': None,
             'comment': None,
             'internal': None,
-            'fee': None,
+            'fee': {
+                'currency': feeCode,
+                'cost': feeAmount,
+            },
             'info': transaction,
         }

ccxt/async_support/xt.py

@@ -39,7 +39,7 @@ class xt(Exchange, ImplicitAPI):
             # futures 1000 times per minute for each single IP -> Otherwise account locked for 10min
             'rateLimit': 100,
             'version': 'v4',
-            'certified': True,
+            'certified': False,
             'pro': False,
             'has': {
                 'CORS': False,

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.44'
+__version__ = '4.3.45'
 
 # -----------------------------------------------------------------------------
 

ccxt/bitstamp.py

@@ -232,7 +232,7 @@ class bitstamp(Exchange, ImplicitAPI):
                         'uni_withdrawal/': 1,
                         'uni_address/': 1,
                         'yfi_withdrawal/': 1,
-                        'yfi_address': 1,
+                        'yfi_address/': 1,
                         'audio_withdrawal/': 1,
                         'audio_address/': 1,
                         'crv_withdrawal/': 1,
@@ -241,7 +241,7 @@ class bitstamp(Exchange, ImplicitAPI):
                         'algo_address/': 1,
                         'comp_withdrawal/': 1,
                         'comp_address/': 1,
-                        'grt_withdrawal': 1,
+                        'grt_withdrawal/': 1,
                         'grt_address/': 1,
                         'usdt_withdrawal/': 1,
                         'usdt_address/': 1,
@@ -379,6 +379,22 @@ class bitstamp(Exchange, ImplicitAPI):
                         'vchf_address/': 1,
                         'veur_withdrawal/': 1,
                         'veur_address/': 1,
+                        'truf_withdrawal/': 1,
+                        'truf_address/': 1,
+                        'wif_withdrawal/': 1,
+                        'wif_address/': 1,
+                        'smt_withdrawal/': 1,
+                        'smt_address/': 1,
+                        'sui_withdrawal/': 1,
+                        'sui_address/': 1,
+                        'jup_withdrawal/': 1,
+                        'jup_address/': 1,
+                        'ondo_withdrawal/': 1,
+                        'ondo_address/': 1,
+                        'boba_withdrawal/': 1,
+                        'boba_address/': 1,
+                        'pyth_withdrawal/': 1,
+                        'pyth_address/': 1,
                     },
                 },
             },

ccxt/kucoin.py

@@ -140,6 +140,7 @@ class kucoin(Exchange, ImplicitAPI):
                     'futuresPublic': 'https://api-futures.kucoin.com',
                     'webExchange': 'https://kucoin.com/_api',
                     'broker': 'https://api-broker.kucoin.com',
+                    'earn': 'https://api.kucoin.com',
                 },
                 'www': 'https://www.kucoin.com',
                 'doc': [
@@ -407,6 +408,9 @@ class kucoin(Exchange, ImplicitAPI):
                         'broker/nd/account': 2,
                         'broker/nd/account/apikey': 2,
                         'broker/nd/rebase/download': 3,
+                        'broker/nd/transfer/detail': 1,
+                        'broker/nd/deposit/detail': 1,
+                        'broker/nd/withdraw/detail': 1,
                     },
                     'post': {
                         'broker/nd/transfer': 1,
@@ -418,6 +422,25 @@ class kucoin(Exchange, ImplicitAPI):
                         'broker/nd/account/apikey': 3,
                     },
                 },
+                'earn': {
+                    'get': {
+                        'otc-loan/loan': 1,
+                        'otc-loan/accounts': 1,
+                        'earn/redeem-preview': 7.5,  # 5EW
+                        'earn/saving/products': 7.5,  # 5EW
+                        'earn/hold-assets': 7.5,  # 5EW
+                        'earn/promotion/products': 7.5,  # 5EW
+                        'earn/kcs-staking/products': 7.5,  # 5EW
+                        'earn/staking/products': 7.5,  # 5EW
+                        'earn/eth-staking/products': 7.5,  # 5EW
+                    },
+                    'post': {
+                        'earn/orders': 7.5,  # 5EW
+                    },
+                    'delete': {
+                        'earn/orders': 7.5,  # 5EW
+                    },
+                },
             },
             'timeframes': {
                 '1m': '1min',
@@ -4506,6 +4529,8 @@ class kucoin(Exchange, ImplicitAPI):
         endpoint = '/api/' + version + '/' + self.implode_params(path, params)
         if api == 'webExchange':
             endpoint = '/' + self.implode_params(path, params)
+        if api == 'earn':
+            endpoint = '/api/v1/' + self.implode_params(path, params)
         query = self.omit(params, self.extract_params(path))
         endpart = ''
         headers = headers if (headers is not None) else {}
@@ -4521,7 +4546,8 @@ class kucoin(Exchange, ImplicitAPI):
         isFuturePrivate = (api == 'futuresPrivate')
         isPrivate = (api == 'private')
         isBroker = (api == 'broker')
-        if isPrivate or isFuturePrivate or isBroker:
+        isEarn = (api == 'earn')
+        if isPrivate or isFuturePrivate or isBroker or isEarn:
             self.check_required_credentials()
             timestamp = str(self.nonce())
             headers = self.extend({

ccxt/luno.py

@@ -897,7 +897,15 @@ class luno(Exchange, ImplicitAPI):
         request: dict = {
             'order_id': id,
         }
-        return self.privatePostStoporder(self.extend(request, params))
+        response = self.privatePostStoporder(self.extend(request, params))
+        #
+        #    {
+        #        "success": True
+        #    }
+        #
+        return self.safe_order({
+            'info': response,
+        })
 
     def fetch_ledger_by_entries(self, code: Str = None, entry=None, limit=None, params={}):
         # by default without entry number or limit number, return most recent entry