@rabbitio/ui-kit 1.0.0-beta.11 → 1.0.0-beta.111

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

@@ -0,0 +1,148 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+import { describe, it, beforeEach, afterEach } from "vitest";
+
+import { GoexmeSwapProvider } from "../../../external-apis/goexmeSwapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+import { Coin } from "../../../../common-apis/models/coin.js";
+import { Protocol } from "../../../../common-apis/models/protocol.js";
+
+describe("goexmeSwapProvider::_fetchSupportedCurrenciesIfNeeded-stack", () => {
+    const apiOK = {
+        btc: { coinName: "Bitcoin", available: true, network: "", tagname: "", minamount: 0.001, maxamount: 10 },
+        eth: { coinName: "Ethereum", available: true, network: "erc20", tagname: "" },
+        usdt: { coinName: "Tether", available: false, network: "" },
+    };
+
+    let provider, axiosStub;
+    beforeEach(() => {
+        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
+        axiosStub = sinon.stub(axios, "get");
+    });
+    afterEach(() => sinon.restore());
+
+    it("constructor sets direct URL when apiKey passed", () => {
+        const p = new GoexmeSwapProvider("/proxy", new Cache(), () => null, false, "key");
+        p._URL.should.equal("https://goexme.io/v1/api");
+    });
+
+    it("_convertCurrencyMeta returns null for restricted set", () => {
+        const restricted = new GoexmeSwapProvider("/", new Cache(), () => null, true);
+        should(restricted._convertCurrencyMeta("abc", { coinName: "Abc" }, new Set())).be.null();
+    });
+
+    it("_convertCurrencyMeta auto-constructs Coin when builder=null and unrestricted", () => {
+        const unrestricted = new GoexmeSwapProvider("/", new Cache(), null, false);
+        const info = unrestricted._convertCurrencyMeta(
+            "btc",
+            { coinName: "Bitcoin Test", network: "", available: true },
+            new Set()
+        );
+        info.should.have.properties({ code: "BTC", network: null });
+        info.coin.should.be.instanceOf(Coin);
+        if (info.coin.protocol) info.coin.protocol.should.be.instanceOf(Protocol);
+    });
+
+    it("fetches once per batch", async () => {
+        axiosStub.resolves({ status: 200, data: apiOK });
+        await provider._fetchSupportedCurrenciesIfNeeded();
+        await provider._fetchSupportedCurrenciesIfNeeded();
+        axiosStub.calledOnce.should.be.true();
+        provider._supportedCoins.length.should.equal(2);
+        provider._supportedCoins.forEach(i => i.coin.should.be.instanceOf(Coin));
+    });
+
+    it("skips coins with available false", async () => {
+        axiosStub.resolves({ status: 200, data: apiOK });
+        await provider._fetchSupportedCurrenciesIfNeeded();
+        provider._supportedCoins.some(i => i.code === "usdt").should.be.false();
+    });
+
+    it("throws on non-200 response", async () => {
+        axiosStub.resolves({ status: 500, data: {} });
+        await provider._fetchSupportedCurrenciesIfNeeded().should.be.rejected();
+    });
+
+    it("propagates axios error", async () => {
+        axiosStub.rejects(new Error("network"));
+        await provider._fetchSupportedCurrenciesIfNeeded().should.be.rejectedWith(/network/);
+    });
+});
+
+describe("goexmeSwapProvider::_ensurePairsLoaded", () => {
+    let provider, axiosStub;
+    beforeEach(() => {
+        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
+        axiosStub = sinon
+            .stub(axios, "get")
+            .callsFake(url =>
+                url.includes("/pairs")
+                    ? Promise.resolve({ status: 200, data: { BTC: ["ETH"] } })
+                    : Promise.resolve({ status: 200, data: {} })
+            );
+    });
+    afterEach(() => sinon.restore());
+
+    it("loads pairs only once within TTL", async () => {
+        await provider._ensurePairsLoaded();
+        const calls = axiosStub.callCount;
+        await provider._ensurePairsLoaded();
+        axiosStub.callCount.should.equal(calls);
+    });
+
+    it("refreshes pairs after expiration", async () => {
+        await provider._ensurePairsLoaded();
+        provider._pairsCacheTimestamp -= provider.PAIRS_EXPIRATION_TIME_MS + 1000;
+        await provider._ensurePairsLoaded();
+        axiosStub.callCount.should.equal(2);
+    });
+
+    it("throws on non-200", async () => {
+        axiosStub.resetBehavior();
+        axiosStub.resolves({ status: 400, data: {} });
+        await provider._ensurePairsLoaded().should.be.rejectedWith(/Failed to load/);
+    });
+
+    it("stores upper-case tickers", async () => {
+        await provider._ensurePairsLoaded();
+        provider._pairsCache.should.have.property("BTC");
+        provider._pairsCache.BTC.has("ETH").should.be.true();
+    });
+});
+
+describe("goexmeSwapProvider::_fetchSupportedCurrenciesIfNeeded race", () => {
+    let provider, axiosStub;
+    beforeEach(() => {
+        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
+        axiosStub = sinon.stub(axios, "get").resolves({
+            status: 200,
+            data: { btc: { coinName: "btc", available: true } },
+        });
+    });
+    afterEach(() => sinon.restore());
+
+    it("two parallel calls trigger two HTTP requests (no dedupe)", async () => {
+        await Promise.all([provider._fetchSupportedCurrenciesIfNeeded(), provider._fetchSupportedCurrenciesIfNeeded()]);
+        axiosStub.callCount.should.equal(2);
+    });
+});
+
+describe("goexmeSwapProvider::helpers", () => {
+    it("getSwapCreationInfoTtlMs returns 30 000 ms", () => {
+        const p = new GoexmeSwapProvider("/", new Cache());
+        p.getSwapCreationInfoTtlMs().should.equal(30000);
+    });
+
+    it("_parseGoexmeDate converts to epoch", () => {
+        const ts = GoexmeSwapProvider._parseGoexmeDate("01.02.2024 03:04:05");
+        ts.should.equal(Date.parse("2024-02-01T03:04:05Z"));
+    });
+
+    it("getPartnersList returns single partner", async () => {
+        const p = new GoexmeSwapProvider("/", new Cache());
+        const partners = await p.getPartnersList();
+        partners.should.have.length(1);
+        partners[0].should.have.property("name", "GoExme");
+    });
+});

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

