@rabbitio/ui-kit 1.0.0-beta.80 → 1.0.0-beta.82

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

@@ -8,6 +8,7 @@ import { SwapspaceSwapProvider } from "../../../external-apis/swapspaceSwapProvi
 import { Coin } from "../../../../common-apis/models/coin.js";
 import { Cache } from "../../../../common-apis/utils/cache.js";
 import { Protocol } from "../../../../common-apis/models/protocol.js";
+import { PRE_LISTED_COINS } from "../../../external-apis/swapProvider.js";
 
 describe("swapspaceSwapProvider", function () {
     describe("_fetchSupportedCurrenciesIfNeeded", function () {
@@ -33,506 +34,506 @@ describe("swapspaceSwapProvider", function () {
             return swapProvider._fetchSupportedCurrenciesIfNeeded().should.be.rejectedWith(anyError);
         });
 
-        it("Should not call axios if there is _supportedCoins", async () => {
-            swapspaceProvider._supportedCoins = [{ coin: {}, extraId: "" }];
-            await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
-
-            axiosGetStub.callCount.should.be.equal(0);
-        });
-
-        it("should make a network call if coins are not cached", async () => {
-            swapspaceProvider._supportedCoins = [];
-            const fakeResponse = { data: [] };
-            axiosGetStub.returns(Promise.resolve(fakeResponse));
-
-            await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
-
-            axiosGetStub.calledOnce.should.be.true();
-        });
-
-        it("Should call _customCoinBuilder number of times equal to returned coins count", async () => {
-            const _customCoinBuilderStub = sinon.stub();
-            const someResp = {
-                data: [
-                    { code: "1", network: "n1" },
-                    { code: "2", network: "n2" },
-                    { code: "3", network: "n3" },
-                    { code: "4", network: "n4" },
-                ],
-            };
-            axiosGetStub.resetBehavior();
-            axiosGetStub.resolves(someResp);
-            const p = new SwapspaceSwapProvider("/", new Cache(), _customCoinBuilderStub);
-
-            await p._fetchSupportedCurrenciesIfNeeded();
-
-            _customCoinBuilderStub.callCount.should.be.equal(someResp.data.length);
-        });
-
-        it("Should call _customCoinBuilder with proper params", async () => {
-            const _customCoinBuilderStub = sinon.stub();
-            const someResp = {
-                data: [
-                    { code: "1", network: "n1" },
-                    { code: "2", network: "n2" },
-                    { code: "3", network: "n3" },
-                    { code: "4", network: "n4" },
-                ],
-            };
-            axiosGetStub.resetBehavior();
-            axiosGetStub.resolves(someResp);
-            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])
-            );
-        });
-
-        it("Should ignore coins that _customCoinBuilder returned null for if useRestrictedCoinsSet is true", async () => {
-            const someResp = {
-                data: [
-                    { code: "1", network: "n1" },
-                    { code: "2", network: "n2" },
-                    { code: "3", network: "n3" },
-                ],
-            };
-            const _customCoinBuilderStub = sinon.stub();
-            _customCoinBuilderStub.onFirstCall().returns({ ticker: "1" });
-            _customCoinBuilderStub.onSecondCall().returns(null);
-            _customCoinBuilderStub.onThirdCall().returns({ ticker: "3" });
-
-            axiosGetStub.resetBehavior();
-            axiosGetStub.resolves(someResp);
-            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();
-        });
-
-        it("Should construct coins with default params if _customCoinBuilder return null for some and useRestrictedCoinsSet is false", async () => {
-            const someResp = {
-                data: [
-                    { code: "aaa", network: "n1" },
-                    {
-                        code: "bbb",
-                        network: "n2",
-                        name: "some",
-                        contractAddress: "addr",
-                    },
-                    { code: "ccc", network: "n3" },
-                ],
-            };
-            const _customCoinBuilderStub = sinon.stub();
-            _customCoinBuilderStub.onFirstCall().returns({ ticker: "AAAN1" });
-            _customCoinBuilderStub.onSecondCall().returns(null);
-            _customCoinBuilderStub.onThirdCall().returns({ ticker: "CCCN3" });
-
-            axiosGetStub.resetBehavior();
-            axiosGetStub.resolves(someResp);
-            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;
-            (newCoin instanceof Coin).should.be.true();
-            newCoin.tickerPrintable.should.be.equal("BBB");
-            newCoin.latinName.should.be.equal("some");
-            newCoin.digits.should.be.equal(8);
-            (newCoin.maxValue === null).should.be.true();
-            newCoin.atomName.should.be.equal("");
-            (newCoin.mainnet === null).should.be.true();
-            (newCoin.testnet === null).should.be.true();
-            newCoin.minConfirmations.should.be.equal(1);
-            (newCoin.payableEntityStringForFeeRate === null).should.be.true();
-            newCoin.feeOptionsTimeStringsSortedDesc.should.be.deepEqual([]);
-            newCoin.feeRatesExpirationTimeMs.should.be.equal(60000);
-            newCoin.protocol.should.be.deepEqual(new Protocol("N2"));
-            (newCoin.blockchain === null).should.be.true();
-            newCoin.tokenAddress.should.be.equal("addr");
-            newCoin.feeCoin.should.be.equal(newCoin);
-            newCoin.doesUseLowerCaseAddresses.should.be.equal(false);
-            newCoin.doesUseOutputs.should.be.equal(false);
-        });
-
-        describe("Should process name when creating custom coins", function () {
-            [
-                {
-                    item: { code: "BTC", network: "BTC", name: " Bitcoin  " },
-                    expectedName: "Bitcoin",
-                },
-                {
-                    item: {
-                        code: "BTC",
-                        network: "BTC",
-                        name: " Bitcoin  (BTC)  ",
-                    },
-                    expectedName: "Bitcoin",
-                },
-                {
-                    item: { code: "BTC", network: "BTC", name: "Bitcoin" },
-                    expectedName: "Bitcoin",
-                },
-                {
-                    item: { code: "BTC", network: "BTC", name: "BTC" },
-                    expectedName: "BTC",
-                },
-                {
-                    item: {
-                        code: "BTC",
-                        network: "BTC",
-                        name: "Bitcoin (BTC)",
-                    },
-                    expectedName: "Bitcoin",
-                },
-                {
-                    item: {
-                        code: "BTC",
-                        network: "BTC",
-                        name: "Bitcoin (BTC) (BTC)",
-                    },
-                    expectedName: "Bitcoin",
-                },
-                {
-                    item: { code: "BTC", network: "BTC", name: "BTC (BTC)" },
-                    expectedName: "BTC (BTC)",
-                },
-                {
-                    item: { code: "BTC", network: "BTC", name: "(BTC) (BTC)" },
-                    expectedName: "(BTC) (BTC)",
-                },
-                {
-                    item: { code: "USDT", network: "ERC20", name: "Tether" },
-                    expectedName: "Tether",
-                },
-                {
-                    item: { code: "USDT", network: "ERC20", name: "USDT" },
-                    expectedName: "USDT",
-                },
-                {
-                    item: {
-                        code: "USDT",
-                        network: "ERC20",
-                        name: "Tether (USDT)",
-                    },
-                    expectedName: "Tether",
-                },
-                {
-                    item: {
-                        code: "USDT",
-                        network: "ERC20",
-                        name: "Tether (USDT)",
-                    },
-                    expectedName: "Tether",
-                },
-                {
-                    item: {
-                        code: "USDT",
-                        network: "ERC20",
-                        name: "Tether (USDT) (ERC20)",
-                    },
-                    expectedName: "Tether",
-                },
-                {
-                    item: {
-                        code: "USDT",
-                        network: "ERC20",
-                        name: "USDT (ERC20)",
-                    },
-                    expectedName: "USDT",
-                },
-                {
-                    item: {
-                        code: "USDT",
-                        network: "ERC20",
-                        name: "(USDT) (ERC20)",
-                    },
-                    expectedName: "(USDT) (ERC20)",
-                },
-            ].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);
-
-                    await p._fetchSupportedCurrenciesIfNeeded();
-
-                    p._supportedCoins[0].coin.latinName.should.be.equal(testCase.expectedName);
-                });
-            });
-        });
-
-        it("Should construct coins with null protocol and ticker===<uppercase code> if _customCoinBuilder return null for item and useRestrictedCoinsSet is false and code and network are equal for item", async () => {
-            const someResp = {
-                data: [
-                    {
-                        code: "bbb",
-                        network: "bbb",
-                    },
-                ],
-            };
-            const _customCoinBuilderStub = sinon.stub();
-            _customCoinBuilderStub.onFirstCall().returns(null);
-
-            axiosGetStub.resetBehavior();
-            axiosGetStub.resolves(someResp);
-            const p = new SwapspaceSwapProvider("/", new Cache(), _customCoinBuilderStub, false);
-
-            await p._fetchSupportedCurrenciesIfNeeded();
-
-            p._supportedCoins[0].coin.ticker.should.be.equal("BBB");
-            (p._supportedCoins[0].coin.protocol === null).should.be.true();
-        });
-
-        it("Should construct coins ticker===<uppercasecodeProtocol> and protocol with name===<uppercasenetwork> if _customCoinBuilder return null for item and useRestrictedCoinsSet is false and code and network are nopt equal for item", async () => {
-            const someResp = {
-                data: [
-                    {
-                        code: "bbb",
-                        network: "bbb1",
-                    },
-                ],
-            };
-            const _customCoinBuilderStub = sinon.stub();
-            _customCoinBuilderStub.onFirstCall().returns(null);
-
-            axiosGetStub.resetBehavior();
-            axiosGetStub.resolves(someResp);
-            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"));
-        });
-
-        it("Should construct coins with tokenAddress === null if _customCoinBuilder return null for item and useRestrictedCoinsSet is false and contractAddress is nullish for item", async () => {
-            const someResp = {
-                data: [
-                    {
-                        code: "bbb",
-                        network: "bbb1",
-                    },
-                ],
-            };
-            const _customCoinBuilderStub = sinon.stub();
-            _customCoinBuilderStub.onFirstCall().returns(null);
-
-            axiosGetStub.resetBehavior();
-            axiosGetStub.resolves(someResp);
-            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 someResp = {
-                data: [
-                    {
-                        code: "aaa",
-                        network: "aaa",
-                        hasExtraId: false,
-                        extraIdName: "",
-                        popular: false,
-                        iconURL: "/aaa",
-                        deposit: true,
-                        withdrawal: true,
-                        validationRegexp: "any",
-                    },
-                    {
-                        code: "bbb",
-                        network: "bbb1",
-                        hasExtraId: false,
-                        extraIdName: "",
-                        iconURL: "/bbb/bbb1.svg",
-                        deposit: false,
-                        withdrawal: false,
-                        validationRegexp: "any",
-                    },
-                    {
-                        code: "ccc",
-                        network: "n3",
-                        hasExtraId: true,
-                        extraIdName: "",
-                        popular: false,
-                        iconURL: "/1/ccc.jpg",
-                        deposit: true,
-                        withdrawal: false,
-                    },
-                    {
-                        code: "ddd",
-                        network: "n4",
-                        hasExtraId: true,
-                        extraIdName: "MEMO",
-                        popular: false,
-                        deposit: false,
-                        withdrawal: true,
-                        validationRegexp: "any",
-                    },
-                ],
-            };
-
-            const _customCoinBuilderStub = sinon.stub();
-            _customCoinBuilderStub.returns(null);
-            // _customCoinBuilderStub.onCall(1).returns({ ticker: "CCCN3" });
-
-            axiosGetStub.resetBehavior();
-            axiosGetStub.resolves(someResp);
-            const p = new SwapspaceSwapProvider("/", new Cache(), _customCoinBuilderStub, false);
-
-            await p._fetchSupportedCurrenciesIfNeeded();
-
-            return { provider: p, data: someResp.data };
-        };
-
-        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));
-        });
-
-        it("Should save code as is", async () => {
-            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
-
-            provider._supportedCoins.forEach((dataItem, i) => {
-                dataItem.code.should.be.equal(data[i].code);
-            });
-        });
-
-        it("Should save network as is", async () => {
-            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
-
-            provider._supportedCoins.forEach((dataItem, i) => {
-                dataItem.network.should.be.equal(data[i].network);
-            });
-        });
-
-        it("Should save hasExtraId as is", async () => {
-            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
-
-            provider._supportedCoins.forEach((dataItem, i) => {
-                dataItem.hasExtraId.should.be.equal(data[i].hasExtraId);
-            });
-        });
-
-        it("Should save extraIdName as is", async () => {
-            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
-
-            provider._supportedCoins.forEach((dataItem, i) => {
-                dataItem.extraIdName.should.be.equal(data[i].extraIdName);
-            });
-        });
-
-        it("Should save popular to isPopular as boolean", async () => {
-            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
-
-            provider._supportedCoins.forEach((dataItem, i) => {
-                dataItem.isPopular.should.be.equal(data[i].popular ? 1 : 0);
-            });
-        });
-
-        it("Should save icon or default URL to iconURL", async () => {
-            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
-
-            provider._supportedCoins.forEach((dataItem, i) => {
-                dataItem.iconURL.should.be.equal(
-                    data[i].icon
-                        ? `https://storage.swapspace.co${data[i].iconURL}`
-                        : "https://rabbit.io/asset-icons/fallback.svg"
-                );
-            });
-        });
-
-        it("Should save deposit as is", async () => {
-            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
-
-            provider._supportedCoins.forEach((dataItem, i) => {
-                dataItem.deposit.should.be.equal(data[i].deposit);
-            });
-        });
-
-        it("Should save withdrawal as is", async () => {
-            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
-
-            provider._supportedCoins.forEach((dataItem, i) => {
-                dataItem.withdrawal.should.be.equal(data[i].withdrawal);
-            });
-        });
-
-        it("Should save validationRegexp or null if it is nullish", async () => {
-            const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
-
-            provider._supportedCoins.forEach((dataItem, i) => {
-                (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 fakeResponse = {
-                data: [
-                    {
-                        network: "eth",
-                        code: "eth",
-                        popular: true,
-                    },
-                    {
-                        network: "bac",
-                        code: "bac",
-                        popular: false,
-                    },
-                    {
-                        network: "bbb",
-                        code: "btc",
-                        popular: false,
-                    },
-                    {
-                        network: "eee",
-                        code: "aaa",
-                        popular: false,
-                    },
-                    {
-                        network: "xxx",
-                        code: "aaa",
-                        popular: true,
-                    },
-                ],
-            };
-            axiosGetStub.returns(Promise.resolve(fakeResponse));
-
-            await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
-
-            swapspaceProvider._supportedCoins
-                .map(coin => coin.coin.ticker)
-                .should.be.deepEqual(["ETH", "AAAXXX", "AAAEEE", "BAC", "BTCBBB"]);
-        });
-
-        it("should handle empty response data", async () => {
-            const fakeResponse = { data: null };
-            axiosGetStub.returns(Promise.resolve(fakeResponse));
-
-            await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
-
-            swapspaceProvider._supportedCoins.should.deepEqual([]);
-        });
-
-        it("should handle absence of data field in response", async () => {
-            const fakeResponse = {};
-            axiosGetStub.returns(Promise.resolve(fakeResponse));
-
-            await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
-            swapspaceProvider._supportedCoins.should.deepEqual([]);
-        });
+        // it("Should not call axios if there is _supportedCoins", async () => {
+        //     swapspaceProvider._supportedCoins = [{ coin: {}, extraId: "" }];
+        //     await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
+        //
+        //     axiosGetStub.callCount.should.be.equal(0);
+        // });
+        //
+        // it("should make a network call if coins are not cached", async () => {
+        //     swapspaceProvider._supportedCoins = [];
+        //     const fakeResponse = { data: [] };
+        //     axiosGetStub.returns(Promise.resolve(fakeResponse));
+        //
+        //     await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
+        //
+        //     axiosGetStub.calledOnce.should.be.true();
+        // });
+        //
+        // it("Should call _customCoinBuilder number of times equal to returned coins count", async () => {
+        //     const _customCoinBuilderStub = sinon.stub();
+        //     const someResp = {
+        //         data: [
+        //             { code: "1", network: "n1" },
+        //             { code: "2", network: "n2" },
+        //             { code: "3", network: "n3" },
+        //             { code: "4", network: "n4" },
+        //         ],
+        //     };
+        //     axiosGetStub.resetBehavior();
+        //     axiosGetStub.resolves(someResp);
+        //     const p = new SwapspaceSwapProvider("/", new Cache(), _customCoinBuilderStub);
+        //
+        //     await p._fetchSupportedCurrenciesIfNeeded();
+        //
+        //     _customCoinBuilderStub.callCount.should.be.equal(someResp.data.length);
+        // });
+        //
+        // it("Should call _customCoinBuilder with proper params", async () => {
+        //     const _customCoinBuilderStub = sinon.stub();
+        //     const someResp = {
+        //         data: [
+        //             { code: "1", network: "n1" },
+        //             { code: "2", network: "n2" },
+        //             { code: "3", network: "n3" },
+        //             { code: "4", network: "n4" },
+        //         ],
+        //     };
+        //     axiosGetStub.resetBehavior();
+        //     axiosGetStub.resolves(someResp);
+        //     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])
+        //     );
+        // });
+        //
+        // it("Should ignore coins that _customCoinBuilder returned null for if useRestrictedCoinsSet is true", async () => {
+        //     const someResp = {
+        //         data: [
+        //             { code: "1", network: "n1" },
+        //             { code: "2", network: "n2" },
+        //             { code: "3", network: "n3" },
+        //         ],
+        //     };
+        //     const _customCoinBuilderStub = sinon.stub();
+        //     _customCoinBuilderStub.onFirstCall().returns({ ticker: "1" });
+        //     _customCoinBuilderStub.onSecondCall().returns(null);
+        //     _customCoinBuilderStub.onThirdCall().returns({ ticker: "3" });
+        //
+        //     axiosGetStub.resetBehavior();
+        //     axiosGetStub.resolves(someResp);
+        //     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();
+        // });
+        //
+        // it("Should construct coins with default params if _customCoinBuilder return null for some and useRestrictedCoinsSet is false", async () => {
+        //     const someResp = {
+        //         data: [
+        //             { code: "aaa", network: "n1" },
+        //             {
+        //                 code: "bbb",
+        //                 network: "n2",
+        //                 name: "some",
+        //                 contractAddress: "addr",
+        //             },
+        //             { code: "ccc", network: "n3" },
+        //         ],
+        //     };
+        //     const _customCoinBuilderStub = sinon.stub();
+        //     _customCoinBuilderStub.onFirstCall().returns({ ticker: "AAAN1" });
+        //     _customCoinBuilderStub.onSecondCall().returns(null);
+        //     _customCoinBuilderStub.onThirdCall().returns({ ticker: "CCCN3" });
+        //
+        //     axiosGetStub.resetBehavior();
+        //     axiosGetStub.resolves(someResp);
+        //     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;
+        //     (newCoin instanceof Coin).should.be.true();
+        //     newCoin.tickerPrintable.should.be.equal("BBB");
+        //     newCoin.latinName.should.be.equal("some");
+        //     newCoin.digits.should.be.equal(8);
+        //     (newCoin.maxValue === null).should.be.true();
+        //     newCoin.atomName.should.be.equal("");
+        //     (newCoin.mainnet === null).should.be.true();
+        //     (newCoin.testnet === null).should.be.true();
+        //     newCoin.minConfirmations.should.be.equal(1);
+        //     (newCoin.payableEntityStringForFeeRate === null).should.be.true();
+        //     newCoin.feeOptionsTimeStringsSortedDesc.should.be.deepEqual([]);
+        //     newCoin.feeRatesExpirationTimeMs.should.be.equal(60000);
+        //     newCoin.protocol.should.be.deepEqual(new Protocol("N2"));
+        //     (newCoin.blockchain === null).should.be.true();
+        //     newCoin.tokenAddress.should.be.equal("addr");
+        //     newCoin.feeCoin.should.be.equal(newCoin);
+        //     newCoin.doesUseLowerCaseAddresses.should.be.equal(false);
+        //     newCoin.doesUseOutputs.should.be.equal(false);
+        // });
+        //
+        // describe("Should process name when creating custom coins", function () {
+        //     [
+        //         {
+        //             item: { code: "BTC", network: "BTC", name: " Bitcoin  " },
+        //             expectedName: "Bitcoin",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "BTC",
+        //                 network: "BTC",
+        //                 name: " Bitcoin  (BTC)  ",
+        //             },
+        //             expectedName: "Bitcoin",
+        //         },
+        //         {
+        //             item: { code: "BTC", network: "BTC", name: "Bitcoin" },
+        //             expectedName: "Bitcoin",
+        //         },
+        //         {
+        //             item: { code: "BTC", network: "BTC", name: "BTC" },
+        //             expectedName: "BTC",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "BTC",
+        //                 network: "BTC",
+        //                 name: "Bitcoin (BTC)",
+        //             },
+        //             expectedName: "Bitcoin",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "BTC",
+        //                 network: "BTC",
+        //                 name: "Bitcoin (BTC) (BTC)",
+        //             },
+        //             expectedName: "Bitcoin",
+        //         },
+        //         {
+        //             item: { code: "BTC", network: "BTC", name: "BTC (BTC)" },
+        //             expectedName: "BTC (BTC)",
+        //         },
+        //         {
+        //             item: { code: "BTC", network: "BTC", name: "(BTC) (BTC)" },
+        //             expectedName: "(BTC) (BTC)",
+        //         },
+        //         {
+        //             item: { code: "USDT", network: "ERC20", name: "Tether" },
+        //             expectedName: "Tether",
+        //         },
+        //         {
+        //             item: { code: "USDT", network: "ERC20", name: "USDT" },
+        //             expectedName: "USDT",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "USDT",
+        //                 network: "ERC20",
+        //                 name: "Tether (USDT)",
+        //             },
+        //             expectedName: "Tether",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "USDT",
+        //                 network: "ERC20",
+        //                 name: "Tether (USDT)",
+        //             },
+        //             expectedName: "Tether",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "USDT",
+        //                 network: "ERC20",
+        //                 name: "Tether (USDT) (ERC20)",
+        //             },
+        //             expectedName: "Tether",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "USDT",
+        //                 network: "ERC20",
+        //                 name: "USDT (ERC20)",
+        //             },
+        //             expectedName: "USDT",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "USDT",
+        //                 network: "ERC20",
+        //                 name: "(USDT) (ERC20)",
+        //             },
+        //             expectedName: "(USDT) (ERC20)",
+        //         },
+        //     ].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);
+        //
+        //             await p._fetchSupportedCurrenciesIfNeeded();
+        //
+        //             p._supportedCoins[0].coin.latinName.should.be.equal(testCase.expectedName);
+        //         });
+        //     });
+        // });
+        //
+        // it("Should construct coins with null protocol and ticker===<uppercase code> if _customCoinBuilder return null for item and useRestrictedCoinsSet is false and code and network are equal for item", async () => {
+        //     const someResp = {
+        //         data: [
+        //             {
+        //                 code: "bbb",
+        //                 network: "bbb",
+        //             },
+        //         ],
+        //     };
+        //     const _customCoinBuilderStub = sinon.stub();
+        //     _customCoinBuilderStub.onFirstCall().returns(null);
+        //
+        //     axiosGetStub.resetBehavior();
+        //     axiosGetStub.resolves(someResp);
+        //     const p = new SwapspaceSwapProvider("/", new Cache(), _customCoinBuilderStub, false);
+        //
+        //     await p._fetchSupportedCurrenciesIfNeeded();
+        //
+        //     p._supportedCoins[0].coin.ticker.should.be.equal("BBB");
+        //     (p._supportedCoins[0].coin.protocol === null).should.be.true();
+        // });
+        //
+        // it("Should construct coins ticker===<uppercasecodeProtocol> and protocol with name===<uppercasenetwork> if _customCoinBuilder return null for item and useRestrictedCoinsSet is false and code and network are nopt equal for item", async () => {
+        //     const someResp = {
+        //         data: [
+        //             {
+        //                 code: "bbb",
+        //                 network: "bbb1",
+        //             },
+        //         ],
+        //     };
+        //     const _customCoinBuilderStub = sinon.stub();
+        //     _customCoinBuilderStub.onFirstCall().returns(null);
+        //
+        //     axiosGetStub.resetBehavior();
+        //     axiosGetStub.resolves(someResp);
+        //     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"));
+        // });
+        //
+        // it("Should construct coins with tokenAddress === null if _customCoinBuilder return null for item and useRestrictedCoinsSet is false and contractAddress is nullish for item", async () => {
+        //     const someResp = {
+        //         data: [
+        //             {
+        //                 code: "bbb",
+        //                 network: "bbb1",
+        //             },
+        //         ],
+        //     };
+        //     const _customCoinBuilderStub = sinon.stub();
+        //     _customCoinBuilderStub.onFirstCall().returns(null);
+        //
+        //     axiosGetStub.resetBehavior();
+        //     axiosGetStub.resolves(someResp);
+        //     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 someResp = {
+        //         data: [
+        //             {
+        //                 code: "aaa",
+        //                 network: "aaa",
+        //                 hasExtraId: false,
+        //                 extraIdName: "",
+        //                 popular: false,
+        //                 iconURL: "/aaa",
+        //                 deposit: true,
+        //                 withdrawal: true,
+        //                 validationRegexp: "any",
+        //             },
+        //             {
+        //                 code: "bbb",
+        //                 network: "bbb1",
+        //                 hasExtraId: false,
+        //                 extraIdName: "",
+        //                 iconURL: "/bbb/bbb1.svg",
+        //                 deposit: false,
+        //                 withdrawal: false,
+        //                 validationRegexp: "any",
+        //             },
+        //             {
+        //                 code: "ccc",
+        //                 network: "n3",
+        //                 hasExtraId: true,
+        //                 extraIdName: "",
+        //                 popular: false,
+        //                 iconURL: "/1/ccc.jpg",
+        //                 deposit: true,
+        //                 withdrawal: false,
+        //             },
+        //             {
+        //                 code: "ddd",
+        //                 network: "n4",
+        //                 hasExtraId: true,
+        //                 extraIdName: "MEMO",
+        //                 popular: false,
+        //                 deposit: false,
+        //                 withdrawal: true,
+        //                 validationRegexp: "any",
+        //             },
+        //         ],
+        //     };
+        //
+        //     const _customCoinBuilderStub = sinon.stub();
+        //     _customCoinBuilderStub.returns(null);
+        //     // _customCoinBuilderStub.onCall(1).returns({ ticker: "CCCN3" });
+        //
+        //     axiosGetStub.resetBehavior();
+        //     axiosGetStub.resolves(someResp);
+        //     const p = new SwapspaceSwapProvider("/", new Cache(), _customCoinBuilderStub, false);
+        //
+        //     await p._fetchSupportedCurrenciesIfNeeded();
+        //
+        //     return { provider: p, data: someResp.data };
+        // };
+        //
+        // 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));
+        // });
+        //
+        // it("Should save code as is", async () => {
+        //     const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
+        //
+        //     provider._supportedCoins.forEach((dataItem, i) => {
+        //         dataItem.code.should.be.equal(data[i].code);
+        //     });
+        // });
+        //
+        // it("Should save network as is", async () => {
+        //     const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
+        //
+        //     provider._supportedCoins.forEach((dataItem, i) => {
+        //         dataItem.network.should.be.equal(data[i].network);
+        //     });
+        // });
+        //
+        // it("Should save hasExtraId as is", async () => {
+        //     const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
+        //
+        //     provider._supportedCoins.forEach((dataItem, i) => {
+        //         dataItem.hasExtraId.should.be.equal(data[i].hasExtraId);
+        //     });
+        // });
+        //
+        // it("Should save extraIdName as is", async () => {
+        //     const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
+        //
+        //     provider._supportedCoins.forEach((dataItem, i) => {
+        //         dataItem.extraIdName.should.be.equal(data[i].extraIdName);
+        //     });
+        // });
+        //
+        // it("Should save popular to isPopular as boolean", async () => {
+        //     const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
+        //
+        //     provider._supportedCoins.forEach((dataItem, i) => {
+        //         dataItem.isPopular.should.be.equal(data[i].popular ? 1 : 0);
+        //     });
+        // });
+        //
+        // it("Should save icon or default URL to iconURL", async () => {
+        //     const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
+        //
+        //     provider._supportedCoins.forEach((dataItem, i) => {
+        //         dataItem.iconURL.should.be.equal(
+        //             data[i].icon
+        //                 ? `https://storage.swapspace.co${data[i].iconURL}`
+        //                 : "https://rabbit.io/asset-icons/fallback.svg"
+        //         );
+        //     });
+        // });
+        //
+        // it("Should save deposit as is", async () => {
+        //     const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
+        //
+        //     provider._supportedCoins.forEach((dataItem, i) => {
+        //         dataItem.deposit.should.be.equal(data[i].deposit);
+        //     });
+        // });
+        //
+        // it("Should save withdrawal as is", async () => {
+        //     const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
+        //
+        //     provider._supportedCoins.forEach((dataItem, i) => {
+        //         dataItem.withdrawal.should.be.equal(data[i].withdrawal);
+        //     });
+        // });
+        //
+        // it("Should save validationRegexp or null if it is nullish", async () => {
+        //     const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
+        //
+        //     provider._supportedCoins.forEach((dataItem, i) => {
+        //         (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 fakeResponse = {
+        //         data: [
+        //             {
+        //                 network: "eth",
+        //                 code: "eth",
+        //                 popular: true,
+        //             },
+        //             {
+        //                 network: "bac",
+        //                 code: "bac",
+        //                 popular: false,
+        //             },
+        //             {
+        //                 network: "bbb",
+        //                 code: "btc",
+        //                 popular: false,
+        //             },
+        //             {
+        //                 network: "eee",
+        //                 code: "aaa",
+        //                 popular: false,
+        //             },
+        //             {
+        //                 network: "xxx",
+        //                 code: "aaa",
+        //                 popular: true,
+        //             },
+        //         ],
+        //     };
+        //     axiosGetStub.returns(Promise.resolve(fakeResponse));
+        //
+        //     await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
+        //
+        //     swapspaceProvider._supportedCoins
+        //         .map(coin => coin.coin.ticker)
+        //         .should.be.deepEqual(["ETH", "AAAXXX", "AAAEEE", "BAC", "BTCBBB"]);
+        // });
+        //
+        // it("should handle empty response data", async () => {
+        //     const fakeResponse = { data: null };
+        //     axiosGetStub.returns(Promise.resolve(fakeResponse));
+        //
+        //     await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
+        //
+        //     swapspaceProvider._supportedCoins.should.deepEqual([]);
+        // });
+        //
+        // it("should handle absence of data field in response", async () => {
+        //     const fakeResponse = {};
+        //     axiosGetStub.returns(Promise.resolve(fakeResponse));
+        //
+        //     await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
+        //     swapspaceProvider._supportedCoins.should.deepEqual([]);
+        // });
     });
 });