ccxt 4.4.92__py2.py3-none-any.whl → 4.4.94__py2.py3-none-any.whl

ccxt/kucoin.py

@@ -1396,35 +1396,31 @@ class kucoin(Exchange, ImplicitAPI):
         #    }
         #
         currenciesData = self.safe_list(response, 'data', [])
+        brokenCurrencies = self.safe_list(self.options, 'brokenCurrencies', ['00', 'OPEN_ERROR', 'HUF', 'BDT'])
+        otherFiats = self.safe_list(self.options, 'fiats', ['KWD', 'IRR', 'PKR'])
         result: dict = {}
         for i in range(0, len(currenciesData)):
             entry = currenciesData[i]
             id = self.safe_string(entry, 'currency')
-            name = self.safe_string(entry, 'fullName')
+            if self.in_array(id, brokenCurrencies):
+                continue  # skip buggy entries: https://t.me/KuCoin_API/217798
             code = self.safe_currency_code(id)
             networks: dict = {}
             chains = self.safe_list(entry, 'chains', [])
-            rawPrecision = self.safe_string(entry, 'precision')
-            precision = self.parse_number(self.parse_precision(rawPrecision))
             chainsLength = len(chains)
-            if not chainsLength:
-                # one buggy coin, which doesn't contain info https://t.me/KuCoin_API/173118
-                continue
             for j in range(0, chainsLength):
                 chain = chains[j]
                 chainId = self.safe_string(chain, 'chainId')
                 networkCode = self.network_id_to_code(chainId, code)
