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

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

@@ -0,0 +1,239 @@
+import "dotenv/config";
+import { describe, it, beforeEach, afterEach, expect, vi } from "vitest";
+import axios from "axios";
+import BigNumber from "bignumber.js";
+
+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#createSwap – live integration", () => {
+    let provider;
+    const axiosOriginalGet = axios.get;
+
+    beforeEach(async () => {
+        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false, GOEXME_API_KEY);
+        await provider._fetchSupportedCurrenciesIfNeeded();
+        await provider._ensurePairsLoaded();
+    });
+
+    afterEach(() => {
+        axios.get = axiosOriginalGet;
+    });
+
+    const byCode = code => provider._supportedCoins.find(c => c.code === code)?.coin || null;
+    const hasPair = (from, to) =>
+        provider._pairsCache?.[from.code]?.has(to.code) || provider._pairsCache?.[from]?.has(to);
+
+    const pickAmount = async (from, to, fallback) => {
+        const info = await provider.getSwapInfo(from, to, fallback);
+        if (info.result) return fallback;
+        if (info.reason === provider.constructor.NO_SWAPS_REASONS.TOO_LOW && info.smallestMin) {
+            return new BigNumber(info.smallestMin).times(1.1).toFixed(from.digits);
+        }
+        throw new Error(`Unable to pick viable amount for ${from.ticker} → ${to.ticker}`);
+    };
+
+    it("creates FLOAT BTC → ETH swap", async () => {
+        const BTC = byCode("BTC");
+        const ETH = byCode("ETH");
+        if (!BTC || !ETH || !hasPair(BTC, ETH)) return;
+
+        const amount = await pickAmount(BTC, ETH, "0.001");
+        const dto = await provider.createSwap(
+            BTC,
+            ETH,
+            amount,
+            "bc1qw508d6qejxtdg4y5r3zarvaryvaxxpcs",
+            "",
+            null,
+            null,
+            false
+        );
+
+        expect(dto.result).toBe(true);
+        expect(dto.fixed).toBe(false);
+        expect(dto.swapId).toBeTruthy();
+    });
+
+    it("creates FIXED BTC → ETH swap", async () => {
+        const BTC = byCode("BTC");
+        const ETH = byCode("ETH");
+        if (!BTC || !ETH || !hasPair(BTC, ETH)) return;
+
+        const amount = await pickAmount(BTC, ETH, "0.002");
+        const dto = await provider.createSwap(
+            BTC,
+            ETH,
+            amount,
+            "bc1qw508d6qejxtdg4y5r3zarvaryvaxxpcs",
+            "",
+            null,
+            null,
+            true
+        );
+
+        expect(dto.fixed).toBe(true);
+        expect(provider._cache.get(`goexme_fixed_ttl_${dto.swapId}`)).toBe(true);
+    });
+
+    it("creates ETH → TRX swap", async () => {
+        const ETH = byCode("ETH");
+        const TRX = byCode("TRX");
+        if (!ETH || !TRX || !hasPair(ETH, TRX)) return;
+
+        const amount = await pickAmount(ETH, TRX, "0.05");
+        const dto = await provider.createSwap(
+            ETH,
+            TRX,
+            amount,
+            "T123456789012345678901234567890123",
+            "",
+            null,
+            null,
+            false
+        );
+
+        expect(dto.result).toBe(true);
+        expect(dto.fromCoin.ticker).toBe("ETH");
+        expect(dto.toCoin.ticker).toBe("TRX");
+    });
+
+    it("creates XMR → BTC swap", async () => {
+        const XMR = byCode("XMR");
+        const BTC = byCode("BTC");
+        if (!XMR || !BTC || !hasPair(XMR, BTC)) return;
+
+        const amount = await pickAmount(XMR, BTC, "1");
+        const dto = await provider.createSwap(
+            XMR,
+            BTC,
+            amount,
+            "bc1qw508d6qejxtdg4y5r3zarvaryvaxxpcs",
+            "",
+            null,
+            null,
+            false
+        );
+
+        expect(dto.result).toBe(true);
+        expect(dto.fromCoin.ticker).toBe("XMR");
+        expect(dto.toCoin.ticker).toBe("BTC");
+    });
+
+    it("creates USDT(TRC20) → ETH swap", async () => {
+        const USDTTRC20 = byCode("USDTTRC20");
+        const ETH = byCode("ETH");
+        if (!USDTTRC20 || !ETH || !hasPair(USDTTRC20, ETH)) return;
+
+        const amount = await pickAmount(USDTTRC20, ETH, "400");
+        const dto = await provider.createSwap(
+            USDTTRC20,
+            ETH,
+            amount,
+            "0xAb5801a7D398351b8bE11C439e05C5b3259aec9B",
+            "",
+            null,
+            null,
+            false
+        );
+
+        expect(dto.result).toBe(true);
+        expect(dto.fromCoin.ticker.toUpperCase()).toMatch(/USDT.*TRC20/);
+        expect(dto.toCoin.ticker).toBe("ETH");
+    });
+
+    it("passes refund address to exchange-create call", async () => {
+        const USDT = byCode("USDT");
+        const BTC = byCode("BTC");
+        if (!USDT || !BTC || !hasPair(USDT, BTC)) return;
+
+        const refundAddr = "0xebb97aa373adec59b33959d2dd67da54dcc0ae00";
+        let capturedParams = null;
+
+        axios.get = async (url, cfg = {}) => {
+            if (url.endsWith("/exchange-create")) capturedParams = cfg.params;
+            return axiosOriginalGet(url, cfg);
+        };
+
+        const amount = await pickAmount(USDT, BTC, "1000");
+        await provider.createSwap(
+            USDT,
+            BTC,
+            amount,
+            "bc1qw508d6qejxtdg4y5r3zarvaryvaxxpcs",
+            refundAddr,
+            null,
+            null,
+            false
+        );
+
+        expect(capturedParams?.refundAddress).toBe(refundAddr);
+    });
+
+    it("adds destinationTag when target coin requires it", async () => {
+        const BTC = byCode("BTC");
+        const XRP = byCode("XRP");
+        if (!BTC || !XRP || !hasPair(BTC, XRP)) return;
+
+        let capturedParams = null;
+        axios.get = async (url, cfg = {}) => {
+            if (url.endsWith("/exchange-create")) capturedParams = cfg.params;
+            return axiosOriginalGet(url, cfg);
+        };
+
+        const amount = await pickAmount(BTC, XRP, "0.002");
+        await provider.createSwap(
+            BTC,
+            XRP,
+            amount,
+            "rUpy3eEg8rqjqfUoLeBnZkscbKbfsPrgd",
+            "",
+            null,
+            null,
+            false,
+            "MEMO123"
+        );
+
+        expect(capturedParams?.destinationTag).toBe("MEMO123");
+    });
+
+    it("omits destinationTag when target coin has no extraId", async () => {
+        const BTC = byCode("BTC");
+        const ETH = byCode("ETH");
+        if (!BTC || !ETH || !hasPair(BTC, ETH)) return;
+
+        let capturedParams = null;
+        axios.get = async (url, cfg = {}) => {
+            if (url.endsWith("/exchange-create")) capturedParams = cfg.params;
+            return axiosOriginalGet(url, cfg);
+        };
+
+        const amount = await pickAmount(BTC, ETH, "0.001");
+        await provider.createSwap(
+            BTC,
+            ETH,
+            amount,
+            "0xAb5801a7D398351b8bE11C439e05C5b3259aec9B",
+            "",
+            null,
+            null,
+            false
+        );
+
+        expect(capturedParams).not.toHaveProperty("destinationTag");
+    });
+
+    it("returns pairNotSupported for JOE → TRX", async () => {
+        const JOE = byCode("JOE");
+        const TRX = byCode("TRX");
+        if (!JOE || !TRX) return;
+
+        const info = await provider.getSwapInfo(JOE, TRX, "50");
+
+        expect(info.result).toBe(false);
+        expect(info.reason).toBe(provider.constructor.NO_SWAPS_REASONS.NOT_SUPPORTED);
+    });
+});

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

@@ -0,0 +1,141 @@
+import "dotenv/config";
+import { describe, it, beforeEach, afterEach, expect, vi } from "vitest";
+import axios from "axios";
+import BigNumber from "bignumber.js";
+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#getSwapInfo – live integration", () => {
+    let provider;
+    const axiosOriginalGet = axios.get;
+
+    beforeEach(async () => {
+        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false, GOEXME_API_KEY);
+        await provider._fetchSupportedCurrenciesIfNeeded();
+        await provider._ensurePairsLoaded();
+    });
+
+    afterEach(() => {
+        axios.get = axiosOriginalGet;
+    });
+
+    const byCode = code => provider._supportedCoins.find(c => c.code === code)?.coin || null;
+    const pickAmount = async (from, to, fallback) => {
+        const info = await provider.getSwapInfo(from, to, fallback);
+        if (info.result) return fallback;
+        if (info.reason === provider.constructor.NO_SWAPS_REASONS.TOO_LOW && info.smallestMin) {
+            return new BigNumber(info.smallestMin).times(1.1).toFixed(from.digits);
+        }
+        throw new Error();
+    };
+
+    it("happy path BTC → ETH", async () => {
+        const BTC = byCode("BTC");
+        const ETH = byCode("ETH");
+        const amount = await pickAmount(BTC, ETH, "0.001");
+        const info = await provider.getSwapInfo(BTC, ETH, amount);
+        expect(info.result).toBe(true);
+        expect(parseFloat(info.rate)).toBeGreaterThan(0);
+        expect(Number(info.min)).toBeLessThanOrEqual(Number(amount));
+        expect(Number(info.max)).toBeGreaterThan(Number(amount));
+    });
+
+    it("pair not supported JOE → TRX", async () => {
+        const JOE = byCode("JOE");
+        const TRX = byCode("TRX");
+        if (!JOE || !TRX) return;
+        const info = await provider.getSwapInfo(JOE, TRX, "50");
+        expect(info.result).toBe(false);
+        expect(info.reason).toBe(provider.constructor.NO_SWAPS_REASONS.NOT_SUPPORTED);
+    });
+
+    it("too low amount", async () => {
+        const BTC = byCode("BTC");
+        const ETH = byCode("ETH");
+        const minInfo = await provider.getSwapInfo(BTC, ETH, "0.001");
+        const low = new BigNumber(minInfo.min || "0.0001").div(10).toFixed(BTC.digits);
+        const info = await provider.getSwapInfo(BTC, ETH, low);
+        expect(info.result).toBe(false);
+        expect(info.reason).toBe(provider.constructor.NO_SWAPS_REASONS.TOO_LOW);
+    });
+
+    it("too high amount", async () => {
+        const BTC = byCode("BTC");
+        const ETH = byCode("ETH");
+        const base = await provider.getSwapInfo(BTC, ETH, "0.001");
+        const high = new BigNumber(base.max || "1").times(50).toFixed(BTC.digits);
+        const info = await provider.getSwapInfo(BTC, ETH, high);
+        expect(info.result).toBe(false);
+        expect(info.reason).toBe(provider.constructor.NO_SWAPS_REASONS.TOO_HIGH);
+    });
+
+    it("rate limit", async () => {
+        axios.get = vi.fn((url, cfg) =>
+            url.endsWith("/rate") ? Promise.reject({ response: { status: 429 } }) : axiosOriginalGet(url, cfg)
+        );
+        const BTC = byCode("BTC");
+        const ETH = byCode("ETH");
+        const info = await provider.getSwapInfo(BTC, ETH, "0.1");
+        expect(info.result).toBe(false);
+        expect(info.reason).toBe(provider.constructor.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+    });
+
+    it("amount param equals passed amount when amountIsToReceive=false", async () => {
+        let captured = null;
+        axios.get = async (url, cfg = {}) => {
+            if (url.endsWith("/rate")) captured = cfg.params.amount;
+            return axiosOriginalGet(url, cfg);
+        };
+        const BTC = byCode("BTC");
+        const ETH = byCode("ETH");
+        await provider.getSwapInfo(BTC, ETH, "0.5");
+        expect(captured).toBe("0.5");
+    });
+
+    it("includes fix=true when fixed quote requested", async () => {
+        let captured = null;
+        axios.get = async (url, cfg = {}) => {
+            if (url.endsWith("/rate")) captured = cfg.params.fix;
+            return axiosOriginalGet(url, cfg);
+        };
+        const BTC = byCode("BTC");
+        const ETH = byCode("ETH");
+        await provider.getSwapInfo(BTC, ETH, "0.2", true);
+        expect(captured).toBe(true);
+    });
+
+    it("handles duplicated tickers", async () => {
+        const DUP = byCode("USDTTRC20TRC20");
+        const BTC = byCode("BTC");
+        if (!DUP) return;
+        const info = await provider.getSwapInfo(DUP, BTC, "50");
+        expect(info.result).toBe(true);
+    });
+
+    it("validates hasExtraId and extraIdName for every allowed coin", async () => {
+        // Fetch raw currencies directly from GoExme to compare against adapter output
+        const raw = await axiosOriginalGet(`${provider._URL}/currencies`, {
+            params: { key: GOEXME_API_KEY },
+        }).then(r => r.data);
+
+        await provider._fetchSupportedCurrenciesIfNeeded();
+
+        Object.entries(raw)
+            .filter(([, meta]) => meta?.available === true)
+            .forEach(([code, meta]) => {
+                const info = provider._supportedCoins.find(c => c.code === code.toUpperCase());
+                if (!info) return; // Coin might be filtered out by allow‑list
+                const tagRaw = (meta.tagname ?? "").trim();
+                const expectsExtra = tagRaw.length > 0;
+                expect(info.hasExtraId).toBe(expectsExtra);
+                if (expectsExtra) {
+                    expect(info.extraIdName).toBe(tagRaw);
+                } else {
+                    expect(info.extraIdName).toBeNull();
+                }
+            });
+    });
+});

package/src/swaps-lib/test/external-apis/swapProvider/getAllSupportedCurrencies.test.js

@@ -0,0 +1,63 @@
+import sinon from "sinon";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+
+describe("swapProvider", function () {
+    describe("getAllSupportedCurrencies", function () {
+        const swapProvider = new SwapProvider(new Cache());
+
+        let _fetchSupportedCurrenciesIfNeededStub;
+        beforeEach(() => {
+            _fetchSupportedCurrenciesIfNeededStub = sinon.stub(swapProvider, "_fetchSupportedCurrenciesIfNeeded");
+        });
+
+        afterEach(() => {
+            _fetchSupportedCurrenciesIfNeededStub.restore();
+            swapProvider._supportedCoins = [];
+        });
+
+        it("Should return an error if the response status is 429", async () => {
+            _fetchSupportedCurrenciesIfNeededStub.resetBehavior();
+            _fetchSupportedCurrenciesIfNeededStub.rejects({
+                response: { status: 429 },
+            });
+
+            const result = await swapProvider.getAllSupportedCurrencies();
+            result.should.deepEqual({
+                result: false,
+                reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
+            });
+        });
+
+        it("Should return an object with 'result' set to true and an array of supported coins if there is initialized list", async () => {
+            swapProvider._supportedCoins = [{ coin: { t: "BTC" }, extraId: "" }, { coin: 1 }, { coin: "4" }];
+            const expectedCoins = swapProvider._supportedCoins.map(item => item.coin);
+
+            const result = await swapProvider.getAllSupportedCurrencies();
+
+            result.should.deepEqual({ result: true, coins: expectedCoins });
+        });
+
+        it("Should always call _fetchSupportedCurrenciesIfNeeded ones", async () => {
+            await swapProvider.getAllSupportedCurrencies();
+
+            _fetchSupportedCurrenciesIfNeededStub.calledOnce.should.be.true();
+        });
+
+        it("Should throw an error if an error occurs while fetching supported currencies", async () => {
+            _fetchSupportedCurrenciesIfNeededStub.throws(new Error("Error fetching supported currencies"));
+
+            try {
+                await swapProvider.getAllSupportedCurrencies();
+                should.fail("Expected an error to be thrown");
+            } catch (error) {
+                error.should.be.instanceOf(Error);
+                error.message.should.containEql("Error fetching supported currencies");
+            }
+        });
+    });
+});