@@ -0,0 +1,115 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+import { describe, it, beforeEach, afterEach, expect } from "vitest";
+
+import { GoexmeSwapProvider } from "../../../external-apis/goexmeSwapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+import { Coin } from "../../../../common-apis/models/coin.js";
+import { Blockchain } from "../../../../common-apis/models/blockchain.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")
+);
+
+const ESTIMATION_STUB = { rate: "0.09143008", rawSwapData: { rate: "0.09143008" } };
+
+describe("goexmeSwapProvider::createSwap", () => {
+    const apiOk = { result: true, id: "id1", depositAddress: "addr-in" };
+    let provider, axiosStub;
+
+    beforeEach(() => {
+        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
+        provider._supportedCoins = [
+            { coin: BTC, code: "BTC", network: "BTC", hasExtraId: true },
+            { coin: ETH, code: "ETH", network: "ETH", hasExtraId: true },
+        ];
+        provider._pairsCache = { BTC: new Set(["ETH"]) };
+        provider._pairsCacheTimestamp = Date.now();
+
+        sinon.stub(provider, "_fetchSupportedCurrenciesIfNeeded").resolves();
+        axiosStub = sinon.stub(axios, "get").resolves({ status: 200, data: apiOk });
+    });
+
+    afterEach(() => sinon.restore());
+
+    it("fetches currencies first", async () => {
+        await provider.createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo");
+        provider._fetchSupportedCurrenciesIfNeeded.calledOnce.should.be.true();
+    });
+
+    it("sends correct query params", async () => {
+        await provider.createSwap(BTC, ETH, "0.2", "dest-addr", "", ESTIMATION_STUB, null, false, "memo");
+        const p = axiosStub.args[0][1].params;
+        p.should.match({
+            from: "BTC",
+            to: "ETH",
+            amount: "0.2",
+            destinationAddress: "dest-addr",
+            destinationTag: "memo",
+        });
+    });
+
+    it("adds fix param when fixed=true", async () => {
+        await provider.createSwap(BTC, ETH, "0.3", "dest", "", ESTIMATION_STUB, null, true, "memo");
+        axiosStub.args[0][1].params.should.have.property("fix", true);
+    });
+
+    it("passes refundAddress and refundTag", async () => {
+        await provider.createSwap(BTC, ETH, "1", "dest", "refundAddr", ESTIMATION_STUB, null, true, "memo", "123tag");
+        const p = axiosStub.args[0][1].params;
+        p.should.have.properties({ refundAddress: "refundAddr", refundTag: "123tag" });
+    });
+
+    it("handles 429", async () => {
+        axiosStub.rejects({ response: { status: 429 } });
+        const r = await provider.createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo");
+        r.reason.should.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+    });
+
+    it("throws internal error when API result=false", async () => {
+        axiosStub.resolves({ status: 200, data: { result: false } });
+        await expect(
+            provider.createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo")
+        ).rejects.toThrow(/Goexme createSwap failed/);
+    });
+
+    it("throws internal error when id/depositAddress missing", async () => {
+        axiosStub.resolves({ status: 200, data: { result: true } });
+        await expect(
+            provider.createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo")
+        ).rejects.toThrow(/Goexme createSwap failed/);
+    });
+
+    it("throws for unsupported coins or pairs", async () => {
+        provider._pairsCache = {};
+        await expect(
+            provider.createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo")
+        ).rejects.toThrow(/Unsupported pair/);
+    });
+
+    it("returns fully shaped DTO on success", async () => {
+        const r = await provider.createSwap(BTC, ETH, "1", "dest-addr", "", ESTIMATION_STUB, null, false, "memo");
+        r.should.match({
+            result: true,
+            swapId: "id1",
+            fromAddress: "addr-in",
+            toAddress: "dest-addr",
+            fixed: false,
+        });
+    });
+});

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

