@rabbitio/ui-kit 1.0.0-beta.64 → 1.0.0-beta.66

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

@@ -99,9 +99,7 @@ describe("swapspaceSwapProvider", function () {
             axiosGetStub = sinon.stub(axios, "get");
 
             trimCryptoAmountByCoinStub = sinon.stub(AmountUtils, "trim");
-            trimCryptoAmountByCoinStub.callsFake((amount) =>
-                amount?.toString()
-            );
+            trimCryptoAmountByCoinStub.callsFake(amount => amount?.toString());
         });
 
         afterEach(() => {
@@ -126,11 +124,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.true();
             result.min.should.be.String();
@@ -143,40 +137,32 @@ describe("swapspaceSwapProvider", function () {
             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 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.1,
+        //                 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 = [
@@ -205,11 +191,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.rawSwapData.should.be.deepEqual(mockData[1]);
         });
@@ -232,11 +214,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.rate.should.be.equal("1.5"); // because 3 divided by 2 is 1.5
         });
@@ -268,11 +246,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.durationMinutesRange.should.be.equal("11-21"); // Using the first one by order
         });
@@ -295,11 +269,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.rawSwapData.should.be.deepEqual(mockData[0]);
         });
@@ -311,94 +281,45 @@ describe("swapspaceSwapProvider", function () {
             ];
             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
-            );
-        });
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
+
+            result.reason.should.be.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+        });
+
+        // it("should return TOO_LOW whы
+
+        // 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 = [
@@ -407,16 +328,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: [] }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
         });
 
         it("should return NOT_SUPPORTED when deposit is false for from currency", async () => {
@@ -426,16 +341,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: [] }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
         });
 
         it("should return NOT_SUPPORTED when withdrawal is false for to currency", async () => {
@@ -445,16 +354,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: [] }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            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 () => {
@@ -478,17 +381,10 @@ describe("swapspaceSwapProvider", function () {
                 })
             );
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1",
-                true
-            );
+            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
-            );
+            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 () => {
@@ -512,17 +408,10 @@ describe("swapspaceSwapProvider", function () {
                 })
             );
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1",
-                false
-            );
+            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
-            );
+            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 () => {
@@ -556,18 +445,13 @@ describe("swapspaceSwapProvider", function () {
                 })
             );
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1",
-                null
-            );
+            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 () => {
+        it("should correctly handle when there are available exchange options and no numeric min", async () => {
             swapspaceSwapProvider._supportedCoins = [
                 { coin: BTC, code: "btc", network: "btc", deposit: true },
                 { coin: ETH, code: "eth", network: "eth", withdrawal: true },
@@ -586,17 +470,13 @@ describe("swapspaceSwapProvider", function () {
                 ],
             });
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "6"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "6");
 
-            result.result.should.be.true();
-            (result.smallestMin === null).should.be.true();
+            result.result.should.be.false();
+            (result.smallestMin === undefined).should.be.true();
         });
 
-        it("should correctly handle when there are available exchange options and no greatest max", async () => {
+        it("should correctly handle when there are available exchange options and no numeric max", async () => {
             swapspaceSwapProvider._supportedCoins = [
                 { coin: BTC, code: "btc", network: "btc", deposit: true },
                 { coin: ETH, code: "eth", network: "eth", withdrawal: true },
@@ -615,14 +495,10 @@ describe("swapspaceSwapProvider", function () {
                 ],
             });
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "0.01"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "0.01");
 
-            result.result.should.be.true();
-            (result.greatestMax === null).should.be.true();
+            result.result.should.be.false();
+            (result.greatestMax === undefined).should.be.true();
         });
 
         it("should increase the min with coinAmountForMinMaxSafety", async () => {
@@ -643,13 +519,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "10",
-                false,
-                "2"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "10", false, "2");
 
             result.result.should.be.true();
             result.min.should.be.equal("0.6");
@@ -682,13 +552,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "10",
-                false,
-                "2"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "10", false, "2");
 
             result.result.should.be.true();
             result.smallestMin.should.be.equal("0.51");
@@ -721,13 +585,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "10",
-                false,
-                "2"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "10", false, "2");
 
             result.result.should.be.true();
             result.greatestMax.should.be.equal("0");
@@ -751,13 +609,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "10",
-                false,
-                "2"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "10", false, "2");
 
             result.result.should.be.true();
             result.max.should.be.equal("3.5");
