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

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

@@ -0,0 +1,1311 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+import { SwapspaceSwapProvider } from "../../../external-apis/swapspaceSwapProvider.js";
+import { Coin } from "../../../../common/models/coin.js";
+import { Blockchain } from "../../../../common/models/blockchain.js";
+import { Cache } from "../../../../common/utils/cache.js";
+
+describe("swapspaceSwapProvider", function () {
+    describe("createSwap", function () {
+        const anyReceivingAddress = "any addr";
+        const anyRefundAddress = "any refund addr";
+        const anyAmount = "100.1319";
+        const anyIp = "123.23.21.22";
+        const anyValidRawSwapData = {
+            fromCurrency: "any currency from",
+            fromNetwork: "any network from",
+            toCurrency: "any currency to",
+            toNetwork: "any network to",
+            id: "any id",
+            partner: "any partner",
+        };
+
+        const BTC = new Coin(
+            "Bitcoin",
+            "BTC",
+            "BTC",
+            8,
+            null,
+            "sat",
+            null,
+            null,
+            1,
+            null,
+            [],
+            null,
+            new Blockchain("Bitcoin")
+        );
+        const ETH = new Coin(
+            "Ethereum",
+            "ETH",
+            "ETH",
+            18,
+            null,
+            "wei",
+            null,
+            null,
+            1,
+            null,
+            [],
+            null,
+            new Blockchain("Ethereum")
+        );
+        const USDCTRC20 = new Coin(
+            "USDCTRC20",
+            "USDCTRC20",
+            "USDC",
+            6,
+            null,
+            "millicents",
+            null,
+            null,
+            1,
+            null,
+            [],
+            null,
+            new Blockchain("Tron")
+        );
+        let swapspaceSwapProvider;
+        let fetchSupportedCurrenciesStub;
+        let axiosPostStub;
+
+        beforeEach(() => {
+            swapspaceSwapProvider = new SwapspaceSwapProvider("/", new Cache());
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: BTC, extraId: "" },
+                { coin: ETH, extraId: "" },
+            ];
+
+            fetchSupportedCurrenciesStub = sinon.stub(
+                swapspaceSwapProvider,
+                "_fetchSupportedCurrenciesIfNeeded"
+            );
+            fetchSupportedCurrenciesStub.resolves();
+
+            axiosPostStub = sinon.stub(axios, "post");
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: 1, address: "from-address" },
+                    to: { amount: 2, address: "to-address" },
+                    rate: 2,
+                    fixed: false,
+                },
+            });
+        });
+
+        afterEach(() => {
+            fetchSupportedCurrenciesStub.restore();
+            axiosPostStub.restore();
+        });
+
+        it("Should fetch supported currencies", async () => {
+            await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+            fetchSupportedCurrenciesStub.calledOnce.should.be.true();
+        });
+
+        it("Should send an axios POST request", async () => {
+            await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+            axiosPostStub.calledOnce.should.be.true();
+        });
+
+        it("Should send the request to the correct URL", async () => {
+            await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+            axiosPostStub.args[0][0].should.equal(
+                `${swapspaceSwapProvider._URL}/api/v2/exchange`
+            );
+        });
+
+        it("Should pass client IP address in request data", async () => {
+            await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                "123.123.123.123",
+                false
+            );
+
+            axiosPostStub.args[0][1].should.have.property(
+                "userIp",
+                "123.123.123.123"
+            );
+        });
+
+        it("Should pass provided refund address in request data", async () => {
+            await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            axiosPostStub.args[0][1].should.have.property(
+                "refund",
+                anyRefundAddress
+            );
+        });
+
+        it("Should use rateId from rawSwapData in request data", async () => {
+            await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                { ...anyValidRawSwapData, id: "test-rateId" },
+                anyIp,
+                false
+            );
+
+            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 },
+            ];
+
+            await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false,
+                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 () => {
+            const someExtraId = "extra123";
+            swapspaceSwapProvider._supportedCoins = [
+                {
+                    coin: USDCTRC20,
+                    hasExtraId: true,
+                    code: "usdt",
+                    network: "trc20",
+                },
+                { coin: ETH },
+            ];
+
+            await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false,
+                null,
+                someExtraId
+            );
+
+            axiosPostStub.args[0][1].should.have.property(
+                "refundExtraId",
+                someExtraId
+            );
+        });
+
+        it('Should omit passed "extraId" or "refundExtraId" when matching coins have hasExtraId false', async () => {
+            const someExtraId = "extra123";
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: USDCTRC20, hasExtraId: false },
+                { coin: ETH, hasExtraId: false },
+            ];
+
+            await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false,
+                someExtraId,
+                someExtraId
+            );
+
+            axiosPostStub.args[0][1].extraId.should.be.equal("");
+            axiosPostStub.args[0][1].refundExtraId.should.be.equal("");
+        });
+
+        it("Should use rawSwapData to form requestData currencies and networks", async () => {
+            await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                {
+                    ...anyValidRawSwapData,
+                    fromCurrency: "from-test",
+                    fromNetwork: "from-network-test",
+                    toCurrency: "to-test",
+                    toNetwork: "to-network-test",
+                },
+                anyIp,
+                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"
+            );
+        });
+
+        [
+            "fromCurrency",
+            "fromNetwork",
+            "toCurrency",
+            "toNetwork",
+            "id",
+            "partner",
+        ].forEach((rawSwapDataProperty) => {
+            it(`Should reject if raw swap data contains wrong ${rawSwapDataProperty}`, async () => {
+                const rawSwapData = {
+                    ...anyValidRawSwapData,
+                    [rawSwapDataProperty]: null,
+                };
+
+                await swapspaceSwapProvider
+                    .createSwap(
+                        USDCTRC20,
+                        ETH,
+                        anyAmount,
+                        anyReceivingAddress,
+                        anyRefundAddress,
+                        rawSwapData,
+                        anyIp,
+                        false
+                    )
+                    .should.be.rejectedWith(/.*Invalid raw swap data.*/);
+            });
+        });
+
+        it("Should send partner from rawSwapData when provided", async () => {
+            await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                { ...anyValidRawSwapData, partner: "testPartner" },
+                anyIp,
+                false
+            );
+
+            axiosPostStub.args[0][1].should.have.property(
+                "partner",
+                "testPartner"
+            );
+        });
+
+        [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,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    fixed
+                );
+
+                axiosPostStub.args[0][1].fixed.should.equal(fixed);
+            });
+        });
+
+        it("Should ensure all required parameters are passed to axios", async () => {
+            await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            const requestData = axiosPostStub.args[0][1];
+            requestData.should.have.properties([
+                "partner",
+                "fromCurrency",
+                "fromNetwork",
+                "toCurrency",
+                "toNetwork",
+                "address",
+                "amount",
+                "fixed",
+                "extraId",
+                "refundExtraId",
+                "rateId",
+                "userIp",
+                "refund",
+            ]);
+        });
+
+        it("Should handle cases where toCurrencyExtraId is not found for the coin", async () => {
+            swapspaceSwapProvider._supportedCoins = [
+                { coin: USDCTRC20, extraId: "" },
+                { coin: ETH },
+            ];
+            await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+            axiosPostStub.args[0][1].extraId.should.be.equal("");
+        });
+
+        it("Should throw an error if swap creation response is invalid", async () => {
+            axiosPostStub.resolves({ data: {} });
+
+            await swapspaceSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                )
+                .should.be.rejected();
+        });
+
+        it("Should handle status 429 and return requests limit exceeded", async () => {
+            axiosPostStub.rejects({ response: { status: 429 } });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            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 () => {
+            axiosPostStub.rejects({
+                response: { status: 422, data: "Pair cannot be processed by" },
+            });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            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 () => {
+            axiosPostStub.rejects({
+                response: { status: 403, data: "IP address is forbidden" },
+            });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            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 () => {
+            axiosPostStub.rejects({
+                response: { status: 422, data: "Amount maximum is" },
+            });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            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 () => {
+            axiosPostStub.rejects({
+                response: { status: 422, data: "Amount minimum is" },
+            });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            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 () => {
+            axiosPostStub.rejects({
+                response: { status: 422, data: "Currency not found" },
+            });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            result.reason.should.equal(
+                SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL
+            );
+        });
+
+        it("Should return the correct swap details if response is valid", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: 1, address: "from-address" },
+                    to: { amount: 2, address: "to-address" },
+                    rate: 2,
+                    fixed: false,
+                },
+            });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            result.should.have.property("swapId", "test-id");
+        });
+
+        it("Should return true in the result property when successful", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: 1, address: "any" },
+                    to: { amount: 2, address: "any" },
+                    rate: 0.5,
+                    fixed: false,
+                },
+            });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            result.should.have.property("result", true);
+        });
+
+        it("Should return a proper structure for a successful swap creation", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: 1, address: "from-address" },
+                    to: { amount: 2, address: "to-address" },
+                    rate: 2,
+                    fixed: false,
+                },
+            });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            result.result.should.be.Boolean();
+            result.swapId.should.be.String();
+            result.fromCoin.should.be.instanceOf(Coin);
+            result.fromAmount.should.be.String();
+            result.fromAddress.should.be.String();
+            result.toCoin.should.be.instanceOf(Coin);
+            result.toAmount.should.be.String();
+            result.toAddress.should.be.String();
+            result.rate.should.be.String();
+            result.fixed.should.be.Boolean();
+        });
+
+        it("Should calculate rate if not provided in the response", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: 1, address: "any" },
+                    to: { amount: 2, address: "any" },
+                    fixed: false,
+                },
+            });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            result.rate.should.equal("2.00000000000000000000");
+        });
+
+        it("Should calculate rate if the provided in the response is 0", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: 1, address: "any" },
+                    to: { amount: 2, address: "any" },
+                    rate: 0,
+                    fixed: false,
+                },
+            });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            result.rate.should.equal("2.00000000000000000000");
+        });
+
+        it("Should return address details correctly as returned by swapspace", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: 4, address: "from-addr" },
+                    to: { amount: 2, address: "to-addr" },
+                    rate: 0.5,
+                    fixed: false,
+                },
+            });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            result.should.have.property("fromAddress", "from-addr");
+            result.should.have.property("toAddress", "to-addr");
+        });
+
+        it("Should return proper fromAmount from the response", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: 1131.0931, address: "any" },
+                    to: { amount: 2, address: "any" },
+                    rate: 0.5,
+                    fixed: false,
+                },
+            });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            result.should.have.property("fromAmount", "1131.093100");
+        });
+
+        it("Should throw an error if from coin is not Coin", async () => {
+            let error;
+            try {
+                await swapspaceSwapProvider.createSwap(
+                    {},
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.message.should.match(/.*Invalid input: .*/);
+        });
+
+        it("Should throw an error if to coin is not Coin", async () => {
+            let error;
+            try {
+                await swapspaceSwapProvider.createSwap(
+                    ETH,
+                    {},
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.message.should.match(/.*Invalid input: .*/);
+        });
+
+        it("Should throw an error if amount is not string", async () => {
+            let error;
+            try {
+                await swapspaceSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    1,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.message.should.match(/.*Invalid input: .*/);
+        });
+
+        it("Should throw an error if address is not string", async () => {
+            let error;
+            try {
+                await swapspaceSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    1,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.message.should.match(/.*Invalid input: .*/);
+        });
+
+        it("Should throw an error if refund address is not string", async () => {
+            let error;
+            try {
+                await swapspaceSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    null,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.message.should.match(/.*Invalid input: .*/);
+        });
+
+        it("Should throw an error if IP address is not string", async () => {
+            let error;
+            try {
+                await swapspaceSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    false
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.message.should.match(/.*Invalid input: .*/);
+        });
+
+        it("Should throw an error if IP address is empty string", async () => {
+            let error;
+            try {
+                await swapspaceSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    "",
+                    false
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.message.should.match(/.*Invalid input: .*/);
+        });
+
+        it("Should throw an error if fixed is not boolean", async () => {
+            let error;
+            try {
+                await swapspaceSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.message.should.match(/.*Invalid input: .*/);
+        });
+
+        it("Should throw an error if swap data has not string fromCurrency", async () => {
+            let error;
+            try {
+                await swapspaceSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    { ...anyValidRawSwapData, fromCurrency: undefined },
+                    anyIp,
+                    false
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.message.should.match(/.*Invalid raw swap data: .*/);
+        });
+
+        it("Should throw an error if swap data has not string fromNetwork", async () => {
+            let error;
+            try {
+                await swapspaceSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    { ...anyValidRawSwapData, fromNetwork: undefined },
+                    anyIp,
+                    false
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.message.should.match(/.*Invalid raw swap data: .*/);
+        });
+
+        it("Should throw an error if swap data has not string toCurrency", async () => {
+            let error;
+            try {
+                await swapspaceSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    { ...anyValidRawSwapData, toCurrency: undefined },
+                    anyIp,
+                    false
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.message.should.match(/.*Invalid raw swap data: .*/);
+        });
+
+        it("Should throw an error if swap data has not string toNetwork", async () => {
+            let error;
+            try {
+                await swapspaceSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    { ...anyValidRawSwapData, toNetwork: undefined },
+                    anyIp,
+                    false
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.message.should.match(/.*Invalid raw swap data: .*/);
+        });
+
+        it("Should throw an error if swap data has not string id", async () => {
+            let error;
+            try {
+                await swapspaceSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    { ...anyValidRawSwapData, id: undefined },
+                    anyIp,
+                    false
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.message.should.match(/.*Invalid raw swap data: .*/);
+        });
+
+        it("Should return proper toAmount from the response", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: 1131.0931, address: "any" },
+                    to: { amount: 2091.92301, address: "any" },
+                    rate: 0.5,
+                    fixed: false,
+                },
+            });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            result.should.have.property("toAmount", "2091.923010000000000000");
+        });
+
+        it("Should handle scenario when amounts or addresses in the response are null", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: null, address: null },
+                    to: { amount: null, address: null },
+                    fixed: false,
+                },
+            });
+
+            await swapspaceSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                )
+                .should.be.rejectedWith(/.*Wrong swap creation result.*/);
+        });
+
+        it("Should handle non-200 HTTP status codes", async () => {
+            axiosPostStub.rejects({
+                response: { status: 500, data: "Server Error" },
+            });
+
+            let error;
+            try {
+                await swapspaceSwapProvider.createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.response.status.should.be.equal(500);
+            error.response.data.should.be.equal("Server Error");
+        });
+
+        it("Should handle network errors without response data", async () => {
+            axiosPostStub.rejects(new Error("Network Error"));
+
+            await swapspaceSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                )
+                .should.be.rejectedWith(/.*Network Error.*/);
+        });
+
+        it("Should handle cases when provided rate in the response is non-numeric", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: 1, address: "from-address" },
+                    to: { amount: 2, address: "to-address" },
+                    rate: "invalid",
+                    fixed: false,
+                },
+            });
+
+            const result = await swapspaceSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                anyIp,
+                false
+            );
+
+            result.rate.should.equal("2.00000000000000000000");
+        });
+
+        it("Should reject when _fetchSupportedCurrenciesIfNeeded throws an error", async () => {
+            fetchSupportedCurrenciesStub.rejects(new Error("Fetching Error"));
+
+            await swapspaceSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                )
+                .should.be.rejectedWith(/.*Fetching Error.*/);
+        });
+
+        it("Should handle the scenario when axios.post throws an error with no response object", async () => {
+            axiosPostStub.rejects(new Error("Network Error"));
+
+            await swapspaceSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                )
+                .should.be.rejectedWith(/.*Network Error.*/);
+        });
+
+        it('Should handle axios.post returning a response with no "id"', async () => {
+            axiosPostStub.resolves({ data: {} });
+
+            await swapspaceSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                )
+                .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 () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: "1", address: "from-address" },
+                    to: { amount: 2, address: "to-address" },
+                    rate: 2,
+                    fixed: false,
+                },
+            });
+
+            await swapspaceSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                )
+                .should.be.rejectedWith(/.*Wrong swap creation result.*/);
+        });
+
+        it("Should handle axios.post returning a response with no to amount or invalid", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: 1, address: "from-address" },
+                    to: { amount: "2", address: "to-address" },
+                    rate: 2,
+                    fixed: false,
+                },
+            });
+
+            await swapspaceSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                )
+                .should.be.rejectedWith(/.*Wrong swap creation result.*/);
+        });
+
+        it("Should handle axios.post returning a response with no from address or invalid", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: 1, address: null },
+                    to: { amount: 2, address: "to-address" },
+                    rate: 2,
+                    fixed: false,
+                },
+            });
+
+            await swapspaceSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                )
+                .should.be.rejectedWith(/.*Wrong swap creation result.*/);
+        });
+
+        it("Should handle axios.post returning a response with no to address or invalid", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: 1, address: "from-address" },
+                    to: { amount: 2, address: null },
+                    rate: 2,
+                    fixed: false,
+                },
+            });
+
+            await swapspaceSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                )
+                .should.be.rejectedWith(/.*Wrong swap creation result.*/);
+        });
+
+        it("Should handle axios.post returning a response with non-boolean fixed", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    from: { amount: 1, address: "from-address" },
+                    to: { amount: 2, address: null },
+                    rate: 2,
+                    fixed: 1,
+                },
+            });
+
+            await swapspaceSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    anyIp,
+                    false
+                )
+                .should.be.rejectedWith(/.*Wrong swap creation result.*/);
+        });
+    });
+});