@@ -0,0 +1,149 @@
+import sinon from "sinon";
+import axios from "axios";
+import { describe, it, beforeEach, afterEach, expect } from "vitest";
+import should from "should";
+
+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::getSwapInfo", () => {
+    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("returns NOT_SUPPORTED if pair absent", async () => {
+        axiosStub.withArgs(sinon.match(/\/pairs/)).resolves({ status: 200, data: { BTC: ["USDT"] } });
+        (await provider.getSwapInfo(BTC, ETH, "1")).reason.should.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+    });
+
+    it("returns TOO_LOW / TOO_HIGH against min/max", async () => {
+        (await provider.getSwapInfo(BTC, ETH, "0.001")).reason.should.equal(SwapProvider.NO_SWAPS_REASONS.TOO_LOW);
+        (await provider.getSwapInfo(BTC, ETH, "10")).reason.should.equal(SwapProvider.NO_SWAPS_REASONS.TOO_HIGH);
+    });
+
+    it("handles case with no min/max limits", async () => {
+        axiosStub.withArgs(sinon.match(/\/rate/)).resolves({ status: 200, data: { result: true, rate: "15" } });
+        const r = await provider.getSwapInfo(BTC, ETH, "1");
+        r.result.should.be.true();
+    });
+
+    it("maps 429 to REQUESTS_LIMIT_EXCEEDED", async () => {
+        axiosStub.withArgs(sinon.match(/\/rate/)).rejects({ response: { status: 429 } });
+        const r = await provider.getSwapInfo(BTC, ETH, "1");
+        r.reason.should.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+    });
+
+    it("returns valid structure on success", async () => {
+        const r = await provider.getSwapInfo(BTC, ETH, "1");
+        r.result.should.be.true();
+        parseFloat(r.rate).should.be.greaterThan(0);
+    });
+
+    it("sends proper params to /rate", async () => {
+        await provider.getSwapInfo(BTC, ETH, "1");
+        const p = axiosStub.args.find(a => a[0].includes("/rate"))[1].params;
+        p.should.match({ from: "BTC", to: "ETH", amount: "1" });
+    });
+
+    it("throws on non-Coin params", async () => {
+        await expect(provider.getSwapInfo({}, {}, "1")).rejects.toThrow();
+    });
+});
+
+describe("goexmeSwapProvider::status mapping & existing swaps", () => {
+    const raw = {
+        status: "success",
+        id: "swap1",
+        date: "21-07-2023 04:17:30",
+        from: "BTC",
+        to: "ETH",
+        depositAddress: "addr-in",
+        destinationAddress: "addr-out",
+        amountFrom: "1",
+        amountTo: "0.01",
+        result: true,
+    };
+    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" },
+        ];
+        sinon.stub(provider, "_fetchSupportedCurrenciesIfNeeded").resolves();
+        axiosStub = sinon.stub(axios, "get").resolves({ status: 200, data: raw });
+    });
+
+    afterEach(() => sinon.restore());
+
+    it("maps every status string", () => {
+        provider._mapGoexmeStatus("time_expired").should.equal(SwapProvider.SWAP_STATUSES.EXPIRED);
+        provider._mapGoexmeStatus("deposit_received").should.equal(SwapProvider.SWAP_STATUSES.PAYMENT_RECEIVED);
+        provider._mapGoexmeStatus("failed").should.equal(SwapProvider.SWAP_STATUSES.FAILED);
+        provider._mapGoexmeStatus("exchanging").should.equal(SwapProvider.SWAP_STATUSES.EXCHANGING);
+        provider._mapGoexmeStatus("reverted").should.equal(SwapProvider.SWAP_STATUSES.REFUNDED);
+    });
+
+    it("throws on unknown status", () => {
+        (() => provider._mapGoexmeStatus("weird")).should.throw(/Unknown Goexme status/);
+    });
+
+    it("skips 404 responses", async () => {
+        axiosStub.onFirstCall().resolves({ status: 404 });
+        axiosStub.onSecondCall().resolves({ status: 200, data: raw });
+        const res = await provider.getExistingSwapsDetailsAndStatus(["x", "swap1"]);
+        res.swaps.should.have.length(1);
+        res.swaps[0].swapId.should.equal("swap1");
+    });
+
+    it("filters out items when coins unsupported", async () => {
+        axiosStub.resetBehavior();
+        axiosStub.resolves({ status: 200, data: { ...raw, from: "LTC" } });
+        const res = await provider.getExistingSwapsDetailsAndStatus(["swapX"]);
+        res.swaps.should.eql([]);
+    });
+
+    it("propagates 429", async () => {
+        axiosStub.resetBehavior();
+        axiosStub.rejects({ response: { status: 429 } });
+        const r = await provider.getExistingSwapsDetailsAndStatus(["id"]);
+        r.reason.should.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+    });
+});

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

