@rabbitio/ui-kit 1.0.0-beta.12 → 1.0.0-beta.121

package/src/swaps-lib/services/publicSwapService.js

@@ -0,0 +1,523 @@
+import { BigNumber } from "bignumber.js";
+
+import { FiatCurrenciesService } from "../../common-apis/services/fiatCurrenciesService.js";
+import { improveAndRethrow } from "../../common-apis/utils/errorUtils.js";
+import { safeStringify } from "../../common-apis/utils/safeStringify.js";
+import { Logger } from "../../common-apis/utils/logging/logger.js";
+import { Coin } from "../../common-apis/models/coin.js";
+import { AmountUtils } from "../../common-apis/utils/amountUtils.js";
+import { BaseSwapCreationInfo } from "../models/baseSwapCreationInfo.js";
+import { SwapUtils } from "../utils/swapUtils.js";
+import { SwapspaceSwapProvider } from "../external-apis/swapspaceSwapProvider.js";
+import { SwapProvider } from "../external-apis/swapProvider.js";
+import { LetsExchangeSwapProvider } from "../external-apis/letsExchangeSwapProvider.js";
+import { GoogleAnalyticsAdapter } from "../../common-apis/adapters/analyticsAdapters/googleAnalyticsAdapter.js";
+
+export class PublicSwapService {
+    static PUBLIC_SWAP_CREATED_ANALYTICS_EVENT = "public_swap_created_event";
+    static PUBLIC_SWAP_SUCCEED_ANALYTICS_EVENT = "public_swap_succeed_event";
+
+    static PUBLIC_SWAPS_COMMON_ERRORS = {
+        REQUESTS_LIMIT_EXCEEDED: "requestsLimitExceeded",
+    };
+
+    static PUBLIC_SWAP_DETAILS_FAIL_REASONS = {
+        AMOUNT_LESS_THAN_MIN_SWAPPABLE: "amountLessThanMinSwappable",
+        AMOUNT_HIGHER_THAN_MAX_SWAPPABLE: "amountHigherThanMaxSwappable",
+        PAIR_NOT_SUPPORTED: "pairNotSupported",
+        NO_FIXED_BUT_HAVE_FLOATING_PUBLIC_SWAP_OPTION: "noFixedButHaveFloatingPublicSwapOption",
+        NO_FLOATING_BUT_HAVE_FIXED_PUBLIC_SWAP_OPTION: "noFloatingButHaveFixedPublicSwapOption",
+    };
+
+    static PUBLIC_SWAP_CREATION_FAIL_REASONS = {
+        RETRIABLE_FAIL: "retriableFail",
+    };
+
+    static PUBLIC_SWAP_RETRIABLE_SWAP_CREATION_ERRORS = {
+        IP_BANNED: "ipBanned",
+    };
+
+    static _fiatDecimalsCount = FiatCurrenciesService.getCurrencyDecimalCountByCode("USD");
+
+    /**
+     * TODO: [feature, critical] implement more adequate providers list&initiation logic. task_id=6a6b0fbbee8a413690c49b1e4ee289cb
+     *
+     * @param apiKeysProxyUrl {string|null}
+     * @param cache {Cache}
+     * @param providers {SwapProvider[]|null}
+     */
+    constructor(apiKeysProxyUrl, cache, providers = null) {
+        if (apiKeysProxyUrl) {
+            this._swapProvider = new SwapspaceSwapProvider(apiKeysProxyUrl, cache, () => null, false);
+            this._fixedSwapProvider = new LetsExchangeSwapProvider(apiKeysProxyUrl, cache, () => null, false);
+        } else if (providers?.length) {
+            this._swapProvider = providers.find(p => p.id === "swapspace");
+            this._fixedSwapProvider = providers.find(p => p.id === "letsexchange");
+        }
+    }
+
+    async initialize() {
+        try {
+            await Promise.all([this._swapProvider.initialize(), this._fixedSwapProvider.initialize()]);
+        } catch (e) {
+            Logger.logError(e, "PublicSwapService.initialize");
+        }
+    }
+
+    /**
+     * Retrieves swap details that can be used to create swap.
+     *
+     * @param provider {SwapProvider}
+     * @param fromCoinOrTicker {Coin|string}
+     * @param toCoinOrTicker {Coin|string}
+     * @param amountCoins {string}
+     * @param [fixed=false] {boolean|null} null means fixed or float doesn't matter
+     * @param [coinUsdtRate=null] {number|null} rate of amount coin to USDT
+     * @param [amountIsToReceive=false] {boolean} whether the given amount is receiving amount.
+     *        False means the amount is the sending amount.
+     * @param bannedPartners {string[]} array of banned swap partners (providers) ids (rabbit ids)
+     * @param [whitelistedPartners=null] {string[]|null} array of banned swap partners (providers) ids (rabbit ids)
+     * @return {Promise<{
+     *             result: false,
+     *             reason: string,
+     *             min: (string|null),
+     *             max: (string|null),
+     *             rate: (string|undefined),
+     *             fiatMin: (number|null),
+     *             fiatMax: (number|null)
+     *         }|{
+     *             result: true,
+     *             swapCreationInfo: BaseSwapCreationInfo
+     *         }>}
+     */
+    async getPublicSwapDetails(
+        provider,
+        fromCoinOrTicker,
+        toCoinOrTicker,
+        amountCoins,
+        fixed = false,
+        coinUsdtRate = null,
+        amountIsToReceive = false,
+        bannedPartners = [],
+        whitelistedPartners = null
+    ) {
+        const loggerSource = "getPublicSwapDetails";
+        try {
+            if (amountIsToReceive && !fixed) {
+                throw new Error("Estimating allowed only for fixed rate.");
+            }
+
+            let fromCoin = fromCoinOrTicker;
+            if (typeof fromCoin === "string") {
+                fromCoin = this.getCoinByTickerIfPresent(fromCoin);
+            }
+            let toCoin = toCoinOrTicker;
+            if (typeof toCoin === "string") {
+                toCoin = this.getCoinByTickerIfPresent(toCoin);
+            }
+            const isPartnerBanned =
+                bannedPartners.includes(provider.id) ||
+                (whitelistedPartners != null && !whitelistedPartners.includes(provider.id));
+            if (!fromCoin || !toCoin || isPartnerBanned) {
+                return {
+                    result: false,
+                    reason: PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.PAIR_NOT_SUPPORTED,
+                    min: null,
+                    max: null,
+                    fiatMin: null,
+                    fiatMax: null,
+                    rate: undefined,
+                };
+            }
+
+            const details = await provider.getSwapInfo(
+                fromCoin,
+                toCoin,
+                amountCoins,
+                fixed,
+                coinUsdtRate,
+                amountIsToReceive,
+                bannedPartners,
+                whitelistedPartners
+            );
+
+            // eslint-disable-next-line no-console
+            console.log("getSwapInfo raw result: ", details, loggerSource);
+
+            const min =
+                details.smallestMin != null && BigNumber(details.smallestMin).gt("0") ? details.smallestMin : null;
+            const max =
+                details.greatestMax != null && BigNumber(details.greatestMax).gt("0") ? details.greatestMax : null;
+            let fiatMin = null,
+                fiatMax = null;
+            if (coinUsdtRate != null) {
+                if (min != null) {
+                    fiatMin = BigNumber(min).times(coinUsdtRate).toFixed(PublicSwapService._fiatDecimalsCount);
+                }
+                if (max != null) {
+                    fiatMax = BigNumber(max).times(coinUsdtRate).toFixed(PublicSwapService._fiatDecimalsCount);
+                }
+            }
+
+            const composeFailResult = reason => ({
+                result: false,
+                reason: reason,
+                min: min ?? null,
+                fiatMin: fiatMin,
+                max: max ?? null,
+                fiatMax: fiatMax,
+                rate: details.rate ?? null,
+            });
+
+            if (!details.result) {
+                if (details?.reason === SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED) {
+                    return composeFailResult(PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.PAIR_NOT_SUPPORTED);
+                } else if (details?.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
+                    SwapUtils.safeHandleRequestsLimitExceeding();
+                    return composeFailResult(PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+                } else if (details?.reason === SwapProvider.NO_SWAPS_REASONS.NO_FLOATING_BUT_HAVE_FIXED) {
+                    return composeFailResult(
+                        PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.NO_FLOATING_BUT_HAVE_FIXED_PUBLIC_SWAP_OPTION
+                    );
+                } else if (details?.reason === SwapProvider.NO_SWAPS_REASONS.NO_FIXED_BUT_HAVE_FLOATING) {
+                    return composeFailResult(
+                        PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.NO_FIXED_BUT_HAVE_FLOATING_PUBLIC_SWAP_OPTION
+                    );
+                }
+            }
+
+            const amountBigNumber = BigNumber(amountCoins);
+            if (typeof min === "string" && amountBigNumber.lt(min)) {
+                return composeFailResult(
+                    PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.AMOUNT_LESS_THAN_MIN_SWAPPABLE
+                );
+            } else if (typeof max === "string" && amountBigNumber.gt(max)) {
+                return composeFailResult(
+                    PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.AMOUNT_HIGHER_THAN_MAX_SWAPPABLE
+                );
+            }
+
+            const fromAmountCoins = amountIsToReceive
+                ? AmountUtils.trim(amountBigNumber.div(details.rate), fromCoin.digits)
+                : amountCoins;
+            const toAmountCoins = amountIsToReceive
+                ? amountCoins
+                : AmountUtils.trim(amountBigNumber.times(details.rate), toCoin.digits);
+            const result = {
+                result: true,
+                swapCreationInfo: new BaseSwapCreationInfo(
+                    fromCoin,
+                    toCoin,
+                    fromAmountCoins,
+                    toAmountCoins,
+                    details.rate,
+                    details.rawSwapData,
+                    min,
+                    fiatMin,
+                    max,
+                    fiatMax,
+                    details.durationMinutesRange,
+                    details.fixed,
+                    provider.id,
+                    details.isRefundAddressRequired
+                ),
+            };
+            Logger.log(
+                `Result: ${safeStringify({
+                    result: result.result,
+                    swapCreationInfo: {
+                        ...result.swapCreationInfo,
+                        fromCoin: result?.swapCreationInfo?.fromCoin?.ticker,
+                        toCoin: result?.swapCreationInfo?.toCoin?.ticker,
+                    },
+                })}`,
+                loggerSource
+            );
+
+            return result;
+        } catch (e) {
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    /**
+     * Creates swap by given params.
+     *
+     * @param provider {SwapProvider}
+     * @param fromCoinTicker {string}
+     * @param toCoinTicker {string}
+     * @param amount {string}
+     * @param proprietarySwapEstimationData {Object|null}
+     * @param toAddress {string}
+     * @param refundAddress {string}
+     * @param clientIp {string}
+     * @param [toCurrencyExtraId] {string}
+     * @param [refundExtraId] {string}
+     * @param [amountIsToReceive=false] {boolean} whether the given amount is receiving amount.
+     *        False means the amount is the sending amount.
+     * @param isFixed {boolean}
+     * @return {Promise<{
+     *             result: true,
+     *             fiatCurrencyCode: string,
+     *             toCoinTicker: string,
+     *             fromAmountFiat: (number|null),
+     *             address: string,
+     *             durationMinutesRange: string,
+     *             fromAmount: string,
+     *             toAmount: string,
+     *             toAmountFiat: (number|null),
+     *             fiatCurrencyDecimals: number,
+     *             fromCoinTicker: string,
+     *             rate: string,
+     *             swapId: string,
+     *             fromCurrencyExtraId: string,
+     *             fixed: boolean
+     *         }|{
+     *             result: false,
+     *             reason: string,
+     *             [errorCode]: string
+     *         }>}
+     */
+    async createPublicSwap(
+        provider,
+        fromCoinTicker,
+        toCoinTicker,
+        amount,
+        proprietarySwapEstimationData,
+        toAddress,
+        refundAddress,
+        clientIp,
+        toCurrencyExtraId,
+        refundExtraId,
+        amountIsToReceive = false,
+        isFixed = false
+    ) {
+        const loggerSource = "createPublicSwap";
+        try {
+            if (
+                !(provider instanceof SwapProvider) ||
+                typeof fromCoinTicker !== "string" ||
+                typeof toCoinTicker !== "string" ||
+                typeof amount !== "string" ||
+                typeof toAddress !== "string"
+            ) {
+                throw new Error(`Wrong input: ${provider} ${fromCoinTicker} ${toCoinTicker} ${amount} ${isFixed}`);
+            }
+
+            Logger.log(
+                `Start: ${provider.id} ${amount} ${fromCoinTicker} -> ${toCoinTicker}. raw data: ${proprietarySwapEstimationData}`,
+                loggerSource
+            );
+
+            const [fromCoin, toCoin] = [fromCoinTicker, toCoinTicker].map(t => this.getCoinByTickerIfPresent(t));
+            const result = await provider.createSwap(
+                fromCoin,
+                toCoin,
+                amount,
+                toAddress,
+                refundAddress,
+                proprietarySwapEstimationData,
+                clientIp,
+                isFixed,
+                toCurrencyExtraId,
+                refundExtraId,
+                amountIsToReceive
+            );
+            Logger.log(
+                `Created:${safeStringify({ ...result, fromCoin: fromCoinTicker, toCoin: toCoinTicker })}`,
+                loggerSource
+            );
+            if (!result?.result) {
+                if (result?.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
+                    SwapUtils.safeHandleRequestsLimitExceeding();
+                    return {
+                        result: false,
+                        reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
+                    };
+                }
+
+                // Expose only specific retriable fails with explicit error code at the public service layer.
+                if (
+                    result?.reason === SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL &&
+                    typeof result?.errorCode === "string" &&
+                    result.errorCode.length > 0
+                ) {
+                    let serviceErrorCode;
+                    switch (result.errorCode) {
+                        case SwapProvider.RETRIABLE_SWAP_CREATION_ERRORS?.IP_BANNED:
+                            serviceErrorCode = PublicSwapService.PUBLIC_SWAP_RETRIABLE_SWAP_CREATION_ERRORS.IP_BANNED;
+                            break;
+                        default:
+                            throw new Error(
+                                `Unhandled retriable swap creation error code received: ${result.errorCode}`
+                            );
+                    }
+
+                    // TODO: [feature, high] implement retrying if one partner fail and we have another partners task_id=a07e367e488f4a4899613ac9056fa359
+
+                    return {
+                        result: false,
+                        reason: PublicSwapService.PUBLIC_SWAP_CREATION_FAIL_REASONS.RETRIABLE_FAIL,
+                        errorCode: serviceErrorCode,
+                    };
+                }
+            }
+            if (result.result && result?.swapId) {
+                let fromAmountFiat = null,
+                    toAmountFiat = null;
+                try {
+                    const fromCoinUsdtRate = (await provider.getCoinToUSDTRate(fromCoinTicker))?.rate ?? null;
+                    const toCoinUsdtRate = (await provider.getCoinToUSDTRate(toCoinTicker))?.rate ?? null;
+                    if (fromCoinUsdtRate != null && result.fromAmount != null) {
+                        fromAmountFiat = BigNumber(result.fromAmount)
+                            .times(fromCoinUsdtRate)
+                            .toFixed(PublicSwapService._fiatDecimalsCount);
+                    }
+                    if (toCoinUsdtRate != null && result.toAmount != null) {
+                        toAmountFiat = BigNumber(result.toAmount)
+                            .times(toCoinUsdtRate)
+                            .toFixed(PublicSwapService._fiatDecimalsCount);
+                    }
+                } catch (e) {
+                    Logger.logError(e, loggerSource, "Failed to calculate fiat amounts for result");
+                }
+
+                await GoogleAnalyticsAdapter.sendEvent(PublicSwapService.PUBLIC_SWAP_CREATED_ANALYTICS_EVENT, {
+                    coin_amount: result.fromAmount,
+                    usd_amount: fromAmountFiat,
+                    fromCoin: fromCoinTicker,
+                    toCoin: toCoinTicker,
+                });
+
+                const toReturn = {
+                    result: true,
+                    swapId: result.swapId,
+                    fromCoinTicker: fromCoinTicker,
+                    toCoinTicker: toCoinTicker,
+                    fromAmount: result.fromAmount,
+                    toAmount: result.toAmount,
+                    fromAmountFiat: fromAmountFiat,
+                    toAmountFiat: toAmountFiat,
+                    fiatCurrencyCode: "USD",
+                    fiatCurrencyDecimals: PublicSwapService._fiatDecimalsCount,
+                    rate: result.rate,
+                    durationMinutesRange: null, // TODO: [feature, high] add duration. task_id=3f3d73d7cf44454282222901409149b5
+                    address: result.fromAddress, // CRITICAL: this is the address to send coins to swaps provider
+                    fromCurrencyExtraId: result.fromCurrencyExtraId ?? "", // CRITICAL: this is the extra ID for address to send coins to swaps provider
+                    fixed: result.fixed,
+                };
+
+                this._savePublicSwapIdLocally(result.swapId);
+
+                Logger.log(
+                    `Returning: ${safeStringify({
+                        ...toReturn,
+                        fromCoin: fromCoinTicker,
+                        toCoin: toCoinTicker,
+                    })}`,
+                    loggerSource
+                );
+                return toReturn;
+            }
+
+            throw new Error(`Unexpected result from provider ${safeStringify(result)}`);
+        } catch (e) {
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    // TODO: [feature, moderate] move to client. task_id=de4b1ddc652b4a27a472341609fcb6e4
+    // /**
+    //  * Retrieves the whole available swaps history by ids saved locally.
+    //  *
+    //  * @return {Promise<{
+    //  *             result: true,
+    //  *             swaps: ExistingSwapWithFiatData[]
+    //  *         }|{
+    //  *             result: false,
+    //  *             reason: string
+    //  *         }>}
+    //  */
+    // async getPublicSwapsHistory() {
+    //     try {
+    //         const swapIds = this._getPublicSwapIdsSavedLocally();
+    //         if (swapIds.length) {
+    //             return await this.getPublicExistingSwapDetailsAndStatus(swapIds);
+    //         }
+    //         return { result: true, swaps: [] };
+    //     } catch (e) {
+    //         improveAndRethrow(e, "getPublicSwapsHistory");
+    //     }
+    // }
+
+    /**
+     * @param swapId {string}
+     * @private
+     */
+    _savePublicSwapIdLocally(swapId) {
+        if (typeof window !== "undefined") {
+            try {
+                const saved = localStorage.getItem("publicSwapIds");
+                const ids = typeof saved === "string" && saved.length > 0 ? saved.split(",") : [];
+                ids.push(swapId);
+                localStorage.setItem("publicSwapIds", ids.join(","));
+            } catch (e) {
+                improveAndRethrow(e, "_savePublicSwapIdLocally");
+            }
+        }
+    }
+
+    /**
+     * @private
+     * @return {string[]}
+     */
+    _getPublicSwapIdsSavedLocally() {
+        if (typeof window !== "undefined") {
+            try {
+                const saved = localStorage.getItem("publicSwapIds");
+                return typeof saved === "string" && saved.length > 0 ? saved.split(",") : [];
+            } catch (e) {
+                improveAndRethrow(e, "_getPublicSwapIdsSavedLocally");
+            }
+        }
+    }
+
+    /**
+     * @param ticker {string}
+     * @return {Coin|null}
+     */
+    getCoinByTickerIfPresent(ticker) {
+        return (
+            this._swapProvider.getCoinByTickerIfPresent(ticker) ??
+            this._fixedSwapProvider.getCoinByTickerIfPresent(ticker)
+        );
+    }
+
+    /**
+     * Retrieves flat partners list across all supported providers (including aggregators).
+     *
+     * @param providers {SwapProvider[]}
+     * @return {Promise<Partner[]>}
+     */
+    async getPartnersList(providers) {
+        try {
+            let allPartners = providers.map(provider => provider.getPartnersList());
+            allPartners = await Promise.all(allPartners);
+            allPartners = allPartners.flat().flat();
+            return allPartners.reduce((prev, cur) => {
+                const alreadyAdded = prev.find(partner => partner.name.toLowerCase() === cur.name.toLowerCase());
+                if (!alreadyAdded) {
+                    prev.push(cur);
+                } else {
+                    // Attempting to fill missing data if there are the same partner from different providers
+                    alreadyAdded.logoUrl = cur.logoUrl ?? alreadyAdded.logoUrl;
+                    alreadyAdded.kycLevel = cur.kycLevel ?? alreadyAdded.kycLevel;
+                }
+                return prev;
+            }, []);
+        } catch (e) {
+            Logger.logError(e, "getPartnersList");
+        }
+        return [];
+    }
+}

package/src/swaps-lib/test/external-apis/changeHeroSwapProvider/_fetchSupportedCurrenciesIfNeeded.test.js

@@ -0,0 +1,155 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { ChangeHeroSwapProvider } from "../../../external-apis/changeHeroSwapProvider.js";
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+
+describe("tests/units/external-apis/changeHeroSwapProvider/_fetchSupportedCurrenciesIfNeeded.test.js", function () {
+    describe("_fetchSupportedCurrenciesIfNeeded", function () {
+        let changeHeroSwapProvider;
+        let axiosPostStub;
+        let _fetchSupportedCurrenciesIfNeededStub;
+
+        const anyError = new Error("Any error");
+
+        const validCurrenciesResponse = () => ({
+            data: {
+                jsonrpc: "2.0",
+                id: "rabbit-123-getCurrenciesFull",
+                result: [
+                    {
+                        name: "BTC",
+                        protocol: "BTC",
+                        publicTicker: "BTC",
+                        fullName: "Bitcoin",
+                        precision: 8,
+                        inboundEnabled: true,
+                        outboundEnabled: true,
+                        extraIdName: "",
+                        image: "https://example.com/btc.svg",
+                        enabled: true,
+                        addressUrl: "https://addr.example.com/$$",
+                        transactionUrl: "https://tx.example.com/$$",
+                        blockchain: "Bitcoin",
+                    },
+                ],
+            },
+        });
+
+        beforeEach(() => {
+            axiosPostStub = sinon.stub(axios, "post");
+            _fetchSupportedCurrenciesIfNeededStub = sinon
+                .stub(SwapProvider.prototype, "_fetchSupportedCurrenciesIfNeeded")
+                .resolves();
+
+            changeHeroSwapProvider = new ChangeHeroSwapProvider("/", new Cache(), undefined, false);
+
+            axiosPostStub.resolves({ data: { result: [] } });
+        });
+
+        afterEach(() => {
+            axiosPostStub.restore();
+            _fetchSupportedCurrenciesIfNeededStub.restore();
+        });
+
+        it("Should throw an error if axios throws error", async () => {
+            axiosPostStub.resetBehavior();
+            axiosPostStub.rejects(anyError);
+
+            return changeHeroSwapProvider._fetchSupportedCurrenciesIfNeeded().should.be.rejectedWith(anyError);
+        });
+
+        it("Should send an axios POST request", async () => {
+            await changeHeroSwapProvider._fetchSupportedCurrenciesIfNeeded();
+
+            axiosPostStub.calledOnce.should.be.true();
+        });
+
+        it("Should send the request to the correct URL", async () => {
+            await changeHeroSwapProvider._fetchSupportedCurrenciesIfNeeded();
+
+            axiosPostStub.args[0][0].should.equal(changeHeroSwapProvider._URL);
+        });
+
+        it('Should request "getCurrenciesFull" JSON-RPC method', async () => {
+            await changeHeroSwapProvider._fetchSupportedCurrenciesIfNeeded();
+
+            axiosPostStub.args[0][1].method.should.equal("getCurrenciesFull");
+        });
+
+        it("Should reject when provider returns invalid payload (no result array)", async () => {
+            axiosPostStub.resolves({ data: { result: null } });
+
+            return changeHeroSwapProvider
+                ._fetchSupportedCurrenciesIfNeeded()
+                .should.be.rejectedWith(/ChangeHero\.getCurrenciesFull returned invalid payload/);
+        });
+
+        it("Should map currencies into supported coins when response is valid", async () => {
+            axiosPostStub.resolves(validCurrenciesResponse());
+
+            await changeHeroSwapProvider._fetchSupportedCurrenciesIfNeeded();
+
+            changeHeroSwapProvider._supportedCoins.length.should.be.above(0);
+        });
+
+        it("Should store transaction URL template by code", async () => {
+            axiosPostStub.resolves(validCurrenciesResponse());
+
+            await changeHeroSwapProvider._fetchSupportedCurrenciesIfNeeded();
+
+            changeHeroSwapProvider._txUrlByCode["btc"].should.equal("https://tx.example.com/$$");
+        });
+
+        it("Should store address URL template by code", async () => {
+            axiosPostStub.resolves(validCurrenciesResponse());
+
+            await changeHeroSwapProvider._fetchSupportedCurrenciesIfNeeded();
+
+            changeHeroSwapProvider._addrUrlByCode["btc"].should.equal("https://addr.example.com/$$");
+        });
+
+        it("Should set supported coins last update timestamp", async () => {
+            axiosPostStub.resolves(validCurrenciesResponse());
+
+            await changeHeroSwapProvider._fetchSupportedCurrenciesIfNeeded();
+
+            changeHeroSwapProvider._supportedCoinsLastUpdateTimestamp.should.be.above(0);
+        });
+
+        it("Should skip invalid currency items that lack required identifiers", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    jsonrpc: "2.0",
+                    id: "rabbit-123-getCurrenciesFull",
+                    result: [
+                        {
+                            name: "ABC",
+                            protocol: "ABC",
+                            fullName: "Abc Coin",
+                            precision: 8,
+                            inboundEnabled: true,
+                            outboundEnabled: true,
+                        },
+                    ],
+                },
+            });
+
+            await changeHeroSwapProvider._fetchSupportedCurrenciesIfNeeded();
+
+            changeHeroSwapProvider._supportedCoins.length.should.equal(0);
+        });
+
+        it("Should call the base _fetchSupportedCurrenciesIfNeeded once after successful load", async () => {
+            axiosPostStub.resolves(validCurrenciesResponse());
+
+            await changeHeroSwapProvider._fetchSupportedCurrenciesIfNeeded();
+
+            _fetchSupportedCurrenciesIfNeededStub.calledOnce.should.be.true();
+        });
+    });
+});