@@ -790,13 +642,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "10",
-                false,
-                "2"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "10", false, "2");
 
             result.result.should.be.true();
             result.greatestMax.should.be.equal("5.5");
@@ -820,13 +666,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "10",
-                false,
-                "2"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "10", false, "2");
 
             result.result.should.be.true();
             result.max.should.be.equal("0");
@@ -848,16 +688,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
         });
 
         it("should filter out banned exchanges", async () => {
@@ -885,16 +719,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
         });
 
         it("should filter out exchanges where toAmount equals 0", async () => {
@@ -914,16 +742,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
         });
 
         it("should correctly compute smallestMin and greatestMax", async () => {
@@ -953,13 +775,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1",
-                false,
-                "2"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1", false, "2");
 
             result.smallestMin.should.be.above(0.5);
             result.greatestMax.should.be.below(5);
@@ -988,16 +804,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({}));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
         });
 
         it("should handle non-array axios response data", async () => {
@@ -1007,16 +817,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: {} }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
         });
 
         it("should handle missing exists property in exchange data", async () => {
@@ -1036,16 +840,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
         });
 
         it("should handle missing fixed property in exchange data", async () => {
@@ -1065,16 +863,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
         });
 
         it("should capture exchanges with exist=false as not supporting the pair", async () => {
@@ -1113,11 +905,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.true();
             result.rawSwapData.should.be.equal(mockData[2]);
@@ -1140,16 +928,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            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 () => {
@@ -1170,11 +952,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             (result.rate === null).should.be.true();
         });
@@ -1197,11 +975,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             (result.rate === null).should.be.true();
         });
@@ -1224,11 +998,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "100"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "100");
 
             result.result.should.be.true();
             (result.smallestMin === null).should.be.true();
@@ -1252,11 +1022,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "100"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "100");
 
             result.result.should.be.true();
             (result.greatestMax === null).should.be.true();
@@ -1289,13 +1055,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "5",
-                false,
-                "2"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "5", false, "2");
 
             result.greatestMax.should.be.below(10);
         });
@@ -1318,16 +1078,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
         });
 
         it("should correct smallestMin and greatestMax using coinAmountForMinMaxSafety", async () => {
@@ -1348,13 +1102,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1",
-                false,
-                "2"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1", false, "2");
 
             result.smallestMin.should.be.above(0.5);
             result.greatestMax.should.be.below(5);
@@ -1378,11 +1126,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             (result.min === null).should.be.true();
         });
@@ -1405,11 +1149,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             (result.max === null).should.be.true();
         });
@@ -1432,16 +1172,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "3"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "3");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            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 () => {
@@ -1462,13 +1196,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1",
-                false,
-                "2"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1", false, "2");
 
             result.result.should.be.true();
             result.min.should.be.equal("0.6");
@@ -1495,11 +1223,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.true();
             result.min.should.be.equal("0.1");
@@ -1526,16 +1250,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
         });
 
         it("should correctly account for coinAmountForMinMaxSafety in rate calculation", async () => {
@@ -1556,13 +1274,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "0.9",
-                false,
-                "2"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "0.9", false, "2");
 
             result.min.should.be.above(0.1);
         });
@@ -1594,16 +1306,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
         });
 
         it("should use the best exchange option according to toAmount", async () => {
@@ -1633,11 +1339,7 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.durationMinutesRange.should.be.equal("11-21");
         });
