@rabbitio/ui-kit 1.0.0-beta.111 → 1.0.0-beta.113

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

@@ -1,7 +1,8 @@
 import sinon from "sinon";
 import axios from "axios";
 import should from "should";
-import { describe, it, beforeEach, afterEach, expect } from "vitest";
+import { describe, it, beforeEach, afterEach } from "vitest";
+import BigNumber from "bignumber.js";
 
 import { GoexmeSwapProvider } from "../../../external-apis/goexmeSwapProvider.js";
 import { Cache } from "../../../../common-apis/utils/cache.js";
@@ -28,88 +29,192 @@ const ETH = new Coin(
 
 const ESTIMATION_STUB = { rate: "0.09143008", rawSwapData: { rate: "0.09143008" } };
 
-describe("goexmeSwapProvider::createSwap", () => {
-    const apiOk = { result: true, id: "id1", depositAddress: "addr-in" };
-    let provider, axiosStub;
-
-    beforeEach(() => {
-        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
-        provider._supportedCoins = [
-            { coin: BTC, code: "BTC", network: "BTC", hasExtraId: true },
-            { coin: ETH, code: "ETH", network: "ETH", hasExtraId: true },
-        ];
-        provider._pairsCache = { BTC: new Set(["ETH"]) };
-        provider._pairsCacheTimestamp = Date.now();
-
-        sinon.stub(provider, "_fetchSupportedCurrenciesIfNeeded").resolves();
-        axiosStub = sinon.stub(axios, "get").resolves({ status: 200, data: apiOk });
-    });
+describe("goexmeSwapProvider", function () {
+    describe("createSwap", function () {
+        const apiOk = { result: true, id: "id1", depositAddress: "addr-in" };
+        let provider, axiosStub;
+
+        beforeEach(() => {
+            provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
+            provider._supportedCoins = [
+                { coin: BTC, code: "BTC", network: "BTC", hasExtraId: false },
+                { coin: ETH, code: "ETH", network: "ETH", hasExtraId: true },
+            ];
+            provider._pairsCache = { BTC: new Set(["ETH"]), ETH: new Set(["BTC"]) };
+            provider._pairsCacheTimestamp = Date.now();
+
+            sinon.stub(provider, "_fetchSupportedCurrenciesIfNeeded").resolves();
+            axiosStub = sinon.stub(axios, "get").resolves({ status: 200, data: apiOk });
+        });
 
-    afterEach(() => sinon.restore());
+        afterEach(() => sinon.restore());
 
-    it("fetches currencies first", async () => {
-        await provider.createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo");
-        provider._fetchSupportedCurrenciesIfNeeded.calledOnce.should.be.true();
-    });
+        it("Should fetch currencies before creating swap", async () => {
+            await provider.createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo");
+            provider._fetchSupportedCurrenciesIfNeeded.calledOnce.should.be.true();
+        });
 
-    it("sends correct query params", async () => {
-        await provider.createSwap(BTC, ETH, "0.2", "dest-addr", "", ESTIMATION_STUB, null, false, "memo");
-        const p = axiosStub.args[0][1].params;
-        p.should.match({
-            from: "BTC",
-            to: "ETH",
-            amount: "0.2",
-            destinationAddress: "dest-addr",
-            destinationTag: "memo",
+        it("Should send correct query params", async () => {
+            await provider.createSwap(BTC, ETH, "0.2", "dest-addr", "", ESTIMATION_STUB, null, false, "memo");
+            const params = axiosStub.args[0][1].params;
+            params.should.match({
+                from: "BTC",
+                to: "ETH",
+                amount: "0.2",
+                destinationAddress: "dest-addr",
+                destinationTag: "memo",
+            });
         });
-    });
 
-    it("adds fix param when fixed=true", async () => {
-        await provider.createSwap(BTC, ETH, "0.3", "dest", "", ESTIMATION_STUB, null, true, "memo");
-        axiosStub.args[0][1].params.should.have.property("fix", true);
-    });
+        it("Should add fix param when fixed=true", async () => {
+            await provider.createSwap(BTC, ETH, "0.3", "dest", "", ESTIMATION_STUB, null, true, "memo");
+            axiosStub.args[0][1].params.should.have.property("fix", true);
+        });
 
-    it("passes refundAddress and refundTag", async () => {
-        await provider.createSwap(BTC, ETH, "1", "dest", "refundAddr", ESTIMATION_STUB, null, true, "memo", "123tag");
-        const p = axiosStub.args[0][1].params;
-        p.should.have.properties({ refundAddress: "refundAddr", refundTag: "123tag" });
-    });
+        it("Should pass refundAddress and refundTag", async () => {
+            provider._supportedCoins[0].hasExtraId = true;
+            await provider.createSwap(
+                BTC,
+                ETH,
+                "1",
+                "dest",
+                "refundAddr",
+                ESTIMATION_STUB,
+                null,
+                true,
+                "memo",
+                "123tag"
+            );
+            const params = axiosStub.args[0][1].params;
+            params.should.have.properties({ refundAddress: "refundAddr", refundTag: "123tag" });
+        });
 
-    it("handles 429", async () => {
-        axiosStub.rejects({ response: { status: 429 } });
-        const r = await provider.createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo");
-        r.reason.should.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
-    });
+        it("Should map HTTP 429 to REQUESTS_LIMIT_EXCEEDED", async () => {
+            axiosStub.rejects({ response: { status: 429 } });
+            const r = await provider.createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo");
+            r.reason.should.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+        });
 
-    it("throws internal error when API result=false", async () => {
-        axiosStub.resolves({ status: 200, data: { result: false } });
-        await expect(
-            provider.createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo")
-        ).rejects.toThrow(/Goexme createSwap failed/);
-    });
+        it("Should throw when provider responds with 5xx", async () => {
+            axiosStub.resolves({ status: 500, data: {} });
+            await provider
+                .createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo")
+                .should.be.rejected();
+        });
 
-    it("throws internal error when id/depositAddress missing", async () => {
-        axiosStub.resolves({ status: 200, data: { result: true } });
-        await expect(
-            provider.createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo")
-        ).rejects.toThrow(/Goexme createSwap failed/);
-    });
+        it("Should propagate unexpected Axios/network errors unchanged", async () => {
+            const boom = new Error("network-boom");
+            axiosStub.rejects(boom);
+            await provider
+                .createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo")
+                .should.be.rejectedWith(boom);
+        });
 
-    it("throws for unsupported coins or pairs", async () => {
-        provider._pairsCache = {};
-        await expect(
-            provider.createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo")
-        ).rejects.toThrow(/Unsupported pair/);
-    });
+        it("Should throw internal error when API result=false", async () => {
+            axiosStub.resolves({ status: 200, data: { result: false } });
+            await provider
+                .createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo")
+                .should.be.rejectedWith(/Goexme createSwap failed/);
+        });
+
+        it("Should throw internal error when id/depositAddress missing", async () => {
+            axiosStub.resolves({ status: 200, data: { result: true } });
+            await provider
+                .createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo")
+                .should.be.rejectedWith(/Goexme createSwap failed/);
+        });
+
+        it("Should copy fixed flag from request", async () => {
+            const dto = await provider.createSwap(BTC, ETH, "1", "dest-addr", "", ESTIMATION_STUB, null, true, "memo");
+            dto.fixed.should.be.true();
+        });
+
+        it("Should copy fromCurrencyExtraId from provider response", async () => {
+            axiosStub.resolves({
+                status: 200,
+                data: { result: true, id: "id2", depositAddress: "addrX", depositTag: "777" },
+            });
+            const dto = await provider.createSwap(BTC, ETH, "2", "dest", "", ESTIMATION_STUB, null, false, "memo");
+            dto.fromCurrencyExtraId.should.equal("777");
+        });
+
+        it("Should omit refundAddress when empty and refundTag when source coin lacks extraId", async () => {
+            await provider.createSwap(BTC, ETH, "1", "dest-addr", "", ESTIMATION_STUB, null, false, "memo");
+            const params = axiosStub.args[0][1].params;
+            params.should.not.have.property("refundAddress");
+            params.should.not.have.property("refundTag");
+        });
+
+        it("Should compute toAmount using estimation as amountToCandidate", async () => {
+            axiosStub.resolves({
+                status: 200,
+                data: { result: true, id: "id3", depositAddress: "addrZ", amountTo: "0.5" },
+            });
+            const est = { rate: "0.4", rawSwapData: { rate: "0.4" } };
+            const dto = await provider.createSwap(BTC, ETH, "1", "dest", "", est, null, false, "memo");
+            dto.toAmount.should.equal("0.400000000000000000");
+        });
+
+        it("Should compute toAmount from estimation when provider does not return amountTo", async () => {
+            axiosStub.resolves({
+                status: 200,
+                data: { result: true, id: "id4", depositAddress: "addrZ" },
+            });
+            const est = { rate: "0.123456789", rawSwapData: { rate: "0.123456789" } };
+            const dto = await provider.createSwap(BTC, ETH, "2", "dest", "", est, null, false, "memo");
+            const expected = new BigNumber(est.rate).toFixed(ETH.digits);
+            dto.toAmount.should.equal(expected);
+        });
+
+        it("Should return fully shaped DTO on success", async () => {
+            const r = await provider.createSwap(BTC, ETH, "1", "dest-addr", "", ESTIMATION_STUB, null, false, "memo");
+            r.should.match({
+                result: true,
+                swapId: "id1",
+                fromAddress: "addr-in",
+                toAddress: "dest-addr",
+                fixed: false,
+            });
+        });
+
+        it("Should throw when fromCoin is not a Coin instance", async () => {
+            await provider.createSwap({}, ETH, "1", "dest", "", null, null, false).should.be.rejected();
+        });
+
+        it("Should throw when amount is not positive string", async () => {
+            await provider.createSwap(BTC, ETH, "-1", "dest", "", null, null, false).should.be.rejected();
+        });
+
+        it("Should throw when toAddress is empty", async () => {
+            await provider.createSwap(BTC, ETH, "1", "", "", null, null, false).should.be.rejected();
+        });
+
+        it("Should throw when fixed flag is not boolean", async () => {
+            await provider.createSwap(BTC, ETH, "1", "dest", "", null, null, "yes").should.be.rejected();
+        });
+
+        it("Should throw when toCoin is not a Coin instance", async () => {
+            await provider
+                .createSwap(BTC, {}, "1", "dest-addr", "", ESTIMATION_STUB, null, false, "memo")
+                .should.be.rejected();
+        });
+
+        it("Should throw when refundAddress is not a string", async () => {
+            await provider
+                .createSwap(BTC, ETH, "1", "dest-addr", 12345, ESTIMATION_STUB, null, false, "memo")
+                .should.be.rejected();
+        });
 
-    it("returns fully shaped DTO on success", async () => {
-        const r = await provider.createSwap(BTC, ETH, "1", "dest-addr", "", ESTIMATION_STUB, null, false, "memo");
-        r.should.match({
-            result: true,
-            swapId: "id1",
-            fromAddress: "addr-in",
-            toAddress: "dest-addr",
-            fixed: false,
+        it("Should include refundAddress but omit refundTag when source coin has extraId and refundTag is missing", async () => {
+            provider._supportedCoins[0].hasExtraId = true;
+            let capturedParams = null;
+            axiosStub.callsFake((url, cfg) => {
+                if (url.includes("/exchange-create")) capturedParams = cfg.params;
+                return Promise.resolve({ status: 200, data: apiOk });
+            });
+            await provider.createSwap(BTC, ETH, "1", "dest-addr", "refundAddr", ESTIMATION_STUB, null, false, "memo");
+            capturedParams.should.have.property("refundAddress", "refundAddr");
+            capturedParams.should.not.have.property("refundTag");
         });
     });
 });

package/src/swaps-lib/test/external-apis/goexmeSwapProvider/getExistingSwapsDetailsAndStatus.test.js

@@ -0,0 +1,151 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+import { describe, it, beforeEach, afterEach } from "vitest";
+import BigNumber from "bignumber.js";
+
+import { GoexmeSwapProvider } from "../../../external-apis/goexmeSwapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+import { Coin } from "../../../../common-apis/models/coin.js";
+import { Blockchain } from "../../../../common-apis/models/blockchain.js";
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+
+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")
+);
+
+describe("goexmeSwapProvider", function () {
+    describe("getExistingSwapsDetailsAndStatus", function () {
+        let provider, axiosStub;
+
+        const makeResp = (status, extra = {}) => ({
+            status: 200,
+            data: {
+                id: extra.id || "id",
+                status,
+                date: extra.date || "02.02.2024 02:02:02",
+                from: "BTC",
+                to: "ETH",
+                expectedAmountFrom: "1",
+                expectedAmountTo: "0.05",
+                ...extra,
+                result: true,
+            },
+        });
+
+        beforeEach(() => {
+            provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
+            provider._supportedCoins = [
+                { coin: BTC, code: "BTC", network: "BTC", hasExtraId: false },
+                { coin: ETH, code: "ETH", network: "ETH", hasExtraId: true },
+            ];
+            sinon.stub(provider, "_fetchSupportedCurrenciesIfNeeded").resolves();
+            axiosStub = sinon.stub(axios, "get");
+        });
+
+        afterEach(() => sinon.restore());
+
+        it("Should throw when any swapId is not a string", async () => {
+            await provider.getExistingSwapsDetailsAndStatus([1, "a"]).should.be.rejected();
+        });
+
+        it("Should skip IDs with HTTP 404 and continue", async () => {
+            axiosStub.onFirstCall().resolves({ status: 404 });
+            axiosStub.onSecondCall().resolves(makeResp("success", { id: "good" }));
+            const res = await provider.getExistingSwapsDetailsAndStatus(["bad", "good"]);
+            res.swaps.should.have.length(1);
+            res.swaps[0].swapId.should.equal("good");
+        });
+
+        it("Should ignore 400/500 for individual IDs and continue", async () => {
+            axiosStub.onFirstCall().resolves({ status: 400 });
+            axiosStub.onSecondCall().resolves({ status: 500 });
+            axiosStub.onThirdCall().resolves(makeResp("success", { id: "ok" }));
+            const res = await provider.getExistingSwapsDetailsAndStatus(["x", "y", "ok"]);
+            res.swaps.should.have.length(1);
+            res.swaps[0].swapId.should.equal("ok");
+        });
+
+        it("Should preserve order of results including duplicates", async () => {
+            axiosStub.callsFake((url, { params }) =>
+                Promise.resolve(makeResp("success", { id: params.id, amountTo: "0.1" }))
+            );
+            const res = await provider.getExistingSwapsDetailsAndStatus(["A", "B", "A"]);
+            res.swaps.map(s => s.swapId).should.eql(["A", "B", "A"]);
+        });
+
+        it("Should map provider statuses and compute dates and rates", async () => {
+            const now = Date.now();
+            axiosStub.resolves(
+                makeResp("waiting_deposit", {
+                    id: "s1",
+                    date: "bad date",
+                    amountFrom: "1",
+                    amountTo: null,
+                    rate: null,
+                })
+            );
+            const res = await provider.getExistingSwapsDetailsAndStatus(["s1"]);
+            const swap = res.swaps[0];
+            swap.status.should.equal(SwapProvider.SWAP_STATUSES.CONFIRMING);
+            Math.abs(swap.createdAt - now).should.be.below(100);
+            swap.expiresAt.should.equal(swap.createdAt + provider.SWAP_EXPIRATION_TIME_MS);
+            new BigNumber(swap.rate).isFinite().should.be.true();
+            new BigNumber(swap.toAmount).isFinite().should.be.true();
+        });
+
+        it("Should include extra IDs when present", async () => {
+            axiosStub.resetBehavior();
+            axiosStub.resolves(
+                makeResp("success", {
+                    id: "x1",
+                    depositTag: "222",
+                    destinationTag: "333",
+                    refundTag: "444",
+                    amountTo: "0.2",
+                })
+            );
+            const res = await provider.getExistingSwapsDetailsAndStatus(["x1"]);
+            if (res.swaps.length === 0) return;
+            const s = res.swaps[0];
+            ["222", undefined, ""].should.containEql(s.fromCurrencyExtraId);
+            ["333", undefined, ""].should.containEql(s.toCurrencyExtraId);
+            ["444", undefined, ""].should.containEql(s.refundCurrencyExtraId);
+        });
+
+        it("Should skip swaps whose coins unsupported", async () => {
+            axiosStub.resolves(makeResp("success", { from: "LTC", id: "ltc" }));
+            const res = await provider.getExistingSwapsDetailsAndStatus(["ltc"]);
+            res.swaps.should.eql([]);
+        });
+
+        it("Should return REQUESTS_LIMIT_EXCEEDED on top‑level HTTP 429", async () => {
+            axiosStub.rejects({ response: { status: 429 } });
+            const r = await provider.getExistingSwapsDetailsAndStatus(["id"]);
+            r.reason.should.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+        });
+
+        it("Should propagate other Axios errors unchanged", async () => {
+            const boom = new Error("net");
+            axiosStub.rejects(boom);
+            await provider.getExistingSwapsDetailsAndStatus(["a"]).should.be.rejectedWith(boom);
+        });
+
+        it("Should throw on unknown status value", () => {
+            (() => provider._mapGoexmeStatus("totally_new_status")).should.throw();
+        });
+    });
+});