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

package/package.json

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

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

@@ -89,25 +89,13 @@ export class GoexmeSwapProvider extends SwapProvider {
         };
 
         this.COINS_EXPIRATION_TIME_MS = 5 * 60 * 1000;
-        this.PAIRS_EXPIRATION_TIME_MS = 5 * 60 * 1000;
         this.SWAP_EXPIRATION_TIME_MS = 4 * 60 * 60 * 1000;
-
-        this._pairsCache = null;
-        this._pairsCacheTimestamp = 0;
     }
 
     getSwapCreationInfoTtlMs() {
         return 30000;
     }
 
-    _isPairSupported(fromInfo, toInfo) {
-        if (!this._pairsCache || !this._pairsCache[fromInfo.code]) return false;
-        const toSet = this._pairsCache[fromInfo.code];
-        /* GoExme may list either the raw provider code **or**
-         * the “pretty” Rabbit ticker in `/pairs`, so we test both. */
-        return toSet.has(toInfo.code) || toSet.has(toInfo.coin.ticker);
-    }
-
     _findInfoByTicker(ticker) {
         return this._supportedCoins.find(i => i.coin.ticker === ticker) || null;
     }
@@ -196,33 +184,6 @@ export class GoexmeSwapProvider extends SwapProvider {
         );
     }
 
-    async _ensurePairsLoaded() {
-        const loggerSource = "Goexme._ensurePairsLoaded";
-        try {
-            if (this._pairsCache && Date.now() - this._pairsCacheTimestamp < this.PAIRS_EXPIRATION_TIME_MS) return;
-
-            const response = await axios.get(`${this._URL}/pairs`, {
-                ...this.axiosPreset,
-                ...createRobustTimeoutSetupForAxios(),
-                params: { key: this._apiKey },
-            });
-
-            if (response.status !== 200 || typeof response.data !== "object") {
-                throw new Error("Failed to load /pairs");
-            }
-
-            this._pairsCache = Object.fromEntries(
-                Object.entries(response.data).map(([from, arr]) => [
-                    from.toUpperCase(),
-                    new Set(arr.map(v => v.toUpperCase())),
-                ])
-            );
-            this._pairsCacheTimestamp = Date.now();
-        } catch (e) {
-            improveAndRethrow(e, loggerSource);
-        }
-    }
-
     _mapGoexmeStatus(status) {
         switch (status) {
             case "new":
@@ -303,12 +264,11 @@ export class GoexmeSwapProvider extends SwapProvider {
                 throw new Error("Invalid params for getSwapInfo");
 
             await this._fetchSupportedCurrenciesIfNeeded();
-            await this._ensurePairsLoaded();
 
             const fromCoinInfo = this._findInfoByTicker(fromCoin.ticker);
             const toCoinInfo = this._findInfoByTicker(toCoin.ticker);
 
-            if (!fromCoinInfo || !toCoinInfo || !this._isPairSupported(fromCoinInfo, toCoinInfo)) {
+            if (!fromCoinInfo || !toCoinInfo) {
                 return {
                     result: false,
                     reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED,
@@ -361,10 +321,18 @@ export class GoexmeSwapProvider extends SwapProvider {
                 };
             }
 
-            /* --------------------------------------------------------
-             * Convert amountTo → ratio so that downstream code can do
-             *   amountFrom * rate === amountTo
-             * -------------------------------------------------------- */
+            if (
+                response.data.rate == null ||
+                BigNumber(response.data.rate).isNaN() ||
+                BigNumber(response.data.rate).lte(0)
+            ) {
+                return {
+                    result: false,
+                    reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED,
+                };
+            }
+
+            // 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 +353,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 +371,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:
+     *
+     *   • `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).
+     *
+     * Processing steps
+     * ----------------
+     * 1. Determine **amountTo** (`rawSwapData.rate`).
+     * 2. Compute the canonical per‑coin **ratio**:
      *
-     * The only safe approach: treat any numeric value we get from
-     * estimation as amountTo, then derive the ratio ourselves.
+     *        ratio = amountTo / amountFrom
      *
-     * 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.
+     * 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,
@@ -447,7 +416,7 @@ export class GoexmeSwapProvider extends SwapProvider {
             const fromCoinInfo = this._findInfoByTicker(fromCoin.ticker);
             const toCoinInfo = this._findInfoByTicker(toCoin.ticker);
 
-            if (!fromCoinInfo || !toCoinInfo || !this._isPairSupported(fromCoinInfo, toCoinInfo)) {
+            if (!fromCoinInfo || !toCoinInfo) {
                 throw new Error(`Unsupported pair ${fromCoin.ticker} -> ${toCoin.ticker}`);
             }
 
@@ -474,6 +443,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 +466,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 +476,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 +529,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 +553,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;

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/_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);
+        });
     });
 });