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

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

@@ -30,9 +30,7 @@ describe("swapspaceSwapProvider", function () {
 
             const swapProvider = new SwapspaceSwapProvider("/", new Cache());
 
-            return swapProvider
-                ._fetchSupportedCurrenciesIfNeeded()
-                .should.be.rejectedWith(anyError);
+            return swapProvider._fetchSupportedCurrenciesIfNeeded().should.be.rejectedWith(anyError);
         });
 
         it("Should not call axios if there is _supportedCoins", async () => {
@@ -64,17 +62,11 @@ describe("swapspaceSwapProvider", function () {
             };
             axiosGetStub.resetBehavior();
             axiosGetStub.resolves(someResp);
-            const p = new SwapspaceSwapProvider(
-                "/",
-                new Cache(),
-                _customCoinBuilderStub
-            );
+            const p = new SwapspaceSwapProvider("/", new Cache(), _customCoinBuilderStub);
 
             await p._fetchSupportedCurrenciesIfNeeded();
 
-            _customCoinBuilderStub.callCount.should.be.equal(
-                someResp.data.length
-            );
+            _customCoinBuilderStub.callCount.should.be.equal(someResp.data.length);
         });
 
         it("Should call _customCoinBuilder with proper params", async () => {
@@ -89,19 +81,12 @@ describe("swapspaceSwapProvider", function () {
             };
             axiosGetStub.resetBehavior();
             axiosGetStub.resolves(someResp);
-            const p = new SwapspaceSwapProvider(
-                "/",
-                new Cache(),
-                _customCoinBuilderStub
-            );
+            const p = new SwapspaceSwapProvider("/", new Cache(), _customCoinBuilderStub);
 
             await p._fetchSupportedCurrenciesIfNeeded();
 
             _customCoinBuilderStub.args.forEach((args, i) =>
-                args.should.be.deepEqual([
-                    someResp.data[i].code,
-                    someResp.data[i].network,
-                ])
+                args.should.be.deepEqual([someResp.data[i].code, someResp.data[i].network])
             );
         });
 
@@ -120,22 +105,13 @@ describe("swapspaceSwapProvider", function () {
 
             axiosGetStub.resetBehavior();
             axiosGetStub.resolves(someResp);
-            const p = new SwapspaceSwapProvider(
-                "/",
-                new Cache(),
-                _customCoinBuilderStub,
-                true
-            );
+            const p = new SwapspaceSwapProvider("/", new Cache(), _customCoinBuilderStub, true);
 
             await p._fetchSupportedCurrenciesIfNeeded();
 
             p._supportedCoins.length.should.be.equal(2);
-            (
-                p._supportedCoins.find((i) => i.coin.ticker === "1") != null
-            ).should.be.true();
-            (
-                p._supportedCoins.find((i) => i.coin.ticker === "3") != null
-            ).should.be.true();
+            (p._supportedCoins.find(i => i.coin.ticker === "1") != null).should.be.true();
+            (p._supportedCoins.find(i => i.coin.ticker === "3") != null).should.be.true();
         });
 
         it("Should construct coins with default params if _customCoinBuilder return null for some and useRestrictedCoinsSet is false", async () => {
@@ -158,20 +134,13 @@ describe("swapspaceSwapProvider", function () {
 
             axiosGetStub.resetBehavior();
             axiosGetStub.resolves(someResp);
-            const p = new SwapspaceSwapProvider(
-                "/",
-                new Cache(),
-                _customCoinBuilderStub,
-                false
-            );
+            const p = new SwapspaceSwapProvider("/", new Cache(), _customCoinBuilderStub, false);
 
             await p._fetchSupportedCurrenciesIfNeeded();
 
             p._supportedCoins.length.should.be.equal(3);
 
-            const newCoin = p._supportedCoins.find(
-                (i) => i.coin.ticker === "BBBN2"
-            )?.coin;
+            const newCoin = p._supportedCoins.find(i => i.coin.ticker === "BBBN2")?.coin;
             (newCoin instanceof Coin).should.be.true();
             newCoin.tickerPrintable.should.be.equal("BBB");
             newCoin.latinName.should.be.equal("some");
@@ -286,25 +255,18 @@ describe("swapspaceSwapProvider", function () {
                     },
                     expectedName: "(USDT) (ERC20)",
                 },
-            ].forEach((testCase) => {
+            ].forEach(testCase => {
                 it("Should construct coins with default params if _customCoinBuilder return null for some and useRestrictedCoinsSet is false", async () => {
                     const someResp = {
                         data: [testCase.item],
                     };
                     axiosGetStub.resetBehavior();
                     axiosGetStub.resolves(someResp);
-                    const p = new SwapspaceSwapProvider(
-                        "/",
-                        new Cache(),
-                        () => null,
-                        false
-                    );
+                    const p = new SwapspaceSwapProvider("/", new Cache(), () => null, false);
 
                     await p._fetchSupportedCurrenciesIfNeeded();
 
-                    p._supportedCoins[0].coin.latinName.should.be.equal(
-                        testCase.expectedName
-                    );
+                    p._supportedCoins[0].coin.latinName.should.be.equal(testCase.expectedName);
                 });
             });
         });
@@ -323,12 +285,7 @@ describe("swapspaceSwapProvider", function () {
 
             axiosGetStub.resetBehavior();
             axiosGetStub.resolves(someResp);
-            const p = new SwapspaceSwapProvider(
-                "/",
-                new Cache(),
-                _customCoinBuilderStub,
-                false
-            );
+            const p = new SwapspaceSwapProvider("/", new Cache(), _customCoinBuilderStub, false);
 
             await p._fetchSupportedCurrenciesIfNeeded();
 
@@ -350,19 +307,12 @@ describe("swapspaceSwapProvider", function () {
 
             axiosGetStub.resetBehavior();
             axiosGetStub.resolves(someResp);
-            const p = new SwapspaceSwapProvider(
-                "/",
-                new Cache(),
-                _customCoinBuilderStub,
-                false
-            );
+            const p = new SwapspaceSwapProvider("/", new Cache(), _customCoinBuilderStub, false);
 
             await p._fetchSupportedCurrenciesIfNeeded();
 
             p._supportedCoins[0].coin.ticker.should.be.equal("BBBBBB1");
-            p._supportedCoins[0].coin.protocol.should.be.deepEqual(
-                new Protocol("BBB1")
-            );
+            p._supportedCoins[0].coin.protocol.should.be.deepEqual(new Protocol("BBB1"));
         });
 
         it("Should construct coins with tokenAddress === null if _customCoinBuilder return null for item and useRestrictedCoinsSet is false and contractAddress is nullish for item", async () => {
@@ -379,19 +329,14 @@ describe("swapspaceSwapProvider", function () {
 
             axiosGetStub.resetBehavior();
             axiosGetStub.resolves(someResp);
-            const p = new SwapspaceSwapProvider(
-                "/",
-                new Cache(),
-                _customCoinBuilderStub,
-                false
-            );
+            const p = new SwapspaceSwapProvider("/", new Cache(), _customCoinBuilderStub, false);
 
             await p._fetchSupportedCurrenciesIfNeeded();
 
             (p._supportedCoins[0].coin.tokenAddress === null).should.be.true();
         });
 
-        const setupAndExecstoreCoinDataFormatTest = async (attribute) => {
+        const setupAndExecstoreCoinDataFormatTest = async attribute => {
             const someResp = {
                 data: [
                     {
@@ -444,12 +389,7 @@ describe("swapspaceSwapProvider", function () {
 
             axiosGetStub.resetBehavior();
             axiosGetStub.resolves(someResp);
-            const p = new SwapspaceSwapProvider(
-                "/",
-                new Cache(),
-                _customCoinBuilderStub,
-                false
-            );
+            const p = new SwapspaceSwapProvider("/", new Cache(), _customCoinBuilderStub, false);
 
             await p._fetchSupportedCurrenciesIfNeeded();
 
@@ -459,14 +399,11 @@ describe("swapspaceSwapProvider", function () {
         it("Should save constructed coin as a coin list item", async () => {
             const { provider } = await setupAndExecstoreCoinDataFormatTest();
 
-            provider._supportedCoins.forEach((i) =>
-                i.coin.should.be.instanceof(Coin)
-            );
+            provider._supportedCoins.forEach(i => i.coin.should.be.instanceof(Coin));
         });
 
         it("Should save code as is", async () => {
-            const { provider, data } =
-                await setupAndExecstoreCoinDataFormatTest();
+            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
 
             provider._supportedCoins.forEach((dataItem, i) => {
                 dataItem.code.should.be.equal(data[i].code);
@@ -474,8 +411,7 @@ describe("swapspaceSwapProvider", function () {
         });
 
         it("Should save network as is", async () => {
-            const { provider, data } =
-                await setupAndExecstoreCoinDataFormatTest();
+            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
 
             provider._supportedCoins.forEach((dataItem, i) => {
                 dataItem.network.should.be.equal(data[i].network);
@@ -483,8 +419,7 @@ describe("swapspaceSwapProvider", function () {
         });
 
         it("Should save hasExtraId as is", async () => {
-            const { provider, data } =
-                await setupAndExecstoreCoinDataFormatTest();
+            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
 
             provider._supportedCoins.forEach((dataItem, i) => {
                 dataItem.hasExtraId.should.be.equal(data[i].hasExtraId);
@@ -492,8 +427,7 @@ describe("swapspaceSwapProvider", function () {
         });
 
         it("Should save extraIdName as is", async () => {
-            const { provider, data } =
-                await setupAndExecstoreCoinDataFormatTest();
+            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
 
             provider._supportedCoins.forEach((dataItem, i) => {
                 dataItem.extraIdName.should.be.equal(data[i].extraIdName);
@@ -501,8 +435,7 @@ describe("swapspaceSwapProvider", function () {
         });
 
         it("Should save popular to isPopular as boolean", async () => {
-            const { provider, data } =
-                await setupAndExecstoreCoinDataFormatTest();
+            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
 
             provider._supportedCoins.forEach((dataItem, i) => {
                 dataItem.isPopular.should.be.equal(!!data[i].popular);
@@ -510,8 +443,7 @@ describe("swapspaceSwapProvider", function () {
         });
 
         it("Should save icon or default URL to iconURL", async () => {
-            const { provider, data } =
-                await setupAndExecstoreCoinDataFormatTest();
+            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
 
             provider._supportedCoins.forEach((dataItem, i) => {
                 dataItem.iconURL.should.be.equal(
@@ -523,8 +455,7 @@ describe("swapspaceSwapProvider", function () {
         });
 
         it("Should save deposit as is", async () => {
-            const { provider, data } =
-                await setupAndExecstoreCoinDataFormatTest();
+            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
 
             provider._supportedCoins.forEach((dataItem, i) => {
                 dataItem.deposit.should.be.equal(data[i].deposit);
@@ -532,8 +463,7 @@ describe("swapspaceSwapProvider", function () {
         });
 
         it("Should save withdrawal as is", async () => {
-            const { provider, data } =
-                await setupAndExecstoreCoinDataFormatTest();
+            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
 
             provider._supportedCoins.forEach((dataItem, i) => {
                 dataItem.withdrawal.should.be.equal(data[i].withdrawal);
@@ -541,24 +471,15 @@ describe("swapspaceSwapProvider", function () {
         });
 
         it("Should save validationRegexp or null if it is nullish", async () => {
-            const { provider, data } =
-                await setupAndExecstoreCoinDataFormatTest();
+            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
 
             provider._supportedCoins.forEach((dataItem, i) => {
-                (
-                    dataItem.validationRegexp ===
-                    (data[i].validationRegexp ?? null)
-                ).should.be.true();
+                (dataItem.validationRegexp === (data[i].validationRegexp ?? null)).should.be.true();
             });
         });
 
         it("should sort list by isPopular and alphabetically by ticker", async () => {
-            const swapspaceProvider = new SwapspaceSwapProvider(
-                "/",
-                new Cache(),
-                () => null,
-                false
-            );
+            const swapspaceProvider = new SwapspaceSwapProvider("/", new Cache(), () => null, false);
             const fakeResponse = {
                 data: [
                     {
@@ -593,14 +514,8 @@ describe("swapspaceSwapProvider", function () {
             await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
 
             swapspaceProvider._supportedCoins
-                .map((coin) => coin.coin.ticker)
-                .should.be.deepEqual([
-                    "AAAXXX",
-                    "ETH",
-                    "AAAEEE",
-                    "BAC",
-                    "BTCBBB",
-                ]);
+                .map(coin => coin.coin.ticker)
+                .should.be.deepEqual(["AAAXXX", "ETH", "AAAEEE", "BAC", "BTCBBB"]);
         });
 
         it("should handle empty response data", async () => {

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

@@ -81,10 +81,7 @@ describe("swapspaceSwapProvider", function () {
                 { coin: ETH, extraId: "" },
             ];
 
-            fetchSupportedCurrenciesStub = sinon.stub(
-                swapspaceSwapProvider,
-                "_fetchSupportedCurrenciesIfNeeded"
-            );
+            fetchSupportedCurrenciesStub = sinon.stub(swapspaceSwapProvider, "_fetchSupportedCurrenciesIfNeeded");
             fetchSupportedCurrenciesStub.resolves();
 
             axiosPostStub = sinon.stub(axios, "post");
@@ -143,9 +140,7 @@ describe("swapspaceSwapProvider", function () {
                 anyIp,
                 false
             );
-            axiosPostStub.args[0][0].should.equal(
-                `${swapspaceSwapProvider._URL}/api/v2/exchange`
-            );
+            axiosPostStub.args[0][0].should.equal(`${swapspaceSwapProvider._URL}/api/v2/exchange`);
         });
 
         it("Should pass client IP address in request data", async () => {
@@ -160,10 +155,7 @@ describe("swapspaceSwapProvider", function () {
                 false
             );
 
-            axiosPostStub.args[0][1].should.have.property(
-                "userIp",
-                "123.123.123.123"
-            );
+            axiosPostStub.args[0][1].should.have.property("userIp", "123.123.123.123");
         });
 
         it("Should pass provided refund address in request data", async () => {
@@ -178,10 +170,7 @@ describe("swapspaceSwapProvider", function () {
                 false
             );
 
-            axiosPostStub.args[0][1].should.have.property(
-                "refund",
-                anyRefundAddress
-            );
+            axiosPostStub.args[0][1].should.have.property("refund", anyRefundAddress);
         });
 
         it("Should use rateId from rawSwapData in request data", async () => {
@@ -196,18 +185,12 @@ describe("swapspaceSwapProvider", function () {
                 false
             );
 
-            axiosPostStub.args[0][1].should.have.property(
-                "rateId",
-                "test-rateId"
-            );
+            axiosPostStub.args[0][1].should.have.property("rateId", "test-rateId");
         });
 
         it('Should send the correct "extraId" passed if toCoin has hasExtraId===true', async () => {
             const someExtraId = "extra123";
-            swapspaceSwapProvider._supportedCoins = [
-                { coin: USDCTRC20 },
-                { coin: ETH, hasExtraId: true },
-            ];
+            swapspaceSwapProvider._supportedCoins = [{ coin: USDCTRC20 }, { coin: ETH, hasExtraId: true }];
 
             await swapspaceSwapProvider.createSwap(
                 USDCTRC20,
@@ -221,10 +204,7 @@ describe("swapspaceSwapProvider", function () {
                 someExtraId
             );
 
-            axiosPostStub.args[0][1].should.have.property(
-                "extraId",
-                someExtraId
-            );
+            axiosPostStub.args[0][1].should.have.property("extraId", someExtraId);
         });
 
         it('Should send the correct "refundExtraId" when refund extraId passed and fromCoin has hasExtraId===true ', async () => {
@@ -252,10 +232,7 @@ describe("swapspaceSwapProvider", function () {
                 someExtraId
             );
 
-            axiosPostStub.args[0][1].should.have.property(
-                "refundExtraId",
-                someExtraId
-            );
+            axiosPostStub.args[0][1].should.have.property("refundExtraId", someExtraId);
         });
 
         it('Should omit passed "extraId" or "refundExtraId" when matching coins have hasExtraId false', async () => {
@@ -300,32 +277,13 @@ describe("swapspaceSwapProvider", function () {
                 false
             );
 
-            axiosPostStub.args[0][1].should.have.property(
-                "fromCurrency",
-                "from-test"
-            );
-            axiosPostStub.args[0][1].should.have.property(
-                "fromNetwork",
-                "from-network-test"
-            );
-            axiosPostStub.args[0][1].should.have.property(
-                "toCurrency",
-                "to-test"
-            );
-            axiosPostStub.args[0][1].should.have.property(
-                "toNetwork",
-                "to-network-test"
-            );
+            axiosPostStub.args[0][1].should.have.property("fromCurrency", "from-test");
+            axiosPostStub.args[0][1].should.have.property("fromNetwork", "from-network-test");
+            axiosPostStub.args[0][1].should.have.property("toCurrency", "to-test");
+            axiosPostStub.args[0][1].should.have.property("toNetwork", "to-network-test");
         });
 
-        [
-            "fromCurrency",
-            "fromNetwork",
-            "toCurrency",
-            "toNetwork",
-            "id",
-            "partner",
-        ].forEach((rawSwapDataProperty) => {
+        ["fromCurrency", "fromNetwork", "toCurrency", "toNetwork", "id", "partner"].forEach(rawSwapDataProperty => {
             it(`Should reject if raw swap data contains wrong ${rawSwapDataProperty}`, async () => {
                 const rawSwapData = {
                     ...anyValidRawSwapData,
@@ -359,13 +317,10 @@ describe("swapspaceSwapProvider", function () {
                 false
             );
 
-            axiosPostStub.args[0][1].should.have.property(
-                "partner",
-                "testPartner"
-            );
+            axiosPostStub.args[0][1].should.have.property("partner", "testPartner");
         });
 
-        [false, true].forEach((fixed) => {
+        [false, true].forEach(fixed => {
             it("Should ensure that fixed is always set to passed fixed value in the request data", async () => {
                 await swapspaceSwapProvider.createSwap(
                     USDCTRC20,
@@ -413,10 +368,7 @@ describe("swapspaceSwapProvider", function () {
         });
 
         it("Should handle cases where toCurrencyExtraId is not found for the coin", async () => {
-            swapspaceSwapProvider._supportedCoins = [
-                { coin: USDCTRC20, extraId: "" },
-                { coin: ETH },
-            ];
+            swapspaceSwapProvider._supportedCoins = [{ coin: USDCTRC20, extraId: "" }, { coin: ETH }];
             await swapspaceSwapProvider.createSwap(
                 USDCTRC20,
                 ETH,
@@ -461,9 +413,7 @@ describe("swapspaceSwapProvider", function () {
                 false
             );
 
-            result.reason.should.equal(
-                SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
-            );
+            result.reason.should.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
         });
 
         it("Should return retriable fail for status 422 and specific 'Pair cannot be processed by' error text", async () => {
@@ -482,9 +432,7 @@ describe("swapspaceSwapProvider", function () {
                 false
             );
 
-            result.reason.should.equal(
-                SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL
-            );
+            result.reason.should.equal(SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
         });
 
         it("Should return retriable fail for status 403 and specific 'IP address is forbidden' error text", async () => {
@@ -503,9 +451,7 @@ describe("swapspaceSwapProvider", function () {
                 false
             );
 
-            result.reason.should.equal(
-                SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL
-            );
+            result.reason.should.equal(SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
         });
 
         it('Should return retriable fail for status 422 and specific "Amount maximum is" error text', async () => {
@@ -524,9 +470,7 @@ describe("swapspaceSwapProvider", function () {
                 false
             );
 
-            result.reason.should.equal(
-                SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL
-            );
+            result.reason.should.equal(SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
         });
 
         it('Should return retriable fail for status 422 and specific "Amount minimum is" error text', async () => {
@@ -545,9 +489,7 @@ describe("swapspaceSwapProvider", function () {
                 false
             );
 
-            result.reason.should.equal(
-                SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL
-            );
+            result.reason.should.equal(SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
         });
 
         it('Should return retriable fail for status 422 and specific "Currency not found" error text', async () => {
@@ -566,9 +508,7 @@ describe("swapspaceSwapProvider", function () {
                 false
             );
 
-            result.reason.should.equal(
-                SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL
-            );
+            result.reason.should.equal(SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
         });
 
         it("Should return the correct swap details if response is valid", async () => {
@@ -1178,9 +1118,7 @@ describe("swapspaceSwapProvider", function () {
                     anyIp,
                     false
                 )
-                .should.be.rejectedWith(
-                    /.*Swap creation succeeded but the response is wrong:.*/
-                );
+                .should.be.rejectedWith(/.*Swap creation succeeded but the response is wrong:.*/);
         });
 
         it("Should handle axios.post returning a response with no from amount or invalid", async () => {

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

@@ -37,14 +37,8 @@ describe("swapspaceSwapProvider", function () {
         });
 
         it("Should return an object with 'result' set to true and an array of supported coins if there is initialized list", async () => {
-            swapspaceProvider._supportedCoins = [
-                { coin: { t: "BTC" }, extraId: "" },
-                { coin: 1 },
-                { coin: "4" },
-            ];
-            const expectedCoins = swapspaceProvider._supportedCoins.map(
-                (item) => item.coin
-            );
+            swapspaceProvider._supportedCoins = [{ coin: { t: "BTC" }, extraId: "" }, { coin: 1 }, { coin: "4" }];
+            const expectedCoins = swapspaceProvider._supportedCoins.map(item => item.coin);
 
             const result = await swapspaceProvider.getAllSupportedCurrencies();
 
@@ -58,18 +52,14 @@ describe("swapspaceSwapProvider", function () {
         });
 
         it("Should throw an error if an error occurs while fetching supported currencies", async () => {
-            _fetchSupportedCurrenciesIfNeededStub.throws(
-                new Error("Error fetching supported currencies")
-            );
+            _fetchSupportedCurrenciesIfNeededStub.throws(new Error("Error fetching supported currencies"));
 
             try {
                 await swapspaceProvider.getAllSupportedCurrencies();
                 should.fail("Expected an error to be thrown");
             } catch (error) {
                 error.should.be.instanceOf(Error);
-                error.message.should.containEql(
-                    "Error fetching supported currencies"
-                );
+                error.message.should.containEql("Error fetching supported currencies");
             }
         });
     });

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

@@ -48,9 +48,7 @@ describe("swapspaceSwapProvider", function () {
                 { coin: "4", withdrawal: true, deposit: null },
                 { coin: "-12312", withdrawal: null, deposit: false },
             ];
-            const expectedCoins = swapspaceProvider._supportedCoins
-                .filter((i) => i.deposit)
-                .map((item) => item.coin);
+            const expectedCoins = swapspaceProvider._supportedCoins.filter(i => i.deposit).map(item => item.coin);
 
             const result = await swapspaceProvider.getDepositCurrencies();
 
@@ -64,18 +62,14 @@ describe("swapspaceSwapProvider", function () {
         });
 
         it("Should throw an error if an error occurs while fetching supported currencies", async () => {
-            _fetchSupportedCurrenciesIfNeededStub.throws(
-                new Error("Error fetching supported currencies")
-            );
+            _fetchSupportedCurrenciesIfNeededStub.throws(new Error("Error fetching supported currencies"));
 
             try {
                 await swapspaceProvider.getDepositCurrencies();
                 should.fail("Expected an error to be thrown");
             } catch (error) {
                 error.should.be.instanceOf(Error);
-                error.message.should.containEql(
-                    "Error fetching supported currencies"
-                );
+                error.message.should.containEql("Error fetching supported currencies");
             }
         });
     });