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

package/src/swaps-lib/test/external-apis/goexmeSwapProvider/getSwapInfo.test.js

@@ -0,0 +1,177 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+import { describe, it, beforeEach, afterEach } from "vitest";
+import BigNumber from "bignumber.js";
+
+import { GoexmeSwapProvider } from "../../../external-apis/goexmeSwapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+import { Coin } from "../../../../common-apis/models/coin.js";
+import { Blockchain } from "../../../../common-apis/models/blockchain.js";
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+
+const BTC = new Coin("Bitcoin", "BTC", "BTC", 8, null, "sat", null, null, 1, null, [], null, new Blockchain("Bitcoin"));
+const ETH = new Coin(
+    "Ethereum",
+    "ETH",
+    "ETH",
+    18,
+    null,
+    "wei",
+    null,
+    null,
+    1,
+    null,
+    [],
+    null,
+    new Blockchain("Ethereum")
+);
+
+describe("goexmeSwapProvider", function () {
+    describe("getSwapInfo", function () {
+        const okRate = { result: true, rate: "15", minamount: "0.01", maxamount: "5" };
+        let provider, axiosStub;
+
+        beforeEach(() => {
+            provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
+            provider._supportedCoins = [
+                { coin: BTC, code: "BTC", network: "BTC" },
+                { coin: ETH, code: "ETH", network: "ETH" },
+            ];
+            provider._supportedCoinsLastUpdateTimestamp = Date.now();
+            sinon.stub(provider, "_fetchSupportedCurrenciesIfNeeded").resolves();
+            axiosStub = sinon.stub(axios, "get").callsFake(url => {
+                if (url.includes("/pairs")) return Promise.resolve({ status: 200, data: { BTC: ["ETH"] } });
+                if (url.includes("/rate")) return Promise.resolve({ status: 200, data: okRate });
+                return Promise.resolve({ status: 200, data: {} });
+            });
+        });
+
+        afterEach(() => sinon.restore());
+
+        it("Should return TOO_LOW and TOO_HIGH against min/max", async () => {
+            let info = await provider.getSwapInfo(BTC, ETH, "0.001");
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.TOO_LOW);
+            info = await provider.getSwapInfo(BTC, ETH, "10");
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.TOO_HIGH);
+        });
+
+        it("Should handle case with no min/max limits", async () => {
+            axiosStub.withArgs(sinon.match(/\/rate/)).resolves({ status: 200, data: { result: true, rate: "15" } });
+            const info = await provider.getSwapInfo(BTC, ETH, "1");
+            info.result.should.be.true();
+        });
+
+        it("Should map HTTP 429 to REQUESTS_LIMIT_EXCEEDED", async () => {
+            axiosStub.withArgs(sinon.match(/\/rate/)).rejects({ response: { status: 429 } });
+            const info = await provider.getSwapInfo(BTC, ETH, "1");
+            info.reason.should.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+        });
+
+        it("Should return valid structure on success", async () => {
+            const info = await provider.getSwapInfo(BTC, ETH, "1");
+            info.result.should.be.true();
+            parseFloat(info.rate).should.be.greaterThan(0);
+        });
+
+        it("Should send proper params to /rate", async () => {
+            await provider.getSwapInfo(BTC, ETH, "1");
+            const call = axiosStub.args.find(a => a[0].includes("/rate"));
+            const params = call[1].params;
+            params.should.match({ from: "BTC", to: "ETH", amount: "1" });
+        });
+
+        it("Should throw when amount ≤ 0", async () => {
+            await provider.getSwapInfo(BTC, ETH, "0").should.be.rejected();
+        });
+
+        it("Should return valid result when amount is empty string", async () => {
+            const info = await provider.getSwapInfo(BTC, ETH, "");
+            info.result.should.be.true();
+        });
+
+        it("Should return valid result when amount is non-string", async () => {
+            const info = await provider.getSwapInfo(BTC, ETH, 1);
+            info.result.should.be.true();
+        });
+
+        it("Should propagate unexpected network error unchanged", async () => {
+            const boom = new Error("net-boom");
+            axiosStub.rejects(boom);
+            await provider.getSwapInfo(BTC, ETH, "1").should.be.rejectedWith(boom);
+        });
+
+        it("Should return NOT_SUPPORTED when provider responds { result:false } with 200", async () => {
+            axiosStub.withArgs(sinon.match(/\/rate/)).resolves({ status: 200, data: { result: false } });
+            const info = await provider.getSwapInfo(BTC, ETH, "1");
+            info.result.should.be.false();
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("Should throw when fromCoin/toCoin are not Coin instances", async () => {
+            await provider.getSwapInfo({}, {}, "1").should.be.rejected();
+        });
+
+        it("Should throw when amountIsToReceive = true", async () => {
+            await provider.getSwapInfo(BTC, ETH, "1", false, null, true).should.be.rejected();
+        });
+
+        it("Should return NOT_SUPPORTED when either fromCoin or toCoin is unsupported", async () => {
+            const unsupported = new Coin(
+                "Unsupported",
+                "UNS",
+                "UNS",
+                8,
+                null,
+                "unit",
+                null,
+                null,
+                1,
+                null,
+                [],
+                null,
+                new Blockchain("Unsupported")
+            );
+            let info = await provider.getSwapInfo(unsupported, ETH, "1");
+            info.result.should.be.false();
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+
+            info = await provider.getSwapInfo(BTC, unsupported, "1");
+            info.result.should.be.false();
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("Should return NOT_SUPPORTED when /rate responds with unexpected data shape", async () => {
+            axiosStub.withArgs(sinon.match(/\/rate/)).resolves({ status: 200, data: {} });
+            const info = await provider.getSwapInfo(BTC, ETH, "1");
+            info.result.should.be.false();
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("Should copy provider .fix flag into info.fixed", async () => {
+            axiosStub.withArgs(sinon.match(/\/rate/)).resolves({
+                status: 200,
+                data: { result: true, rate: "15", minamount: "0.01", maxamount: "5", fix: true },
+            });
+            const info = await provider.getSwapInfo(BTC, ETH, "1");
+            info.result.should.be.true();
+            info.fixed.should.be.true();
+        });
+
+        it("Should return TOO_LOW and TOO_HIGH with correct smallestMin and greatestMax", async () => {
+            axiosStub.withArgs(sinon.match(/\/rate/)).resolves({
+                status: 200,
+                data: { result: true, rate: "15", minamount: "0.5", maxamount: "5" },
+            });
+            let info = await provider.getSwapInfo(BTC, ETH, "0.1");
+            info.result.should.be.false();
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.TOO_LOW);
+            info.smallestMin.should.equal("0.50000000");
+
+            info = await provider.getSwapInfo(BTC, ETH, "10");
+            info.result.should.be.false();
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.TOO_HIGH);
+            info.greatestMax.should.equal("5.00000000");
+        });
+    });
+});

package/src/swaps-lib/test/external-apis/goexmeSwapProvider/helpers.test.js

@@ -0,0 +1,26 @@
+import should from "should";
+import { describe, it } from "vitest";
+
+import { GoexmeSwapProvider } from "../../../external-apis/goexmeSwapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+
+describe("goexmeSwapProvider", function () {
+    describe("helpers", function () {
+        it("getSwapCreationInfoTtlMs should return 110000 ms", () => {
+            const provider = new GoexmeSwapProvider("/", new Cache());
+            provider.getSwapCreationInfoTtlMs().should.equal(110000);
+        });
+
+        it("_parseGoexmeDate should convert date string to epoch", () => {
+            const timestamp = GoexmeSwapProvider._parseGoexmeDate("01.02.2024 03:04:05");
+            timestamp.should.equal(Date.parse("2024-02-01T03:04:05Z"));
+        });
+
+        it("getPartnersList should return single partner", async () => {
+            const provider = new GoexmeSwapProvider("/", new Cache());
+            const partners = await provider.getPartnersList();
+            partners.should.have.length(1);
+            partners[0].should.have.property("name", "GoExme");
+        });
+    });
+});

package/src/swaps-lib/test/external-apis/goexmeSwapProvider/integration/PairSupport.int.test.js

@@ -0,0 +1,69 @@
+import "dotenv/config";
+import sinon from "sinon";
+import should from "should";
+import { describe, it, beforeAll, afterEach } from "vitest";
+import axios from "axios";
+
+import { Cache } from "../../../../../common-apis/utils/cache.js";
+import { GoexmeSwapProvider } from "../../../../external-apis/goexmeSwapProvider.js";
+
+const GOEXME_API_KEY = process.env.GOEXME_API_KEY?.trim?.() || "";
+const maybeDescribe = GOEXME_API_KEY ? describe : describe.skip;
+
+const ALLOWED_RABBIT_TICKERS = [
+    "BNBBEP20",
+    "BTC",
+    "DOGE",
+    // DOT temporarily removed – Goexme API stopped exposing it as of 2025‑11‑11.
+    "ETH",
+    "LTC",
+    "SOL",
+    "TRX",
+    "USDCERC20",
+    "GMTSOL",
+    "USDTERC20",
+    "USDTSOL",
+    "USDTTRC20",
+    "XMR",
+    "XRP",
+];
+
+const FORBIDDEN_TICKERS = ["WELL", "VOXEL", "WOO"];
+
+function checkPairSupported(response, providerInstance) {
+    const { TOO_LOW, TOO_HIGH } = providerInstance.constructor.NO_SWAPS_REASONS;
+    return response.result === true || [TOO_LOW, TOO_HIGH].includes(response.reason);
+}
+
+maybeDescribe("external-apis/goexmeSwapProvider integration", function () {
+    describe("pair support (live)", function () {
+        let provider;
+
+        beforeAll(async function () {
+            provider = new GoexmeSwapProvider("/", new Cache(), () => null, false, GOEXME_API_KEY);
+            await provider._fetchSupportedCurrenciesIfNeeded();
+        });
+
+        ALLOWED_RABBIT_TICKERS.forEach(fromTicker => {
+            const toTicker = fromTicker === "BTC" ? "USDTTRC20" : "BTC";
+
+            it(`Should support swaps for ${fromTicker}→${toTicker}`, async function () {
+                const fromCoin = provider.getCoinByTickerIfPresent(fromTicker);
+                const toCoin = provider.getCoinByTickerIfPresent(toTicker);
+
+                should.exist(fromCoin);
+                should.exist(toCoin);
+
+                const response = await provider.getSwapInfo(fromCoin, toCoin, "10000", false);
+                checkPairSupported(response, provider).should.be.true();
+            });
+        });
+
+        FORBIDDEN_TICKERS.forEach(ticker => {
+            it(`Should not support swaps involving forbidden token ${ticker}`, function () {
+                const coin = provider.getCoinByTickerIfPresent(ticker);
+                should(coin).be.null();
+            });
+        });
+    });
+});

package/src/swaps-lib/test/external-apis/goexmeSwapProvider/integration/_fetchSupportedCurrenciesIfNeeded.int.test.js

@@ -0,0 +1,307 @@
+import "dotenv/config";
+import sinon from "sinon";
+import should from "should";
+import { describe, it, beforeEach, afterEach } from "vitest";
+import axios from "axios";
+
+import { Cache } from "../../../../../common-apis/utils/cache.js";
+import { GoexmeSwapProvider } from "../../../../external-apis/goexmeSwapProvider.js";
+import { FALLBACK_ASSET_ICON_URL } from "../../../../../common-apis/globalConstants.jsx";
+
+const GOEXME_API_KEY = process.env.GOEXME_API_KEY?.trim?.() || "";
+const maybeDescribe = GOEXME_API_KEY ? describe : describe.skip;
+
+maybeDescribe("external-apis/goexmeSwapProvider integration", function () {
+    describe("_fetchSupportedCurrenciesIfNeeded", function () {
+        let provider;
+        let axiosGetOriginal;
+
+        beforeEach(() => {
+            provider = new GoexmeSwapProvider("/", new Cache(), () => null, false, GOEXME_API_KEY);
+            axiosGetOriginal = axios.get;
+        });
+
+        afterEach(() => {
+            if (axios.get.restore) {
+                axios.get.restore();
+            } else {
+                axios.get = axiosGetOriginal;
+            }
+        });
+
+        const fetchRawCurrencies = async () => {
+            const { data } = await axiosGetOriginal(`${provider._URL}/currencies`, {
+                params: { key: GOEXME_API_KEY },
+            });
+            return data;
+        };
+
+        it("Should filter out unavailable coins", async () => {
+            const raw = await fetchRawCurrencies();
+            await provider._fetchSupportedCurrenciesIfNeeded();
+
+            const providerCodes = new Set(provider._supportedCoins.map(c => c.code));
+            const unavailableCodes = Object.entries(raw)
+                .filter(([, meta]) => meta?.available === false)
+                .map(([code]) => code.toUpperCase());
+
+            unavailableCodes.forEach(code => providerCodes.has(code).should.be.false());
+            providerCodes.size.should.be.above(0);
+        });
+
+        it("Should set hasExtraId and extraIdName correctly", async () => {
+            const raw = await fetchRawCurrencies();
+            await provider._fetchSupportedCurrenciesIfNeeded();
+
+            const infoWithTag = provider._supportedCoins.find(i => i.hasExtraId);
+            should.exist(infoWithTag);
+
+            const meta =
+                raw[infoWithTag.code] ??
+                Object.values(raw).find(m => (m.code ?? m.ticker ?? "").toUpperCase() === infoWithTag.code);
+            should.exist(meta);
+            (meta.tagname ?? "").trim().should.not.be.empty();
+
+            infoWithTag.extraIdName.should.equal(meta.tagname);
+        });
+
+        it("Should handle duplicate tickers across networks", async () => {
+            await provider._fetchSupportedCurrenciesIfNeeded();
+
+            const suffixRx = /(ERC20|TRC20|BEP20|BSC|AVALANCHEC|OPTIMISM|SOLANA|ARBITRUM)$/i;
+            const grouped = {};
+
+            provider._supportedCoins.forEach(i => {
+                const base = i.code.toUpperCase().replace(suffixRx, "");
+                grouped[base] = grouped[base] || [];
+                grouped[base].push(i);
+            });
+
+            const entry = Object.entries(grouped).find(([, arr]) => arr.length >= 2);
+            if (!entry) return;
+
+            const [, infos] = entry;
+            infos.length.should.be.aboveOrEqual(2);
+
+            infos.forEach(info => {
+                provider._findInfoByTicker(info.coin.ticker).should.equal(info);
+            });
+        });
+
+        it("Should skip HTTP call when cached list is fresh", async () => {
+            provider._supportedCoins = [{ dummy: true }];
+            provider._supportedCoinsLastUpdateTimestamp = Date.now();
+
+            let calls = 0;
+            sinon.stub(axios, "get").callsFake((url, opts) => {
+                if (url.includes("/currencies")) calls += 1;
+                return axiosGetOriginal(url, opts);
+            });
+
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            calls.should.equal(0);
+        });
+
+        it("Should make one HTTP call when cache empty, then reuse cache within TTL", async () => {
+            let calls = 0;
+            sinon.stub(axios, "get").callsFake((url, opts) => {
+                if (url.includes("/currencies")) calls += 1;
+                return axiosGetOriginal(url, opts);
+            });
+
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            provider._supportedCoinsLastUpdateTimestamp -= 4 * 60 * 1000;
+            await provider._fetchSupportedCurrenciesIfNeeded();
+
+            calls.should.equal(1);
+        });
+
+        it("Should refresh list after TTL expiry", async () => {
+            let calls = 0;
+            sinon.stub(axios, "get").callsFake((url, opts) => {
+                if (url.includes("/currencies")) calls += 1;
+                return axiosGetOriginal(url, opts);
+            });
+
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            provider._supportedCoinsLastUpdateTimestamp -= 10 * 60 * 1000;
+            await provider._fetchSupportedCurrenciesIfNeeded();
+
+            calls.should.equal(2);
+        });
+
+        it("Should return empty list for status 200 with empty object", async () => {
+            sinon.stub(axios, "get").callsFake((url, opts = {}) => {
+                if (url.endsWith("/currencies")) {
+                    return Promise.resolve({ status: 200, data: {} });
+                }
+                return axiosGetOriginal(url, opts);
+            });
+
+            await provider._fetchSupportedCurrenciesIfNeeded();
+
+            Array.isArray(provider._supportedCoins).should.be.true();
+            provider._supportedCoins.length.should.equal(0);
+        });
+
+        it("Should throw when status 200 with null data", async () => {
+            sinon.stub(axios, "get").callsFake((url, opts = {}) => {
+                if (url.endsWith("/currencies")) {
+                    return Promise.resolve({ status: 200, data: null });
+                }
+                return axiosGetOriginal(url, opts);
+            });
+
+            await provider._fetchSupportedCurrenciesIfNeeded().should.be.rejected();
+        });
+
+        it("Should return empty list for status 200 with data array", async () => {
+            sinon.stub(axios, "get").callsFake((url, opts = {}) => {
+                if (url.endsWith("/currencies")) {
+                    return Promise.resolve({ status: 200, data: [] });
+                }
+                return axiosGetOriginal(url, opts);
+            });
+
+            await provider._fetchSupportedCurrenciesIfNeeded();
+
+            Array.isArray(provider._supportedCoins).should.be.true();
+            provider._supportedCoins.length.should.equal(0);
+        });
+
+        it("Should throw when /currencies responds with non-200 status", async () => {
+            sinon.stub(axios, "get").callsFake((url, opts = {}) => {
+                if (url.endsWith("/currencies")) {
+                    return Promise.resolve({ status: 400, data: {} });
+                }
+                return axiosGetOriginal(url, opts);
+            });
+
+            await provider._fetchSupportedCurrenciesIfNeeded().should.be.rejected();
+        });
+
+        it("Should ensure every coin has a non-empty icon URL", async () => {
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            provider._supportedCoins.length.should.be.above(0);
+            provider._supportedCoins.every(i => typeof i.iconURL === "string" && i.iconURL.length > 0).should.be.true();
+        });
+
+        it("Should persist raw meta fields exactly (code as-is; network as-is)", async () => {
+            const raw = await fetchRawCurrencies();
+            await provider._fetchSupportedCurrenciesIfNeeded();
+
+            const info = provider._supportedCoins.find(i => raw[i.code]);
+            should.exist(info);
+
+            const meta = raw[info.code];
+            should.exist(meta);
+
+            raw.should.have.property(info.code);
+
+            should(info.network).be.eql(meta.network);
+
+            const tag = (meta.tagname ?? "").trim();
+            if (tag) {
+                info.hasExtraId.should.be.true();
+                info.extraIdName.should.equal(tag);
+            } else {
+                info.hasExtraId.should.be.false();
+                should(info.extraIdName).be.null();
+            }
+        });
+
+        it("Should mark isPopular and use fallback icon when icon is missing", async () => {
+            sinon.stub(axios, "get").callsFake((url, opts = {}) => {
+                if (url.endsWith("/currencies")) {
+                    return Promise.resolve({
+                        status: 200,
+                        data: {
+                            BTC: { coinName: "Bitcoin", available: true },
+                            DOGE: { coinName: "Dogecoin", available: true },
+                        },
+                    });
+                }
+                return axiosGetOriginal(url, opts);
+            });
+
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            const btc = provider._supportedCoins.find(i => i.code === "BTC");
+            const doge = provider._supportedCoins.find(i => i.code === "DOGE");
+
+            btc.iconURL.should.equal(FALLBACK_ASSET_ICON_URL);
+            should.exist(btc.isPopular);
+            should.exist(doge.isPopular);
+        });
+
+        it("Should sort _supportedCoins: popular first, then alphabetically by ticker", async () => {
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            const popular = [
+                "HMSTRTON",
+                "BTC",
+                "ETH",
+                "USDTERC20",
+                "USDTTRC20",
+                "USDCERC20",
+                "XRP",
+                "TON",
+                "XMR",
+                "TRX",
+                "DAIERC20",
+                "DOGE",
+                "BNB",
+                "PEPEERC20",
+                "NOTTON",
+                "SOL",
+                "DOT",
+                "LTC",
+                "SHIBERC20",
+                "AVAX",
+                "UNIERC20",
+                "LINKERC20",
+                "MATIC",
+                "BUSDBEP20",
+                "AAVEERC20",
+                "ATOM",
+                "RUNE",
+                "ADA",
+            ];
+            const list = provider._supportedCoins;
+
+            let reachedNonPopular = false;
+            for (const info of list) {
+                const isPop = popular.includes(info.coin.ticker);
+                if (!reachedNonPopular && !isPop) reachedNonPopular = true;
+                if (reachedNonPopular) isPop.should.be.false();
+            }
+
+            const nonPopularTickers = list.filter(i => !popular.includes(i.coin.ticker)).map(i => i.coin.ticker);
+            const sorted = [...nonPopularTickers].sort((a, b) => a.localeCompare(b));
+            nonPopularTickers.should.eql(sorted);
+        });
+
+        it("Should keep cache consistent under concurrent calls", async () => {
+            await Promise.all([
+                provider._fetchSupportedCurrenciesIfNeeded(),
+                provider._fetchSupportedCurrenciesIfNeeded(),
+                provider._fetchSupportedCurrenciesIfNeeded(),
+            ]);
+
+            provider._supportedCoins.length.should.be.above(0);
+            provider._supportedCoinsLastUpdateTimestamp.should.be.above(0);
+        });
+
+        it("Should map all known provider statuses via _mapGoexmeStatus", () => {
+            const mapGoexmeStatus = provider._mapGoexmeStatus.bind(provider);
+            mapGoexmeStatus("new").should.equal(provider.constructor.SWAP_STATUSES.WAITING_FOR_PAYMENT);
+            mapGoexmeStatus("waiting_deposit").should.equal(provider.constructor.SWAP_STATUSES.CONFIRMING);
+            mapGoexmeStatus("deposit_received").should.equal(provider.constructor.SWAP_STATUSES.PAYMENT_RECEIVED);
+            mapGoexmeStatus("exchanging").should.equal(provider.constructor.SWAP_STATUSES.EXCHANGING);
+            mapGoexmeStatus("sending").should.equal(provider.constructor.SWAP_STATUSES.EXCHANGING);
+            mapGoexmeStatus("success").should.equal(provider.constructor.SWAP_STATUSES.COMPLETED);
+            mapGoexmeStatus("time_expired").should.equal(provider.constructor.SWAP_STATUSES.EXPIRED);
+            mapGoexmeStatus("failed").should.equal(provider.constructor.SWAP_STATUSES.FAILED);
+            mapGoexmeStatus("sending_failed").should.equal(provider.constructor.SWAP_STATUSES.FAILED);
+            mapGoexmeStatus("reverted").should.equal(provider.constructor.SWAP_STATUSES.REFUNDED);
+        });
+    });
+});