@rabbitio/ui-kit 1.0.0-beta.12 → 1.0.0-beta.121

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

@@ -0,0 +1,938 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+import { describe, it, beforeEach, afterEach } from "vitest";
+
+import { ChangeNowSwapProvider } from "../../../external-apis/changeNowSwapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+import { Coin } from "../../../../common-apis/models/coin.js";
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+
+describe("src/swaps-lib/external-apis/changeNowSwapProvider.js", function () {
+    describe("createSwap", function () {
+        let provider;
+        let axiosPostStub;
+        let fetchCoinsStub;
+        let validateStub;
+        let fromCoin;
+        let toCoin;
+
+        function buildCoin(ticker, digits = 8) {
+            return new Coin(
+                ticker,
+                ticker,
+                ticker,
+                digits,
+                null,
+                "",
+                null,
+                null,
+                1,
+                null,
+                [],
+                60000,
+                null,
+                null,
+                null,
+                false
+            );
+        }
+
+        beforeEach(function () {
+            provider = new ChangeNowSwapProvider(null, new Cache());
+            axiosPostStub = sinon.stub(axios, "post");
+            fetchCoinsStub = sinon.stub(provider, "_fetchSupportedCurrenciesIfNeeded").resolves();
+            validateStub = sinon.stub(provider, "_validateAddressWithProvider");
+            fromCoin = buildCoin("BTC");
+            toCoin = buildCoin("ETH");
+        });
+
+        afterEach(function () {
+            sinon.restore();
+        });
+
+        it("Should return retriable fail on invalid input parameters", async function () {
+            let thrown1;
+            try {
+                await provider.createSwap({}, toCoin, "1", "addr", null, {}, null, false);
+            } catch (e) {
+                thrown1 = e;
+            }
+            should.exist(thrown1);
+            (thrown1.message || "").toLowerCase().includes("invalid swap parameters").should.be.true();
+
+            let thrown2;
+            try {
+                await provider.createSwap(fromCoin, toCoin, "-1", "addr", null, {}, null, false);
+            } catch (e) {
+                thrown2 = e;
+            }
+            should.exist(thrown2);
+            (thrown2.message || "").toLowerCase().includes("invalid swap parameters").should.be.true();
+        });
+
+        it("Should return retriable fail when toAddress is empty", async function () {
+            let thrown;
+            try {
+                await provider.createSwap(fromCoin, toCoin, "1", " ", null, {}, null, false);
+            } catch (e) {
+                thrown = e;
+            }
+            should.exist(thrown);
+            (thrown.message || "").toLowerCase().includes("invalid destination address").should.be.true();
+        });
+
+        it("Should throw when supported coin info for fromCoin is missing (internal inconsistency)", async function () {
+            provider._supportedCoins = [
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            validateStub.resolves(true);
+
+            let thrown;
+            try {
+                await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            } catch (e) {
+                thrown = e;
+            }
+            should.exist(thrown);
+            (thrown.message || "").toLowerCase().includes("internal inconsistency").should.be.true();
+        });
+
+        it("Should throw when supported coin info for toCoin is missing (internal inconsistency)", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            validateStub.resolves(true);
+
+            let thrown;
+            try {
+                await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            } catch (e) {
+                thrown = e;
+            }
+            should.exist(thrown);
+            (thrown.message || "").toLowerCase().includes("internal inconsistency").should.be.true();
+        });
+
+        it("Should return retriable fail when payout address validation fails", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            validateStub.resolves(false);
+            const res = await provider.createSwap(fromCoin, toCoin, "1", "invalidAddr", null, {}, null, false);
+            res.result.should.be.false();
+            res.reason.should.equal(provider.constructor.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+        });
+
+        it("Should return retriable fail when refund address validation fails", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            validateStub.onCall(0).resolves(true);
+            validateStub.onCall(1).resolves(false);
+            const res = await provider.createSwap(fromCoin, toCoin, "1", "valid", "badRefund", {}, null, false);
+            res.result.should.be.false();
+            res.reason.should.equal(provider.constructor.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+        });
+
+        it("Should construct payload and return swap details on success", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "swapId", payinAddress: "fromAddr", payinExtraId: "memo", fromAmount: "5", toAmount: "10" },
+            });
+            const estimationData = { rate: "2", rateId: "rid123" };
+            const res = await provider.createSwap(
+                fromCoin,
+                toCoin,
+                "5",
+                "userToAddr",
+                "refundAddr",
+                estimationData,
+                null,
+                true,
+                "destTag",
+                "refundTag",
+                false
+            );
+            axiosPostStub.calledOnce.should.be.true();
+            const callArgs = axiosPostStub.firstCall.args;
+            callArgs[0].should.match(/\/exchange$/);
+            const payload = callArgs[1];
+            payload.fromCurrency.should.equal("BTC");
+            payload.toCurrency.should.equal("ETH");
+            payload.address.should.equal("userToAddr");
+            payload.fromAmount.should.equal("5");
+            payload.flow.should.equal("fixed-rate");
+            payload.rateId.should.equal("rid123");
+            payload.extraId.should.equal("destTag");
+            payload.refundAddress.should.equal("refundAddr");
+            payload.refundExtraId.should.equal("refundTag");
+            res.result.should.be.true();
+            res.swapId.should.equal("swapId");
+            res.fromAmount.should.equal("5");
+            res.toAmount.should.equal("10");
+            res.rate.should.equal("2");
+            res.fromCurrencyExtraId.should.equal("memo");
+            res.fixed.should.be.true();
+        });
+
+        it("Should map provider error messages to retriable fail reason per adapter behavior", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            validateStub.resolves(true);
+
+            axiosPostStub.resolves({ status: 400, data: { error: "Minimum amount is 10" } });
+            let res = await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            res.result.should.be.false();
+            res.reason.should.equal(provider.constructor.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+
+            axiosPostStub.resolves({ status: 400, data: { error: "Not supported" } });
+            res = await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            res.result.should.be.false();
+            res.reason.should.equal(provider.constructor.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+
+            axiosPostStub.resolves({ status: 400, data: { error: "Invalid address" } });
+            res = await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            res.result.should.be.false();
+            res.reason.should.equal(provider.constructor.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+
+            axiosPostStub.resolves({ status: 400, data: { error: "Something else" } });
+            res = await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            res.result.should.be.false();
+            res.reason.should.equal(provider.constructor.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+        });
+
+        it("Should return retriable fail when a network error is thrown", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.rejects(new Error("network down"));
+
+            let thrown;
+            try {
+                await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            } catch (e) {
+                thrown = e;
+            }
+            should.exist(thrown);
+        });
+
+        it("Should throw error when fromCoin is not a Coin instance", async function () {
+            let thrown;
+            try {
+                await provider.createSwap({}, toCoin, "1", "addr", null, {}, null, false);
+            } catch (e) {
+                thrown = e;
+            }
+            should.exist(thrown);
+            (thrown.message || "").toLowerCase().includes("invalid swap parameters").should.be.true();
+        });
+
+        it("Should throw error when toCoin is not a Coin instance", async function () {
+            let thrown;
+            try {
+                await provider.createSwap(fromCoin, {}, "1", "addr", null, {}, null, false);
+            } catch (e) {
+                thrown = e;
+            }
+            should.exist(thrown);
+            (thrown.message || "").toLowerCase().includes("invalid swap parameters").should.be.true();
+        });
+
+        it("Should throw error when amount is not a positive string", async function () {
+            let thrown1;
+            try {
+                await provider.createSwap(fromCoin, toCoin, 1, "addr", null, {}, null, false);
+            } catch (e) {
+                thrown1 = e;
+            }
+            should.exist(thrown1);
+            (thrown1.message || "").toLowerCase().includes("invalid swap parameters").should.be.true();
+
+            let thrown2;
+            try {
+                await provider.createSwap(fromCoin, toCoin, "0", "addr", null, {}, null, false);
+            } catch (e) {
+                thrown2 = e;
+            }
+            should.exist(thrown2);
+            (thrown2.message || "").toLowerCase().includes("invalid swap parameters").should.be.true();
+        });
+
+        it("Should not call axios when payout address validation fails", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: "btc",
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: "eth",
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(false);
+            const res = await provider.createSwap(fromCoin, toCoin, "1", "bad", null, {}, null, false);
+            res.result.should.be.false();
+            axiosPostStub.called.should.be.false();
+        });
+
+        it("Should not call axios when refund address validation fails", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: "btc",
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: "eth",
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.onCall(0).resolves(true);
+            validateStub.onCall(1).resolves(false);
+            const res = await provider.createSwap(fromCoin, toCoin, "1", "good", "bad", {}, null, false);
+            res.result.should.be.false();
+            axiosPostStub.called.should.be.false();
+        });
+
+        it("Should include network parameters in the payload when networks are specified", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: "btc",
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: "eth",
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", payinAddress: "in", fromAmount: "1", toAmount: "2" },
+            });
+            await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            const payload = axiosPostStub.firstCall.args[1];
+            payload.fromNetwork.should.equal("btc");
+            payload.toNetwork.should.equal("eth");
+        });
+
+        it("Should send toAmount instead of fromAmount when amountIsToReceive is true", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", payinAddress: "in", fromAmount: "3", toAmount: "5" },
+            });
+            await provider.createSwap(fromCoin, toCoin, "7", "addr", null, {}, null, false, "", "", true);
+            const payload = axiosPostStub.firstCall.args[1];
+            should(payload.fromAmount).be.undefined();
+            payload.toAmount.should.equal("7");
+        });
+
+        it("Should not include extraId when none is provided", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", payinAddress: "in", fromAmount: "1", toAmount: "2" },
+            });
+            await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false, "");
+            const payload = axiosPostStub.firstCall.args[1];
+            should(payload.extraId).be.undefined();
+        });
+
+        it("Should not include refundAddress and refundExtraId when not provided", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", payinAddress: "in", fromAmount: "1", toAmount: "2" },
+            });
+            await provider.createSwap(fromCoin, toCoin, "1", "addr", "", {}, null, false);
+            const payload = axiosPostStub.firstCall.args[1];
+            should(payload.refundAddress).be.undefined();
+            should(payload.refundExtraId).be.undefined();
+        });
+
+        it("Should include refundExtraId when provided", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", payinAddress: "in", fromAmount: "1", toAmount: "2" },
+            });
+            await provider.createSwap(fromCoin, toCoin, "1", "addr", "refund", {}, null, false, "", "refundTag");
+            const payload = axiosPostStub.firstCall.args[1];
+            payload.refundExtraId.should.equal("refundTag");
+        });
+
+        it("Should include rateId from rawSwapData when provided in estimationData", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", payinAddress: "in", fromAmount: "1", toAmount: "2" },
+            });
+
+            const estimationData = { rate: "1", rateId: "abc" };
+            await provider.createSwap(fromCoin, toCoin, "1", "addr", null, estimationData, null, true);
+            const payload = axiosPostStub.firstCall.args[1];
+            payload.rateId.should.equal("abc");
+        });
+
+        it("Should compute rate from returned amounts when estimationData.rate is not provided", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", payinAddress: "in", fromAmount: "2", toAmount: "6" },
+            });
+            const res = await provider.createSwap(fromCoin, toCoin, "2", "addr", null, {}, null, false);
+            res.rate.should.equal("3");
+        });
+
+        it("Should return null rate when no amounts and no rate provided", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({ status: 200, data: { id: "id", payinAddress: "in" } });
+            const res = await provider.createSwap(fromCoin, toCoin, "5", "addr", null, {}, null, false);
+            should(res.rate).be.null();
+        });
+
+        it("Should handle 201 status as success and compute rate", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 201,
+                data: { id: "id", payinAddress: "in", fromAmount: "3", toAmount: "9" },
+            });
+            const res = await provider.createSwap(fromCoin, toCoin, "3", "addr", null, {}, null, false);
+            res.result.should.be.true();
+            res.rate.should.equal("3");
+        });
+
+        it("Should set swapId to null when exchangeId returned instead of id", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { exchangeId: "ex123", payinAddress: "in", fromAmount: "1", toAmount: "2" },
+            });
+            const res = await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            should(res.swapId).be.null();
+        });
+
+        it("Should set swapId to null when requestId returned instead of id", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { requestId: "req456", payinAddress: "in", fromAmount: "1", toAmount: "2" },
+            });
+            const res = await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            should(res.swapId).be.null();
+        });
+
+        it("Should leave fromAddress null when payinAddress missing", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", fromAddress: "fa", fromAmount: "1", toAmount: "2" },
+            });
+            const res = await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            should(res.fromAddress).be.null();
+        });
+
+        it("Should leave fromAddress null when only address field is returned", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", address: "fallback", fromAmount: "1", toAmount: "2" },
+            });
+            const res = await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            should(res.fromAddress).be.null();
+        });
+
+        it("Should set fromCurrencyExtraId null when payinExtraId is missing", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", payinAddress: "in", fromCurrencyExtraId: "fcx", fromAmount: "1", toAmount: "2" },
+            });
+            const res = await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            should(res.fromCurrencyExtraId).be.null();
+        });
+
+        it("Should set fixed to false and omit flow when fixed parameter is false", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", payinAddress: "in", fromAmount: "1", toAmount: "2" },
+            });
+            const res = await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            const payload = axiosPostStub.firstCall.args[1];
+            should(payload.flow).be.undefined();
+            should(payload.rateId).be.undefined();
+            res.fixed.should.be.false();
+        });
+
+        it("Should validate only payout address when refundAddress is not provided", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", payinAddress: "in", fromAmount: "1", toAmount: "2" },
+            });
+            await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            validateStub.callCount.should.equal(1);
+        });
+
+        it("Should validate both payout and refund addresses when refundAddress is provided", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.onCall(0).resolves(true);
+            validateStub.onCall(1).resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", payinAddress: "in", fromAmount: "1", toAmount: "2" },
+            });
+            await provider.createSwap(fromCoin, toCoin, "1", "addr", "refund", {}, null, false);
+            validateStub.callCount.should.equal(2);
+        });
+
+        it("Should call address validation with correct parameters", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: "btc", deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: "eth", deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            validateStub.onCall(0).resolves(true);
+            validateStub.onCall(1).resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", payinAddress: "in", fromAmount: "1", toAmount: "2" },
+            });
+            await provider.createSwap(fromCoin, toCoin, "1", "toAddr", "refAddr", {}, null, false);
+            const firstCallArgs = validateStub.getCall(0).args;
+            firstCallArgs[0].should.equal("eth");
+            firstCallArgs[1].should.equal("ETH");
+            firstCallArgs[2].should.equal("toAddr");
+            const secondCallArgs = validateStub.getCall(1).args;
+            secondCallArgs[0].should.equal("btc");
+            secondCallArgs[1].should.equal("BTC");
+            secondCallArgs[2].should.equal("refAddr");
+        });
+
+        it("Should call fetchSupportedCurrenciesIfNeeded once per swap", async function () {
+            provider._supportedCoins = [
+                {
+                    coin: fromCoin,
+                    code: fromCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+                {
+                    coin: toCoin,
+                    code: toCoin.ticker,
+                    network: null,
+                    deposit: true,
+                    withdrawal: true,
+                    isAvailable: true,
+                },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({
+                status: 200,
+                data: { id: "id", payinAddress: "in", fromAmount: "1", toAmount: "2" },
+            });
+            await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            fetchCoinsStub.calledOnce.should.be.true();
+        });
+
+        it("Should return retriable fail for 404 response with 'Amount out of range'", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({ status: 404, data: { error: "Amount out of range" } });
+            const res = await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            res.result.should.be.false();
+            res.reason.should.equal(provider.constructor.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+        });
+
+        it("Should return retriable fail for 404 response with unknown error", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null, deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "ETH", network: null, deposit: true, withdrawal: true, isAvailable: true },
+            ];
+            validateStub.resolves(true);
+            axiosPostStub.resolves({ status: 404, data: { error: "Some unexpected issue" } });
+            const res = await provider.createSwap(fromCoin, toCoin, "1", "addr", null, {}, null, false);
+            res.result.should.be.false();
+            res.reason.should.equal(provider.constructor.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+        });
+        it("Should map rejected 403 with Cloudflare header to RETRIABLE_FAIL + IP_BANNED", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "btc", network: "btc", deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "eth", network: "eth", deposit: true, withdrawal: true, isAvailable: true },
+            ];
+
+            validateStub.resolves(true);
+
+            axiosPostStub.rejects({
+                response: {
+                    status: 403,
+                    headers: { "cf-ray": "ray-id" },
+                    data: "Forbidden",
+                },
+            });
+
+            const res = await provider.createSwap(fromCoin, toCoin, "1", "addr", "", {}, null, false);
+
+            res.should.match({
+                result: false,
+                reason: SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL,
+                errorCode: SwapProvider.RETRIABLE_SWAP_CREATION_ERRORS.IP_BANNED,
+                partner: provider.id,
+            });
+        });
+
+        it("Should map rejected 4xx containing 'ip' + 'blocked' to RETRIABLE_FAIL + IP_BANNED", async function () {
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "btc", network: "btc", deposit: true, withdrawal: true, isAvailable: true },
+                { coin: toCoin, code: "eth", network: "eth", deposit: true, withdrawal: true, isAvailable: true },
+            ];
+
+            validateStub.resolves(true);
+
+            axiosPostStub.rejects({
+                response: {
+                    status: 401,
+                    headers: {},
+                    data: "your ip is blocked",
+                },
+            });
+
+            const res = await provider.createSwap(fromCoin, toCoin, "1", "addr", "", {}, null, false);
+
+            res.should.match({
+                result: false,
+                reason: SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL,
+                errorCode: SwapProvider.RETRIABLE_SWAP_CREATION_ERRORS.IP_BANNED,
+                partner: provider.id,
+            });
+        });
+    });
+});