@@ -0,0 +1,97 @@
+import "dotenv/config";
+import { describe, it, beforeAll, expect } from "vitest";
+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;
+
+/**
+ * ------------------------------------------------------------------
+ * Positive-case:  every token below **must** be exchangable
+ *                  against a major counterpart (BTC, or ETH for BTC)
+ * ------------------------------------------------------------------
+ */
+const ALLOWED_RABBIT_TICKERS = [
+    "BNBBEP20",
+    "BTC",
+    "DOGE",
+    "DOT",
+    "ETH",
+    // "GMTSOL",
+    "LTC",
+    "SOL",
+    "TRX",
+    "USDCERC20",
+    "USDTERC20",
+    // "USDTBEP20",
+    "USDTSOL",
+    "USDTTRC20",
+    "XMR",
+    "XRP",
+];
+
+/**
+ * ------------------------------------------------------------------
+ * Negative-case:  these tokens MUST NOT be supported by the adapter
+ * ------------------------------------------------------------------
+ */
+const FORBIDDEN_TICKERS = ["ADA", "1INCH", "TRUMP"];
+
+/**
+ * ------------------------------------------------------------------
+ * Helper – treat “pair supported” broadly:
+ *            • response.result === true
+ *            • OR response.reason is TOO_LOW / TOO_HIGH
+ * Any other outcome (NOT_SUPPORTED etc.) means the pair fails
+ * ------------------------------------------------------------------
+ */
+function isPairSupported(resp, provider) {
+    const { TOO_LOW, TOO_HIGH } = provider.constructor.NO_SWAPS_REASONS;
+    return resp.result === true || [TOO_LOW, TOO_HIGH].includes(resp.reason);
+}
+
+maybeDescribe("GoexmeSwapProvider – pairs availability (live)", () => {
+    let provider;
+
+    beforeAll(async () => {
+        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false, GOEXME_API_KEY);
+        await provider._fetchSupportedCurrenciesIfNeeded();
+        await provider._ensurePairsLoaded();
+    });
+
+    /* ------------------------------------------------------------------
+     * Positive tests – one per *allowed* Rabbit-ticker
+     * ---------------------------------------------------------------- */
+    ALLOWED_RABBIT_TICKERS.forEach(ticker => {
+        const fromTicker = ticker;
+        // Use BTC as the counterpart for every token except BTC itself.
+        const toTicker = ticker === "BTC" ? "ETH" : "BTC";
+
+        it(`supports swaps for ${fromTicker} → ${toTicker}`, async () => {
+            const fromCoin = provider.getCoinByTickerIfPresent(fromTicker);
+            const toCoin = provider.getCoinByTickerIfPresent(toTicker);
+
+            // Sanity: both coins must be known to the adapter
+            expect(fromCoin, "fromCoin missing").toBeTruthy();
+            expect(toCoin, "toCoin missing").toBeTruthy();
+
+            const resp = await provider.getSwapInfo(fromCoin, toCoin, "1", false);
+
+            expect(
+                isPairSupported(resp, provider),
+                `Pair ${fromTicker}/${toTicker} unexpectedly unsupported: ${JSON.stringify(resp)}`
+            ).toBe(true);
+        });
+    });
+
+    /* ------------------------------------------------------------------
+     * Negative tests – one per *forbidden* ticker
+     * ---------------------------------------------------------------- */
+    FORBIDDEN_TICKERS.forEach(ticker => {
+        it(`does NOT support swaps involving forbidden token ${ticker}`, async () => {
+            const coin = provider.getCoinByTickerIfPresent(ticker);
+            expect(coin).toBeNull();
+        });
+    });
+});

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

