@rabbitio/ui-kit 1.0.0-beta.42 → 1.0.0-beta.45

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

@@ -0,0 +1,1892 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+import { SwapspaceSwapProvider } from "../../../external-apis/swapspaceSwapProvider.js";
+import { Cache } from "../../../../common/utils/cache.js";
+import { AmountUtils } from "../../../../common/amountUtils.js";
+import { Coin } from "../../../../common/models/coin.js";
+import { Blockchain } from "../../../../common/models/blockchain.js";
+
+describe("swapspaceSwapProvider", function () {
+    describe("getSwapInfo", function () {
+        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 TRX = new Coin(
+            "Tron",
+            "TRX",
+            "TRX",
+            18,
+            null,
+            "sun",
+            null,
+            null,
+            1,
+            null,
+            [],
+            null,
+            new Blockchain("Tron")
+        );
+        const USDCTRC20 = new Coin(
+            "USDCTRC20",
+            "USDCTRC20",
+            "USDC",
+            6,
+            null,
+            "millicents",
+            null,
+            null,
+            1,
+            null,
+            [],
+            null,
+            new Blockchain("Tron")
+        );
+        const USDTERC20 = new Coin(
+            "USDTERC20",
+            "USDTERC20",
+            "USDT",
+            6,
+            null,
+            "millicents",
+            null,
+            null,
+            1,
+            null,
+            [],
+            null,
+            new Blockchain("Ethereum")
+        );
+
+        let swapspaceSwapProvider;
+        let axiosGetStub;
+        let trimCryptoAmountByCoinStub;
+
+        beforeEach(() => {
+            swapspaceSwapProvider = new SwapspaceSwapProvider("", new Cache());
+
+            axiosGetStub = sinon.stub(axios, "get");
+
+            trimCryptoAmountByCoinStub = sinon.stub(AmountUtils, "trim");
+            trimCryptoAmountByCoinStub.callsFake((amount) =>
+                amount?.toString()
+            );
+        });
+
+        afterEach(() => {
+            sinon.restore();
+        });
+
+        it("should return a result of correct format when available exchanges are present", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.true();
+            result.min.should.be.String();
+            result.max.should.be.String();
+            result.smallestMin.should.be.String();
+            result.greatestMax.should.be.String();
+            result.rate.should.be.String();
+            result.durationMinutesRange.should.be.String();
+            result.rawSwapData.should.be.Object();
+            result.fixed.should.be.Boolean();
+        });
+
+        it("should return a result of correct format when there are no available exchange options but some not relevant options have min/max amount", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            axiosGetStub.resolves({
+                data: [
+                    {
+                        exists: true,
+                        fixed: false,
+                        toAmount: 0,
+                        fromAmount: 1,
+                        duration: "10-20",
+                        max: 5,
+                        min: 0.1,
+                    },
+                ],
+            });
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "0.01"
+            );
+
+            result.result.should.be.false();
+            (
+                Object.values(SwapProvider.NO_SWAPS_REASONS).find(
+                    (v) => result.reason === v
+                ) == null
+            ).should.be.false();
+            result.smallestMin.should.be.String();
+            result.greatestMax.should.be.String();
+        });
+
+        it("should use the exchange with the highest rate", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 3,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.rawSwapData.should.be.deepEqual(mockData[1]);
+        });
+
+        it("should return result with proper rate calculation if the selected exchange has toAmount, fromAmount and the coin usd rate is successfully retrieved", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 3,
+                    fromAmount: 2,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.rate.should.be.equal("1.5"); // because 3 divided by 2 is 1.5
+        });
+
+        it("should use the first best exchange option when multiple exchanges have the same toAmount", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 3,
+                    fromAmount: 1,
+                    duration: "11-21",
+                    max: 5,
+                    min: 0.1,
+                },
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 3,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 6,
+                    min: 0.2,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.durationMinutesRange.should.be.equal("11-21"); // Using the first one by order
+        });
+
+        it("should return a rawSwapData object for available exchanges", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.rawSwapData.should.be.deepEqual(mockData[0]);
+        });
+
+        it("should handle REQUESTS_LIMIT_EXCEEDED when axios returns a 429", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            axiosGetStub.throws({ response: { status: 429 } });
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.reason.should.be.equal(
+                SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+            );
+        });
+
+        it("should return TOO_LOW when amount is below the smallest minimum and there are no available exchange option", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 0,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 2,
+                },
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 0,
+                    fromAmount: 1,
+                    duration: "10-30",
+                    max: 50,
+                    min: 3,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.TOO_LOW
+            );
+        });
+
+        it("should return TOO_HIGH when amount is above the greatest max and there are no available exchange option", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 0,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 4,
+                    min: 0.1,
+                },
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 0,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 1.1,
+                    min: 0.4,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "10"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.TOO_HIGH
+            );
+        });
+
+        it("should return NOT_SUPPORTED when no exchanges support the pair", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: [] }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should return NOT_SUPPORTED when deposit is false for from currency", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: false },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: [] }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should return NOT_SUPPORTED when withdrawal is false for to currency", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: false },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: [] }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should return NO_FIXED_BUT_HAVE_FLOATING when fixed passed is true and there is no fixed option but there is floating option", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            axiosGetStub.returns(
+                Promise.resolve({
+                    data: [
+                        {
+                            exists: true,
+                            fixed: false,
+                            toAmount: 10,
+                            fromAmount: 1,
+                            duration: "10-20",
+                            max: 5,
+                            min: 0.1,
+                        },
+                    ],
+                })
+            );
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1",
+                true
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NO_FIXED_BUT_HAVE_FLOATING
+            );
+        });
+
+        it("should return NO_FLOATING_BUT_HAVE_FIXED when fixed passed is false and there is no floating option but there is fixed option", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            axiosGetStub.returns(
+                Promise.resolve({
+                    data: [
+                        {
+                            exists: true,
+                            fixed: true,
+                            toAmount: 10,
+                            fromAmount: 1,
+                            duration: "10-20",
+                            max: 5,
+                            min: 0.1,
+                        },
+                    ],
+                })
+            );
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1",
+                false
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NO_FLOATING_BUT_HAVE_FIXED
+            );
+        });
+
+        it("should return best option across both fixed and floating when fixed passed is null", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const opts = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 10,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+                {
+                    exists: true,
+                    fixed: true,
+                    toAmount: 11,
+                    fromAmount: 1,
+                    duration: "2",
+                    max: 6,
+                    min: 0.3,
+                },
+            ];
+            axiosGetStub.returns(
+                Promise.resolve({
+                    data: opts,
+                })
+            );
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1",
+                null
+            );
+
+            result.result.should.be.true();
+            result.rawSwapData.should.be.deepEqual(opts[1]);
+        });
+
+        it("should correctly handle when there are available exchange options and no smallest min", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            axiosGetStub.resolves({
+                data: [
+                    {
+                        exists: true,
+                        fixed: false,
+                        toAmount: 10,
+                        fromAmount: 1,
+                        duration: "10-20",
+                        max: 5,
+                        min: "a",
+                    },
+                ],
+            });
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "6"
+            );
+
+            result.result.should.be.true();
+            (result.smallestMin === null).should.be.true();
+        });
+
+        it("should correctly handle when there are available exchange options and no greatest max", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            axiosGetStub.resolves({
+                data: [
+                    {
+                        exists: true,
+                        fixed: false,
+                        toAmount: 10,
+                        fromAmount: 1,
+                        duration: "10-20",
+                        max: "f",
+                        min: 0.1,
+                    },
+                ],
+            });
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "0.01"
+            );
+
+            result.result.should.be.true();
+            (result.greatestMax === null).should.be.true();
+        });
+
+        it("should increase the min with coinAmountForMinMaxSafety", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 4,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "10",
+                false,
+                "2"
+            );
+
+            result.result.should.be.true();
+            result.min.should.be.equal("0.6");
+        });
+
+        it("should increase the smallestMin with coinAmountForMinMaxSafety", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 4,
+                    min: 0.01,
+                },
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 4,
+                    min: 0.2,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "10",
+                false,
+                "2"
+            );
+
+            result.result.should.be.true();
+            result.smallestMin.should.be.equal("0.51");
+        });
+
+        it("should set greatestMax to 0 if greatestMax - coinAmountForMinMaxSafety is negative", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 0.4,
+                    min: 0.1,
+                },
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 0.3,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "10",
+                false,
+                "2"
+            );
+
+            result.result.should.be.true();
+            result.greatestMax.should.be.equal("0");
+        });
+
+        it("should decrease the max with coinAmountForMinMaxSafety", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 4,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "10",
+                false,
+                "2"
+            );
+
+            result.result.should.be.true();
+            result.max.should.be.equal("3.5");
+        });
+
+        it("should decrease the greatestMax with coinAmountForMinMaxSafety", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 4,
+                    min: 0.1,
+                },
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 6,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "10",
+                false,
+                "2"
+            );
+
+            result.result.should.be.true();
+            result.greatestMax.should.be.equal("5.5");
+        });
+
+        it("should set max to 0 if max - coinAmountForMinMaxSafety is negative", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 0.4,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "10",
+                false,
+                "2"
+            );
+
+            result.result.should.be.true();
+            result.max.should.be.equal("0");
+        });
+
+        it("should filter out exchanges without toAmount", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should filter out banned exchanges", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    id: "",
+                    supportRate: 2,
+                    duration: "11-38",
+                    min: 0.00029295,
+                    max: 0,
+                    fixed: false,
+                    partner: "stealthex",
+                    exists: true,
+                    fromAmount: 0.1,
+                    fromCurrency: "btc",
+                    fromNetwork: "btc",
+                    toAmount: 1.3223873,
+                    toCurrency: "eth",
+                    toNetwork: "eth",
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should filter out exchanges where toAmount equals 0", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    toAmount: 0,
+                    fixed: false,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should correctly compute smallestMin and greatestMax", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 3,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 3,
+                    min: 0.5,
+                },
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1",
+                false,
+                "2"
+            );
+
+            result.smallestMin.should.be.above(0.5);
+            result.greatestMax.should.be.below(5);
+        });
+
+        it("should handle general axios error", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const error = new Error();
+            error.response = { status: 500 };
+            axiosGetStub.throws(error);
+
+            try {
+                await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
+            } catch (error) {
+                error.should.be.an.instanceof(Error);
+            }
+        });
+
+        it("should handle missing data in axios response", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            axiosGetStub.returns(Promise.resolve({}));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should handle non-array axios response data", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: {} }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should handle missing exists property in exchange data", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should handle missing fixed property in exchange data", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should capture exchanges with exist=false as not supporting the pair", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: false,
+                    fixed: false,
+                    toAmount: 200,
+                    fromAmount: 1,
+                    duration: "9-21",
+                    max: 51,
+                    min: 0.11,
+                },
+                {
+                    exists: false,
+                    fixed: false,
+                    toAmount: 300,
+                    fromAmount: 1,
+                    duration: "12-22",
+                    max: 15,
+                    min: 0.13,
+                },
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "11-23",
+                    max: 11,
+                    min: 0.12,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.true();
+            result.rawSwapData.should.be.equal(mockData[2]);
+        });
+
+        it("should consider missing exists property as not supporting the pair", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should return null rate when fromAmount is not number greater than 0", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 3,
+                    fromAmount: 0,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            (result.rate === null).should.be.true();
+        });
+
+        it("should return null rate when toAmount is not number greater than 0 in response", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 3,
+                    fromAmount: 0,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            (result.rate === null).should.be.true();
+        });
+
+        it("should use an exchange with min=0 as unlimited", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 1000,
+                    min: 0,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "100"
+            );
+
+            result.result.should.be.true();
+            (result.smallestMin === null).should.be.true();
+        });
+
+        it("should use an exchange with max=0 as unlimited", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 0,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "100"
+            );
+
+            result.result.should.be.true();
+            (result.greatestMax === null).should.be.true();
+        });
+
+        it("should set greatestMax based on availableExchanges when no exchange has max=0", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 10,
+                    min: 0.1,
+                },
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 3,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.5,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "5",
+                false,
+                "2"
+            );
+
+            result.greatestMax.should.be.below(10);
+        });
+
+        it("should handle exchanges with non-numeric toAmount", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: "invalid",
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should correct smallestMin and greatestMax using coinAmountForMinMaxSafety", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 3,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.5,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1",
+                false,
+                "2"
+            );
+
+            result.smallestMin.should.be.above(0.5);
+            result.greatestMax.should.be.below(5);
+        });
+
+        it("should treat min=0 from an exchange as no limit", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 1,
+                    min: 0,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            (result.min === null).should.be.true();
+        });
+
+        it("should treat max=0 from an exchange as no limit", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 0,
+                    min: 1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            (result.max === null).should.be.true();
+        });
+
+        it("should consider min > max as an invalid exchange option", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 1,
+                    min: 5,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "3"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should handle not null/undefined coin->usd rate - safety coin amount should be used as 0", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1",
+                false,
+                "2"
+            );
+
+            result.result.should.be.true();
+            result.min.should.be.equal("0.6");
+            result.max.should.be.equal("4.5");
+            result.smallestMin.should.be.equal("0.6");
+            result.greatestMax.should.be.equal("4.5");
+        });
+
+        it("should handle null coin->usd rate - safety coin amount should be used as 0", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.true();
+            result.min.should.be.equal("0.1");
+            result.max.should.be.equal("5");
+            result.smallestMin.should.be.equal("0.1");
+            result.greatestMax.should.be.equal("5");
+        });
+
+        it("should consider an exchange with negative toAmount as not supporting the pair", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: -2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should correctly account for coinAmountForMinMaxSafety in rate calculation", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 3,
+                    fromAmount: 2,
+                    duration: "10-20",
+                    max: 1,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "0.9",
+                false,
+                "2"
+            );
+
+            result.min.should.be.above(0.1);
+        });
+
+        it("should handle scenario where all exchanges have negative toAmount", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: -2,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: -3,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 6,
+                    min: 0.2,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+
+        it("should use the best exchange option according to toAmount", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 3.1,
+                    fromAmount: 1,
+                    duration: "11-21",
+                    max: 5,
+                    min: 0.1,
+                },
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 3,
+                    fromAmount: 1,
+                    duration: "10-20",
+                    max: 6,
+                    min: 0.2,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.durationMinutesRange.should.be.equal("11-21");
+        });
+
+        it(`should use toNetwork from _supportedCoins`, async () => {
+            const expToNetwork = "slkjfn2";
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, network: "btc" },
+                { coin: ETH, network: expToNetwork },
+            ];
+            axiosGetStub.callsFake((url) => {
+                url.includes(`&toNetwork=${expToNetwork}&`).should.be.true();
+                return Promise.resolve({ data: [] });
+            });
+
+            await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
+        });
+
+        it(`should use fromNetwork from _supportedCoins`, async () => {
+            const expNetwork = "slkjfn2";
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, network: expNetwork },
+                { coin: ETH, network: "eth" },
+            ];
+            axiosGetStub.callsFake((url) => {
+                url.includes(`&fromNetwork=${expNetwork}&`).should.be.true();
+                return Promise.resolve({ data: [] });
+            });
+
+            await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
+        });
+
+        it("should respect the estimated=false parameter in the axios request", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            axiosGetStub.callsFake((url) => {
+                url.includes("estimated=false").should.be.true();
+                return Promise.resolve({ data: [] });
+            });
+
+            await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
+        });
+
+        it("should not convey float or fixed parameters in the axios request", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            axiosGetStub.callsFake((url) => {
+                url.should.not.containEql("float=");
+                url.should.not.containEql("fixed=");
+                return Promise.resolve({ data: [] });
+            });
+
+            await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
+        });
+
+        it("should respect amount parameter in the axios request", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            axiosGetStub.callsFake((url) => {
+                url.should.containEql("amount=1");
+                return Promise.resolve({ data: [] });
+            });
+
+            await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
+        });
+
+        it("should pass the from code from supportedCoins as parameter in the axios request", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "aaa", network: "btc" },
+                { coin: ETH, code: "eth", network: "eth" },
+            ];
+            axiosGetStub.callsFake((url) => {
+                url.should.containEql(`fromCurrency=aaa&`);
+                return Promise.resolve({ data: [] });
+            });
+
+            await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
+        });
+
+        it("should pass the to code from supportedCoins as parameter in the axios request", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc" },
+                { coin: ETH, code: "aaa", network: "eth" },
+            ];
+            axiosGetStub.callsFake((url) => {
+                url.should.containEql(`toCurrency=aaa&`);
+                return Promise.resolve({ data: [] });
+            });
+
+            await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
+        });
+
+        it("should generate correct URL for TRX to ERC20 USDT swap", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: TRX, code: "trx", network: "trx" },
+                { coin: USDTERC20, code: "usdt", network: "erc20" },
+            ];
+            axiosGetStub.callsFake((url) => {
+                url.should.containEql(`/api/v2/amounts`);
+                url.should.containEql("fromCurrency=trx");
+                url.should.containEql("fromNetwork=trx");
+                url.should.containEql("toCurrency=usdt");
+                url.should.containEql("toNetwork=erc20");
+                url.should.containEql("amount=100");
+                url.should.containEql("float=true");
+                url.should.containEql("estimated=false");
+                return Promise.resolve({ data: [] });
+            });
+
+            await swapspaceSwapProvider.getSwapInfo(TRX, USDTERC20, "100");
+        });
+
+        it("should generate correct URL for BTC to ETH swap", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            axiosGetStub.callsFake((url) => {
+                url.should.containEql(`/api/v2/amounts`);
+                url.should.containEql("fromCurrency=btc");
+                url.should.containEql("fromNetwork=btc");
+                url.should.containEql("toCurrency=eth");
+                url.should.containEql("toNetwork=eth");
+                url.should.containEql("amount=1");
+                url.should.containEql("estimated=false");
+                return Promise.resolve({ data: [] });
+            });
+
+            await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
+        });
+
+        it("should generate correct URL for TRC20 USDC to BTC swap", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+                { coin: USDCTRC20, code: "usdc", network: "trc20" },
+            ];
+            axiosGetStub.callsFake((url) => {
+                url.should.containEql(`/api/v2/amounts`);
+                url.should.containEql("fromCurrency=usdc");
+                url.should.containEql("fromNetwork=trc20");
+                url.should.containEql("toCurrency=btc");
+                url.should.containEql("toNetwork=btc");
+                url.should.containEql("amount=50.0235");
+                url.should.containEql("float=true");
+                url.should.containEql("estimated=false");
+                return Promise.resolve({ data: [] });
+            });
+
+            await swapspaceSwapProvider.getSwapInfo(USDCTRC20, BTC, "50.0235");
+        });
+
+        it("should return null for durationMinutesRange if bestRateOption does not contain the duration property", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: 3,
+                    fromAmount: 1,
+                    max: 5,
+                    min: 0.1,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            (result.durationMinutesRange === null).should.be.true();
+        });
+
+        it("should throw error when passing coins with unknown tickers or protocols", async () => {
+            try {
+                await swapspaceSwapProvider.getSwapInfo(
+                    { ticker: "unknownCoin" },
+                    ETH,
+                    "1"
+                );
+            } catch (error) {
+                error.should.be.an.instanceof(Error);
+            }
+        });
+
+        it("should throw error for non-string amountCoins input", async () => {
+            try {
+                await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
+            } catch (error) {
+                error.should.be.an.instanceof(Error);
+            }
+        });
+
+        it("should throw error for negative amountCoins input", async () => {
+            try {
+                await swapspaceSwapProvider.getSwapInfo(BTC, ETH, -1);
+            } catch (error) {
+                error.should.be.an.instanceof(Error);
+            }
+        });
+
+        it("should handle scenario where all exchanges have non-string toAmount and fromAmount", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true },
+            ];
+            const mockData = [
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: "invalid",
+                    fromAmount: "invalid",
+                    duration: "10-20",
+                    max: 5,
+                    min: 0.1,
+                },
+                {
+                    exists: true,
+                    fixed: false,
+                    toAmount: "invalid",
+                    fromAmount: "invalid",
+                    duration: "10-20",
+                    max: 6,
+                    min: 0.2,
+                },
+            ];
+            axiosGetStub.returns(Promise.resolve({ data: mockData }));
+
+            const result = await swapspaceSwapProvider.getSwapInfo(
+                BTC,
+                ETH,
+                "1"
+            );
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(
+                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            );
+        });
+    });
+});