@rabbitio/ui-kit 1.0.0-beta.10 → 1.0.0-beta.100

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

@@ -0,0 +1,1043 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { ExolixSwapProvider } from "../../../external-apis/exolixSwapProvider.js";
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+import { Coin } from "../../../../common-apis/models/coin.js";
+import { Blockchain } from "../../../../common-apis/models/blockchain.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+
+describe("exolixSwapProvider", function () {
+    describe("createSwap", function () {
+        const anyReceivingAddress = "any addr";
+        const anyRefundAddress = "any refund addr";
+        const anyAmount = "100.1319";
+        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 exolixSwapProvider;
+        let fetchSupportedCurrenciesStub;
+        let axiosPostStub;
+
+        beforeEach(() => {
+            exolixSwapProvider = new ExolixSwapProvider("/", new Cache());
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, extraId: "" },
+                { coin: ETH, extraId: "" },
+                { coin: USDCTRC20, extraId: "" },
+            ];
+
+            fetchSupportedCurrenciesStub = sinon.stub(exolixSwapProvider, "_fetchSupportedCurrenciesIfNeeded");
+            fetchSupportedCurrenciesStub.resolves();
+
+            axiosPostStub = sinon.stub(axios, "post");
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    amount: 1,
+                    amountTo: 2,
+                    coinFrom: {
+                        memoName: "",
+                    },
+                    coinTo: {
+                        memoName: "",
+                    },
+                    depositAddress: "from-address",
+                    withdrawalAddress: "to-address",
+                    refundAddress: "refund-address",
+                    rate: 2,
+                    rateType: "float",
+                },
+                status: 200,
+            });
+        });
+
+        afterEach(() => {
+            fetchSupportedCurrenciesStub.restore();
+            axiosPostStub.restore();
+        });
+
+        it("Should fetch supported currencies", async () => {
+            await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                false
+            );
+            fetchSupportedCurrenciesStub.calledOnce.should.be.true();
+        });
+
+        it("Should send an axios POST request", async () => {
+            await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                false
+            );
+            axiosPostStub.calledOnce.should.be.true();
+        });
+
+        it("Should send the request to the correct URL", async () => {
+            await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                false
+            );
+            axiosPostStub.args[0][0].should.equal(`${exolixSwapProvider._URL}/transactions`);
+        });
+
+        it("Should pass provided refund address in request data", async () => {
+            await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                false
+            );
+
+            axiosPostStub.args[0][1].should.have.property("refundAddress", anyRefundAddress);
+        });
+
+        it('Should send the correct "withdrawalExtraId" passed if toCoin has hasExtraId===true', async () => {
+            const someExtraId = "extra123";
+            exolixSwapProvider._supportedCoins = [{ coin: USDCTRC20 }, { coin: ETH, hasExtraId: true }];
+
+            await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                false,
+                someExtraId
+            );
+
+            axiosPostStub.args[0][1].should.have.property("withdrawalExtraId", someExtraId);
+        });
+
+        it('Should send the correct "refundExtraId" when refund extraId passed and fromCoin has hasExtraId===true ', async () => {
+            const someExtraId = "extra123";
+            exolixSwapProvider._supportedCoins = [
+                {
+                    coin: USDCTRC20,
+                    hasExtraId: true,
+                    code: "usdt",
+                    network: "trc20",
+                },
+                { coin: ETH },
+            ];
+
+            await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                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";
+            exolixSwapProvider._supportedCoins = [
+                { coin: USDCTRC20, hasExtraId: false },
+                { coin: ETH, hasExtraId: false },
+            ];
+
+            await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                false,
+                someExtraId,
+                someExtraId
+            );
+
+            axiosPostStub.args[0][1]["withdrawalExtraId"].should.be.equal("");
+            axiosPostStub.args[0][1]["refundExtraId"].should.be.equal("");
+        });
+
+        [false, true].forEach(fixed => {
+            it("Should ensure that fixed is always set to passed fixed value in the request data", async () => {
+                await exolixSwapProvider.createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    fixed
+                );
+
+                axiosPostStub.args[0][1].rateType.should.equal(fixed ? "fixed" : "float");
+            });
+        });
+
+        it("Should ensure all required parameters are passed to axios", async () => {
+            await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                false
+            );
+
+            const requestData = axiosPostStub.args[0][1];
+            requestData.should.have.properties([
+                "coinFrom",
+                "networkFrom",
+                "coinTo",
+                "networkTo",
+                "amount",
+                "withdrawalAmount",
+                "withdrawalAddress",
+                "withdrawalExtraId",
+                "refundAddress",
+                "refundExtraId",
+                "rateType",
+            ]);
+        });
+
+        it("Should handle cases where toCurrencyExtraId is not found for the coin", async () => {
+            exolixSwapProvider._supportedCoins = [{ coin: USDCTRC20, extraId: "" }, { coin: ETH }];
+            await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                false
+            );
+            axiosPostStub.args[0][1]["withdrawalExtraId"].should.be.equal("");
+        });
+
+        it("Should throw an error if swap creation response is invalid", async () => {
+            axiosPostStub.resolves({ data: {} });
+
+            await exolixSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    false
+                )
+                .should.be.rejected();
+        });
+
+        it("Should handle status 429 and return requests limit exceeded", async () => {
+            axiosPostStub.rejects({ response: { status: 429 } });
+
+            const result = await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                false
+            );
+
+            result.reason.should.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+        });
+
+        it('Should return retriable fail for status 400 and specific "Amount to exchange is higher" error text', async () => {
+            axiosPostStub.rejects({
+                response: {
+                    status: 400,
+                    data: {
+                        fromAmount: 1,
+                        message: "Amount to exchange is higher the possible max amount to exchange",
+                        maxAmount: 1000,
+                        toAmount: 0,
+                    },
+                },
+            });
+
+            const result = await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                false
+            );
+
+            result.reason.should.equal(SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+        });
+
+        it('Should return retriable fail for status 400 and specific "Amount to exchange is below" error text', async () => {
+            axiosPostStub.rejects({
+                response: {
+                    status: 400,
+                    data: {
+                        fromAmount: 1,
+                        message: "Amount to exchange is below the possible min amount to exchange",
+                        minAmount: 10,
+                        toAmount: 0,
+                    },
+                },
+            });
+
+            const result = await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                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: {
+                        error: "Such exchange pair is not available",
+                    },
+                },
+            });
+
+            const result = await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                false
+            );
+
+            // In swapspace this was "retriable fail", but here the not supported fits
+            // better, because this means that there is no such coin in the system
+
+            result.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("Should return the correct swap details if response is valid", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    amount: 1,
+                    amountTo: 2,
+                    rate: 2,
+                    depositAddress: "from-address",
+                    withdrawalAddress: "to-address",
+                    rateType: "float",
+                },
+            });
+
+            const result = await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                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",
+                    amount: 1,
+                    amountTo: 2,
+                    rate: 2,
+                    depositAddress: "from-address",
+                    withdrawalAddress: "to-address",
+                    rateType: "float",
+                },
+            });
+
+            const result = await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                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",
+                    amount: 1,
+                    amountTo: 2,
+                    rate: 2,
+                    depositAddress: "from-address",
+                    withdrawalAddress: "to-address",
+                    rateType: "float",
+                },
+            });
+
+            const result = await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                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",
+                    amount: 1,
+                    amountTo: 2,
+                    depositAddress: "from-address",
+                    withdrawalAddress: "to-address",
+                    rateType: "float",
+                },
+            });
+
+            const result = await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                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",
+                    amount: 1,
+                    amountTo: 2,
+                    rate: 0,
+                    depositAddress: "from-address",
+                    withdrawalAddress: "to-address",
+                    rateType: "float",
+                },
+            });
+
+            const result = await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                false
+            );
+
+            result.rate.should.equal("2.00000000000000000000");
+        });
+
+        it("Should return address details correctly as returned by provider", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    amount: 4,
+                    amountTo: 2,
+                    rate: 0.5,
+                    depositAddress: "from-addr",
+                    withdrawalAddress: "to-addr",
+                    rateType: "float",
+                },
+            });
+
+            const result = await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                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",
+                    amount: 1131.0931,
+                    amountTo: 2,
+                    rate: 0.5,
+                    depositAddress: "from-addr",
+                    withdrawalAddress: "to-addr",
+                    rateType: "float",
+                },
+            });
+
+            const result = await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                false
+            );
+
+            result.should.have.property("fromAmount", "1131.093100");
+        });
+
+        it("Should throw an error if from coin is not Coin", async () => {
+            let error;
+            try {
+                await exolixSwapProvider.createSwap(
+                    {},
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    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 exolixSwapProvider.createSwap(
+                    ETH,
+                    {},
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    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 exolixSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    1,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    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 exolixSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    999,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    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 exolixSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    null,
+                    anyValidRawSwapData,
+                    null,
+                    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 exolixSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            error.message.should.match(/.*Invalid input: .*/);
+        });
+
+        it("Should return proper toAmount from the response", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    amount: 1131.0931,
+                    amountTo: 2091.92301,
+                    rate: 0.5,
+                    depositAddress: "from-addr",
+                    withdrawalAddress: "to-addr",
+                    rateType: "float",
+                },
+            });
+
+            const result = await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                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",
+                    amount: null,
+                    amountTo: null,
+                    rate: 0.5,
+                    depositAddress: null,
+                    withdrawalAddress: null,
+                    rateType: "float",
+                },
+            });
+
+            await exolixSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    false
+                )
+                .should.be.rejectedWith(/.*Swap was created but the data was incorrect.*/);
+        });
+
+        it("Should handle non-200 HTTP status codes", async () => {
+            axiosPostStub.rejects({
+                response: { status: 500, data: "Server Error" },
+            });
+
+            let error;
+            try {
+                await exolixSwapProvider.createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    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 exolixSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    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",
+                    amount: 1,
+                    amountTo: 2,
+                    rate: 2,
+                    depositAddress: "from-addr",
+                    withdrawalAddress: "to-addr",
+                    rateType: "float",
+                },
+            });
+
+            const result = await exolixSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                anyValidRawSwapData,
+                null,
+                false
+            );
+
+            result.rate.should.equal("2.00000000000000000000");
+        });
+
+        it("Should reject when _fetchSupportedCurrenciesIfNeeded throws an error", async () => {
+            fetchSupportedCurrenciesStub.rejects(new Error("Fetching Error"));
+
+            await exolixSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    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 exolixSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    false
+                )
+                .should.be.rejectedWith(/.*Network Error.*/);
+        });
+
+        it('Should handle axios.post returning a response with no "id"', async () => {
+            axiosPostStub.resolves({ data: {} });
+
+            await exolixSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    false
+                )
+                .should.be.rejectedWith(/.*Swap creation failed, API response*/);
+        });
+
+        it("Should handle axios.post returning a response with from amount in string type", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    amount: "1",
+                    amountTo: 2,
+                    rate: 2,
+                    depositAddress: "from-addr",
+                    withdrawalAddress: "to-addr",
+                    rateType: "float",
+                },
+            });
+
+            await exolixSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    false
+                )
+                .should.be.rejectedWith(/.*Swap was created but the data was incorrect*/);
+        });
+
+        it("Should handle axios.post returning a response with to amount in string type", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    amount: 1,
+                    amountTo: "2",
+                    rate: 2,
+                    depositAddress: "from-addr",
+                    withdrawalAddress: "to-addr",
+                    rateType: "float",
+                },
+            });
+
+            await exolixSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    false
+                )
+                .should.be.rejectedWith(/.*Swap was created but the data was incorrect*/);
+        });
+
+        it("Should handle axios.post returning a response with no from address or invalid", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    amount: 1,
+                    amountTo: 2,
+                    rate: 2,
+                    depositAddress: null,
+                    withdrawalAddress: "to-addr",
+                    rateType: "float",
+                },
+            });
+
+            await exolixSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    false
+                )
+                .should.be.rejectedWith(/.*Swap was created but the data was incorrect*/);
+        });
+
+        it("Should handle axios.post returning a response with no to address or invalid", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    amount: 1,
+                    amountTo: 2,
+                    rate: 2,
+                    depositAddress: "from-addr",
+                    withdrawalAddress: null,
+                    rateType: "float",
+                },
+            });
+
+            await exolixSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    false
+                )
+                .should.be.rejectedWith(/.*Swap was created but the data was incorrect*/);
+        });
+
+        it("Should handle axios.post returning a response with non-boolean fixed", async () => {
+            axiosPostStub.resolves({
+                data: {
+                    id: "test-id",
+                    amount: 1,
+                    amountTo: 2,
+                    rate: 2,
+                    depositAddress: "from-addr",
+                    withdrawalAddress: "to-addr",
+                    rateType: 123,
+                },
+            });
+
+            await exolixSwapProvider
+                .createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    anyValidRawSwapData,
+                    null,
+                    false
+                )
+                .should.be.rejectedWith(/.*Swap was created but the data was incorrect*/);
+        });
+    });
+});