ccxt 4.4.82__py2.py3-none-any.whl → 4.4.85__py2.py3-none-any.whl

ccxt/ellipx.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.ellipx import ImplicitAPI
 import math
-from ccxt.base.types import Any, Balances, Currencies, Currency, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Ticker, Trade, TradingFeeInterface, Transaction
+from ccxt.base.types import Any, Balances, Currencies, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Ticker, Trade, TradingFeeInterface, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -799,80 +799,178 @@ class ellipx(Exchange, ImplicitAPI):
             'results_per_page': 100,
             '_expand': '/Crypto_Token,/Crypto_Chain',
         }, params))
-        currencies = {}
-        data = self.safe_value(response, 'data', [])
+        result = {}
+        data = self.safe_list(response, 'data', [])
         for i in range(0, len(data)):
-            currency = self.parse_currency(data[i])
-            code = self.safe_string(currency, 'code')
-            if code is not None:
-                currencies[code] = currency
-        return currencies
-
-    def parse_currency(self, currency) -> Currency:
-        id = self.safe_string(currency, 'Crypto_Token__')
-        token = self.safe_value(currency, 'Crypto_Token', {})
-        code = self.safe_currency_code(self.safe_string(token, 'Symbol'))
-        name = self.safe_string(token, 'Name')
-        active = self.safe_string(currency, 'Status') == 'valid'
-        deposit = self.safe_string(currency, 'Can_Deposit') == 'Y'
-        withdraw = self.safe_string(currency, 'Status') == 'valid'
-        fee = None
-        if currency['Withdraw_Fee'] is not None:
-            fee = self.parse_number(self.parse_amount(currency['Withdraw_Fee']))
-        precision = self.parse_number(self.parse_precision(self.safe_string(token, 'Decimals')))
-        minDeposit = None
-        if currency['Minimum_Deposit'] is not None:
-            minDeposit = self.parse_amount(currency['Minimum_Deposit'])
-        minWithdraw = None
-        if currency['Minimum_Withdraw'] is not None:
-            minWithdraw = self.parse_amount(currency['Minimum_Withdraw'])
-        networkId = self.safe_string(currency, 'Crypto_Chain__')
-        networkData = self.safe_value(currency, 'Crypto_Chain', {})
-        networkCode = self.safe_string(networkData, 'Type', 'default')
-        networks = {
-            'string': None,
-            'info': networkCode == {} if 'default' else networkData,
-            'id': networkId or id or '',
-            'network': networkCode,
-            'active': active,
-            'deposit': deposit,
-            'withdraw': withdraw,
-            'fee': fee,
-            'precision': precision,
-            'limits': {
-                'deposit': {
-                    'min': minDeposit,
-                    'max': None,
-                },
-                'withdraw': {
-                    'min': minWithdraw,
-                    'max': None,
-                },
-            },
-        }
-        result: Currency = {
-            'info': currency,
-            'id': id,
-            'code': code,
-            'name': name,
-            'active': active,
-            'deposit': deposit,
-            'withdraw': withdraw,
-            'fee': fee,
-            'precision': precision,
-            'type': None,
-            'limits': {
-                'amount': {
-                    'min': None,
-                    'max': None,
-                },
-                'withdraw': {
-                    'min': minWithdraw,
-                    'max': None,
+            networkEntry = data[i]
+            #
+            #    {
+            #        "Crypto_Token_Info__": "crtev-5nsn35-f4ir-g5hp-iaft-i4ztx6zu",
+            #        "Crypto_Token__": "crtok-c5v3mh-grfn-hl5d-lmel-fvggbf4i",
+            #        "Crypto_Chain__": "chain-xjbini-7wlz-dmzf-gm7z-zf7ei6fq",
+            #        "Type": "native",
+            #        "Symbol": null,
+            #        "Name": null,
+            #        "Contract_Address": null,
+            #        "Minimum_Deposit": {
+            #            "v": "6",
+            #            "e": "6",
+            #            "f": "6.0e-6"
+            #        },
+            #        "Minimum_Withdraw": {
+            #            "v": "15",
+            #            "e": "5",
+            #            "f": "0.00015"
+            #        },
+            #        "Withdraw_Fee": {
+            #            "v": "1",
+            #            "e": "4",
+            #            "f": "0.0001"
+            #        },
+            #        "Minimum_Collect": null,
+            #        "Status": "valid",
+            #        "Can_Deposit": "Y",
+            #        "Decimals": null,
+            #        "Priority": "100",
+            #        "Created": {
+            #            "unix": "1727552199",
+            #            "us": "0",
+            #            "iso": "2024-09-28 19:36:39.000000",
+            #            "tz": "UTC",
+            #            "full": "1727552199000000",
+            #            "unixms": "1727552199000"
+            #        },
+            #        "Crypto_Token": {
+            #            "Crypto_Token__": "crtok-c5v3mh-grfn-hl5d-lmel-fvggbf4i",
+            #            "Name": "Bitcoin",
+            #            "Symbol": "BTC",
+            #            "Decimals": "8",
+            #            "CMC_Id": "1",
+            #            "Priority": "100",
+            #            "Can_Deposit": "Y",
+            #            "Category": "token",
+            #            "Testnet": "N",
+            #            "Created": {
+            #                "unix": "1727552113",
+            #                "us": "0",
+            #                "iso": "2024-09-28 19:35:13.000000",
+            #                "tz": "UTC",
+            #                "full": "1727552113000000",
+            #                "unixms": "1727552113000"
+            #            },
+            #            "Logo": [
+            #                {
+            #                    "Crypto_Token_Logo__": "ctklg-aoozyr-rzm5-fphf-dhm7-5wbtetha",
+            #                    "Crypto_Token__": "crtok-c5v3mh-grfn-hl5d-lmel-fvggbf4i",
+            #                    "Blob__": "blob-d6hvgx-37s5-dh5h-ogj5-qxqvnaoy",
+            #                    "Default": "Y",
+            #                    "Format": "png",
+            #                    "Priority": "0",
+            #                    "Created": {
+            #                        "unix": "1730196627",
+            #                        "us": "929660",
+            #                        "iso": "2024-10-29 10:10:27.929660",
+            #                        "tz": "UTC",
+            #                        "full": "1730196627929660",
+            #                        "unixms": "1730196627929"
+            #                    },
+            #                    "Source": {
+            #                        "Media_Image__": "blob-d6hvgx-37s5-dh5h-ogj5-qxqvnaoy",
+            #                        "Url": "https://static.atonline.net/image/m_X7_tnmIYFCwn6EUVQuMKqrCuPB3CMl4ONTegeYpC0wIg68YZM0CuBpbjspnYwz/1a942eab068a2173e66d08c736283cfe22e1c1ed"
+            #                    }
+            #                }
+            #            ]
+            #        },
+            #        "Crypto_Chain": {
+            #            "Crypto_Chain__": "chain-xjbini-7wlz-dmzf-gm7z-zf7ei6fq",
+            #            "EVM_Chain__": null,
+            #            "Crypto_Token__": "crtok-c5v3mh-grfn-hl5d-lmel-fvggbf4i",
+            #            "Name": "Bitcoin",
+            #            "Key": "bitcoin",
+            #            "Type": "Bitcoin",
+            #            "Curve": "secp256k1",
+            #            "Backend_Url": null,
+            #            "Wallet_Verification_Methods": {
+            #                "signature": True
+            #            },
+            #            "Block_Margin": "3",
+            #            "Created": {
+            #                "unix": "1725340084",
+            #                "us": "0",
+            #                "iso": "2024-09-03 05:08:04.000000",
+            #                "tz": "UTC",
+            #                "full": "1725340084000000",
+            #                "unixms": "1725340084000"
+            #            }
+            #        }
+            #    }
+            #
+            id = self.safe_string(networkEntry, 'Crypto_Token__')
+            token = self.safe_dict(networkEntry, 'Crypto_Token', {})
+            code = self.safe_currency_code(self.safe_string(token, 'Symbol'))
+            if not (code in result):
+                result[code] = {
+                    'id': id,
+                    'code': code,
+                    'info': [],
+                    'type': None,
+                    'name': self.safe_string(token, 'Name'),
+                    'active': None,
+                    'deposit': None,
+                    'withdraw': None,
+                    'fee': None,
+                    'precision': None,
+                    'limits': {
+                        'amount': {
+                            'min': None,
+                            'max': None,
+                        },
+                        'withdraw': {
+                            'min': None,
+                            'max': None,
+                        },
+                        'deposit': {
+                            'min': None,
+                            'max': None,
+                        },
+                    },
+                    'networks': {},
+                }
+            networkId = self.safe_string(networkEntry, 'Crypto_Chain__')
+            cryptoChainDict = self.safe_string(networkEntry, 'Crypto_Chain')
+            networkName = self.safe_string(cryptoChainDict, 'Type', 'default')
+            networkCode = self.network_id_to_code(networkName)
+            result[code]['networks'][networkCode] = {
+                'id': networkId,
+                'network': networkCode,
+                'active': self.safe_string(networkEntry, 'Status') == 'valid',
+                'deposit': self.safe_string(networkEntry, 'Can_Deposit') == 'Y',
+                'withdraw': None,
+                'fee': self.parse_number(self.parse_amount(networkEntry['Withdraw_Fee'])),
+                'precision': self.parse_number(self.parse_precision(self.safe_string(token, 'Decimals'))),
+                'limits': {
+                    'amount': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'withdraw': {
+                        'min': self.parse_amount(networkEntry['Minimum_Withdraw']),
+                        'max': None,
+                    },
+                    'deposit': {
+                        'min': self.parse_amount(networkEntry['Minimum_Deposit']),
+                        'max': None,
+                    },
                 },
-            },
-            'networks': networks,
-        }
+            }
+            infos = self.safe_list(result[code], 'info', [])
+            infos.append(networkEntry)
+            result[code]['info'] = infos
+        # only after all entries are formed in currencies, restructure each entry
+        allKeys = list(result.keys())
+        for i in range(0, len(allKeys)):
+            code = allKeys[i]
+            result[code] = self.safe_currency_structure(result[code])  # self is needed after adding network entry
         return result
 
     def fetch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
@@ -1065,14 +1163,14 @@ class ellipx(Exchange, ImplicitAPI):
         for i in range(0, len(dataArray)):
             entry = dataArray[i]
             balance = self.safe_dict(entry, 'Balance', {})
-            currency = self.safe_string(balance, 'currency')
-            if currency is not None:
+            code = self.safe_string(balance, 'currency')
+            if code is not None:
                 account = {
                     'free': self.parse_amount(entry['Unencumbered_Balance']['value_xint']),
                     'used': self.parse_amount(entry['Liabilities']['value_xint']),
                     'total': self.parse_amount(balance['value_xint']),
                 }
-                result[currency] = account
+                result[code] = account
         return self.safe_balance(result)
 
     def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
@@ -1678,7 +1776,7 @@ class ellipx(Exchange, ImplicitAPI):
 
         https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.zegupoa8g4t9
 
-        :param str code: Currency code
+        :param str code: unified currency code
         :param number amount: Amount to withdraw
         :param str address: Destination wallet address
         :param str [tag]: Additional tag/memo for currencies that require it

ccxt/gate.py

@@ -1865,7 +1865,7 @@ class gate(Exchange, ImplicitAPI):
                     'code': code,
                     'type': type,
                     'precision': precision,
-                    'limits': self.limits,
+                    'limits': None,
                     'networks': {},
                     'info': [],  # will be filled below
                 }