@@ -0,0 +1,171 @@
+import "dotenv/config";
+import { describe, it, beforeEach, afterEach, expect, vi } 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;
+
+maybeDescribe("GoexmeSwapProvider – live integration tests", () => {
+    let provider;
+    const axiosOriginalGet = axios.get;
+
+    beforeEach(() => {
+        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false, GOEXME_API_KEY);
+    });
+
+    afterEach(() => {
+        axios.get = axiosOriginalGet;
+    });
+
+    const fetchRawCurrencies = async () => {
+        const { data } = await axiosOriginalGet(`${provider._URL}/currencies`, {
+            params: { key: GOEXME_API_KEY },
+        });
+        return data;
+    };
+
+    it("filters 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 => expect(providerCodes.has(code)).toBe(false));
+        expect(providerCodes.size).toBeGreaterThan(0);
+    });
+
+    it("sets hasExtraId and extraIdName correctly", async () => {
+        const raw = await fetchRawCurrencies();
+        await provider._fetchSupportedCurrenciesIfNeeded();
+
+        const infoWithTag = provider._supportedCoins.find(i => i.hasExtraId);
+        expect(infoWithTag).toBeDefined();
+
+        const meta =
+            raw[infoWithTag.code] ??
+            Object.values(raw).find(m => (m.code ?? m.ticker ?? "").toUpperCase() === infoWithTag.code);
+        expect(meta).toBeDefined();
+        expect((meta.tagname ?? "").trim()).not.toBe("");
+
+        expect(infoWithTag.extraIdName).toBe(meta.tagname);
+    });
+
+    it("handles 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) {
+            console.warn("No duplicate tickers among allowed coins – skipping duplicate assertion");
+            return;
+        }
+
+        const [, infos] = entry;
+        expect(infos.length).toBeGreaterThanOrEqual(2);
+
+        infos.forEach(info => {
+            expect(provider._findInfoByTicker(info.coin.ticker)).toBe(info);
+        });
+    });
+
+    it("uses currencies cache within TTL", async () => {
+        let calls = 0;
+        axios.get = async (...args) => {
+            if (args[0].includes("/currencies")) calls += 1;
+            return axiosOriginalGet(...args);
+        };
+
+        await provider._fetchSupportedCurrenciesIfNeeded();
+        provider._supportedCoinsLastUpdateTimestamp -= 4 * 60 * 1000;
+        await provider._fetchSupportedCurrenciesIfNeeded();
+
+        expect(calls).toBe(1);
+    });
+
+    it("reloads currencies cache after TTL expiry", async () => {
+        let calls = 0;
+        axios.get = async (...args) => {
+            if (args[0].includes("/currencies")) calls += 1;
+            return axiosOriginalGet(...args);
+        };
+
+        await provider._fetchSupportedCurrenciesIfNeeded();
+        provider._supportedCoinsLastUpdateTimestamp -= 10 * 60 * 1000;
+        await provider._fetchSupportedCurrenciesIfNeeded();
+
+        expect(calls).toBe(2);
+    });
+
+    it("uses pairs cache within TTL", async () => {
+        let calls = 0;
+        axios.get = async (...args) => {
+            if (args[0].includes("/pairs")) calls += 1;
+            return axiosOriginalGet(...args);
+        };
+
+        await provider._ensurePairsLoaded();
+        provider._pairsCacheTimestamp -= 4 * 60 * 1000;
+        await provider._ensurePairsLoaded();
+
+        expect(calls).toBe(1);
+    });
+
+    it("reloads pairs cache after TTL expiry", async () => {
+        let calls = 0;
+        axios.get = async (...args) => {
+            if (args[0].includes("/pairs")) calls += 1;
+            return axiosOriginalGet(...args);
+        };
+
+        await provider._ensurePairsLoaded();
+        provider._pairsCacheTimestamp -= 10 * 60 * 1000;
+        await provider._ensurePairsLoaded();
+
+        expect(calls).toBe(2);
+    });
+
+    it("throws on non-200 response", async () => {
+        axios.get = vi.fn((url, opts = {}) =>
+            url.endsWith("/currencies") ? Promise.resolve({ status: 500, data: {} }) : axiosOriginalGet(url, opts)
+        );
+        await expect(provider._fetchSupportedCurrenciesIfNeeded()).rejects.toThrow();
+    });
+
+    it("keeps cache consistent under concurrent calls", async () => {
+        await Promise.all([
+            provider._fetchSupportedCurrenciesIfNeeded(),
+            provider._fetchSupportedCurrenciesIfNeeded(),
+            provider._fetchSupportedCurrenciesIfNeeded(),
+        ]);
+
+        expect(provider._supportedCoins.length).toBeGreaterThan(0);
+        expect(provider._supportedCoinsLastUpdateTimestamp).toBeGreaterThan(0);
+    });
+
+    it("_mapGoexmeStatus maps every value", () => {
+        const m = provider._mapGoexmeStatus.bind(provider);
+        expect(m("new")).toBe(provider.constructor.SWAP_STATUSES.WAITING_FOR_PAYMENT);
+        expect(m("waiting_deposit")).toBe(provider.constructor.SWAP_STATUSES.CONFIRMING);
+        expect(m("deposit_received")).toBe(provider.constructor.SWAP_STATUSES.PAYMENT_RECEIVED);
+        expect(m("exchanging")).toBe(provider.constructor.SWAP_STATUSES.EXCHANGING);
+        expect(m("sending")).toBe(provider.constructor.SWAP_STATUSES.EXCHANGING);
+        expect(m("success")).toBe(provider.constructor.SWAP_STATUSES.COMPLETED);
+        expect(m("time_expired")).toBe(provider.constructor.SWAP_STATUSES.EXPIRED);
+        expect(m("failed")).toBe(provider.constructor.SWAP_STATUSES.FAILED);
+        expect(m("sending_failed")).toBe(provider.constructor.SWAP_STATUSES.FAILED);
+        expect(m("reverted")).toBe(provider.constructor.SWAP_STATUSES.REFUNDED);
+    });
+});