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

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

@@ -1,5 +1,7 @@
 import "dotenv/config";
-import { describe, it, beforeEach, afterEach, expect, vi } from "vitest";
+import sinon from "sinon";
+import should from "should";
+import { describe, it, beforeEach, afterEach } from "vitest";
 import axios from "axios";
 import BigNumber from "bignumber.js";
 
@@ -9,231 +11,323 @@ import { GoexmeSwapProvider } from "../../../../external-apis/goexmeSwapProvider
 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);
+maybeDescribe("external-apis/goexmeSwapProvider integration", function () {
+    describe("createSwap (live)", function () {
+        let provider;
+        let axiosOriginalGet;
+
+        beforeEach(async () => {
+            provider = new GoexmeSwapProvider("/", new Cache(), () => null, false, GOEXME_API_KEY);
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            axiosOriginalGet = axios.get;
+        });
+
+        afterEach(() => {
+            if (axios.get.restore) {
+                axios.get.restore();
+            } else {
+                axios.get = axiosOriginalGet;
+            }
+        });
+
+        const getCoinByCode = code => provider._supportedCoins.find(c => c.code === code)?.coin || null;
+        const pairSupported = (fromCoin, toCoin) =>
+            provider._pairsCache?.[fromCoin.code]?.has(toCoin.code) || provider._pairsCache?.[fromCoin]?.has(toCoin);
+
+        const pickValidAmount = async (fromCoin, toCoin, fallbackAmount) => {
+            const info = await provider.getSwapInfo(fromCoin, toCoin, fallbackAmount);
+            if (info.result) return fallbackAmount;
+            if (info.reason === provider.constructor.NO_SWAPS_REASONS.TOO_LOW && info.smallestMin) {
+                return new BigNumber(info.smallestMin).times(1.1).toFixed(fromCoin.digits);
+            }
+            throw new Error(`Unable to pick viable amount for ${fromCoin.ticker} → ${toCoin.ticker}`);
         };
 
-        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);
+        it("Should create a FLOAT BTC→ETH swap", async () => {
+            const btcCoin = getCoinByCode("BTC");
+            const ethCoin = getCoinByCode("ETH");
+            if (!btcCoin || !ethCoin || !pairSupported(btcCoin, ethCoin)) return;
+
+            const amount = await pickValidAmount(btcCoin, ethCoin, "0.001");
+            const result = await provider.createSwap(
+                btcCoin,
+                ethCoin,
+                amount,
+                "bc1qw508d6qejxtdg4y5r3zarvaryvaxxpcs",
+                "",
+                null,
+                null,
+                false
+            );
+
+            result.result.should.be.true();
+            result.fixed.should.be.false();
+            should.exist(result.swapId);
+        });
+
+        it("Should create a FIXED BTC→ETH swap and cache TTL", async () => {
+            const btcCoin = getCoinByCode("BTC");
+            const ethCoin = getCoinByCode("ETH");
+            if (!btcCoin || !ethCoin || !pairSupported(btcCoin, ethCoin)) return;
+
+            const amount = await pickValidAmount(btcCoin, ethCoin, "0.002");
+            const result = await provider.createSwap(
+                btcCoin,
+                ethCoin,
+                amount,
+                "bc1qw508d6qejxtdg4y5r3zarvaryvaxxpcs",
+                "",
+                null,
+                null,
+                true
+            );
+
+            result.fixed.should.be.true();
+            provider._cache.get(`goexme_fixed_ttl_${result.swapId}`).should.be.true();
+        });
+
+        it("Should create an ETH→TRX swap", async () => {
+            const ethCoin = getCoinByCode("ETH");
+            const trxCoin = getCoinByCode("TRX");
+            if (!ethCoin || !trxCoin || !pairSupported(ethCoin, trxCoin)) return;
+
+            const amount = await pickValidAmount(ethCoin, trxCoin, "0.05");
+            const result = await provider.createSwap(
+                ethCoin,
+                trxCoin,
+                amount,
+                "T123456789012345678901234567890123",
+                "",
+                null,
+                null,
+                false
+            );
+
+            result.result.should.be.true();
+            result.fromCoin.ticker.should.equal("ETH");
+            result.toCoin.ticker.should.equal("TRX");
+        });
+
+        it("Should create an XMR→BTC swap", async () => {
+            const xmrCoin = getCoinByCode("XMR");
+            const btcCoin = getCoinByCode("BTC");
+            if (!xmrCoin || !btcCoin || !pairSupported(xmrCoin, btcCoin)) return;
+
+            const amount = await pickValidAmount(xmrCoin, btcCoin, "1");
+            const result = await provider.createSwap(
+                xmrCoin,
+                btcCoin,
+                amount,
+                "bc1qw508d6qejxtdg4y5r3zarvaryvaxxpcs",
+                "",
+                null,
+                null,
+                false
+            );
+
+            result.result.should.be.true();
+            result.fromCoin.ticker.should.equal("XMR");
+            result.toCoin.ticker.should.equal("BTC");
+        });
+
+        it("Should create a USDT(TRC20)→ETH swap", async () => {
+            const usdtTrc20Coin = getCoinByCode("USDTTRC20");
+            const ethCoin = getCoinByCode("ETH");
+            if (!usdtTrc20Coin || !ethCoin || !pairSupported(usdtTrc20Coin, ethCoin)) return;
+
+            const amount = await pickValidAmount(usdtTrc20Coin, ethCoin, "400");
+            const result = await provider.createSwap(
+                usdtTrc20Coin,
+                ethCoin,
+                amount,
+                "0xAb5801a7D398351b8bE11C439e05C5b3259aec9B",
+                "",
+                null,
+                null,
+                false
+            );
+
+            result.result.should.be.true();
+            result.fromCoin.ticker.toUpperCase().should.match(/USDT.*TRC20/);
+            result.toCoin.ticker.should.equal("ETH");
+        });
+
+        it("Should pass refund address to exchange‑create call", async () => {
+            const usdtCoin = getCoinByCode("USDT");
+            const btcCoin = getCoinByCode("BTC");
+            if (!usdtCoin || !btcCoin || !pairSupported(usdtCoin, btcCoin)) return;
+
+            const refundAddress = "0xebb97aa373adec59b33959d2dd67da54dcc0ae00";
+            let capturedParams = null;
+
+            const getStub = sinon.stub(axios, "get").callsFake((url, cfg = {}) => {
+                if (url.endsWith("/exchange-create")) capturedParams = cfg.params;
+                return axiosOriginalGet(url, cfg);
+            });
+
+            const amount = await pickValidAmount(usdtCoin, btcCoin, "1000");
+            await provider.createSwap(
+                usdtCoin,
+                btcCoin,
+                amount,
+                "bc1qw508d6qejxtdg4y5r3zarvaryvaxxpcs",
+                refundAddress,
+                null,
+                null,
+                false
+            );
+
+            capturedParams.should.have.property("refundAddress", refundAddress);
+            getStub.restore();
+        });
+
+        it("Should add destinationTag when target coin requires it", async () => {
+            const btcCoin = getCoinByCode("BTC");
+            const xrpCoin = getCoinByCode("XRP");
+            if (!btcCoin || !xrpCoin || !pairSupported(btcCoin, xrpCoin)) return;
+
+            let capturedParams = null;
+            const getStub = sinon.stub(axios, "get").callsFake((url, cfg = {}) => {
+                if (url.endsWith("/exchange-create")) capturedParams = cfg.params;
+                return axiosOriginalGet(url, cfg);
+            });
+
+            const amount = await pickValidAmount(btcCoin, xrpCoin, "0.002");
+            await provider.createSwap(
+                btcCoin,
+                xrpCoin,
+                amount,
+                "rUpy3eEg8rqjqfUoLeBnZkscbKbfsPrgd",
+                "",
+                null,
+                null,
+                false,
+                "MEMO123"
+            );
+
+            capturedParams.should.have.property("destinationTag", "MEMO123");
+            getStub.restore();
+        });
+
+        it("Should omit destinationTag when target coin has no extraId", async () => {
+            const btcCoin = getCoinByCode("BTC");
+            const ethCoin = getCoinByCode("ETH");
+            if (!btcCoin || !ethCoin || !pairSupported(btcCoin, ethCoin)) return;
+
+            let capturedParams = null;
+            const getStub = sinon.stub(axios, "get").callsFake((url, cfg = {}) => {
+                if (url.endsWith("/exchange-create")) capturedParams = cfg.params;
+                return axiosOriginalGet(url, cfg);
+            });
+
+            const amount = await pickValidAmount(btcCoin, ethCoin, "0.001");
+            await provider.createSwap(
+                btcCoin,
+                ethCoin,
+                amount,
+                "0xAb5801a7D398351b8bE11C439e05C5b3259aec9B",
+                "",
+                null,
+                null,
+                false
+            );
+
+            should(capturedParams).not.have.property("destinationTag");
+            getStub.restore();
+        });
+
+        it("Should throw when amountIsToReceive=true", async () => {
+            const btcCoin = getCoinByCode("BTC");
+            const ethCoin = getCoinByCode("ETH");
+            if (!btcCoin || !ethCoin || !pairSupported(btcCoin, ethCoin)) return;
+
+            const amount = await pickValidAmount(btcCoin, ethCoin, "0.001");
+            await provider
+                .createSwap(
+                    btcCoin,
+                    ethCoin,
+                    amount,
+                    "bc1qw508d6qejxtdg4y5r3zarvaryvaxxpcs",
+                    "",
+                    null,
+                    null,
+                    false,
+                    "",
+                    "",
+                    true
+                )
+                .should.be.rejected();
+        });
+
+        it("Should throw when destinationTag is required but not provided", async () => {
+            const btcCoin = getCoinByCode("BTC");
+            const xrpCoin = getCoinByCode("XRP");
+            if (!btcCoin || !xrpCoin || !pairSupported(btcCoin, xrpCoin)) return;
+
+            const amount = await pickValidAmount(btcCoin, xrpCoin, "0.002");
+            await provider
+                .createSwap(btcCoin, xrpCoin, amount, "rUpy3eEg8rqjqfUoLeBnZkscbKbfsPrgd", "", null, null, false, "")
+                .should.be.rejected();
+        });
+
+        it("Should not include refundTag when source coin has no extraId", async () => {
+            const btcCoin = getCoinByCode("BTC");
+            const ethCoin = getCoinByCode("ETH");
+            if (!btcCoin || !ethCoin || !pairSupported(btcCoin, ethCoin)) return;
+
+            let capturedParams = null;
+            const getStub = sinon.stub(axios, "get").callsFake((url, cfg = {}) => {
+                if (url.endsWith("/exchange-create")) capturedParams = cfg.params;
+                return axiosOriginalGet(url, cfg);
+            });
+
+            const amount = await pickValidAmount(btcCoin, ethCoin, "0.001");
+            await provider.createSwap(
+                btcCoin,
+                ethCoin,
+                amount,
+                "bc1qw508d6qejxtdg4y5r3zarvaryvaxxpcs",
+                "1BitcoinRefundAddrxxxxxxxxxxxx",
+                null,
+                null,
+                false
+            );
+
+            should(capturedParams).not.have.property("refundTag");
+            getStub.restore();
+        });
+
+        it("Should compute toAmount from rate×amount when amountTo not returned", async () => {
+            const btcCoin = getCoinByCode("BTC");
+            const ethCoin = getCoinByCode("ETH");
+            if (!btcCoin || !ethCoin || !pairSupported(btcCoin, ethCoin)) return;
+
+            const amount = await pickValidAmount(btcCoin, ethCoin, "0.003");
+            const result = await provider.createSwap(
+                btcCoin,
+                ethCoin,
+                amount,
+                "bc1qw508d6qejxtdg4y5r3zarvaryvaxxpcs",
+                "",
+                null,
+                null,
+                false
+            );
+
+            const expected = new BigNumber(result.fromAmount)
+                .times(result.rate)
+                .decimalPlaces(result.toCoin.digits, BigNumber.ROUND_DOWN);
+            new BigNumber(result.toAmount).eq(expected).should.be.true();
+        });
+
+        it("Should return NOT_SUPPORTED for JOE→TRX pair", async () => {
+            const joeCoin = getCoinByCode("JOE");
+            const trxCoin = getCoinByCode("TRX");
+            if (!joeCoin || !trxCoin) return;
+
+            const info = await provider.getSwapInfo(joeCoin, trxCoin, "50");
+            info.result.should.be.false();
+            info.reason.should.equal(provider.constructor.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
     });
 });