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

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

@@ -0,0 +1,702 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { ChangeHeroSwapProvider } from "../../../external-apis/changeHeroSwapProvider.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("changeHeroSwapProvider", function () {
+    describe("createSwap", function () {
+        const anyReceivingAddress = "any addr";
+        const anyRefundAddress = "any refund addr";
+        const anyAmount = "100.1319";
+
+        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")
+        );
+
+        const validRpcSuccess = (overrides = {}) => ({
+            data: {
+                jsonrpc: "2.0",
+                id: "rabbit-xyz",
+                result: {
+                    id: "test-id",
+                    payinAddress: "from-address",
+                    payoutAddress: "to-address",
+                    payinExtraId: "",
+                    payoutExtraId: "",
+                    amountExpectedFrom: 1,
+                    amountExpectedTo: 2,
+                    rateType: "float",
+                    expiresIn: 150,
+                    ...overrides,
+                },
+            },
+            status: 200,
+        });
+
+        const fixedEstimationPayload = { result: { id: "provided-rate-id" } };
+
+        let changeHeroSwapProvider;
+        let fetchSupportedCurrenciesStub;
+        let axiosPostStub;
+
+        beforeEach(() => {
+            changeHeroSwapProvider = new ChangeHeroSwapProvider("/", new Cache());
+            changeHeroSwapProvider._supportedCoins = [
+                { coin: BTC, hasExtraId: false, code: "btc", network: "BTC" },
+                { coin: ETH, hasExtraId: false, code: "eth", network: "ETH" },
+                { coin: USDCTRC20, hasExtraId: false, code: "usdc", network: "TRC20" },
+            ];
+
+            fetchSupportedCurrenciesStub = sinon.stub(changeHeroSwapProvider, "_fetchSupportedCurrenciesIfNeeded");
+            fetchSupportedCurrenciesStub.resolves();
+
+            axiosPostStub = sinon.stub(axios, "post");
+            axiosPostStub.resolves(validRpcSuccess());
+        });
+
+        afterEach(() => {
+            fetchSupportedCurrenciesStub.restore();
+            axiosPostStub.restore();
+        });
+
+        it("Should fetch supported currencies", async () => {
+            await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+            fetchSupportedCurrenciesStub.calledOnce.should.be.true();
+        });
+
+        it("Should send an axios POST request", async () => {
+            await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+            axiosPostStub.calledOnce.should.be.true();
+        });
+
+        it("Should send the request to the correct URL", async () => {
+            await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+            axiosPostStub.args[0][0].should.equal(changeHeroSwapProvider._URL);
+        });
+
+        it("Should pass provided refund address in request data", async () => {
+            await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+            axiosPostStub.args[0][1].params.refundAddress.should.equal(anyRefundAddress);
+        });
+
+        it("Should pass provided receiving address in request data", async () => {
+            await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+            axiosPostStub.args[0][1].params.address.should.equal(anyReceivingAddress);
+        });
+
+        it('Should send the correct "extraId" passed if toCoin has hasExtraId===true', async () => {
+            const someExtraId = "extra123";
+            changeHeroSwapProvider._supportedCoins = [
+                { coin: USDCTRC20, hasExtraId: false, code: "usdc", network: "TRC20" },
+                { coin: ETH, hasExtraId: true, code: "eth", network: "ETH" },
+            ];
+
+            await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false,
+                someExtraId
+            );
+
+            axiosPostStub.args[0][1].params.extraId.should.equal(someExtraId);
+        });
+
+        it('Should send the correct "refundExtraId" when refund extraId passed and fromCoin has hasExtraId===true', async () => {
+            const someExtraId = "refundTag";
+            changeHeroSwapProvider._supportedCoins = [
+                { coin: USDCTRC20, hasExtraId: true, code: "usdc", network: "TRC20" },
+                { coin: ETH, hasExtraId: false, code: "eth", network: "ETH" },
+            ];
+
+            await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false,
+                null,
+                someExtraId
+            );
+
+            axiosPostStub.args[0][1].params.refundExtraId.should.equal(someExtraId);
+        });
+
+        it('Should omit passed "extraId" when toCoin.hasExtraId===false', async () => {
+            const someExtraId = "extra123";
+            changeHeroSwapProvider._supportedCoins = [
+                { coin: USDCTRC20, hasExtraId: false, code: "usdc", network: "TRC20" },
+                { coin: ETH, hasExtraId: false, code: "eth", network: "ETH" },
+            ];
+
+            await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false,
+                someExtraId
+            );
+
+            axiosPostStub.args[0][1].params.extraId.should.equal("");
+        });
+
+        it('Should omit passed "refundExtraId" when fromCoin.hasExtraId===false', async () => {
+            const someExtraId = "refundTag";
+            changeHeroSwapProvider._supportedCoins = [
+                { coin: USDCTRC20, hasExtraId: false, code: "usdc", network: "TRC20" },
+                { coin: ETH, hasExtraId: true, code: "eth", network: "ETH" },
+            ];
+
+            await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false,
+                null,
+                someExtraId
+            );
+
+            axiosPostStub.args[0][1].params.refundExtraId.should.equal("");
+        });
+
+        it("Should ensure JSON-RPC method is createTransaction for float rate", async () => {
+            await changeHeroSwapProvider.createSwap(
+                BTC,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+            axiosPostStub.args[0][1].method.should.equal("createTransaction");
+        });
+
+        it("Should ensure JSON-RPC method is createFixTransaction for fixed rate", async () => {
+            await changeHeroSwapProvider.createSwap(
+                BTC,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                fixedEstimationPayload,
+                null,
+                true
+            );
+            axiosPostStub.args[0][1].method.should.equal("createFixTransaction");
+        });
+
+        it("Should pass 'amount' in params for amountIsToReceive=false", async () => {
+            await changeHeroSwapProvider.createSwap(
+                BTC,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false,
+                "",
+                "",
+                false
+            );
+            axiosPostStub.args[0][1].params.amount.should.equal(anyAmount);
+        });
+
+        it("Should pass 'amountTo' in params for amountIsToReceive=true in fixed flow", async () => {
+            await changeHeroSwapProvider.createSwap(
+                BTC,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                fixedEstimationPayload,
+                null,
+                true,
+                "",
+                "",
+                true
+            );
+            (axiosPostStub.args[0][1].params.amountTo === anyAmount).should.be.true();
+        });
+
+        it("Should pass provided rateId from proprietary estimation data for fixed flow", async () => {
+            await changeHeroSwapProvider.createSwap(
+                BTC,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                fixedEstimationPayload,
+                null,
+                true
+            );
+            axiosPostStub.args[0][1].params.rateId.should.equal("provided-rate-id");
+        });
+
+        it("Should reject when fixed and no rateId provided", async () => {
+            await changeHeroSwapProvider
+                .createSwap(BTC, ETH, anyAmount, anyReceivingAddress, anyRefundAddress, null, null, true)
+                .should.be.rejectedWith(/Fixed-rate flow requires rateId/);
+        });
+
+        it("Should return the correct swapId if response is valid", async () => {
+            const result = await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+            result.should.have.property("swapId", "test-id");
+        });
+
+        it("Should return true in the result property when successful", async () => {
+            const result = await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+            result.should.have.property("result", true);
+        });
+
+        it("Should compute and return rate from expected amounts", async () => {
+            const result = await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+            result.rate.should.equal("2.00000000000000000000");
+        });
+
+        it("Should forward address details exactly as returned by provider", async () => {
+            axiosPostStub.resolves(validRpcSuccess({ payinAddress: "from-addr", payoutAddress: "to-addr" }));
+
+            const result = await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+
+            (result.fromAddress === "from-addr" && result.toAddress === "to-addr").should.be.true();
+        });
+
+        it("Should return proper fromAmount formatted per coin digits", async () => {
+            axiosPostStub.resolves(validRpcSuccess({ amountExpectedFrom: 1131.0931 }));
+
+            const result = await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+
+            result.should.have.property("fromAmount", "1131.093100");
+        });
+
+        it("Should return proper toAmount formatted per coin digits", async () => {
+            axiosPostStub.resolves(validRpcSuccess({ amountExpectedTo: 2091.92301 }));
+
+            const result = await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+
+            result.should.have.property("toAmount", "2091.923010000000000000");
+        });
+
+        it("Should set fixed=true in result when fixed flow is used even if rateType is not 'fix'", async () => {
+            axiosPostStub.resolves(validRpcSuccess({ rateType: "float" }));
+
+            const result = await changeHeroSwapProvider.createSwap(
+                BTC,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                fixedEstimationPayload,
+                null,
+                true
+            );
+
+            result.fixed.should.be.true();
+        });
+
+        it("Should throw an error if from coin is not Coin", async () => {
+            let error;
+            try {
+                await changeHeroSwapProvider.createSwap(
+                    {},
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    null,
+                    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 changeHeroSwapProvider.createSwap(
+                    ETH,
+                    {},
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    null,
+                    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 changeHeroSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    1,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    null,
+                    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 changeHeroSwapProvider.createSwap(BTC, ETH, anyAmount, 999, anyRefundAddress, null, 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 changeHeroSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    null,
+                    null,
+                    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 changeHeroSwapProvider.createSwap(
+                    BTC,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    null,
+                    null
+                );
+            } catch (e) {
+                error = e;
+            }
+            error.message.should.match(/.*Invalid input: .*/);
+        });
+
+        it("Should throw an error when amountIsToReceive is true for float rate (unsupported)", async () => {
+            await changeHeroSwapProvider
+                .createSwap(BTC, ETH, anyAmount, anyReceivingAddress, anyRefundAddress, null, null, false, "", "", true)
+                .should.be.rejectedWith(/.*doesn't support exchanging to get the exact receiving amount.*/);
+        });
+
+        it("Should handle status 429 and return requests limit exceeded", async () => {
+            axiosPostStub.rejects({ response: { status: 429 } });
+
+            const result = await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+
+            result.reason.should.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+        });
+
+        it("Should reject for HTTP 400", async () => {
+            axiosPostStub.rejects({ response: { status: 400 } });
+
+            const error = await should(
+                changeHeroSwapProvider.createSwap(
+                    USDCTRC20,
+                    ETH,
+                    anyAmount,
+                    anyReceivingAddress,
+                    anyRefundAddress,
+                    null,
+                    null,
+                    false
+                )
+            ).be.rejected();
+
+            (error.response?.status === 400).should.be.true();
+        });
+
+        it("Should return retriable fail when RPC error message is present", async () => {
+            axiosPostStub.rejects({ response: { data: { error: { message: "any rpc error" } } } });
+
+            const result = await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+
+            result.reason.should.equal(SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+        });
+
+        it('Should reject when RPC response contains no "result.id"', async () => {
+            axiosPostStub.resolves({ data: { jsonrpc: "2.0", id: "x", result: {} } });
+
+            await changeHeroSwapProvider
+                .createSwap(USDCTRC20, ETH, anyAmount, anyReceivingAddress, anyRefundAddress, null, null, false)
+                .should.be.rejectedWith(/.*Swap creation failed:.*/);
+        });
+
+        it("Should reject when provider returns null addresses", async () => {
+            axiosPostStub.resolves(validRpcSuccess({ payinAddress: null, payoutAddress: null }));
+
+            await changeHeroSwapProvider
+                .createSwap(BTC, ETH, anyAmount, anyReceivingAddress, anyRefundAddress, null, null, false)
+                .should.be.rejectedWith(/Swap was created but data is incomplete/);
+        });
+
+        it("Should reject when payinAddress is invalid type (not string and not null)", async () => {
+            axiosPostStub.resolves(validRpcSuccess({ payinAddress: 123 }));
+
+            await changeHeroSwapProvider
+                .createSwap(BTC, ETH, anyAmount, anyReceivingAddress, anyRefundAddress, null, null, false)
+                .should.be.rejectedWith(/.*Swap was created but data is incomplete.*/);
+        });
+
+        it("Should reject when payoutAddress is invalid type (not string and not null)", async () => {
+            axiosPostStub.resolves(validRpcSuccess({ payoutAddress: 123 }));
+
+            await changeHeroSwapProvider
+                .createSwap(BTC, ETH, anyAmount, anyReceivingAddress, anyRefundAddress, null, null, false)
+                .should.be.rejectedWith(/.*Swap was created but data is incomplete.*/);
+        });
+
+        it("Should accept amountExpectedFrom/To as string types", async () => {
+            axiosPostStub.resolves(
+                validRpcSuccess({ amountExpectedFrom: "1", amountExpectedTo: "2", rateType: "float" })
+            );
+
+            const result = await changeHeroSwapProvider.createSwap(
+                USDCTRC20,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+
+            result.rate.should.equal("2.00000000000000000000");
+        });
+
+        it("Should propagate fromCurrencyExtraId from provider's payinExtraId", async () => {
+            axiosPostStub.resolves(validRpcSuccess({ payinExtraId: "memo-in-123" }));
+
+            const result = await changeHeroSwapProvider.createSwap(
+                BTC,
+                ETH,
+                anyAmount,
+                anyReceivingAddress,
+                anyRefundAddress,
+                null,
+                null,
+                false
+            );
+
+            result.fromCurrencyExtraId.should.equal("memo-in-123");
+        });
+
+        it("Should handle network errors without response data", async () => {
+            axiosPostStub.rejects(new Error("Network Error"));
+
+            await changeHeroSwapProvider
+                .createSwap(BTC, ETH, anyAmount, anyReceivingAddress, anyRefundAddress, null, null, false)
+                .should.be.rejectedWith(/.*Network Error.*/);
+        });
+    });
+});