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

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

@@ -0,0 +1,95 @@
+import should from "should";
+import { 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", function () {
+    describe("_convertCurrencyMeta", function () {
+        it("Should return null for restricted set", () => {
+            const restrictedProvider = new GoexmeSwapProvider("/", new Cache(), () => null, true);
+            const mapping = { rabbitTicker: "ABC", tickerPrintable: "ABC", protocol: null };
+            const providerItem = { coinName: "Abc", decimals: 8, available: true, tagname: "", network: "" };
+
+            should(restrictedProvider._convertCurrencyMeta("ABC", providerItem, mapping)).be.null();
+        });
+
+        it("Should auto-construct Coin when builder is null and unrestricted", function () {
+            const provider = new GoexmeSwapProvider("/", new Cache(), null, false);
+            const mapping = { rabbitTicker: "BTC", tickerPrintable: "BTC", protocol: null };
+            const providerCode = "BTC";
+            const providerItem = {
+                coinName: "Bitcoin",
+                decimals: 8,
+                available: true,
+                tagname: "",
+                network: "Bitcoin",
+            };
+            const currencyInfo = provider._convertCurrencyMeta(providerCode, providerItem, mapping);
+            currencyInfo.should.have.properties({ code: "BTC", network: "Bitcoin" });
+            currencyInfo.coin.should.be.instanceOf(Coin);
+            if (currencyInfo.coin.protocol) currencyInfo.coin.protocol.should.be.instanceOf(Protocol);
+        });
+
+        it("Should set hasExtraId=true and extraIdName when tagname present", function () {
+            const provider = new GoexmeSwapProvider("/", new Cache(), null, false);
+            const mapping = { rabbitTicker: "XRP", tickerPrintable: "XRP", protocol: null };
+            const providerCode = "XRP";
+            const providerItem = {
+                coinName: "Ripple",
+                decimals: 6,
+                available: true,
+                tagname: "DestinationTag",
+            };
+            const currencyInfo = provider._convertCurrencyMeta(providerCode, providerItem, mapping);
+            currencyInfo.hasExtraId.should.be.true();
+            currencyInfo.extraIdName.should.equal("DestinationTag");
+        });
+
+        it("Should set hasExtraId=false and extraIdName=null when no tagname", function () {
+            const provider = new GoexmeSwapProvider("/", new Cache(), null, false);
+            const mapping = { rabbitTicker: "LTC", tickerPrintable: "LTC", protocol: null };
+            const providerCode = "LTC";
+            const providerItem = {
+                coinName: "Litecoin",
+                decimals: 8,
+                available: true,
+                tagname: "",
+            };
+            const currencyInfo = provider._convertCurrencyMeta(providerCode, providerItem, mapping);
+            currencyInfo.hasExtraId.should.be.false();
+            should(currencyInfo.extraIdName).be.null();
+        });
+    });
+
+    describe("constructor", function () {
+        it("Should default _URL to proxy path when apiKey empty", () => {
+            const provider = new GoexmeSwapProvider("/proxy", new Cache());
+            provider._URL.should.equal("/proxy/goexme");
+        });
+
+        it("Should set direct URL when apiKey passed", () => {
+            const providerWithKey = new GoexmeSwapProvider("/proxy", new Cache(), () => null, false, "key");
+            providerWithKey._URL.should.equal("https://goexme.io/v1/api");
+        });
+
+        it("Should not set Authorization header", () => {
+            const providerWithSecret = new GoexmeSwapProvider("/proxy", new Cache(), () => null, false, "mySecret");
+            should(providerWithSecret.headers).not.have.property("Authorization");
+        });
+
+        it("Should not set any unexpected headers", () => {
+            const providerWithSecret = new GoexmeSwapProvider("/proxy", new Cache(), () => null, false, "mySecret");
+            Object.keys(providerWithSecret.headers).should.eql([]);
+        });
+
+        it("Should allow only 200 and 404 in validateStatus", () => {
+            const defaultProvider = new GoexmeSwapProvider("/", new Cache());
+            const allowedStatuses = [200, 404];
+            allowedStatuses.forEach(status => defaultProvider.axiosPreset.validateStatus(status).should.be.true());
+            [199, 500].forEach(status => defaultProvider.axiosPreset.validateStatus(status).should.be.false());
+        });
+    });
+});

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

