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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rabbitio/ui-kit",
-    "version": "1.0.0-beta.110",
+    "version": "1.0.0-beta.112",
     "description": "Rabbit.io react.js components kit",
     "type": "module",
     "main": "./dist/index.cjs",

package/src/common-apis/tests/integration/external-apis/ipAddressProviders/getClientIpAddress.test.js

@@ -5,10 +5,14 @@ import { IpAddressProvider } from "../../../../external-apis/ipAddressProviders.
 
 describe("ipAddressProviders", function () {
     describe("#getClientIpAddress", function () {
-        it("Should successfully retrieve IP address", async function () {
-            (
-                await new IpAddressProvider("https://plankton-app-k6der.ondigitalocean.app").getClientIpAddress()
-            ).should.not.be.empty();
-        });
+        it(
+            "Should successfully retrieve IP address",
+            async function () {
+                (
+                    await new IpAddressProvider("https://plankton-app-k6der.ondigitalocean.app").getClientIpAddress()
+                ).should.not.be.empty();
+            },
+            { timeout: 100_000 }
+        );
     });
 });

package/src/swaps-lib/external-apis/exolixSwapProvider.js

@@ -501,46 +501,53 @@ export class ExolixSwapProvider extends SwapProvider {
             const swaps = fetchedSwaps
                 .map(r => r.data)
                 .map((swap, index) => {
-                    const fromCoin = this._supportedCoins.find(
-                        i => i.code === swap.coinFrom.coinCode && i.network === swap.coinFrom.network
-                    )?.coin;
-                    const toCoin = this._supportedCoins.find(
-                        i => i.code === swap.coinTo.coinCode && i.network === swap.coinTo.network
-                    )?.coin;
-                    if (!fromCoin || !toCoin) {
-                        return []; // We skip swaps with not supported coins for now
+                    try {
+                        const fromCoin = this._supportedCoins.find(
+                            i => i.code === swap.coinFrom.coinCode && i.network === swap.coinFrom.network
+                        )?.coin ?? { ticker: toRabbitTicker(swap.coinFrom.coinCode, swap.coinFrom.network), digits: 8 };
+                        const toCoin = this._supportedCoins.find(
+                            i => i.code === swap.coinTo.coinCode && i.network === swap.coinTo.network
+                        )?.coin ?? { ticker: toRabbitTicker(swap.coinTo.coinCode, swap.coinTo.network), digits: 8 };
+                        if (!fromCoin || !toCoin) {
+                            return []; // We skip swaps with not supported coins for now
+                        }
+
+                        const toUtcTimestamp = timeStr =>
+                            Date.parse(timeStr.match(/.+[Zz]$/) ? timeStr : `${timeStr}Z`);
+                        const createdAt = toUtcTimestamp(swap.createdAt);
+                        const expiresAt = createdAt + 25 * 60 * 1000; // Hack with hard-coded 25 minutes
+                        const isExpiredByTime = expiresAt < Date.now();
+                        const status = this._mapExolixStatusToRabbitStatus(swap.status, isExpiredByTime);
+                        const toDigits =
+                            status === SwapProvider.SWAP_STATUSES.REFUNDED ? fromCoin.digits : toCoin.digits;
+                        return new ExistingSwap(
+                            swapIds[index],
+                            status,
+                            createdAt,
+                            expiresAt,
+                            -1,
+                            AmountUtils.trim(swap.rate, this._maxRateDigits),
+                            swap?.rateType === "fixed",
+                            swap.refundAddress,
+                            swap.depositAddress,
+                            fromCoin,
+                            AmountUtils.trim(swap.amount, fromCoin.digits),
+                            swap.hashIn.hash,
+                            swap.hashIn.link,
+                            toCoin,
+                            AmountUtils.trim(swap.amountTo, toDigits),
+                            swap.hashOut.hash,
+                            swap.hashOut.link,
+                            swap.withdrawalAddress,
+                            this.id,
+                            swap.depositExtraId ?? null,
+                            swap.withdrawalExtraId ?? null,
+                            swap.refundExtraId ?? null
+                        );
+                    } catch (e) {
+                        console.log("Failed to parse loaded swap", e);
+                        return [];
                     }
-
-                    const toUtcTimestamp = timeStr => Date.parse(timeStr.match(/.+[Zz]$/) ? timeStr : `${timeStr}Z`);
-                    const createdAt = toUtcTimestamp(swap.createdAt);
-                    const expiresAt = createdAt + 25 * 60 * 1000; // Hack with hard-coded 25 minutes
-                    const isExpiredByTime = expiresAt < Date.now();
-                    const status = this._mapExolixStatusToRabbitStatus(swap.status, isExpiredByTime);
-                    const toDigits = status === SwapProvider.SWAP_STATUSES.REFUNDED ? fromCoin.digits : toCoin.digits;
-                    return new ExistingSwap(
-                        swapIds[index],
-                        status,
-                        createdAt,
-                        expiresAt,
-                        -1,
-                        AmountUtils.trim(swap.rate, this._maxRateDigits),
-                        swap?.rateType === "fixed",
-                        swap.refundAddress,
-                        swap.depositAddress,
-                        fromCoin,
-                        AmountUtils.trim(swap.amount, fromCoin.digits),
-                        swap.hashIn.hash,
-                        swap.hashIn.link,
-                        toCoin,
-                        AmountUtils.trim(swap.amountTo, toDigits),
-                        swap.hashOut.hash,
-                        swap.hashOut.link,
-                        swap.withdrawalAddress,
-                        this.id,
-                        swap.depositExtraId ?? null,
-                        swap.withdrawalExtraId ?? null,
-                        swap.refundExtraId ?? null
-                    );
                 })
                 .flat();
             Logger.log(`Swap details result ${safeStringify(swaps)}`, loggerSource);

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

@@ -361,10 +361,7 @@ export class GoexmeSwapProvider extends SwapProvider {
                 };
             }
 
-            /* --------------------------------------------------------
-             * Convert amountTo → ratio so that downstream code can do
-             *   amountFrom * rate === amountTo
-             * -------------------------------------------------------- */
+             // Convert amountTo → ratio so that downstream code can do amountFrom * rate === amountTo
             let rateRatio = null;
             if (response.data.rate != null && BigNumber(amountCoins).gt(0)) {
                 rateRatio = AmountUtils.trim(
@@ -385,10 +382,6 @@ export class GoexmeSwapProvider extends SwapProvider {
                 rawSwapData: response.data,
                 /**
                  * GoExme never requires a refund address.
-                 *
-                 * The official API documentation marks `destinationTag` / `refundTag` as **optional**.
-                 * Support chat confirmation (2025‑06‑27): "Yes, it's optional and can be omitted even for small amounts."
-                 *
                  */
                 isRefundAddressRequired: false,
             };
@@ -407,23 +400,28 @@ export class GoexmeSwapProvider extends SwapProvider {
     /**
      * Creates a swap on GoExme.
      *
-     * We cannot rely on what upper layers put into
-     * `proprietarySwapEstimationData.rate`:
-     *   • sometimes it is the **amountTo** (GoExme original value);
-     *   • sometimes it is already a **ratio** – but we cannot know.
+     * The `proprietarySwapEstimationData` object **must** carry two distinct values
+     * produced by a prior `/rate` call:
      *
-     * The only safe approach: treat any numeric value we get from
-     * estimation as amountTo, then derive the ratio ourselves.
+     *   • `rawSwapData.rate` – **amountTo**
+     *       (the exact number of coins GoExme will send to the user);
+     *   • `rate`             – **ratio**
+     *       (`amountTo / amountFrom`, i.e. Rabbit‑style per‑coin rate).
      *
-     * Steps:
-     *   1. Pick the first non-null of
-     *        – estimation.rawSwapData.rate
-     *        – estimation.rate
-     *      (both are amountTo for GoExme).
-     *   2. Store it as `toAmountCalculated`.
-     *   3. Compute `rateRatio = toAmount / amountFrom`.
-     *      → both mandatory fields (`rate`, `withdrawal.amount`)
-     *        are always present, avoiding schema validation errors.
+     * Processing steps
+     * ----------------
+     * 1. Determine **amountTo** (`rawSwapData.rate`).
+     * 2. Compute the canonical per‑coin **ratio**:
+     *
+     *        ratio = amountTo / amountFrom
+     *
+     * 3. Return both numbers for downstream code:
+     *      • `rate`     → ratio (Rabbit convention);
+     *      • `toAmount` → amountTo (final coins the user receives).
+     *
+     * This guarantees the invariant:
+     *
+     *     amountFrom * rate === toAmount
      */
     async createSwap(
         fromCoin,
@@ -474,6 +472,9 @@ export class GoexmeSwapProvider extends SwapProvider {
             };
 
             params.amount = amount;
+
+            // Add refundAddress only if extraId is present:
+            // GoExme documents these fields as optional, and support (2025‑06‑27) confirmed that.
             if (toCoinInfo.hasExtraId && toCurrencyExtraId) params.destinationTag = toCurrencyExtraId;
             if (refundAddress) {
                 params.refundAddress = refundAddress;
@@ -494,9 +495,7 @@ export class GoexmeSwapProvider extends SwapProvider {
                 throw new Error(errMsg);
             }
 
-            /*------------------------------------------------------------
-             * Extract amountTo from estimation (first non-null source).
-             *-----------------------------------------------------------*/
+            // Extract amountTo from estimation (first non-null source).
             const amountToCandidate =
                 proprietarySwapEstimationData?.rawSwapData?.rate ?? proprietarySwapEstimationData?.rate ?? null;
 
@@ -506,9 +505,7 @@ export class GoexmeSwapProvider extends SwapProvider {
 
             const toAmountCalculated = AmountUtils.trim(amountToCandidate, toCoin.digits);
 
-            /*------------------------------------------------------------
-             * Derive ratio so that amountFrom * ratio = amountTo.
-             *-----------------------------------------------------------*/
+             // Derive ratio so that amountFrom * ratio = amountTo.
             const rateRatio = AmountUtils.trim(
                 BigNumber(toAmountCalculated).div(amount).toString(),
                 this._maxRateDigits
@@ -561,26 +558,23 @@ export class GoexmeSwapProvider extends SwapProvider {
 
             const statusResponses = await Promise.all(swapIds.map(fetchOne));
 
-            /* helper: normalize coin code using CODE_TRANSLATIONS */
+            // helper: normalize coin code using CODE_TRANSLATIONS
             const normalize = code => CODE_TRANSLATIONS[code.toUpperCase()] ?? code.toUpperCase();
 
             const swaps = statusResponses
                 .map((statusData, swapIndex) => {
                     if (!statusData) return null;
 
-                    /* ------------------ coins ------------------ */
                     const fromCoinTicker = toRabbitTicker(normalize(statusData.from), "");
                     const toCoinTicker = toRabbitTicker(normalize(statusData.to), "");
 
                     let fromCoin = this.getCoinByTickerIfPresent(fromCoinTicker);
                     let toCoin = this.getCoinByTickerIfPresent(toCoinTicker);
 
-                    /* fallback: look up by raw provider code if ticker lookup failed */
                     if (!fromCoin) {
                         const byCode = this._supportedCoins.find(c => c.code === statusData.from);
                         fromCoin = byCode?.coin ?? null;
                     }
-                    /* fallback: look up by raw provider code if ticker lookup failed */
                     if (!toCoin) {
                         const byCode = this._supportedCoins.find(c => c.code === statusData.to);
                         toCoin = byCode?.coin ?? null;
@@ -588,11 +582,9 @@ export class GoexmeSwapProvider extends SwapProvider {
 
                     if (!fromCoin || !toCoin) return null;
 
-                    /* timestamps */
                     const createdAt = GoexmeSwapProvider._parseGoexmeDate(statusData.date);
                     const expiresAt = createdAt + this.SWAP_EXPIRATION_TIME_MS;
 
-                    /* amounts & rate */
                     const amountFromEffective = statusData.amountFrom ?? statusData.expectedAmountFrom ?? "0";
                     const amountToEffective = statusData.amountTo ?? statusData.expectedAmountTo ?? null;
                     let rateVal = statusData.rate;
@@ -620,11 +612,11 @@ export class GoexmeSwapProvider extends SwapProvider {
                         statusData.depositAddress,
                         fromCoin,
                         AmountUtils.trim(amountFromEffective, fromCoin.digits),
-                        null,
+                        statusData.depositHash,
                         null,
                         toCoin,
                         toAmountTrimmed,
-                        statusData.txId ?? null,
+                        statusData.txId,
                         null,
                         statusData.destinationAddress,
                         this.id,

package/src/swaps-lib/external-apis/swapspaceSwapProvider.js

@@ -509,56 +509,64 @@ export class SwapspaceSwapProvider extends SwapProvider {
             };
             const responses = await Promise.all(swapIds.map(swapId => getNotFailingOn404(swapId)));
             const wo404 = responses.flat();
-            Logger.log("All swaps RAW: " + JSON.stringify(wo404.map(r => r.data)), loggerSource);
+            Logger.log("All swaps RAW swapspace: " + JSON.stringify(wo404.map(r => r.data)), loggerSource);
             const swaps = wo404
                 .map(r => r.data)
                 .map((swap, index) => {
-                    const fromCoin = this._supportedCoins.find(
-                        i => i.code === swap.from.code && i.network === swap.from.network
-                    )?.coin;
-                    const toCoin = this._supportedCoins.find(
-                        i => i.code === swap.to.code && i.network === swap.to.network
-                    )?.coin;
-                    if (!fromCoin || !toCoin) {
-                        return []; // We skip swaps with not supported coins for now
-                    }
+                    try {
+                        let fromCoin = this._supportedCoins.find(
+                            i => i.code === swap.from.code && i.network === swap.from.network
+                        )?.coin ?? { ticker: toRabbitTicker(swap.from.code, swap.from.network), digits: 8 };
+                        let toCoin = this._supportedCoins.find(
+                            i => i.code === swap.to.code && i.network === swap.to.network
+                        )?.coin ?? { ticker: toRabbitTicker(swap.to.code, swap.to.network), digits: 8 };
+
+                        if (!fromCoin || !toCoin) {
+                            return []; // We skip swaps with not supported coins for now
+                        }
 
-                    const toUtcTimestamp = timeStr => Date.parse(timeStr.match(/.+[Zz]$/) ? timeStr : `${timeStr}Z`);
-                    const expiresAt = toUtcTimestamp(swap.timestamps.expiresAt);
-                    const isExpiredByTime = expiresAt < Date.now();
-                    const status = this._mapSwapspaceStatusToRabbitStatus(swap.status, isExpiredByTime);
-                    const toDigits = status === SwapProvider.SWAP_STATUSES.REFUNDED ? fromCoin.digits : toCoin.digits;
-                    const addressToSendCoinsToSwapspace = swap.from.address;
-                    const toUrl = (swap.blockExplorerTransactionUrl.to ?? "")
-                        .replace(/from=swapspace&?/g, "")
-                        .replaceAll(/&&+/g, "&")
-                        .replace("?&", "?")
-                        .replace(/&$/, "")
-                        .replace(/\?$/, "");
-                    return new ExistingSwap(
-                        swapIds[index],
-                        status,
-                        toUtcTimestamp(swap.timestamps.createdAt),
-                        expiresAt,
-                        swap.confirmations,
-                        AmountUtils.trim(swap.rate, this._maxRateDigits),
-                        swap.fixed,
-                        swap.refundAddress,
-                        addressToSendCoinsToSwapspace,
-                        fromCoin,
-                        AmountUtils.trim(swap.from.amount, fromCoin.digits),
-                        swap.from.transactionHash,
-                        swap.blockExplorerTransactionUrl.from,
-                        toCoin,
-                        AmountUtils.trim(swap.to.amount, toDigits),
-                        swap.to.transactionHash,
-                        toUrl,
-                        swap.to.address,
-                        swap.partner,
-                        swap.from.extraId ?? null,
-                        swap.to.extraId ?? null,
-                        swap.refundExtraId ?? null
-                    );
+                        const toUtcTimestamp = timeStr =>
+                            Date.parse(timeStr.match(/.+[Zz]$/) ? timeStr : `${timeStr}Z`);
+                        const expiresAt = toUtcTimestamp(swap.timestamps.expiresAt);
+                        const isExpiredByTime = expiresAt < Date.now();
+                        const status = this._mapSwapspaceStatusToRabbitStatus(swap.status, isExpiredByTime);
+                        const toDigits =
+                            status === SwapProvider.SWAP_STATUSES.REFUNDED ? fromCoin.digits : toCoin.digits;
+                        const addressToSendCoinsToSwapspace = swap.from.address;
+                        const toUrl = (swap.blockExplorerTransactionUrl.to ?? "")
+                            .replace(/from=swapspace&?/g, "")
+                            .replaceAll(/&&+/g, "&")
+                            .replace("?&", "?")
+                            .replace(/&$/, "")
+                            .replace(/\?$/, "");
+                        return new ExistingSwap(
+                            swapIds[index],
+                            status,
+                            toUtcTimestamp(swap.timestamps.createdAt),
+                            expiresAt,
+                            swap.confirmations,
+                            AmountUtils.trim(swap.rate, this._maxRateDigits),
+                            swap.fixed,
+                            swap.refundAddress,
+                            addressToSendCoinsToSwapspace,
+                            fromCoin,
+                            AmountUtils.trim(swap.from.amount, fromCoin.digits),
+                            swap.from.transactionHash,
+                            swap.blockExplorerTransactionUrl.from,
+                            toCoin,
+                            AmountUtils.trim(swap.to.amount, toDigits),
+                            swap.to.transactionHash,
+                            toUrl,
+                            swap.to.address,
+                            swap.partner,
+                            swap.from.extraId ?? null,
+                            swap.to.extraId ?? null,
+                            swap.refundExtraId ?? null
+                        );
+                    } catch (e) {
+                        console.log("Failed to parse loaded swap", e);
+                        return [];
+                    }
                 })
                 .flat();
             Logger.log(`Swap details result ${safeStringify(swaps)}`, loggerSource);

package/src/swaps-lib/models/existingSwap.js

@@ -76,7 +76,7 @@ export class ExistingSwap {
      * @param {number} expiresAt - The timestamp when the swap expires.
      * @param {number|null} confirmations - The number of confirmations the swap has received, or null.
      * @param {string} rate - The exchange rate for the swap.
-     * @param {null} fixed - Indicates if the rate is fixed.
+     * @param {boolean} fixed - Indicates if the rate is fixed.
      * @param {string|null} refundAddress - The address to refund to in case of failure, or null.
      * @param {string} payToAddress - The address to send the funds to.
      * @param {Coin} fromCoin - The coin that is being swapped from.

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

@@ -0,0 +1,80 @@
+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);
+            should(restrictedProvider._convertCurrencyMeta("abc", { coinName: "Abc" })).be.null();
+        });
+
+        it("Should auto‑construct Coin when builder is null and unrestricted", () => {
+            const unrestrictedProvider = new GoexmeSwapProvider("/", new Cache(), null, false);
+            const currencyInfo = unrestrictedProvider._convertCurrencyMeta("btc", {
+                coinName: "Bitcoin Test",
+                network: "",
+                available: true,
+            });
+            currencyInfo.should.have.properties({ code: "BTC", network: null });
+            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", () => {
+            const unrestrictedProvider = new GoexmeSwapProvider("/", new Cache(), null, false);
+            const currencyInfo = unrestrictedProvider._convertCurrencyMeta("xrp", {
+                coinName: "Ripple",
+                network: "",
+                available: true,
+                tagname: "DestinationTag",
+            });
+            currencyInfo.hasExtraId.should.be.true();
+            currencyInfo.extraIdName.should.equal("DestinationTag");
+        });
+
+        it("Should set hasExtraId=false and extraIdName=null when no tagname", () => {
+            const unrestrictedProvider = new GoexmeSwapProvider("/", new Cache(), null, false);
+            const currencyInfo = unrestrictedProvider._convertCurrencyMeta("ltc", {
+                coinName: "Litecoin",
+                network: "",
+                available: true,
+            });
+            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, 400 and 404 in validateStatus", () => {
+            const defaultProvider = new GoexmeSwapProvider("/", new Cache());
+            const allowedStatuses = [200, 400, 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/_ensurePairsLoaded.test.js

@@ -0,0 +1,77 @@
+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("_ensurePairsLoaded", function () {
+        let provider, axiosGetStub;
+
+        beforeEach(() => {
+            provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
+            axiosGetStub = sinon.stub(axios, "get").callsFake(url => {
+                if (url.includes("/pairs")) {
+                    return Promise.resolve({
+                        status: 200,
+                        data: { btc: ["eth", "ETH"] },
+                    });
+                }
+                return Promise.resolve({ status: 200, data: {} });
+            });
+        });
+
+        afterEach(() => {
+            axiosGetStub.restore();
+        });
+
+        it("Should normalise codes to upper‑case", async () => {
+            await provider._ensurePairsLoaded();
+            provider._pairsCache.should.have.property("BTC");
+        });
+
+        it("Should remove duplicate tickers", async () => {
+            await provider._ensurePairsLoaded();
+            Array.from(provider._pairsCache.BTC).should.eql(["ETH"]);
+        });
+
+        it("Should not call axios again while pairs cache is fresh", async () => {
+            await provider._ensurePairsLoaded();
+            const calls = axiosGetStub.callCount;
+            await provider._ensurePairsLoaded();
+            axiosGetStub.callCount.should.equal(calls);
+        });
+
+        it("Should refresh pairs after expiration", async () => {
+            await provider._ensurePairsLoaded();
+            const calls = axiosGetStub.callCount;
+
+            provider._pairsCacheTimestamp -= provider.PAIRS_EXPIRATION_TIME_MS + 1;
+
+            await provider._ensurePairsLoaded();
+            axiosGetStub.callCount.should.equal(calls + 1);
+        });
+
+        it("Should reject when response status is not 200", async () => {
+            axiosGetStub.resetBehavior();
+            axiosGetStub.resolves({ status: 400, data: {} });
+
+            return provider._ensurePairsLoaded().should.be.rejected();
+        });
+
+        it("Should reject when data is not an object", async () => {
+            axiosGetStub.resetBehavior();
+            axiosGetStub.resolves({ status: 200, data: "not‑object" });
+
+            return provider._ensurePairsLoaded().should.be.rejected();
+        });
+
+        it("Should propagate axios error", async () => {
+            axiosGetStub.resetBehavior();
+            axiosGetStub.rejects(new Error("network"));
+            return provider._ensurePairsLoaded().should.be.rejectedWith(/network/);
+        });
+    });
+});