ccxt/gemini.py

@@ -275,7 +275,7 @@ class gemini(Exchange, ImplicitAPI):
                 'fetchMarketFromWebRetries': 10,
                 'fetchMarketsFromAPI': {
                     'fetchDetailsForAllSymbols': False,
-                    'quoteCurrencies': ['USDT', 'GUSD', 'USD', 'DAI', 'EUR', 'GBP', 'SGD', 'BTC', 'ETH', 'LTC', 'BCH'],
+                    'quoteCurrencies': ['USDT', 'GUSD', 'USD', 'DAI', 'EUR', 'GBP', 'SGD', 'BTC', 'ETH', 'LTC', 'BCH', 'SOL'],
                 },
                 'fetchMarkets': {
                     'webApiEnable': True,  # fetches from WEB
@@ -430,7 +430,6 @@ class gemini(Exchange, ImplicitAPI):
             networkCode = None
             if networkId is not None:
                 networkCode = self.network_id_to_code(networkId)
-            if networkCode is not None:
                 networks[networkCode] = {
                     'info': currency,
                     'id': networkId,
@@ -451,7 +450,7 @@ class gemini(Exchange, ImplicitAPI):
                         },
                     },
                 }
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'info': currency,
                 'id': id,
                 'code': code,
@@ -473,7 +472,7 @@ class gemini(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': networks,
-            }
+            })
         return result
 
     def fetch_markets(self, params={}) -> List[Market]:

ccxt/hitbtc.py

@@ -929,29 +929,46 @@ class hitbtc(Exchange, ImplicitAPI):
         """
         response = self.publicGetPublicCurrency(params)
         #
-        #     {
-        #       "WEALTH": {
-        #         "full_name": "ConnectWealth",
-        #         "payin_enabled": False,
-        #         "payout_enabled": False,
-        #         "transfer_enabled": True,
-        #         "precision_transfer": "0.001",
-        #         "networks": [
-        #           {
-        #             "network": "ETH",
-        #             "protocol": "ERC20",
-        #             "default": True,
-        #             "payin_enabled": False,
-        #             "payout_enabled": False,
-        #             "precision_payout": "0.001",
-        #             "payout_fee": "0.016800000000",
-        #             "payout_is_payment_id": False,
-        #             "payin_payment_id": False,
-        #             "payin_confirmations": "2"
-        #           }
-        #         ]
-        #       }
-        #     }
+        #    {
+        #        "DFC": {
+        #            "full_name": "DeFiScale",
+        #            "crypto": True,
+        #            "payin_enabled": False,
+        #            "payout_enabled": True,
+        #            "transfer_enabled": False,
+        #            "transfer_to_wallet_enabled": True,
+        #            "transfer_to_exchange_enabled": False,
+        #            "sign": "D",
+        #            "crypto_payment_id_name": "",
+        #            "crypto_explorer": "https://etherscan.io/tx/{tx}",
+        #            "precision_transfer": "0.00000001",
+        #            "delisted": False,
+        #            "networks": [
+        #                {
+        #                    "code": "ETH",
+        #                    "network_name": "Ethereum",
+        #                    "network": "ETH",
+        #                    "protocol": "ERC-20",
+        #                    "default": True,
+        #                    "is_ens_available": True,
+        #                    "payin_enabled": True,
+        #                    "payout_enabled": True,
+        #                    "precision_payout": "0.000000000000000001",
+        #                    "payout_fee": "277000.0000000000",
+        #                    "payout_is_payment_id": False,
+        #                    "payin_payment_id": False,
+        #                    "payin_confirmations": "2",
+        #                    "contract_address": "0x1b2a76da77d03b7fc21189d9838f55bd849014af",
+        #                    "crypto_payment_id_name": "",
+        #                    "crypto_explorer": "https://etherscan.io/tx/{tx}",
+        #                    "is_multichain": True,
+        #                    "asset_id": {
+        #                        "contract_address": "0x1b2a76da77d03b7fc21189d9838f55bd849014af"
+        #                    }
+        #                }
+        #            ]
+        #        },
+        #    }
         #
         result: dict = {}
         currencies = list(response.keys())
@@ -959,46 +976,22 @@ class hitbtc(Exchange, ImplicitAPI):
             currencyId = currencies[i]
             code = self.safe_currency_code(currencyId)
             entry = response[currencyId]
-            name = self.safe_string(entry, 'full_name')
-            precision = self.safe_number(entry, 'precision_transfer')
-            payinEnabled = self.safe_bool(entry, 'payin_enabled', False)
-            payoutEnabled = self.safe_bool(entry, 'payout_enabled', False)
-            transferEnabled = self.safe_bool(entry, 'transfer_enabled', False)
-            active = payinEnabled and payoutEnabled and transferEnabled
-            rawNetworks = self.safe_value(entry, 'networks', [])
-            isCrypto = self.safe_bool(entry, 'crypto')
-            type = 'crypto' if isCrypto else 'fiat'
+            rawNetworks = self.safe_list(entry, 'networks', [])
             networks: dict = {}
-            fee = None
-            depositEnabled = None
-            withdrawEnabled = None
             for j in range(0, len(rawNetworks)):
                 rawNetwork = rawNetworks[j]
                 networkId = self.safe_string_2(rawNetwork, 'protocol', 'network')
                 networkCode = self.network_id_to_code(networkId)
-                networkCode = networkCode.upper() if (networkCode is not None) else None
-                fee = self.safe_number(rawNetwork, 'payout_fee')
-                networkPrecision = self.safe_number(rawNetwork, 'precision_payout')
-                payinEnabledNetwork = self.safe_bool(rawNetwork, 'payin_enabled', False)
-                payoutEnabledNetwork = self.safe_bool(rawNetwork, 'payout_enabled', False)
-                activeNetwork = payinEnabledNetwork and payoutEnabledNetwork
-                if payinEnabledNetwork and not depositEnabled:
-                    depositEnabled = True
-                elif not payinEnabledNetwork:
-                    depositEnabled = False
-                if payoutEnabledNetwork and not withdrawEnabled:
-                    withdrawEnabled = True
-                elif not payoutEnabledNetwork:
-                    withdrawEnabled = False
+                networkCode = networkCode.upper() if (networkCode is not None) else code  # is white label, ensure we safeguard from possible bugs
                 networks[networkCode] = {
                     'info': rawNetwork,
                     'id': networkId,
                     'network': networkCode,
-                    'fee': fee,
-                    'active': activeNetwork,
-                    'deposit': payinEnabledNetwork,
-                    'withdraw': payoutEnabledNetwork,
-                    'precision': networkPrecision,
+                    'active': None,
+                    'fee': self.safe_number(rawNetwork, 'payout_fee'),
+                    'deposit': self.safe_bool(rawNetwork, 'payin_enabled'),
+                    'withdraw': self.safe_bool(rawNetwork, 'payout_enabled'),
+                    'precision': self.safe_number(rawNetwork, 'precision_payout'),
                     'limits': {
                         'withdraw': {
                             'min': None,
@@ -1006,27 +999,25 @@ class hitbtc(Exchange, ImplicitAPI):
                         },
                     },
                 }
-            networksKeys = list(networks.keys())
-            networksLength = len(networksKeys)
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'info': entry,
                 'code': code,
                 'id': currencyId,
-                'precision': precision,
-                'name': name,
-                'active': active,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
+                'precision': self.safe_number(entry, 'precision_transfer'),
+                'name': self.safe_string(entry, 'full_name'),
+                'active': not self.safe_bool(entry, 'delisted'),
+                'deposit': self.safe_bool(entry, 'payin_enabled'),
+                'withdraw': self.safe_bool(entry, 'payout_enabled'),
                 'networks': networks,
-                'fee': fee if (networksLength <= 1) else None,
+                'fee': None,
                 'limits': {
                     'amount': {
                         'min': None,
                         'max': None,
                     },
                 },
-                'type': type,
-            }
+                'type': None,  # 'crypto' field emits incorrect values
+            })
         return result
 
     def create_deposit_address(self, code: str, params={}) -> DepositAddress:

ccxt/hyperliquid.py

@@ -368,7 +368,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             id = i
             name = self.safe_string(data, 'name')
             code = self.safe_currency_code(name)
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'name': name,
                 'code': code,
@@ -390,7 +390,7 @@ class hyperliquid(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-            }
+            })
         return result
 
     def fetch_markets(self, params={}) -> List[Market]:

ccxt/kraken.py

@@ -1616,6 +1616,8 @@ class kraken(Exchange, ImplicitAPI):
             'volume': self.amount_to_precision(symbol, amount),
         }
         orderRequest = self.order_request('createOrder', symbol, type, request, amount, price, params)
+        flags = self.safe_string(orderRequest[0], 'oflags', '')
+        isUsingCost = flags.find('viqc') > -1
         response = self.privatePostAddOrder(self.extend(orderRequest[0], orderRequest[1]))
         #
         #     {
@@ -1627,6 +1629,10 @@ class kraken(Exchange, ImplicitAPI):
         #     }
         #
         result = self.safe_dict(response, 'result')
+        result['usingCost'] = isUsingCost
+        # it's impossible to know if the order was created using cost or base currency
+        # becuase kraken only returns something like self: {order: 'buy 10.00000000 LTCUSD @ market'}
+        # self usingCost flag is used to help the parsing but omited from the order
         return self.parse_order(result)
 
     def find_market_by_altname_or_id(self, id):
@@ -1713,22 +1719,15 @@ class kraken(Exchange, ImplicitAPI):
         #     }
         #
         #  ws - createOrder
-        #    {
-        #        "descr": 'sell 0.00010000 XBTUSDT @ market',
-        #        "event": 'addOrderStatus',
-        #        "reqid": 1,
-        #        "status": 'ok',
-        #        "txid": 'OAVXZH-XIE54-JCYYDG'
-        #    }
+        #     {
+        #         "order_id": "OXM2QD-EALR2-YBAVEU"
+        #     }
+        #
         #  ws - editOrder
-        #    {
-        #        "descr": "order edited price = 9000.00000000",
-        #        "event": "editOrderStatus",
-        #        "originaltxid": "O65KZW-J4AW3-VFS74A",
-        #        "reqid": 3,
-        #        "status": "ok",
-        #        "txid": "OTI672-HJFAO-XOIPPK"
-        #    }
+        #     {
+        #         "amend_id": "TJSMEH-AA67V-YUSQ6O",
+        #         "order_id": "OXM2QD-EALR2-YBAVEU"
+        #     }
         #
         #  {
         #      "error": [],
@@ -1796,6 +1795,8 @@ class kraken(Exchange, ImplicitAPI):
         #         "oflags": "fciq"
         #     }
         #
+        isUsingCost = self.safe_bool(order, 'usingCost', False)
+        order = self.omit(order, 'usingCost')
         description = self.safe_dict(order, 'descr', {})
         orderDescriptionObj = self.safe_dict(order, 'descr')  # can be null
         orderDescription = None
@@ -1808,11 +1809,15 @@ class kraken(Exchange, ImplicitAPI):
         marketId = None
         price = None
         amount = None
+        cost = None
         triggerPrice = None
         if orderDescription is not None:
             parts = orderDescription.split(' ')
             side = self.safe_string(parts, 0)
-            amount = self.safe_string(parts, 1)
+            if not isUsingCost:
+                amount = self.safe_string(parts, 1)
+            else:
+                cost = self.safe_string(parts, 1)
             marketId = self.safe_string(parts, 2)
             part4 = self.safe_string(parts, 4)
             part5 = self.safe_string(parts, 5)
@@ -1842,13 +1847,12 @@ class kraken(Exchange, ImplicitAPI):
         # kraken truncates the cost in the api response so we will ignore it and calculate it from average & filled
         # cost = self.safe_string(order, 'cost')
         price = self.safe_string(description, 'price', price)
-        # when type = trailling stop returns price = '+50.0000%'
-        if (price is not None) and price.endswith('%'):
+        # when type = trailing stop returns price = '+50.0000%'
+        if (price is not None) and (price.endswith('%') or Precise.string_equals(price, '0.00000') or Precise.string_equals(price, '0')):
             price = None  # self is not the price we want
-        if (price is None) or Precise.string_equals(price, '0'):
+        if price is None:
             price = self.safe_string(description, 'price2')
-        if (price is None) or Precise.string_equals(price, '0'):
-            price = self.safe_string(order, 'price', price)
+            price = self.safe_string_2(order, 'limitprice', 'price', price)
         flags = self.safe_string(order, 'oflags', '')
         isPostOnly = flags.find('post') > -1
         average = self.safe_number(order, 'price')
@@ -1865,7 +1869,7 @@ class kraken(Exchange, ImplicitAPI):
                 elif flags.find('fcib') >= 0:
                     fee['currency'] = market['base']
         status = self.parse_order_status(self.safe_string(order, 'status'))
-        id = self.safe_string_n(order, ['id', 'txid', 'amend_id'])
+        id = self.safe_string_n(order, ['id', 'txid', 'order_id', 'amend_id'])
         if (id is None) or (id.startswith('[')):
             txid = self.safe_list(order, 'txid')
             id = self.safe_string(txid, 0)
@@ -1922,7 +1926,7 @@ class kraken(Exchange, ImplicitAPI):
             'triggerPrice': triggerPrice,
             'takeProfitPrice': takeProfitPrice,
             'stopLossPrice': stopLossPrice,
-            'cost': None,
+            'cost': cost,
             'amount': amount,
             'filled': filled,
             'average': average,

ccxt/kucoinfutures.py

@@ -1510,6 +1510,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         :param str [params.timeInForce]: GTC, GTT, IOC, or FOK, default is GTC, limit orders only
         :param str [params.postOnly]: Post only flag, invalid when timeInForce is IOC or FOK
         :param float [params.cost]: the cost of the order in units of USDT
+        :param str [params.marginMode]: 'cross' or 'isolated', default is 'isolated'
  ----------------- Exchange Specific Parameters -----------------
         :param float [params.leverage]: Leverage size of the order(mandatory param in request, default is 1)
         :param str [params.clientOid]: client order id, defaults to uuid if not passed
@@ -1607,6 +1608,10 @@ class kucoinfutures(kucoin, ImplicitAPI):
             'type': type,  # limit or market
             'leverage': 1,
         }
+        marginModeUpper = self.safe_string_upper(params, 'marginMode')
+        if marginModeUpper is not None:
+            params = self.omit(params, 'marginMode')
+            request['marginMode'] = marginModeUpper
         cost = self.safe_string(params, 'cost')
         params = self.omit(params, 'cost')
         if cost is not None: