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

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

@@ -0,0 +1,342 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+import { describe, it, beforeEach, afterEach } from "vitest";
+
+import { ChangeNowSwapProvider } from "../../../external-apis/changeNowSwapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+import { Coin } from "../../../../common-apis/models/coin.js";
+
+describe("src/swaps-lib/external-apis/changeNowSwapProvider.js", function () {
+    describe("getSwapInfo", function () {
+        let provider;
+        let axiosGetStub;
+        let fetchCoinsStub;
+        let fromCoin;
+        let toCoin;
+
+        function buildCoin(ticker, digits = 8) {
+            return new Coin(
+                ticker,
+                ticker,
+                ticker,
+                digits,
+                null,
+                "",
+                null,
+                null,
+                1,
+                null,
+                [],
+                60000,
+                null,
+                null,
+                null,
+                false
+            );
+        }
+
+        beforeEach(function () {
+            provider = new ChangeNowSwapProvider(null, new Cache());
+            axiosGetStub = sinon.stub(axios, "get");
+            fetchCoinsStub = sinon.stub(provider, "_fetchSupportedCurrenciesIfNeeded").resolves();
+            fromCoin = buildCoin("BTC", 8);
+            toCoin = buildCoin("ETH", 8);
+        });
+
+        afterEach(function () {
+            sinon.restore();
+        });
+
+        it("Should throw on invalid input parameters", async function () {
+            const invalidCoin = { ticker: "BTC" };
+
+            let thrown1;
+            try {
+                await provider.getSwapInfo(invalidCoin, toCoin, "1");
+            } catch (e) {
+                thrown1 = e;
+            }
+            should.exist(thrown1);
+            (thrown1.message || "").toLowerCase().includes("invalid swap parameters").should.be.true();
+
+            let thrown2;
+            try {
+                await provider.getSwapInfo(fromCoin, toCoin, "0");
+            } catch (e) {
+                thrown2 = e;
+            }
+            should.exist(thrown2);
+            (thrown2.message || "").toLowerCase().includes("invalid swap parameters").should.be.true();
+        });
+
+        it("Should return NOT_SUPPORTED when either coin is unsupported", async function () {
+            provider._supportedCoins = [];
+            const result = await provider.getSwapInfo(fromCoin, toCoin, "1");
+            result.result.should.be.false();
+            result.reason.should.equal(provider.constructor.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("Should return TOO_LOW when the requested amount is below provider minimum", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.onCall(0).resolves({ status: 200, data: { minAmount: "10", maxAmount: "100" } });
+            axiosGetStub.onCall(1).resolves({ status: 200, data: {} });
+
+            const result = await provider.getSwapInfo(fromCoin, toCoin, "5");
+
+            result.result.should.be.false();
+            result.reason.should.equal(provider.constructor.NO_SWAPS_REASONS.TOO_LOW);
+            result.smallestMin.should.equal("10");
+            result.greatestMax.should.equal("100");
+        });
+
+        it("Should return TOO_HIGH when the requested amount is above provider maximum", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.onCall(0).resolves({ status: 200, data: { minAmount: "1", maxAmount: "10" } });
+            axiosGetStub.onCall(1).resolves({ status: 200, data: {} });
+            const result = await provider.getSwapInfo(fromCoin, toCoin, "20");
+            result.result.should.be.false();
+            result.reason.should.equal(provider.constructor.NO_SWAPS_REASONS.TOO_HIGH);
+            result.smallestMin.should.equal("1");
+            result.greatestMax.should.equal("10");
+        });
+
+        it("Should return correct estimation and rate for a successful floating rate swap", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.onCall(0).resolves({ status: 200, data: {} });
+            axiosGetStub.onCall(1).resolves({
+                status: 200,
+                data: { fromAmount: "5", toAmount: "10", rateId: "id1", transactionSpeedForecast: "30" },
+            });
+
+            const res = await provider.getSwapInfo(fromCoin, toCoin, "5", false);
+            res.result.should.be.true();
+            res.rate.should.equal("2");
+            should(res.min).be.null();
+            should(res.smallestMin).be.null();
+            should(res.greatestMax).be.null();
+            res.durationMinutesRange.should.equal("30");
+            res.fixed.should.be.false();
+            res.rawSwapData.fromAmount.should.equal("5");
+            res.rawSwapData.toAmount.should.equal("10");
+            res.rawSwapData.rate.should.equal("2");
+            res.rawSwapData.rateId.should.equal("id1");
+        });
+
+        it("Should include fixed rate flow when fixed = true and use provided rateId", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.onCall(0).resolves({ status: 200, data: {} });
+            axiosGetStub.onCall(1).resolves({
+                status: 200,
+                data: { fromAmount: "5", toAmount: "7.5", rateId: "fixed123", transactionSpeedForecast: "15" },
+            });
+            const result = await provider.getSwapInfo(fromCoin, toCoin, "5", true);
+            result.fixed.should.be.true();
+            result.rate.should.equal("1.5");
+            result.rawSwapData.rateId.should.equal("fixed123");
+        });
+
+        it("Should throw when estimation response is not 200", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.onCall(0).resolves({ status: 200, data: {} });
+            axiosGetStub.onCall(1).resolves({ status: 400, data: "error" });
+
+            let thrown;
+            try {
+                await provider.getSwapInfo(fromCoin, toCoin, "5");
+            } catch (e) {
+                thrown = e;
+            }
+            should.exist(thrown);
+            (thrown.message || "").toLowerCase().includes("unexpected estimate response").should.be.true();
+        });
+
+        it("Should return NOT_SUPPORTED when deposit or withdrawal unavailable or coin disabled", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: false, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            let res = await provider.getSwapInfo(fromCoin, toCoin, "1");
+            res.result.should.be.false();
+            res.reason.should.equal(provider.constructor.NO_SWAPS_REASONS.NOT_SUPPORTED);
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: false, isAvailable: true },
+            ];
+            res = await provider.getSwapInfo(fromCoin, toCoin, "1");
+            res.result.should.be.false();
+            res.reason.should.equal(provider.constructor.NO_SWAPS_REASONS.NOT_SUPPORTED);
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: false },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            res = await provider.getSwapInfo(fromCoin, toCoin, "1");
+            res.result.should.be.false();
+            res.reason.should.equal(provider.constructor.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("Should include fixed-rate flow parameter only when fixed is true", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: "btc", deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: "eth", deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.withArgs(sinon.match(/\/exchange\/range/)).resolves({ status: 200, data: {} });
+            axiosGetStub.withArgs(sinon.match(/\/exchange\/estimated-amount/)).resolves({
+                status: 200,
+                data: { fromAmount: "1", toAmount: "2" },
+            });
+            await provider.getSwapInfo(fromCoin, toCoin, "1", true);
+            let call = axiosGetStub.getCalls().find(c => c.args[0].includes("/exchange/estimated-amount"));
+            call.args[1].params.flow.should.equal("fixed-rate");
+            axiosGetStub.resetHistory();
+            await provider.getSwapInfo(fromCoin, toCoin, "1", false);
+            call = axiosGetStub.getCalls().find(c => c.args[0].includes("/exchange/estimated-amount"));
+            call.args[1].params.flow.should.equal("standard");
+        });
+
+        it("Should send toAmount when amountIsToReceive is true", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: "btc", deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: "eth", deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.withArgs(sinon.match(/\/exchange\/range/)).resolves({ status: 200, data: {} });
+            axiosGetStub.withArgs(sinon.match(/\/exchange\/estimated-amount/)).resolves({
+                status: 200,
+                data: { fromAmount: "2", toAmount: "4" },
+            });
+            const amountWanted = "4";
+            await provider.getSwapInfo(fromCoin, toCoin, amountWanted, false, null, true);
+            let call = axiosGetStub.getCalls().find(c => c.args[0].includes("/exchange/estimated-amount"));
+            should(call.args[1].params.fromAmount).be.undefined();
+            call.args[1].params.toAmount.should.equal(amountWanted);
+            const res = await provider.getSwapInfo(fromCoin, toCoin, amountWanted, false, null, true);
+            res.result.should.be.true();
+            res.rawSwapData.fromAmount.should.equal("2");
+            res.rawSwapData.toAmount.should.equal("4");
+            res.rate.should.equal("2");
+        });
+
+        it("Should compute rate when fromAmount or toAmount missing in estimation", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.onCall(0).resolves({ status: 200, data: {} });
+            axiosGetStub.onCall(1).resolves({ status: 200, data: { toAmount: "15" } });
+            const res = await provider.getSwapInfo(fromCoin, toCoin, "5");
+            res.rawSwapData.fromAmount.should.equal("5");
+            res.rawSwapData.toAmount.should.equal("15");
+            res.rate.should.equal("3");
+        });
+
+        it("Should ignore invalid range response and still proceed", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.onCall(0).resolves({ status: 200, data: "unexpected" });
+            axiosGetStub.onCall(1).resolves({ status: 200, data: { fromAmount: "2", toAmount: "4" } });
+            const res = await provider.getSwapInfo(fromCoin, toCoin, "2");
+            res.result.should.be.true();
+            should(res.min).be.null();
+            res.rate.should.equal("2");
+        });
+
+        it("Should include fromNetwork and toNetwork params in both range and estimation requests", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: "btc",
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: "eth",
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            axiosGetStub.withArgs(sinon.match(/\/exchange\/range/)).resolves({ status: 200, data: {} });
+            axiosGetStub.withArgs(sinon.match(/\/exchange\/estimated-amount/)).resolves({
+                status: 200,
+                data: { fromAmount: "1", toAmount: "2" },
+            });
+            await provider.getSwapInfo(fromCoin, toCoin, "1");
+            const rangeCall = axiosGetStub.getCalls().find(c => c.args[0].includes("/exchange/range"));
+            rangeCall.args[1].params.fromNetwork.should.equal("btc");
+            rangeCall.args[1].params.toNetwork.should.equal("eth");
+            const estCall = axiosGetStub.getCalls().find(c => c.args[0].includes("/exchange/estimated-amount"));
+            estCall.args[1].params.fromNetwork.should.equal("btc");
+            estCall.args[1].params.toNetwork.should.equal("eth");
+        });
+
+        it("Should propagate Axios rejection (non-429) as an exception", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.rejects(new Error("network down"));
+
+            let thrown;
+            try {
+                await provider.getSwapInfo(fromCoin, toCoin, "1");
+            } catch (e) {
+                thrown = e;
+            }
+            should.exist(thrown);
+        });
+
+        it("Should throw when estimation returns 200 with non-object data", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.onCall(0).resolves({ status: 200, data: {} });
+            axiosGetStub.onCall(1).resolves({ status: 200, data: "invalid" });
+
+            let thrown;
+            try {
+                await provider.getSwapInfo(fromCoin, toCoin, "5");
+            } catch (e) {
+                thrown = e;
+            }
+            should.exist(thrown);
+            (thrown.message || "").toLowerCase().includes("unexpected estimate response").should.be.true();
+        });
+
+        it("Should include min and max in success response when provider returns them", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.onCall(0).resolves({ status: 200, data: { minAmount: "1", maxAmount: "20" } });
+            axiosGetStub.onCall(1).resolves({ status: 200, data: { fromAmount: "5", toAmount: "10" } });
+            const res = await provider.getSwapInfo(fromCoin, toCoin, "5");
+            res.result.should.be.true();
+            res.min.should.equal("1");
+            res.max.should.equal("20");
+            res.smallestMin.should.equal("1");
+            res.greatestMax.should.equal("20");
+        });
+    });
+});

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

@@ -0,0 +1,34 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { ExolixSwapProvider } from "../../../external-apis/exolixSwapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+
+describe("exolixSwapProvider", function () {
+    describe("_fetchSupportedCurrenciesIfNeeded", function () {
+        const exolixSwapProvider = new ExolixSwapProvider("/", new Cache());
+        const anyError = new Error("Any error");
+
+        let axiosGetStub;
+        beforeEach(() => {
+            axiosGetStub = sinon.stub(axios, "get");
+        });
+
+        afterEach(() => {
+            axiosGetStub.restore();
+            exolixSwapProvider._supportedCoins = [];
+        });
+
+        it("Should throw an error if axios throws error", async () => {
+            axiosGetStub.resetBehavior();
+            axiosGetStub.rejects(anyError);
+
+            const swapProvider = new ExolixSwapProvider("/", new Cache());
+
+            return swapProvider._fetchSupportedCurrenciesIfNeeded().should.be.rejectedWith(anyError);
+        });
+    });
+});