@@ -1648,7 +1350,7 @@ describe("swapspaceSwapProvider", function () {
                 { coin: BTC, network: "btc" },
                 { coin: ETH, network: expToNetwork },
             ];
-            axiosGetStub.callsFake((url) => {
+            axiosGetStub.callsFake(url => {
                 url.includes(`&toNetwork=${expToNetwork}&`).should.be.true();
                 return Promise.resolve({ data: [] });
             });
@@ -1662,7 +1364,7 @@ describe("swapspaceSwapProvider", function () {
                 { coin: BTC, network: expNetwork },
                 { coin: ETH, network: "eth" },
             ];
-            axiosGetStub.callsFake((url) => {
+            axiosGetStub.callsFake(url => {
                 url.includes(`&fromNetwork=${expNetwork}&`).should.be.true();
                 return Promise.resolve({ data: [] });
             });
@@ -1675,7 +1377,7 @@ describe("swapspaceSwapProvider", function () {
                 { coin: BTC, code: "btc", network: "btc", deposit: true },
                 { coin: ETH, code: "eth", network: "eth", withdrawal: true },
             ];
-            axiosGetStub.callsFake((url) => {
+            axiosGetStub.callsFake(url => {
                 url.includes("estimated=false").should.be.true();
                 return Promise.resolve({ data: [] });
             });
@@ -1688,7 +1390,7 @@ describe("swapspaceSwapProvider", function () {
                 { coin: BTC, code: "btc", network: "btc", deposit: true },
                 { coin: ETH, code: "eth", network: "eth", withdrawal: true },
             ];
-            axiosGetStub.callsFake((url) => {
+            axiosGetStub.callsFake(url => {
                 url.should.not.containEql("float=");
                 url.should.not.containEql("fixed=");
                 return Promise.resolve({ data: [] });
@@ -1702,7 +1404,7 @@ describe("swapspaceSwapProvider", function () {
                 { coin: BTC, code: "btc", network: "btc", deposit: true },
                 { coin: ETH, code: "eth", network: "eth", withdrawal: true },
             ];
-            axiosGetStub.callsFake((url) => {
+            axiosGetStub.callsFake(url => {
                 url.should.containEql("amount=1");
                 return Promise.resolve({ data: [] });
             });
@@ -1715,7 +1417,7 @@ describe("swapspaceSwapProvider", function () {
                 { coin: BTC, code: "aaa", network: "btc" },
                 { coin: ETH, code: "eth", network: "eth" },
             ];
-            axiosGetStub.callsFake((url) => {
+            axiosGetStub.callsFake(url => {
                 url.should.containEql(`fromCurrency=aaa&`);
                 return Promise.resolve({ data: [] });
             });
@@ -1728,7 +1430,7 @@ describe("swapspaceSwapProvider", function () {
                 { coin: BTC, code: "btc", network: "btc" },
                 { coin: ETH, code: "aaa", network: "eth" },
             ];
-            axiosGetStub.callsFake((url) => {
+            axiosGetStub.callsFake(url => {
                 url.should.containEql(`toCurrency=aaa&`);
                 return Promise.resolve({ data: [] });
             });
@@ -1741,7 +1443,7 @@ describe("swapspaceSwapProvider", function () {
                 { coin: TRX, code: "trx", network: "trx" },
                 { coin: USDTERC20, code: "usdt", network: "erc20" },
             ];
-            axiosGetStub.callsFake((url) => {
+            axiosGetStub.callsFake(url => {
                 url.should.containEql(`/api/v2/amounts`);
                 url.should.containEql("fromCurrency=trx");
                 url.should.containEql("fromNetwork=trx");
@@ -1761,7 +1463,7 @@ describe("swapspaceSwapProvider", function () {
                 { coin: BTC, code: "btc", network: "btc", deposit: true },
                 { coin: ETH, code: "eth", network: "eth", withdrawal: true },
             ];
-            axiosGetStub.callsFake((url) => {
+            axiosGetStub.callsFake(url => {
                 url.should.containEql(`/api/v2/amounts`);
                 url.should.containEql("fromCurrency=btc");
                 url.should.containEql("fromNetwork=btc");
@@ -1781,7 +1483,7 @@ describe("swapspaceSwapProvider", function () {
                 { coin: ETH, code: "eth", network: "eth", withdrawal: true },
                 { coin: USDCTRC20, code: "usdc", network: "trc20" },
             ];
-            axiosGetStub.callsFake((url) => {
+            axiosGetStub.callsFake(url => {
                 url.should.containEql(`/api/v2/amounts`);
                 url.should.containEql("fromCurrency=usdc");
                 url.should.containEql("fromNetwork=trc20");
@@ -1813,22 +1515,14 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            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"
-                );
+                await swapspaceSwapProvider.getSwapInfo({ ticker: "unknownCoin" }, ETH, "1");
             } catch (error) {
                 error.should.be.an.instanceof(Error);
             }
@@ -1877,16 +1571,10 @@ describe("swapspaceSwapProvider", function () {
             ];
             axiosGetStub.returns(Promise.resolve({ data: mockData }));
 
-            const result = await swapspaceSwapProvider.getSwapInfo(
-                BTC,
-                ETH,
-                "1"
-            );
+            const result = await swapspaceSwapProvider.getSwapInfo(BTC, ETH, "1");
 
             result.result.should.be.false();
-            result.reason.should.be.equal(
-                SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-            );
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
         });
     });
 });