@rabbitio/ui-kit 1.0.0-beta.110 → 1.0.0-beta.112

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

@@ -1,148 +1,75 @@
 import sinon from "sinon";
 import axios from "axios";
 import should from "should";
-import { describe, it, beforeEach, afterEach } from "vitest";
+import { beforeEach, afterEach, describe, it } from "vitest";
 
 import { GoexmeSwapProvider } from "../../../external-apis/goexmeSwapProvider.js";
 import { Cache } from "../../../../common-apis/utils/cache.js";
-import { Coin } from "../../../../common-apis/models/coin.js";
-import { Protocol } from "../../../../common-apis/models/protocol.js";
-
-describe("goexmeSwapProvider::_fetchSupportedCurrenciesIfNeeded-stack", () => {
-    const apiOK = {
-        btc: { coinName: "Bitcoin", available: true, network: "", tagname: "", minamount: 0.001, maxamount: 10 },
-        eth: { coinName: "Ethereum", available: true, network: "erc20", tagname: "" },
-        usdt: { coinName: "Tether", available: false, network: "" },
-    };
-
-    let provider, axiosStub;
-    beforeEach(() => {
-        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
-        axiosStub = sinon.stub(axios, "get");
-    });
-    afterEach(() => sinon.restore());
 
-    it("constructor sets direct URL when apiKey passed", () => {
-        const p = new GoexmeSwapProvider("/proxy", new Cache(), () => null, false, "key");
-        p._URL.should.equal("https://goexme.io/v1/api");
-    });
+describe("goexmeSwapProvider", function () {
+    describe("_fetchSupportedCurrenciesIfNeeded", function () {
+        let provider, axiosGetStub;
 
-    it("_convertCurrencyMeta returns null for restricted set", () => {
-        const restricted = new GoexmeSwapProvider("/", new Cache(), () => null, true);
-        should(restricted._convertCurrencyMeta("abc", { coinName: "Abc" }, new Set())).be.null();
-    });
+        beforeEach(() => {
+            provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
+            axiosGetStub = sinon.stub(axios, "get");
+        });
 
-    it("_convertCurrencyMeta auto-constructs Coin when builder=null and unrestricted", () => {
-        const unrestricted = new GoexmeSwapProvider("/", new Cache(), null, false);
-        const info = unrestricted._convertCurrencyMeta(
-            "btc",
-            { coinName: "Bitcoin Test", network: "", available: true },
-            new Set()
-        );
-        info.should.have.properties({ code: "BTC", network: null });
-        info.coin.should.be.instanceOf(Coin);
-        if (info.coin.protocol) info.coin.protocol.should.be.instanceOf(Protocol);
-    });
+        afterEach(() => {
+            axiosGetStub.restore();
+            provider._supportedCoins = [];
+        });
 
-    it("fetches once per batch", async () => {
-        axiosStub.resolves({ status: 200, data: apiOK });
-        await provider._fetchSupportedCurrenciesIfNeeded();
-        await provider._fetchSupportedCurrenciesIfNeeded();
-        axiosStub.calledOnce.should.be.true();
-        provider._supportedCoins.length.should.equal(2);
-        provider._supportedCoins.forEach(i => i.coin.should.be.instanceOf(Coin));
-    });
+        it("Should load and map available currencies when status is 200", async () => {
+            const apiOK = {
+                btc: { coinName: "Bitcoin", available: true, network: "", tagname: "" },
+                eth: { coinName: "Ethereum", available: true, network: "erc20", tagname: "" },
+                usdt: { coinName: "Tether", available: false, network: "" },
+            };
+            axiosGetStub.resolves({ status: 200, data: apiOK });
 
-    it("skips coins with available false", async () => {
-        axiosStub.resolves({ status: 200, data: apiOK });
-        await provider._fetchSupportedCurrenciesIfNeeded();
-        provider._supportedCoins.some(i => i.code === "usdt").should.be.false();
-    });
+            await provider._fetchSupportedCurrenciesIfNeeded();
 
-    it("throws on non-200 response", async () => {
-        axiosStub.resolves({ status: 500, data: {} });
-        await provider._fetchSupportedCurrenciesIfNeeded().should.be.rejected();
-    });
+            provider._supportedCoins.length.should.equal(2);
+            provider._supportedCoins.forEach(info => info.coin.should.be.instanceOf(info.coin.constructor));
+        });
 
-    it("propagates axios error", async () => {
-        axiosStub.rejects(new Error("network"));
-        await provider._fetchSupportedCurrenciesIfNeeded().should.be.rejectedWith(/network/);
-    });
-});
+        it("Should skip currencies with available=false", async () => {
+            const apiPartial = {
+                btc: { coinName: "Bitcoin", available: false, network: "", tagname: "" },
+                eth: { coinName: "Ethereum", available: true, network: "", tagname: "" },
+            };
+            axiosGetStub.resolves({ status: 200, data: apiPartial });
 
-describe("goexmeSwapProvider::_ensurePairsLoaded", () => {
-    let provider, axiosStub;
-    beforeEach(() => {
-        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
-        axiosStub = sinon
-            .stub(axios, "get")
-            .callsFake(url =>
-                url.includes("/pairs")
-                    ? Promise.resolve({ status: 200, data: { BTC: ["ETH"] } })
-                    : Promise.resolve({ status: 200, data: {} })
-            );
-    });
-    afterEach(() => sinon.restore());
+            await provider._fetchSupportedCurrenciesIfNeeded();
 
-    it("loads pairs only once within TTL", async () => {
-        await provider._ensurePairsLoaded();
-        const calls = axiosStub.callCount;
-        await provider._ensurePairsLoaded();
-        axiosStub.callCount.should.equal(calls);
-    });
+            provider._supportedCoins.length.should.equal(1);
+            provider._supportedCoins[0].code.should.equal("ETH");
+        });
 
-    it("refreshes pairs after expiration", async () => {
-        await provider._ensurePairsLoaded();
-        provider._pairsCacheTimestamp -= provider.PAIRS_EXPIRATION_TIME_MS + 1000;
-        await provider._ensurePairsLoaded();
-        axiosStub.callCount.should.equal(2);
-    });
+        it("Should reject when response status is not 200", async () => {
+            axiosGetStub.resolves({ status: 500, data: {} });
 
-    it("throws on non-200", async () => {
-        axiosStub.resetBehavior();
-        axiosStub.resolves({ status: 400, data: {} });
-        await provider._ensurePairsLoaded().should.be.rejectedWith(/Failed to load/);
-    });
+            return provider._fetchSupportedCurrenciesIfNeeded().should.be.rejected();
+        });
 
-    it("stores upper-case tickers", async () => {
-        await provider._ensurePairsLoaded();
-        provider._pairsCache.should.have.property("BTC");
-        provider._pairsCache.BTC.has("ETH").should.be.true();
-    });
-});
+        it("Should propagate axios error", async () => {
+            axiosGetStub.rejects(new Error("network"));
 
-describe("goexmeSwapProvider::_fetchSupportedCurrenciesIfNeeded race", () => {
-    let provider, axiosStub;
-    beforeEach(() => {
-        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
-        axiosStub = sinon.stub(axios, "get").resolves({
-            status: 200,
-            data: { btc: { coinName: "btc", available: true } },
+            return provider._fetchSupportedCurrenciesIfNeeded().should.be.rejectedWith(/network/);
         });
-    });
-    afterEach(() => sinon.restore());
 
-    it("two parallel calls trigger two HTTP requests (no dedupe)", async () => {
-        await Promise.all([provider._fetchSupportedCurrenciesIfNeeded(), provider._fetchSupportedCurrenciesIfNeeded()]);
-        axiosStub.callCount.should.equal(2);
-    });
-});
-
-describe("goexmeSwapProvider::helpers", () => {
-    it("getSwapCreationInfoTtlMs returns 30 000 ms", () => {
-        const p = new GoexmeSwapProvider("/", new Cache());
-        p.getSwapCreationInfoTtlMs().should.equal(30000);
-    });
+        it("Should not call axios again while cache is fresh", async () => {
+            const apiOK = {
+                btc: { coinName: "Bitcoin", available: true, network: "", tagname: "" },
+            };
+            axiosGetStub.resolves({ status: 200, data: apiOK });
 
-    it("_parseGoexmeDate converts to epoch", () => {
-        const ts = GoexmeSwapProvider._parseGoexmeDate("01.02.2024 03:04:05");
-        ts.should.equal(Date.parse("2024-02-01T03:04:05Z"));
-    });
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            const initialCalls = axiosGetStub.callCount;
+            await provider._fetchSupportedCurrenciesIfNeeded();
 
-    it("getPartnersList returns single partner", async () => {
-        const p = new GoexmeSwapProvider("/", new Cache());
-        const partners = await p.getPartnersList();
-        partners.should.have.length(1);
-        partners[0].should.have.property("name", "GoExme");
+            axiosGetStub.callCount.should.equal(initialCalls);
+        });
     });
 });

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,199 @@ 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 throw for unsupported coins or pairs", async () => {
+            provider._pairsCache = {};
+            await provider
+                .createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo")
+                .should.be.rejectedWith(/Unsupported pair/);
+        });
+
+        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();
+        });
+    });
+});