package/src/swaps-lib/test/external-apis/swapProvider/getDepositCurrencies.test.js

@@ -0,0 +1,73 @@
+import sinon from "sinon";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+
+describe("swapProvider", function () {
+    describe("getDepositCurrencies", function () {
+        const swapProvider = new SwapProvider(new Cache());
+
+        let _fetchSupportedCurrenciesIfNeededStub;
+        beforeEach(() => {
+            _fetchSupportedCurrenciesIfNeededStub = sinon.stub(swapProvider, "_fetchSupportedCurrenciesIfNeeded");
+        });
+
+        afterEach(() => {
+            _fetchSupportedCurrenciesIfNeededStub.restore();
+            swapProvider._supportedCoins = [];
+        });
+
+        it("Should return an error if the response status is 429", async () => {
+            _fetchSupportedCurrenciesIfNeededStub.resetBehavior();
+            _fetchSupportedCurrenciesIfNeededStub.rejects({
+                response: { status: 429 },
+            });
+
+            const result = await swapProvider.getDepositCurrencies();
+            result.should.deepEqual({
+                result: false,
+                reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
+            });
+        });
+
+        it("Should return an object with 'result' set to true and an array of supported coins having deposit == true", async () => {
+            swapProvider._supportedCoins = [
+                {
+                    coin: { t: "BTC" },
+                    extraId: "",
+                    withdrawal: true,
+                    deposit: true,
+                },
+                { coin: 1, withdrawal: false, deposit: true },
+                { coin: "4", withdrawal: true, deposit: null },
+                { coin: "-12312", withdrawal: null, deposit: false },
+            ];
+            const expectedCoins = swapProvider._supportedCoins.filter(i => i.deposit).map(item => item.coin);
+
+            const result = await swapProvider.getDepositCurrencies();
+
+            result.should.deepEqual({ result: true, coins: expectedCoins });
+        });
+
+        it("Should always call _fetchSupportedCurrenciesIfNeeded ones", async () => {
+            await swapProvider.getDepositCurrencies();
+
+            _fetchSupportedCurrenciesIfNeededStub.calledOnce.should.be.true();
+        });
+
+        it("Should throw an error if an error occurs while fetching supported currencies", async () => {
+            _fetchSupportedCurrenciesIfNeededStub.throws(new Error("Error fetching supported currencies"));
+
+            try {
+                await swapProvider.getDepositCurrencies();
+                should.fail("Expected an error to be thrown");
+            } catch (error) {
+                error.should.be.instanceOf(Error);
+                error.message.should.containEql("Error fetching supported currencies");
+            }
+        });
+    });
+});