@@ -0,0 +1,75 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { GoexmeSwapProvider } from "../../../external-apis/goexmeSwapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+
+describe("goexmeSwapProvider", function () {
+    describe("_fetchSupportedCurrenciesIfNeeded", function () {
+        let provider, axiosGetStub;
+
+        beforeEach(() => {
+            provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
+            axiosGetStub = sinon.stub(axios, "get");
+        });
+
+        afterEach(() => {
+            axiosGetStub.restore();
+            provider._supportedCoins = [];
+        });
+
+        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 });
+
+            await provider._fetchSupportedCurrenciesIfNeeded();
+
+            provider._supportedCoins.length.should.equal(2);
+            provider._supportedCoins.forEach(info => info.coin.should.be.instanceOf(info.coin.constructor));
+        });
+
+        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 });
+
+            await provider._fetchSupportedCurrenciesIfNeeded();
+
+            provider._supportedCoins.length.should.equal(1);
+            provider._supportedCoins[0].code.should.equal("ETH");
+        });
+
+        it("Should reject when response status is not 200", async () => {
+            axiosGetStub.resolves({ status: 500, data: {} });
+
+            return provider._fetchSupportedCurrenciesIfNeeded().should.be.rejected();
+        });
+
+        it("Should propagate axios error", async () => {
+            axiosGetStub.rejects(new Error("network"));
+
+            return provider._fetchSupportedCurrenciesIfNeeded().should.be.rejectedWith(/network/);
+        });
+
+        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 });
+
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            const initialCalls = axiosGetStub.callCount;
+            await provider._fetchSupportedCurrenciesIfNeeded();
+
+            axiosGetStub.callCount.should.equal(initialCalls);
+        });
+    });
+});

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

@@ -0,0 +1,225 @@
+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 { SwapProvider } from "../../../external-apis/swapProvider.js";
+import { Coin } from "../../../../common-apis/models/coin.js";
+import { Blockchain } from "../../../../common-apis/models/blockchain.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")
+);
+
+const ESTIMATION_STUB = { rate: "0.09143008", rawSwapData: { rate: "0.09143008" } };
+
+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());
+
+        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("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("Should pass refundAddress and refundTag", async () => {
+            provider._supportedCoins[0].hasExtraId = true;
+            await provider.createSwap(
+                BTC,
+                ETH,
+                "1",
+                "dest",
+                "refundAddr",
+                ESTIMATION_STUB,
+                null,
+                false,
+                "memo",
+                "123tag"
+            );
+            const params = axiosStub.args[0][1].params;
+            params.should.have.properties({ refundAddress: "refundAddr", refundTag: "123tag" });
+        });
+
+        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("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("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("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 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 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("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");
+        });
+        it("Should map 403 with Cloudflare header to RETRIABLE_FAIL + IP_BANNED", async () => {
+            axiosStub.rejects({ response: { status: 403, headers: { "CF-RAY": "zzz" }, data: "Forbidden" } });
+
+            const r = await provider.createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo");
+
+            r.result.should.be.false();
+            r.reason.should.equal(SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+            r.errorCode.should.equal(SwapProvider.RETRIABLE_SWAP_CREATION_ERRORS.IP_BANNED);
+        });
+
+        it("Should map 4xx body containing 'ip' + 'blocked/banned' to IP_BANNED", async () => {
+            axiosStub.rejects({ response: { status: 401, data: "ip address banned due to abuse" } });
+
+            const r = await provider.createSwap(BTC, ETH, "1", "dest", "", ESTIMATION_STUB, null, false, "memo");
+
+            r.result.should.be.false();
+            r.reason.should.equal(SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+            r.errorCode.should.equal(SwapProvider.RETRIABLE_SWAP_CREATION_ERRORS.IP_BANNED);
+        });
+    });
+});

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

@@ -0,0 +1,175 @@
+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 keep swaps visible via fallback mapping when coins are unsupported", async function () {
+            provider._supportedCoins = [];
+            const makeResp = (status, extra = {}) => ({
+                status: 200,
+                data: {
+                    status,
+                    date: "02.02.2024 12:22:02",
+                    from: "LTC",
+                    to: "ETH",
+                    amountFrom: "1",
+                    amountTo: "0.05",
+                    depositAddress: "in",
+                    destinationAddress: "out",
+                    ...extra,
+                },
+            });
+            axiosStub.resolves(makeResp("success", { id: "ltc" }));
+            const res = await provider.getExistingSwapsDetailsAndStatus(["ltc"]);
+            res.result.should.be.true();
+            res.swaps.length.should.equal(1);
+            const swap = res.swaps[0];
+            should.exist(swap);
+            should.exist(swap.fromCoin);
+            should.exist(swap.toCoin);
+            (typeof swap.fromCoin.ticker).should.equal("string");
+            (typeof swap.fromCoin.digits).should.equal("number");
+            (typeof swap.toCoin.ticker).should.equal("string");
+            (typeof swap.toCoin.digits).should.equal("number");
+        });
+
+        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();
+        });
+    });
+});