-                chainWithdrawEnabled = self.safe_bool(chain, 'isWithdrawEnabled', False)
-                chainDepositEnabled = self.safe_bool(chain, 'isDepositEnabled', False)
                 networks[networkCode] = {
                     'info': chain,
                     'id': chainId,
                     'name': self.safe_string(chain, 'chainName'),
                     'code': networkCode,
-                    'active': chainWithdrawEnabled and chainDepositEnabled,
+                    'active': None,
                     'fee': self.safe_number(chain, 'withdrawalMinFee'),
-                    'deposit': chainDepositEnabled,
-                    'withdraw': chainWithdrawEnabled,
+                    'deposit': self.safe_bool(chain, 'isDepositEnabled'),
+                    'withdraw': self.safe_bool(chain, 'isWithdrawEnabled'),
                     'precision': self.parse_number(self.parse_precision(self.safe_string(chain, 'withdrawPrecision'))),
                     'limits': {
                         'withdraw': {
@@ -1438,10 +1434,12 @@ class kucoin(Exchange, ImplicitAPI):
                     },
                 }
             # kucoin has determined 'fiat' currencies with below logic
-            isFiat = (rawPrecision == '2') and (chainsLength == 0)
+            rawPrecision = self.safe_string(entry, 'precision')
+            precision = self.parse_number(self.parse_precision(rawPrecision))
+            isFiat = self.in_array(id, otherFiats) or ((rawPrecision == '2') and (chainsLength == 0))
             result[code] = self.safe_currency_structure({
                 'id': id,
-                'name': name,
+                'name': self.safe_string(entry, 'fullName'),
                 'code': code,
                 'type': 'fiat' if isFiat else 'crypto',
                 'precision': precision,
@@ -2627,7 +2625,7 @@ class kucoin(Exchange, ImplicitAPI):
         """
         self.load_markets()
         request: dict = {}
-        trigger = self.safe_bool(params, 'stop', False)
+        trigger = self.safe_bool_2(params, 'trigger', 'stop', False)
         hf = None
         hf, params = self.handle_hf_and_params(params)
         params = self.omit(params, 'stop')

ccxt/latoken.py

@@ -247,6 +247,8 @@ class latoken(Exchange, ImplicitAPI):
                 'fetchTradingFee': {
                     'method': 'fetchPrivateTradingFee',  # or 'fetchPublicTradingFee'
                 },
+                'timeDifference': 0,  # the difference between system clock and exchange clock
+                'adjustForTimeDifference': True,  # controls the adjustment logic upon instantiation
             },
             'features': {
                 'spot': {
@@ -347,39 +349,6 @@ class latoken(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of objects representing market data
         """
-        currencies = self.fetch_currencies_from_cache(params)
-        #
-        #     [
-        #         {
-        #             "id":"1a075819-9e0b-48fc-8784-4dab1d186d6d",
-        #             "status":"CURRENCY_STATUS_ACTIVE",
-        #             "type":"CURRENCY_TYPE_ALTERNATIVE",  # CURRENCY_TYPE_CRYPTO, CURRENCY_TYPE_IEO
-        #             "name":"MyCryptoBank",
-        #             "tag":"MCB",
-        #             "description":"",
-        #             "logo":"",
-        #             "decimals":18,
-        #             "created":1572912000000,
-        #             "tier":1,
-        #             "assetClass":"ASSET_CLASS_UNKNOWN",
-        #             "minTransferAmount":0
-        #         },
-        #         {
-        #             "id":"db02758e-2507-46a5-a805-7bc60355b3eb",
-        #             "status":"CURRENCY_STATUS_ACTIVE",
-        #             "type":"CURRENCY_TYPE_FUTURES_CONTRACT",
-        #             "name":"BTC USDT Futures Contract",
-        #             "tag":"BTCUSDT",
-        #             "description":"",
-        #             "logo":"",
-        #             "decimals":8,
-        #             "created":1589459984395,
-        #             "tier":1,
-        #             "assetClass":"ASSET_CLASS_UNKNOWN",
-        #             "minTransferAmount":0
-        #         },
-        #     ]
-        #
         response = self.publicGetPair(params)
         #
         #     [
@@ -401,8 +370,9 @@ class latoken(Exchange, ImplicitAPI):
         #         }
         #     ]
         #
-        if self.safe_value(self.options, 'adjustForTimeDifference', True):
+        if self.safe_bool(self.options, 'adjustForTimeDifference', False):
             self.load_time_difference()
+        currencies = self.safe_dict(self.options, 'cachedCurrencies', {})
         currenciesById = self.index_by(currencies, 'id')
         result = []
         for i in range(0, len(response)):
@@ -411,11 +381,13 @@ class latoken(Exchange, ImplicitAPI):
             # the exchange shows them inverted
             baseId = self.safe_string(market, 'baseCurrency')
             quoteId = self.safe_string(market, 'quoteCurrency')
-            baseCurrency = self.safe_value(currenciesById, baseId)
-            quoteCurrency = self.safe_value(currenciesById, quoteId)
-            if baseCurrency is not None and quoteCurrency is not None:
-                base = self.safe_currency_code(self.safe_string(baseCurrency, 'tag'))
-                quote = self.safe_currency_code(self.safe_string(quoteCurrency, 'tag'))
+            baseCurrency = self.safe_dict(currenciesById, baseId)
+            quoteCurrency = self.safe_dict(currenciesById, quoteId)
+            baseCurrencyInfo = self.safe_dict(baseCurrency, 'info')
+            quoteCurrencyInfo = self.safe_dict(quoteCurrency, 'info')
+            if baseCurrencyInfo is not None and quoteCurrencyInfo is not None:
+                base = self.safe_currency_code(self.safe_string(baseCurrencyInfo, 'tag'))
+                quote = self.safe_currency_code(self.safe_string(quoteCurrencyInfo, 'tag'))
                 lowercaseQuote = quote.lower()
                 capitalizedQuote = self.capitalize(lowercaseQuote)
                 status = self.safe_string(market, 'status')
@@ -470,28 +442,13 @@ class latoken(Exchange, ImplicitAPI):
                 })
         return result
 
-    def fetch_currencies_from_cache(self, params={}):
-        # self method is now redundant
-        # currencies are now fetched before markets
-        options = self.safe_value(self.options, 'fetchCurrencies', {})
-        timestamp = self.safe_integer(options, 'timestamp')
-        expires = self.safe_integer(options, 'expires', 1000)
-        now = self.milliseconds()
-        if (timestamp is None) or ((now - timestamp) > expires):
-            response = self.publicGetCurrency(params)
-            self.options['fetchCurrencies'] = self.extend(options, {
-                'response': response,
-                'timestamp': now,
-            })
-        return self.safe_value(self.options['fetchCurrencies'], 'response')
-
     def fetch_currencies(self, params={}) -> Currencies:
         """
         fetches all available currencies on an exchange
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an associative dictionary of currencies
         """
-        response = self.fetch_currencies_from_cache(params)
+        response = self.publicGetCurrency(params)
         #
         #     [
         #         {
@@ -530,27 +487,18 @@ class latoken(Exchange, ImplicitAPI):
             id = self.safe_string(currency, 'id')
             tag = self.safe_string(currency, 'tag')
             code = self.safe_currency_code(tag)
-            fee = self.safe_number(currency, 'fee')
             currencyType = self.safe_string(currency, 'type')
-            type = None
-            if currencyType == 'CURRENCY_TYPE_ALTERNATIVE':
-                type = 'other'
-            else:
-                # CURRENCY_TYPE_CRYPTO and CURRENCY_TYPE_IEO are all cryptos
-                type = 'crypto'
-            status = self.safe_string(currency, 'status')
-            active = (status == 'CURRENCY_STATUS_ACTIVE')
-            name = self.safe_string(currency, 'name')
-            result[code] = {
+            isCrypto = (currencyType == 'CURRENCY_TYPE_CRYPTO' or currencyType == 'CURRENCY_TYPE_IEO')
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'code': code,
                 'info': currency,
-                'name': name,
-                'type': type,
-                'active': active,
+                'name': self.safe_string(currency, 'name'),
+                'type': 'crypto' if isCrypto else 'other',
+                'active': self.safe_string(currency, 'status') == 'CURRENCY_STATUS_ACTIVE',
                 'deposit': None,
                 'withdraw': None,
-                'fee': fee,
+                'fee': self.safe_number(currency, 'fee'),
                 'precision': self.parse_number(self.parse_precision(self.safe_string(currency, 'decimals'))),
                 'limits': {
                     'amount': {
@@ -563,7 +511,7 @@ class latoken(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': {},
-            }
+            })
         return result
 
     def fetch_balance(self, params={}) -> Balances:

ccxt/lbank.py

@@ -137,7 +137,7 @@ class lbank(Exchange, ImplicitAPI):
                             'accuracy': 2.5,
                             'usdToCny': 2.5,
                             'assetConfigs': 2.5,
-                            'withdrawConfigs': 2.5,
+                            'withdrawConfigs': 2.5 * 1.5,  # frequently rate-limits, so increase self endpoint RL
                             'timestamp': 2.5,
                             'ticker/24hr': 2.5,
                             'ticker': 2.5,
@@ -674,7 +674,7 @@ class lbank(Exchange, ImplicitAPI):
                 'active': True,
                 'contract': True,
                 'linear': True,
-                'inverse': None,
+                'inverse': False,
                 'contractSize': self.safe_number(market, 'volumeMultiple'),
                 'expiry': None,
                 'expiryDatetime': None,

ccxt/okx.py

@@ -80,6 +80,7 @@ class okx(Exchange, ImplicitAPI):
                 'createTriggerOrder': True,
                 'editOrder': True,
                 'fetchAccounts': True,
+                'fetchAllGreeks': True,
                 'fetchBalance': True,
                 'fetchBidsAsks': None,
                 'fetchBorrowInterest': True,
@@ -2555,11 +2556,11 @@ class okx(Exchange, ImplicitAPI):
             # it may be incorrect to use total, free and used for swap accounts
             eq = self.safe_string(balance, 'eq')
             availEq = self.safe_string(balance, 'availEq')
-            if (eq is None) or (availEq is None):
+            account['total'] = eq
+            if availEq is None:
                 account['free'] = self.safe_string(balance, 'availBal')
                 account['used'] = self.safe_string(balance, 'frozenBal')
             else:
-                account['total'] = eq
                 account['free'] = availEq
             result[code] = account
         result['timestamp'] = timestamp
@@ -2957,7 +2958,8 @@ class okx(Exchange, ImplicitAPI):
                 stopLossTriggerPrice = self.safe_value_n(stopLoss, ['triggerPrice', 'stopPrice', 'slTriggerPx'])
                 if stopLossTriggerPrice is None:
                     raise InvalidOrder(self.id + ' createOrder() requires a trigger price in params["stopLoss"]["triggerPrice"], or params["stopLoss"]["stopPrice"], or params["stopLoss"]["slTriggerPx"] for a stop loss order')
-                request['slTriggerPx'] = self.price_to_precision(symbol, stopLossTriggerPrice)
+                slTriggerPx = self.price_to_precision(symbol, stopLossTriggerPrice)
+                request['slTriggerPx'] = slTriggerPx
                 stopLossLimitPrice = self.safe_value_n(stopLoss, ['price', 'stopLossPrice', 'slOrdPx'])
                 stopLossOrderType = self.safe_string(stopLoss, 'type')
                 if stopLossOrderType is not None:
@@ -3023,6 +3025,12 @@ class okx(Exchange, ImplicitAPI):
             # tpOrdKind is 'condition' which is the default
             if twoWayCondition:
                 request['ordType'] = 'oco'
+            if side == 'sell':
+                request = self.omit(request, 'tgtCcy')
+            if self.safe_string(request, 'tdMode') == 'cash':
+                # for some reason tdMode = cash throws
+                # {"code":"1","data":[{"algoClOrdId":"","algoId":"","clOrdId":"","sCode":"51000","sMsg":"Parameter tdMode error ","tag":""}],"msg":""}
+                request['tdMode'] = marginMode
             if takeProfitPrice is not None:
                 request['tpTriggerPx'] = self.price_to_precision(symbol, takeProfitPrice)
                 tpOrdPxReq = '-1'
@@ -3613,6 +3621,84 @@ class okx(Exchange, ImplicitAPI):
         #         "uTime": "1621910749815"
         #     }
         #
+        # watchOrders & fetchClosedOrders
+        #
+        #    {
+        #        "algoClOrdId": "",
+        #        "algoId": "",
+        #        "attachAlgoClOrdId": "",
+        #        "attachAlgoOrds": [],
+        #        "cancelSource": "",
+        #        "cancelSourceReason": "",  # not present in WS, but present in fetchClosedOrders
+        #        "category": "normal",
+        #        "ccy": "",  # empty in WS, but eg. `USDT` in fetchClosedOrders
+        #        "clOrdId": "",
+        #        "cTime": "1751705801423",
+        #        "feeCcy": "USDT",
+        #        "instId": "LINK-USDT-SWAP",
+        #        "instType": "SWAP",
+        #        "isTpLimit": "false",
+        #        "lever": "3",
+        #        "linkedAlgoOrd": {"algoId": ""},
+        #        "ordId": "2657625147249614848",
+        #        "ordType": "limit",
+        #        "posSide": "net",
+        #        "px": "13.142",
+        #        "pxType": "",
+        #        "pxUsd": "",
+        #        "pxVol": "",
+        #        "quickMgnType": "",
+        #        "rebate": "0",
+        #        "rebateCcy": "USDT",
+        #        "reduceOnly": "true",
+        #        "side": "sell",
+        #        "slOrdPx": "",
+        #        "slTriggerPx": "",
+        #        "slTriggerPxType": "",
+        #        "source": "",
+        #        "stpId": "",
+        #        "stpMode": "cancel_maker",
+        #        "sz": "0.1",
+        #        "tag": "",
+        #        "tdMode": "isolated",
+        #        "tgtCcy": "",
+        #        "tpOrdPx": "",
+        #        "tpTriggerPx": "",
+        #        "tpTriggerPxType": "",
+        #        "uTime": "1751705807467",
+        #        "reqId": "",                      # field present only in WS
+        #        "msg": "",                        # field present only in WS
+        #        "amendResult": "",                # field present only in WS
+        #        "amendSource": "",                # field present only in WS
+        #        "code": "0",                      # field present only in WS
+        #        "fillFwdPx": "",                  # field present only in WS
+        #        "fillMarkVol": "",                # field present only in WS
+        #        "fillPxUsd": "",                  # field present only in WS
+        #        "fillPxVol": "",                  # field present only in WS
+        #        "lastPx": "13.142",               # field present only in WS
+        #        "notionalUsd": "1.314515408",     # field present only in WS
+        #
+        #     #### these below fields are empty on first omit from websocket, because of "creation" event. however, if order is executed, it also immediately sends another update with these fields filled  ###
+        #
+        #        "pnl": "-0.0001",
+        #        "accFillSz": "0.1",
+        #        "avgPx": "13.142",
+        #        "state": "filled",
+        #        "fee": "-0.00026284",
+        #        "fillPx": "13.142",
+        #        "tradeId": "293429690",
+        #        "fillSz": "0.1",
+        #        "fillTime": "1751705807467",
+        #        "fillNotionalUsd": "1.314515408",  # field present only in WS
+        #        "fillPnl": "-0.0001",             # field present only in WS
+        #        "fillFee": "-0.00026284",         # field present only in WS
+        #        "fillFeeCcy": "USDT",             # field present only in WS
+        #        "execType": "M",                  # field present only in WS
+        #        "fillMarkPx": "13.141",           # field present only in WS
+        #        "fillIdxPx": "13.147"             # field present only in WS
+        #    }
+        #
+        #
         # Algo Order fetchOpenOrders, fetchCanceledOrders, fetchClosedOrders
         #
         #     {
@@ -7547,6 +7633,76 @@ class okx(Exchange, ImplicitAPI):
                 return self.parse_greeks(entry, market)
         return None
 
+    def fetch_all_greeks(self, symbols: Strings = None, params={}) -> List[Greeks]:
+        """
+        fetches all option contracts greeks, financial metrics used to measure the factors that affect the price of an options contract
+
+        https://www.okx.com/docs-v5/en/#public-data-rest-api-get-option-market-data
+
+        :param str[] [symbols]: unified symbols of the markets to fetch greeks for, all markets are returned if not assigned
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str params['uly']: Underlying, either uly or instFamily is required
+        :param str params['instFamily']: Instrument family, either uly or instFamily is required
+        :returns dict: a `greeks structure <https://docs.ccxt.com/#/?id=greeks-structure>`
+        """
+        self.load_markets()
+        request: dict = {}
+        symbols = self.market_symbols(symbols, None, True, True, True)
+        symbolsLength = None
+        if symbols is not None:
+            symbolsLength = len(symbols)
+        if (symbols is None) or (symbolsLength != 1):
+            uly = self.safe_string(params, 'uly')
+            if uly is not None:
+                request['uly'] = uly
+            instFamily = self.safe_string(params, 'instFamily')
+            if instFamily is not None:
+                request['instFamily'] = instFamily
+            if (uly is None) and (instFamily is None):
+                raise BadRequest(self.id + ' fetchAllGreeks() requires either a uly or instFamily parameter')
+        market = None
+        if symbols is not None:
+            if symbolsLength == 1:
+                market = self.market(symbols[0])
+                marketId = market['id']
+                optionParts = marketId.split('-')
+                request['uly'] = market['info']['uly']
+                request['instFamily'] = market['info']['instFamily']
+                request['expTime'] = self.safe_string(optionParts, 2)
+        params = self.omit(params, ['uly', 'instFamily'])
+        response = self.publicGetPublicOptSummary(self.extend(request, params))
+        #
+        #     {
+        #         "code": "0",
+        #         "data": [
+        #             {
+        #                 "askVol": "0",
+        #                 "bidVol": "0",
+        #                 "delta": "0.5105464486882039",
+        #                 "deltaBS": "0.7325502184143025",
+        #                 "fwdPx": "37675.80158694987186",
+        #                 "gamma": "-0.13183515090501083",
+        #                 "gammaBS": "0.000024139685826358558",
+        #                 "instId": "BTC-USD-240329-32000-C",
+        #                 "instType": "OPTION",
+        #                 "lever": "4.504428015946619",
+        #                 "markVol": "0.5916253554539876",
+        #                 "realVol": "0",
+        #                 "theta": "-0.0004202992014012855",
+        #                 "thetaBS": "-18.52354631567909",
+        #                 "ts": "1699586421976",
+        #                 "uly": "BTC-USD",
+        #                 "vega": "0.0020207455080045846",
+        #                 "vegaBS": "74.44022302387287",
+        #                 "volLv": "0.5948549730405797"
+        #             },
+        #         ],
+        #         "msg": ""
+        #     }
+        #
+        data = self.safe_list(response, 'data', [])
+        return self.parse_all_greeks(data, symbols)
+
     def parse_greeks(self, greeks: dict, market: Market = None) -> Greeks:
         #
         #     {

ccxt/paradex.py

@@ -57,6 +57,7 @@ class paradex(Exchange, ImplicitAPI):
                 'createTriggerOrder': True,
                 'editOrder': False,
                 'fetchAccounts': False,
+                'fetchAllGreeks': True,
                 'fetchBalance': True,
                 'fetchBorrowInterest': False,
                 'fetchBorrowRateHistories': False,
@@ -2346,6 +2347,59 @@ class paradex(Exchange, ImplicitAPI):
         greeks = self.safe_dict(data, 0, {})
         return self.parse_greeks(greeks, market)
 
+    def fetch_all_greeks(self, symbols: Strings = None, params={}) -> List[Greeks]:
+        """
+        fetches all option contracts greeks, financial metrics used to measure the factors that affect the price of an options contract
+
+        https://docs.api.testnet.paradex.trade/#list-available-markets-summary
+
+        :param str[] [symbols]: unified symbols of the markets to fetch greeks for, all markets are returned if not assigned
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `greeks structure <https://docs.ccxt.com/#/?id=greeks-structure>`
+        """
+        self.load_markets()
+        symbols = self.market_symbols(symbols, None, True, True, True)
+        request: dict = {
+            'market': 'ALL',
+        }
+        response = self.publicGetMarketsSummary(self.extend(request, params))
+        #
+        #     {
+        #         "results": [
+        #             {
+        #                 "symbol": "BTC-USD-114000-P",
+        #                 "mark_price": "10835.66892602",
+        #                 "mark_iv": "0.71781855",
+        #                 "delta": "-0.98726024",
+        #                 "greeks": {
+        #                     "delta": "-0.9872602390817709",
+        #                     "gamma": "0.000004560958862297231",
+        #                     "vega": "227.11344863639806",
+        #                     "rho": "-302.0617972461581",
+        #                     "vanna": "0.06609830491614832",
+        #                     "volga": "925.9501532805552"
+        #                 },
+        #                 "last_traded_price": "10551.5",
+        #                 "bid": "10794.9",
+        #                 "bid_iv": "0.05",
+        #                 "ask": "10887.3",
+        #                 "ask_iv": "0.8783283",
+        #                 "last_iv": "0.05",
+        #                 "volume_24h": "0",
+        #                 "total_volume": "195240.72672261014",
+        #                 "created_at": 1747644009995,
+        #                 "underlying_price": "103164.79162649",
+        #                 "open_interest": "0",
+        #                 "funding_rate": "0.000004464241170536191",
+        #                 "price_change_rate_24h": "0.074915",
+        #                 "future_funding_rate": "0.0001"
+        #             }
+        #         ]
+        #     }
+        #
+        results = self.safe_list(response, 'results', [])
+        return self.parse_all_greeks(results, symbols)
+
     def parse_greeks(self, greeks: dict, market: Market = None) -> Greeks:
         #
         #     {

ccxt/phemex.py

@@ -2658,14 +2658,14 @@ class phemex(Exchange, ImplicitAPI):
                 triggerDirection = None
                 triggerDirection, params = self.handle_param_string(params, 'triggerDirection')
                 if triggerDirection is None:
-                    raise ArgumentsRequired(self.id + " createOrder() also requires a 'triggerDirection' parameter with either 'up' or 'down' value")
+                    raise ArgumentsRequired(self.id + " createOrder() also requires a 'triggerDirection' parameter with either 'ascending' or 'descending' value")
                 # the flow defined per https://phemex-docs.github.io/#more-order-type-examples
-                if triggerDirection == 'up':
+                if triggerDirection == 'ascending' or triggerDirection == 'up':
                     if side == 'sell':
                         request['ordType'] = 'MarketIfTouched' if (type == 'Market') else 'LimitIfTouched'
                     elif side == 'buy':
                         request['ordType'] = 'Stop' if (type == 'Market') else 'StopLimit'
-                elif triggerDirection == 'down':
+                elif triggerDirection == 'descending' or triggerDirection == 'down':
                     if side == 'sell':
                         request['ordType'] = 'Stop' if (type == 'Market') else 'StopLimit'
                     elif side == 'buy':

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.92'
+__version__ = '4.4.94'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/bitstamp.py

@@ -10,6 +10,7 @@ from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import ArgumentsRequired
+from ccxt.base.precise import Precise
 
 
 class bitstamp(ccxt.async_support.bitstamp):
@@ -296,6 +297,7 @@ class bitstamp(ccxt.async_support.bitstamp):
         #        "price_str":"1000.00"
         #     },
         #     "channel":"private-my_orders_ltcusd-4848701",
+        #     "event": "order_deleted"  # field only present for cancelOrder
         # }
         #
         channel = self.safe_string(message, 'channel')
@@ -307,29 +309,58 @@ class bitstamp(ccxt.async_support.bitstamp):
         subscription = self.safe_value(client.subscriptions, channel)
         symbol = self.safe_string(subscription, 'symbol')
         market = self.market(symbol)
+        order['event'] = self.safe_string(message, 'event')
         parsed = self.parse_ws_order(order, market)
         stored.append(parsed)
         client.resolve(self.orders, channel)
 
     def parse_ws_order(self, order, market=None):
         #
-        #   {
-        #        "id":"1463471322288128",
-        #        "id_str":"1463471322288128",
-        #        "order_type":1,
-        #        "datetime":"1646127778",
-        #        "microtimestamp":"1646127777950000",
-        #        "amount":0.05,
-        #        "amount_str":"0.05000000",
-        #        "price":1000,
-        #        "price_str":"1000.00"
+        #    {
+        #        "id": "1894876776091648",
+        #        "id_str": "1894876776091648",
+        #        "order_type": 0,
+        #        "order_subtype": 0,
+        #        "datetime": "1751451375",
+        #        "microtimestamp": "1751451375070000",
+        #        "amount": 1.1,
+        #        "amount_str": "1.10000000",
+        #        "amount_traded": "0",
+        #        "amount_at_create": "1.10000000",
+        #        "price": 10.23,
+        #        "price_str": "10.23",
+        #        "is_liquidation": False,
+        #        "trade_account_id": 0
         #    }
         #
         id = self.safe_string(order, 'id_str')
-        orderType = self.safe_string_lower(order, 'order_type')
+        orderTypeRaw = self.safe_string_lower(order, 'order_type')
+        side = 'sell' if (orderTypeRaw == '1') else 'buy'
+        orderSubTypeRaw = self.safe_string_lower(order, 'order_subtype')  # https://www.bitstamp.net/websocket/v2/#:~:text=order_subtype
+        orderType: Str = None
+        timeInForce: Str = None
+        if orderSubTypeRaw == '0':
+            orderType = 'limit'
+        elif orderSubTypeRaw == '2':
+            orderType = 'market'
+        elif orderSubTypeRaw == '4':
+            orderType = 'limit'
+            timeInForce = 'IOC'
+        elif orderSubTypeRaw == '6':
+            orderType = 'limit'
+            timeInForce = 'FOK'
+        elif orderSubTypeRaw == '8':
+            orderType = 'limit'
+            timeInForce = 'GTD'
         price = self.safe_string(order, 'price_str')
         amount = self.safe_string(order, 'amount_str')
-        side = 'sell' if (orderType == '1') else 'buy'
+        filled = self.safe_string(order, 'amount_traded')
+        event = self.safe_string(order, 'event')
+        status = None
+        if Precise.string_eq(filled, amount):
+            status = 'closed'
+        elif event == 'order_deleted':
+            status = 'canceled'
         timestamp = self.safe_timestamp(order, 'datetime')
         market = self.safe_market(None, market)
         symbol = market['symbol']
@@ -341,8 +372,8 @@ class bitstamp(ccxt.async_support.bitstamp):
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'lastTradeTimestamp': None,
-            'type': None,
-            'timeInForce': None,
+            'type': orderType,
+            'timeInForce': timeInForce,
             'postOnly': None,
             'side': side,
             'price': price,
@@ -351,9 +382,9 @@ class bitstamp(ccxt.async_support.bitstamp):
             'amount': amount,
             'cost': None,
             'average': None,
-            'filled': None,
+            'filled': filled,
             'remaining': None,
-            'status': None,
+            'status': status,
             'fee': None,
             'trades': None,
         }, market)
@@ -417,6 +448,7 @@ class bitstamp(ccxt.async_support.bitstamp):
         #         "price_str":"1000.00"
         #         },
         #         "channel":"private-my_orders_ltcusd-4848701",
+        #         "event": "order_deleted"  # field only present for cancelOrder
         #     }
         #
         channel = self.safe_string(message, 'channel')