package/src/swaps-lib/test/external-apis/swapProvider/getWithdrawalCurrencies.test.js

@@ -0,0 +1,102 @@
+import sinon from "sinon";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+
+describe("swapProvider", function () {
+    describe("getWithdrawalCurrencies", function () {
+        const swapProvider = new SwapProvider(new Cache());
+
+        let _fetchSupportedCurrenciesIfNeededStub;
+        beforeEach(() => {
+            _fetchSupportedCurrenciesIfNeededStub = sinon.stub(swapProvider, "_fetchSupportedCurrenciesIfNeeded");
+        });
+
+        afterEach(() => {
+            _fetchSupportedCurrenciesIfNeededStub.restore();
+            swapProvider._supportedCoins = [];
+        });
+
+        it("Should return an error if the response status is 429", async () => {
+            _fetchSupportedCurrenciesIfNeededStub.resetBehavior();
+            _fetchSupportedCurrenciesIfNeededStub.rejects({
+                response: { status: 429 },
+            });
+
+            const result = await swapProvider.getWithdrawalCurrencies();
+            result.should.deepEqual({
+                result: false,
+                reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
+            });
+        });
+
+        it("Should return an object with 'result' set to true and an array of supported coins having withdrawal == true", async () => {
+            swapProvider._supportedCoins = [
+                {
+                    coin: { t: "BTC" },
+                    extraId: "",
+                    withdrawal: true,
+                    deposit: true,
+                },
+                { coin: 1, withdrawal: false, deposit: true },
+                { coin: "4", withdrawal: true, deposit: null },
+                { coin: "-12312", withdrawal: null, deposit: false },
+            ];
+            const expectedCoins = swapProvider._supportedCoins.filter(i => i.withdrawal).map(item => item.coin);
+
+            const result = await swapProvider.getWithdrawalCurrencies();
+
+            result.should.deepEqual({ result: true, coins: expectedCoins });
+        });
+
+        it("Should return an object with 'result' set to true and an array of supported coins having withdrawal == true except the passed coin ticker", async () => {
+            swapProvider._supportedCoins = [
+                {
+                    coin: { ticker: "BTC" },
+                    extraId: "",
+                    withdrawal: true,
+                    deposit: true,
+                },
+                {
+                    coin: { ticker: "ALGO" },
+                    extraId: "",
+                    withdrawal: true,
+                    deposit: true,
+                },
+                { coin: 1, withdrawal: false, deposit: null },
+                { coin: "4", withdrawal: true, deposit: true },
+                { coin: "-12312", withdrawal: null, deposit: false },
+            ];
+            const expectedCoins = swapProvider._supportedCoins
+                .filter(i => i.withdrawal && i.coin.ticker !== "ALGO")
+                .map(item => item.coin);
+
+            const result = await swapProvider.getWithdrawalCurrencies({
+                ticker: "ALGO",
+            });
+
+            result.should.deepEqual({ result: true, coins: expectedCoins });
+        });
+
+        it("Should always call _fetchSupportedCurrenciesIfNeeded ones", async () => {
+            await swapProvider.getWithdrawalCurrencies();
+
+            _fetchSupportedCurrenciesIfNeededStub.calledOnce.should.be.true();
+        });
+
+        it("Should throw an error if an error occurs while fetching supported currencies", async () => {
+            _fetchSupportedCurrenciesIfNeededStub.rejects(new Error("Error fetching supported currencies"));
+
+            try {
+                await swapProvider.getWithdrawalCurrencies();
+                should.fail("Expected an error to be thrown");
+            } catch (error) {
+                error.should.be.instanceOf(Error);
+                error.message.should.containEql("Error fetching supported currencies");
+            }
+        });
+    });
+});