@rabbitio/ui-kit 1.0.0-beta.113 → 1.0.0-beta.114

package/src/swaps-lib/external-apis/changeNowSwapProvider.js

@@ -0,0 +1,746 @@
+import axios from "axios";
+import BigNumber from "bignumber.js";
+
+import { improveAndRethrow } from "../../common-apis/utils/errorUtils.js";
+import { DEFAULT_CRYPTO_DECIMAL_COUNT, FALLBACK_ASSET_ICON_URL } from "../../common-apis/globalConstants.jsx";
+import { Logger } from "../../common-apis/utils/logging/logger.js";
+import { Coin } from "../../common-apis/models/coin.js";
+import { Protocol } from "../../common-apis/models/protocol.js";
+import { safeStringify } from "../../common-apis/utils/safeStringify.js";
+import { AmountUtils } from "../../common-apis/utils/amountUtils.js";
+
+import { SwapProvider } from "./swapProvider.js";
+import { SwapProviderCoinInfo } from "../models/swapProviderCoinInfo.js";
+import { ExistingSwap } from "../models/existingSwap.js";
+import { Partner, KYC_LEVELS } from "../models/partner.js";
+import { createRobustTimeoutSetupForAxios } from "./utils.js";
+
+/**
+ * ChangeNowSwapProvider wraps ChangeNOW API v2 to provide swap functionality.
+ *
+ * IMPORTANT: this adapter operates strictly on a hardcoded whitelist of
+ * Rabbit tickers mapped to (ticker, network) pairs in ChangeNOW API. Any
+ * asset outside of the map below is considered unsupported by this adapter
+ * and will not be used at all.
+ *
+ * Mapping rule:
+ *   Rabbit ticker (our internal) → { code, network } for ChangeNOW.
+ *   Example: USDTTRC20 → { code: "usdt", network: "trx" }.
+ *
+ * We propagate the Rabbit ticker as the internal coin identifier everywhere,
+ * and when calling ChangeNOW we use the corresponding code/network from the
+ * map.
+ *
+ * Flows:
+ *   - Floating rate → flow=standard
+ *   - Fixed rate    → flow=fixed-rate (you MUST pass the rateId obtained
+ *     from /exchange/estimated-amount when creating a swap). The presence
+ *     of "validUntil" in transaction details indicates a fixed‑rate swap.
+ *
+ * Expiration:
+ *   ChangeNOW does not auto-expire swaps. For UI simplicity we treat swaps
+ *   as expired after 4 hours (see _swapExpirationMs).
+ */
+
+// Strict whitelist of supported assets: RabbitTicker -> { code: ChangeNOW ticker, network: ChangeNOW network }
+const RABBIT_TO_CHANGENOW_MAP = Object.freeze({
+    BNBBEP20: { code: "bnb", network: "bsc", tickerPrintable: "BNB", protocol: "BEP20" },
+    BNBOPBNB: { code: "bnb", network: "opbnb", tickerPrintable: "BNB", protocol: "OPBNB" },
+    BTC: { code: "btc", network: "btc", tickerPrintable: "BTC", protocol: null },
+    DOGE: { code: "doge", network: "doge", tickerPrintable: "DOGE", protocol: null },
+    DOT: { code: "dot", network: "dot", tickerPrintable: "DOT", protocol: null },
+    ETH: { code: "eth", network: "eth", tickerPrintable: "ETH", protocol: null },
+    ETHBASE: { code: "eth", network: "base", tickerPrintable: "ETH", protocol: "BASE" },
+    GMTSOL: { code: "gmt", network: "sol", tickerPrintable: "GMT", protocol: "SOL" },
+    KAS: { code: "kas", network: "kas", tickerPrintable: "KAS", protocol: null },
+    LTC: { code: "ltc", network: "ltc", tickerPrintable: "LTC", protocol: null },
+    PYUSDSOL: { code: "pyusd", network: "sol", tickerPrintable: "PYUSD", protocol: "SOL" },
+    SOL: { code: "sol", network: "sol", tickerPrintable: "SOL", protocol: null },
+    TON: { code: "ton", network: "ton", tickerPrintable: "TON", protocol: null },
+    TRX: { code: "trx", network: "trx", tickerPrintable: "TRX", protocol: null },
+    "USDC.EARBITRUM": { code: "arbusdce", network: "arbitrum", tickerPrintable: "USDC", protocol: "EARBITRUM" },
+    USDCARBITRUM: { code: "usdc", network: "arbitrum", tickerPrintable: "USDC", protocol: "ARBITRUM" },
+    USDCERC20: { code: "usdc", network: "eth", tickerPrintable: "USDC", protocol: "ERC20" },
+    USDTBEP20: { code: "usdt", network: "bsc", tickerPrintable: "USDT", protocol: "BEP20" },
+    USDTERC20: { code: "usdt", network: "eth", tickerPrintable: "USDT", protocol: "ERC20" },
+    USDTPOLYGON: { code: "usdt", network: "matic", tickerPrintable: "USDT", protocol: "POLYGON" },
+    USDTSOL: { code: "usdt", network: "sol", tickerPrintable: "USDT", protocol: "SOL" },
+    USDTTRC20: { code: "usdt", network: "trx", tickerPrintable: "USDT", protocol: "TRC20" },
+    WBTCERC20: { code: "wbtc", network: "eth", tickerPrintable: "WBTC", protocol: "ERC20" },
+    XMR: { code: "xmr", network: "xmr", tickerPrintable: "XMR", protocol: null },
+    XRP: { code: "xrp", network: "xrp", tickerPrintable: "XRP", protocol: null },
+});
+
+export class ChangeNowSwapProvider extends SwapProvider {
+    constructor(
+        apiKeysProxyUrl = null,
+        cache,
+        customCoinBuilder = (ticker, network) => null,
+        useRestrictedCoinsSet = true,
+        apiKey = null
+    ) {
+        super("changenow", cache, customCoinBuilder, useRestrictedCoinsSet, false, true);
+        this._apiKey = apiKey;
+        this._URL = apiKey ? "https://api.changenow.io/v2" : `${apiKeysProxyUrl}/${this.id}`;
+        this._commonHeaders = apiKey ? { "x-changenow-api-key": apiKey } : {};
+        this._axiosGetPreset = {
+            headers: this._commonHeaders,
+            validateStatus: status => [200, 400, 404].includes(status),
+        };
+        this._axiosPostPreset = {
+            headers: { ...this._commonHeaders, "Content-Type": "application/json" },
+            validateStatus: status => [200, 201, 400, 404].includes(status),
+        };
+
+        this._swapExpirationMs = 4 * 60 * 60 * 1000;
+
+        this._partners = [];
+    }
+
+    getSwapCreationInfoTtlMs() {
+        return 110000;
+    }
+
+    /**
+     * Loads ChangeNOW currencies and maps ONLY assets from RABBIT_TO_CHANGENOW_MAP.
+     *
+     * - coin.ticker in our system is EXACTLY the Rabbit ticker (e.g., USDTTRC20).
+     * - code/network used for ChangeNOW requests come from the map (e.g., usdt + trx).
+     * - Any asset not present in the map is ignored entirely.
+     */
+    async _fetchSupportedCurrenciesIfNeeded() {
+        const loggerSource = "ChangeNow::_fetchSupportedCurrenciesIfNeeded";
+        if (!this._shouldCoinsListBeLoaded()) {
+            return;
+        }
+        try {
+            const response = await axios.get(`${this._URL}/exchange/currencies`, {
+                ...this._axiosGetPreset,
+                ...createRobustTimeoutSetupForAxios(),
+                params: {},
+            });
+            if (response.status !== 200 || !Array.isArray(response.data)) {
+                throw new Error(
+                    `Unexpected /exchange/currencies response: ${response.status}, ${safeStringify(response.data)}`
+                );
+            }
+
+            const currencies = response.data;
+
+            // Index currencies by "ticker|network" (both lowercased) for quick lookup.
+            const byTickerAndNetwork = new Map();
+            for (const item of currencies) {
+                try {
+                    const t = (item.ticker ?? "").toLowerCase();
+                    const n = (item.network ?? "").toLowerCase();
+                    if (!t) continue;
+                    byTickerAndNetwork.set(`${t}|${n}`, item);
+                } catch (e) {
+                    Logger.logError(e, `${loggerSource} while indexing currencies`);
+                }
+            }
+
+            const mappedCoins = Object.entries(RABBIT_TO_CHANGENOW_MAP).map(([rabbitTicker, mapping]) => {
+                try {
+                    const codeLower = (mapping.code ?? "").toLowerCase();
+                    const networkLower = (mapping.network ?? "").toLowerCase();
+                    const item = byTickerAndNetwork.get(`${codeLower}|${networkLower}`);
+
+                    // If ChangeNOW doesn't return this (ticker, network) pair — skip the asset.
+                    if (!item) return null;
+
+                    const internalTicker = rabbitTicker;
+                    const providerCurrencyCode = (mapping.code ?? "").toUpperCase();
+                    const providerNetwork = networkLower || null;
+
+                    const tickerPrintable = mapping.tickerPrintable;
+                    const protocol = mapping.protocol ? new Protocol(mapping.protocol) : null;
+
+                    let coinObject = null;
+                    if (this._customCoinBuilder) {
+                        coinObject = this._customCoinBuilder(internalTicker, mapping.protocol ?? null);
+                    }
+                    if (!coinObject && !this.useRestrictedCoinsSet) {
+                        const name = item.name ?? internalTicker;
+                        const decimals =
+                            typeof item.decimals === "number" ? item.decimals : DEFAULT_CRYPTO_DECIMAL_COUNT;
+                        const contract = item.tokenContract || null;
+                        coinObject = new Coin(
+                            name,
+                            internalTicker,
+                            tickerPrintable,
+                            decimals,
+                            null,
+                            "",
+                            null,
+                            null,
+                            1,
+                            null,
+                            [],
+                            60000,
+                            null,
+                            protocol,
+                            contract,
+                            false
+                        );
+                    }
+                    if (!coinObject) return null;
+
+                    const hasExtraId = item.isExtraIdSupported ?? false;
+                    const extraIdName = item.extraIdName ?? null;
+                    const depositAvailable = item.sell === true;
+                    const withdrawalAvailable = item.buy === true;
+                    const popularity = item.featured ? 1 : 0;
+                    const validationRegex = item.validationRegexp ?? null;
+                    const iconUrl = item.image ?? FALLBACK_ASSET_ICON_URL;
+
+                    return new SwapProviderCoinInfo(
+                        coinObject,
+                        providerCurrencyCode,
+                        providerNetwork,
+                        !!hasExtraId,
+                        extraIdName,
+                        popularity,
+                        iconUrl,
+                        depositAvailable,
+                        withdrawalAvailable,
+                        validationRegex,
+                        true
+                    );
+                } catch (error) {
+                    Logger.logError(error, `${loggerSource} while processing mapped currency ${rabbitTicker}`);
+                    return null;
+                }
+            });
+
+            this._supportedCoins = mappedCoins.filter(Boolean);
+            this._supportedCoinsLastUpdateTimestamp = Date.now();
+            this._putPopularCoinsFirst();
+            await super._fetchSupportedCurrenciesIfNeeded();
+        } catch (error) {
+            improveAndRethrow(error, loggerSource);
+        }
+    }
+
+    async _validateAddressWithProvider(network, baseCode, address, extraId = null) {
+        const loggerSource = "ChangeNow::_validateAddressWithProvider";
+        try {
+            if (!this._apiKey) {
+                return this.isAddressValidForAsset({ ticker: baseCode }, address);
+            }
+
+            // Compose request parameters: currency (ticker or network) and address.
+            const currencyParameter = (network || baseCode).toLowerCase();
+            const parameters = { currency: currencyParameter, address };
+
+            // Some currencies (e.g. XRP) require a destination tag/memo for validation.
+            // Passing extraId will prevent "Extra Id is required" errors.
+            if (extraId) {
+                parameters.extraId = extraId;
+            }
+
+            const response = await axios.get(`${this._URL}/validate/address`, {
+                ...this._axiosGetPreset,
+                ...createRobustTimeoutSetupForAxios(),
+                params: parameters,
+            });
+
+            if (response.status === 200 && typeof response.data === "object") {
+                const isValid = response.data?.result === true;
+                if (!isValid) {
+                    Logger.log(
+                        `Address validation failed: ${address}, reason: ${response.data?.message}`,
+                        loggerSource
+                    );
+                }
+                return isValid;
+            }
+
+            // Unexpected response: return true to avoid blocking the swap.
+            Logger.log(
+                `Unexpected address validation response for ${address}: ${safeStringify(response.data)}`,
+                loggerSource
+            );
+            return true;
+        } catch (error) {
+            Logger.logError(error, loggerSource);
+            return true;
+        }
+    }
+
+    async getSwapInfo(
+        fromCoin,
+        toCoin,
+        amountCoins,
+        fixed = false,
+        fromCoinToUsdRate = null,
+        amountIsToReceive = false,
+        bannedPartners = [],
+        whitelistedPartners = null
+    ) {
+        const loggerSource = "ChangeNow::getSwapInfo";
+        try {
+            if (
+                !(fromCoin instanceof Coin) ||
+                !(toCoin instanceof Coin) ||
+                typeof amountCoins !== "string" ||
+                BigNumber(amountCoins).lte("0")
+            ) {
+                throw new Error(`Invalid swap parameters: ${amountCoins} ${fromCoin?.ticker} -> ${toCoin?.ticker}`);
+            }
+            await this._fetchSupportedCurrenciesIfNeeded();
+            const fromInfo = this._supportedCoins.find(info => info.coin.ticker === fromCoin.ticker);
+            const toInfo = this._supportedCoins.find(info => info.coin.ticker === toCoin.ticker);
+            if (
+                !fromInfo ||
+                !toInfo ||
+                !fromInfo.deposit ||
+                !fromInfo.isAvailable ||
+                !toInfo.withdrawal ||
+                !toInfo.isAvailable
+            ) {
+                return {
+                    result: false,
+                    reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED,
+                    smallestMin: null,
+                    greatestMax: null,
+                };
+            }
+            const fromCode = fromInfo.code;
+            const toCode = toInfo.code;
+            const fromNetwork = fromInfo.network;
+            const toNetwork = toInfo.network;
+
+            let minAmount = null;
+            let maxAmount = null;
+            try {
+                const rangeResponse = await axios.get(`${this._URL}/exchange/range`, {
+                    ...this._axiosGetPreset,
+                    ...createRobustTimeoutSetupForAxios(),
+                    params: {
+                        fromCurrency: fromCode,
+                        toCurrency: toCode,
+                        ...(fromNetwork ? { fromNetwork } : {}),
+                        ...(toNetwork ? { toNetwork } : {}),
+                        ...(fixed ? { flow: "fixed-rate" } : {}),
+                    },
+                });
+                if (rangeResponse.status === 200 && typeof rangeResponse.data === "object") {
+                    const data = rangeResponse.data;
+                    if (data.minAmount != null && BigNumber(data.minAmount).gt("0")) {
+                        minAmount = BigNumber(
+                            AmountUtils.trim(data.minAmount, amountIsToReceive ? toCoin.digits : fromCoin.digits)
+                        ).toString();
+                    }
+                    if (data.maxAmount != null && BigNumber(data.maxAmount).gt("0")) {
+                        maxAmount = BigNumber(
+                            AmountUtils.trim(data.maxAmount, amountIsToReceive ? toCoin.digits : fromCoin.digits)
+                        ).toString();
+                    }
+                } else {
+                    Logger.log(
+                        `Unexpected /exchange/range response: ${rangeResponse.status}, ${safeStringify(
+                            rangeResponse.data
+                        )}`,
+                        loggerSource
+                    );
+                }
+            } catch (error) {
+                Logger.logError(error, `${loggerSource} while fetching range`);
+            }
+            const requestedAmount = BigNumber(amountCoins);
+            if (minAmount != null && requestedAmount.lt(minAmount)) {
+                return {
+                    result: false,
+                    reason: SwapProvider.NO_SWAPS_REASONS.TOO_LOW,
+                    smallestMin: minAmount,
+                    greatestMax: maxAmount,
+                };
+            }
+            if (maxAmount != null && requestedAmount.gt(maxAmount)) {
+                return {
+                    result: false,
+                    reason: SwapProvider.NO_SWAPS_REASONS.TOO_HIGH,
+                    smallestMin: minAmount,
+                    greatestMax: maxAmount,
+                };
+            }
+
+            const estimateParameters = {
+                fromCurrency: fromCode,
+                toCurrency: toCode,
+                ...(fromNetwork ? { fromNetwork } : {}),
+                ...(toNetwork ? { toNetwork } : {}),
+                flow: fixed ? "fixed-rate" : "standard",
+            };
+            if (amountIsToReceive) {
+                estimateParameters.toAmount = amountCoins;
+            } else {
+                estimateParameters.fromAmount = amountCoins;
+            }
+            const estimateResponse = await axios.get(`${this._URL}/exchange/estimated-amount`, {
+                ...this._axiosGetPreset,
+                ...createRobustTimeoutSetupForAxios(),
+                params: estimateParameters,
+            });
+            if (estimateResponse.status !== 200 || typeof estimateResponse.data !== "object") {
+                throw new Error(
+                    `Unexpected estimate response: ${estimateResponse.status} ${safeStringify(estimateResponse.data)}`
+                );
+            }
+            const estimation = estimateResponse.data;
+            const fromAmountResult =
+                estimation.fromAmount != null ? BigNumber(estimation.fromAmount).toString() : amountCoins;
+            const toAmountResult =
+                estimation.toAmount != null ? BigNumber(estimation.toAmount).toString() : amountCoins;
+            const rateValue = BigNumber(toAmountResult).div(BigNumber(fromAmountResult)).toString();
+            const durationMinutesRange = estimation.transactionSpeedForecast ?? "";
+            const rateId = estimation.rateId ?? null;
+            const rawSwapData = {
+                fromAmount: fromAmountResult,
+                toAmount: toAmountResult,
+                rate: rateValue,
+                rateId,
+                fromCode,
+                toCode,
+                fromNetwork,
+                toNetwork,
+            };
+            return {
+                result: true,
+                min: minAmount,
+                max: maxAmount,
+                smallestMin: minAmount,
+                greatestMax: maxAmount,
+                rate: rateValue,
+                durationMinutesRange: durationMinutesRange ? `${durationMinutesRange}` : "",
+                fixed: !!fixed,
+                isRefundAddressRequired: false,
+                rawSwapData,
+            };
+        } catch (error) {
+            if (error?.response?.status === 429) {
+                return {
+                    result: false,
+                    reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
+                    smallestMin: null,
+                    greatestMax: null,
+                };
+            }
+            Logger.logError(error, loggerSource);
+            improveAndRethrow(error, loggerSource);
+        }
+    }
+
+    async createSwap(
+        fromCoin,
+        toCoin,
+        amount,
+        toAddress,
+        refundAddress,
+        proprietarySwapEstimationData,
+        clientIpAddress,
+        fixed,
+        toCurrencyExtraId = "",
+        refundExtraId = "",
+        amountIsToReceive = false
+    ) {
+        const loggerSource = "ChangeNow::createSwap";
+        try {
+            if (
+                !(fromCoin instanceof Coin) ||
+                !(toCoin instanceof Coin) ||
+                typeof amount !== "string" ||
+                BigNumber(amount).lte("0")
+            ) {
+                throw new Error(`Invalid swap parameters: ${amount} ${fromCoin?.ticker} -> ${toCoin?.ticker}`);
+            }
+
+            if (typeof toAddress !== "string" || !toAddress.trim()) {
+                throw new Error(`Invalid destination address: ${safeStringify(toAddress)}`);
+            }
+
+            await this._fetchSupportedCurrenciesIfNeeded();
+
+            const fromInfo = this._supportedCoins.find(info => info.coin.ticker === fromCoin.ticker);
+            const toInfo = this._supportedCoins.find(info => info.coin.ticker === toCoin.ticker);
+
+            if (!fromInfo || !toInfo) {
+                throw new Error(
+                    `Internal inconsistency: supported coin info not found (${
+                        !fromInfo ? `from=${fromCoin?.ticker}` : ""
+                    }${!fromInfo && !toInfo ? ", " : ""}${!toInfo ? `to=${toCoin?.ticker}` : ""})`
+                );
+            }
+
+            const fromCode = fromInfo.code;
+            const toCode = toInfo.code;
+            const fromNetwork = fromInfo.network;
+            const toNetwork = toInfo.network;
+
+            const addressValid = await this._validateAddressWithProvider(
+                toNetwork,
+                toCode,
+                toAddress,
+                toCurrencyExtraId
+            );
+            if (!addressValid) {
+                return {
+                    result: false,
+                    reason: SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL,
+                    partner: this.id,
+                };
+            }
+            if (refundAddress && refundAddress.trim()) {
+                const refundValid = await this._validateAddressWithProvider(
+                    fromNetwork,
+                    fromCode,
+                    refundAddress,
+                    refundExtraId
+                );
+                if (!refundValid) {
+                    return {
+                        result: false,
+                        reason: SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL,
+                        partner: this.id,
+                    };
+                }
+            }
+
+            const payload = {
+                fromCurrency: fromCode,
+                toCurrency: toCode,
+                address: toAddress,
+            };
+
+            if (fromNetwork) payload.fromNetwork = fromNetwork;
+            if (toNetwork) payload.toNetwork = toNetwork;
+
+            if (amountIsToReceive) {
+                payload.toAmount = amount;
+            } else {
+                payload.fromAmount = amount;
+            }
+            if (fixed) {
+                payload.flow = "fixed-rate";
+                const rateId = proprietarySwapEstimationData?.rateId ?? null;
+                if (rateId) {
+                    payload.rateId = rateId;
+                } else {
+                    throw new Error("Fixed-rate flow requires rateId from estimation");
+                }
+            }
+            if (toCurrencyExtraId) payload.extraId = toCurrencyExtraId;
+            if (refundAddress) payload.refundAddress = refundAddress;
+            if (refundExtraId) payload.refundExtraId = refundExtraId;
+
+            Logger.log(`Sending ChangeNOW create payload: ${safeStringify(payload)}`, loggerSource);
+
+            const response = await axios.post(`${this._URL}/exchange`, payload, {
+                ...this._axiosPostPreset,
+                ...createRobustTimeoutSetupForAxios(),
+            });
+
+            Logger.log(`ChangeNOW create response: ${safeStringify(response.data)}`, loggerSource);
+
+            const data = response.data;
+
+            if (response.status !== 200 && response.status !== 201) {
+                const errorMessageFromProvider =
+                    data?.error || data?.message || `Unexpected response status ${response.status}`;
+                Logger.log(
+                    `ChangeNOW swap creation failed. status=${response.status}, message=${errorMessageFromProvider}`,
+                    loggerSource
+                );
+
+                return {
+                    result: false,
+                    reason: SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL,
+                    partner: this.id,
+                };
+            }
+
+            const swapId = data?.id ?? null;
+            const payinAddress = data?.payinAddress ?? null;
+            const payinExtraId = data?.payinExtraId ?? null;
+            const returnedFromAmount = data?.fromAmount ?? null;
+            const returnedToAmount = data?.toAmount ?? null;
+
+            const computedRate =
+                proprietarySwapEstimationData?.rate ||
+                (returnedFromAmount && returnedToAmount
+                    ? BigNumber(returnedToAmount).div(BigNumber(returnedFromAmount)).toString()
+                    : null);
+
+            return {
+                result: true,
+                swapId: swapId,
+                fromCoin,
+                fromAmount: returnedFromAmount != null ? BigNumber(returnedFromAmount).toString() : undefined,
+                fromAddress: payinAddress,
+                toCoin,
+                toAmount: returnedToAmount != null ? BigNumber(returnedToAmount).toString() : undefined,
+                toAddress: toAddress,
+                fromCurrencyExtraId: payinExtraId,
+                rate: computedRate,
+                fixed: !!fixed,
+            };
+        } catch (error) {
+            const status = error?.response?.status;
+            if (status === 429) {
+                return { result: false, reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED, partner: this.id };
+            }
+            improveAndRethrow(error, loggerSource);
+        }
+    }
+
+    async getExistingSwapsDetailsAndStatus(swapIds) {
+        const loggerSource = "ChangeNow::getExistingSwapsDetailsAndStatus";
+        try {
+            if (!Array.isArray(swapIds) || swapIds.length === 0) {
+                return { result: true, swaps: [] };
+            }
+            await this._fetchSupportedCurrenciesIfNeeded();
+            const swaps = new Array(swapIds.length).fill(null);
+            for (let index = 0; index < swapIds.length; index++) {
+                const id = swapIds[index];
+                try {
+                    const response = await axios.get(`${this._URL}/exchange/by-id`, {
+                        ...this._axiosGetPreset,
+                        ...createRobustTimeoutSetupForAxios(),
+                        params: { id },
+                    });
+                    if (response.status !== 200 || typeof response.data !== "object") {
+                        continue;
+                    }
+                    const transactionData = response.data;
+                    const statusRaw = (transactionData.status || "").toLowerCase();
+
+                    const createdAtMilliseconds =
+                        transactionData.createdAt != null ? new Date(transactionData.createdAt).getTime() : null;
+                    let expiresAtMilliseconds;
+                    if (transactionData.validUntil != null) {
+                        expiresAtMilliseconds = new Date(transactionData.validUntil).getTime();
+                    } else {
+                        expiresAtMilliseconds =
+                            createdAtMilliseconds != null ? createdAtMilliseconds + this._swapExpirationMs : null;
+                    }
+                    const isExpiredByTime = expiresAtMilliseconds != null ? expiresAtMilliseconds < Date.now() : false;
+                    const status = this._mapChangeNowStatusToRabbitStatus(statusRaw, isExpiredByTime);
+
+                    const fromAmountRaw = transactionData.amountFrom ?? transactionData.expectedAmountFrom ?? null;
+                    const toAmountRaw = transactionData.amountTo ?? transactionData.expectedAmountTo ?? null;
+                    const fromAmountString = fromAmountRaw != null ? BigNumber(fromAmountRaw).toString() : null;
+                    const toAmountString = toAmountRaw != null ? BigNumber(toAmountRaw).toString() : null;
+                    const computedRate =
+                        fromAmountString != null && toAmountString != null
+                            ? BigNumber(toAmountString).div(BigNumber(fromAmountString)).toString()
+                            : null;
+                    const payinAddress = transactionData.payinAddress ?? null;
+                    const payinTransactionHash = transactionData.payinHash ?? null;
+                    const payoutAddress = transactionData.payoutAddress ?? null;
+                    const payoutTransactionHash = transactionData.payoutHash ?? null;
+
+                    // Determine from/to currency codes and networks (base ticker + network).
+                    const fromCurrencyCode = transactionData.fromCurrency?.toUpperCase?.() ?? null;
+                    const toCurrencyCode = transactionData.toCurrency?.toUpperCase?.() ?? null;
+                    const fromNetwork = transactionData.fromNetwork?.toLowerCase() ?? null;
+                    const toNetwork = transactionData.toNetwork?.toLowerCase() ?? null;
+
+                    const fromInfo = this._supportedCoins.find(info => {
+                        const matchBase =
+                            fromCurrencyCode &&
+                            info.code.toUpperCase() === fromCurrencyCode &&
+                            (!fromNetwork || info.network === fromNetwork);
+                        return matchBase;
+                    });
+                    const toInfoMatch = this._supportedCoins.find(info => {
+                        const matchBase =
+                            toCurrencyCode &&
+                            info.code.toUpperCase() === toCurrencyCode &&
+                            (!toNetwork || info.network === toNetwork);
+                        return matchBase;
+                    });
+
+                    const fromCoinObject = fromInfo ? fromInfo.coin : null;
+                    const toCoinObject = toInfoMatch ? toInfoMatch.coin : null;
+
+                    const isFixed = transactionData.validUntil != null; // validUntil denotes fixed‑rate swap
+
+                    const existingSwap = new ExistingSwap(
+                        id,
+                        status,
+                        createdAtMilliseconds,
+                        expiresAtMilliseconds,
+                        -1,
+                        computedRate,
+                        isFixed,
+                        transactionData.refundAddress ?? null,
+                        payinAddress,
+                        fromCoinObject,
+                        fromAmountString,
+                        payinTransactionHash,
+                        null,
+                        toCoinObject,
+                        toAmountString,
+                        payoutTransactionHash,
+                        null,
+                        payoutAddress,
+                        this.id,
+                        transactionData.payinExtraId ?? null,
+                        transactionData.payoutExtraId ?? null,
+                        transactionData.refundExtraId ?? null
+                    );
+                    swaps[index] = existingSwap;
+                } catch (error) {
+                    Logger.logError(error, `${loggerSource} for id ${id}`);
+                }
+            }
+            return { result: true, swaps };
+        } catch (error) {
+            Logger.logError(error, loggerSource);
+            if (error?.response?.status === 429) {
+                return { result: false, reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED };
+            }
+            improveAndRethrow(error, loggerSource);
+        }
+    }
+
+    _mapChangeNowStatusToRabbitStatus(status, isExpiredByTime) {
+        switch (status) {
+            case "new":
+            case "waiting":
+                if (isExpiredByTime) {
+                    return SwapProvider.SWAP_STATUSES.EXPIRED;
+                }
+                return SwapProvider.SWAP_STATUSES.WAITING_FOR_PAYMENT;
+            case "confirming":
+                return SwapProvider.SWAP_STATUSES.CONFIRMING;
+            case "exchanging":
+                return SwapProvider.SWAP_STATUSES.EXCHANGING;
+            case "sending":
+                return SwapProvider.SWAP_STATUSES.EXCHANGING;
+            case "finished":
+                return SwapProvider.SWAP_STATUSES.COMPLETED;
+            case "failed":
+                return SwapProvider.SWAP_STATUSES.FAILED;
+            case "refunded":
+                return SwapProvider.SWAP_STATUSES.REFUNDED;
+            case "verifying":
+                return SwapProvider.SWAP_STATUSES.VERIFYING;
+            default:
+                throw new Error(`Unknown ChangeNOW status: ${status}`);
+        }
+    }
+
+    async getPartnersList() {
+        return [
+            new Partner(
+                this.id,
+                "ChangeNOW",
+                "https://storage.swapspace.co/static/wrzph_gI7rsmSgYt3x5f1kAuz.svg",
+                KYC_LEVELS.LOW
+            ),
+        ];
+    }
+}