@rabbitio/ui-kit 1.0.0-beta.72 → 1.0.0-beta.74

package/package.json

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

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

@@ -0,0 +1,457 @@
+import axios from "axios";
+import { BigNumber } from "bignumber.js";
+import { AmountUtils } from "../../common-apis/amountUtils.js";
+import { improveAndRethrow } from "../../common-apis/errorUtils.js";
+import { SwapProvider } from "./swapProvider.js";
+import { ExistingSwap } from "../models/existingSwap.js";
+import { Coin } from "../../common-apis/models/coin.js";
+import { Protocol } from "../../common-apis/models/protocol.js";
+import { safeStringify } from "../../common-apis/utils/safeStringify.js";
+import { Logger } from "../../common-apis/utils/logging/logger.js";
+import { DEFAULT_CRYPTO_DECIMAL_COUNT, FALLBACK_ASSET_ICON_URL } from "../../common-apis/globalConstants.jsx";
+
+export class LetsExchangeSwapProvider extends SwapProvider {
+    constructor(apiKeysProxyUrl, cache, customCoinBuilder = (coin, network) => null, useRestrictedCoinsSet = true) {
+        super(cache, customCoinBuilder, useRestrictedCoinsSet);
+        this._partners = [];
+        this._URL = `${apiKeysProxyUrl}/letsexchange`;
+        this.isAggregator = false;
+        this.COINS_EXPIRATION_TIME_MS = 5 * 60 * 1000;
+        this.coinsLastUpdateTimestamp = null;
+    }
+
+    static AFFILIATE_ID = "0zbj9hf7xg7jgdgv";
+
+    getSwapCreationInfoTtlMs() {
+        return 110000;
+    }
+
+    async _fetchSupportedCurrenciesIfNeeded() {
+        const loggerSource = "_fetchSupportedCurrenciesIfNeeded";
+        try {
+            if (
+                !this._supportedCoins?.length ||
+                !this.coinsLastUpdateTimestamp ||
+                this.coinsLastUpdateTimestamp + this.COINS_EXPIRATION_TIME_MS < Date.now()
+            ) {
+                const rawResponse = await axios.get(`${this._URL}/v2/coins`);
+                Logger.log(`Retrieved ${rawResponse?.data?.length}`, loggerSource);
+                let allowedCoins = rawResponse?.data ?? [];
+                Logger.log(`Allowed cnt ${allowedCoins.length}`, loggerSource);
+
+                this._supportedCoins = allowedCoins
+                    .map(item => {
+                        const code = item.code.toUpperCase();
+
+                        if (!Array.isArray(item.networks)) return [];
+
+                        return item.networks.map(networkDetails => {
+                            const network = networkDetails.code.toUpperCase();
+                            let coin = this._customCoinBuilder(code, network);
+                            if (!coin && !this.useRestrictedCoinsSet) {
+                                let name = this.removeProtocolNameFromCoinName(item.name, code, network);
+                                const ticker = `${code}${code === network ? "" : network}`;
+                                const defaultDecimalPlacesForCoinNotSupportedOOB = DEFAULT_CRYPTO_DECIMAL_COUNT;
+                                const defaultMinConfirmationsForCoinNotSupportedOOB = 1;
+                                coin = new Coin(
+                                    name,
+                                    ticker,
+                                    code,
+                                    defaultDecimalPlacesForCoinNotSupportedOOB,
+                                    null,
+                                    "",
+                                    null,
+                                    null,
+                                    defaultMinConfirmationsForCoinNotSupportedOOB,
+                                    null,
+                                    [],
+                                    60000,
+                                    null,
+                                    code !== network ? new Protocol(network) : null,
+                                    item.contract_address || null,
+                                    false
+                                );
+                            }
+                            if (coin) {
+                                return {
+                                    coin: coin,
+                                    code: item.code,
+                                    network: networkDetails.code,
+                                    hasExtraId: !!networkDetails.has_extra,
+                                    extraIdName: networkDetails.extra_name ?? null,
+                                    isPopular: item.rating || 0,
+                                    iconURL: item.icon ? item.icon : FALLBACK_ASSET_ICON_URL,
+                                    deposit: true, // Letsexchange provide no such details
+                                    withdrawal: true, // Letsexchange provide no such details
+                                    validationRegexp: networkDetails.validation_address_regex ?? null,
+                                    isAvailable:
+                                        (typeof item.is_active !== "number" || item.is_active === 1) &&
+                                        (typeof item.disabled !== "number" || item.disabled === 0) &&
+                                        (typeof networkDetails.is_active !== "number" ||
+                                            networkDetails.is_active === 1),
+                                };
+                            }
+                            return [];
+                        });
+                    })
+                    .flat();
+                this.coinsLastUpdateTimestamp = Date.now();
+                this._putPopularCoinsFirst();
+            }
+        } catch (e) {
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    async getSwapInfo(
+        fromCoin,
+        toCoin,
+        amountCoins,
+        fixed = false,
+        fromCoinToUsdRate = null,
+        amountIsToReceive = false
+    ) {
+        const loggerSource = "getSwapInfo";
+        try {
+            if (
+                !(fromCoin instanceof Coin) ||
+                !(toCoin instanceof Coin) ||
+                typeof amountCoins !== "string" ||
+                BigNumber(amountCoins).lt("0") ||
+                (fixed !== null && typeof fixed !== "boolean") ||
+                (amountIsToReceive && !fixed)
+            ) {
+                throw new Error(
+                    `Wrong input params: ${amountCoins} ${fromCoin.ticker} -> ${toCoin.ticker}, ${
+                        fromCoin instanceof Coin
+                    }, ${toCoin instanceof Coin}, ${typeof fixed} ${fixed}, ${amountIsToReceive}`
+                );
+            }
+            const fromCoinDetails = this._supportedCoins.find(i => i.coin?.ticker === fromCoin?.ticker);
+            const toCoinDetails = this._supportedCoins.find(i => i.coin?.ticker === toCoin?.ticker);
+            if (!fromCoinDetails || !toCoinDetails) {
+                throw new Error("Failed to find coin details for: " + fromCoin.ticker + " -> " + toCoin.ticker);
+            }
+            if (
+                !fromCoinDetails.deposit ||
+                !fromCoinDetails.isAvailable ||
+                !toCoinDetails.withdrawal ||
+                !toCoinDetails.isAvailable
+            ) {
+                return {
+                    result: false,
+                    reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED,
+                };
+            }
+
+            const pathAndQuery = `/v1/info${amountIsToReceive ? "-revert" : `?float=${!fixed}`}`;
+            const response = await axios.post(`${this._URL}${pathAndQuery}`, {
+                from: fromCoinDetails.code,
+                to: toCoinDetails.code,
+                network_from: fromCoinDetails.network,
+                network_to: toCoinDetails.network,
+                amount: amountCoins,
+                affiliate_id: LetsExchangeSwapProvider.AFFILIATE_ID,
+            });
+            Logger.log(`Retrieved ${response?.data}`, loggerSource);
+            const data = response.data;
+
+            // TODO: [dev] add SwapProvider.NO_SWAPS_REASONS.NO_FIXED_BUT_HAVE_FLOATING - request alternative rate. task_id=
+
+            // TODO: [feature, low] implement extra coins to fit min/max if there are frequent errors due to min/max exceeding
+            // let extraCoinsToFitMinMax = "0";
+            // if (typeof fromCoinToUsdRate === "string" && BigNumber(fromCoinToUsdRate).gt("0")) {
+            //     const extraUsdToFitMinMax = BigNumber("1"); // We correct the limits as the exact limit can fluctuate and cause failed swap creation
+            //     extraCoinsToFitMinMax = AmountUtils.trim(extraUsdToFitMinMax.div(fromCoinToUsdRate), fromCoin.digits);
+            // }
+            let min = null;
+            if (data?.min_amount) {
+                min = AmountUtils.trim(data?.min_amount, amountIsToReceive ? toCoin.digits : fromCoin.digits);
+            }
+            let max = null;
+            if (data?.max_amount) {
+                max = AmountUtils.trim(data?.max_amount, amountIsToReceive ? toCoin.digits : fromCoin.digits);
+            }
+
+            if (data.success === false && data.error) {
+                // TODO: [dev] waiting for response from letsexchange about their not-documented responses
+                // {
+                //     "success": false,
+                //     "error": "Internal error"
+                // }
+                throw new Error("Failed to estimate swap letsexchange");
+            }
+
+            if (BigNumber(data.rate).eq("0") || BigNumber(data.amount).eq("0")) {
+                // TODO actualize according to letsexchage clarification - decide, can we count on min/max abcense? task_id=76512110797f4eab8b37f1bb789825cb
+                // amount: "0", rate: "0", rate_id: ""
+                let reason = SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED;
+                if (min && BigNumber(amountCoins).lt(min)) {
+                    reason = SwapProvider.NO_SWAPS_REASONS.TOO_LOW;
+                } else if (max && BigNumber(amountCoins).gt(max)) {
+                    reason = SwapProvider.NO_SWAPS_REASONS.TOO_HIGH;
+                } else if (!amountIsToReceive) {
+                    // If we are not requesting receiving amount (it cannot be floating-rate)
+                    // todo [feature, moderate] request alternative rate. task_id=31884db5392f49738c20a86115c90e1f
+                    // const alternativeRate = 1;
+                    // const alternativeRateAvailable = alternativeRate;
+                    // if (alternativeRateAvailable) {
+                    //     reason = fixed
+                    //         ? SwapProvider.NO_SWAPS_REASONS.NO_FIXED_BUT_HAVE_FLOATING
+                    //         : SwapProvider.NO_SWAPS_REASONS.NO_FLOATING_BUT_HAVE_FIXED;
+                    // }
+                }
+                return {
+                    result: false,
+                    reason: reason,
+                    smallestMin: min,
+                    greatestMax: max,
+                };
+            }
+            const rate = amountIsToReceive
+                ? BigNumber(amountCoins).div(data.amount)
+                : BigNumber(data.amount).div(amountCoins);
+            return {
+                result: true,
+                min: min,
+                max: max,
+                smallestMin: min,
+                greatestMax: max,
+                rate: AmountUtils.trim(rate, this._maxRateDigits),
+                durationMinutesRange: null,
+                fixed: fixed,
+                rawSwapData: data,
+                isRefundAddressRequired: false,
+            };
+        } catch (e) {
+            if (e?.response?.status === 429) {
+                return {
+                    result: false,
+                    reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
+                };
+            }
+            Logger.log(`Internal error when getting swap options ${safeStringify(e)}`, loggerSource);
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    async createSwap(
+        fromCoin,
+        toCoin,
+        amount,
+        toAddress,
+        refundAddress,
+        rawSwapData,
+        clientIpAddress,
+        fixed,
+        toCurrencyExtraId = "",
+        refundExtraId = "",
+        amountIsToReceive = false
+    ) {
+        const loggerSource = "createSwap";
+        try {
+            if (
+                !(fromCoin instanceof Coin) ||
+                !(toCoin instanceof Coin) ||
+                typeof amount !== "string" ||
+                typeof toAddress !== "string" ||
+                typeof refundAddress !== "string" ||
+                typeof clientIpAddress != "string" ||
+                typeof fixed != "boolean"
+            ) {
+                throw new Error(
+                    `Invalid input: ${fromCoin} ${toCoin} ${amount} ${toAddress} ${refundAddress} ${fixed}`
+                );
+            }
+            if (typeof rawSwapData !== "object" || (fixed && !rawSwapData.rate_id)) {
+                throw new Error(`Invalid raw swap data: ${safeStringify(rawSwapData)}`);
+            }
+            const fromCoinDetails = this._supportedCoins.find(i => i.coin?.ticker === fromCoin?.ticker);
+            const toCoinDetails = this._supportedCoins.find(i => i.coin?.ticker === toCoin?.ticker);
+            if (!fromCoinDetails || !toCoinDetails) {
+                throw new Error("Failed to find coin details for: " + fromCoin.ticker + " -> " + toCoin.ticker);
+            }
+            const requestBody = {
+                coin_from: fromCoinDetails.code,
+                network_from: fromCoinDetails.network,
+                coin_to: toCoinDetails.code,
+                network_to: toCoinDetails.network,
+                withdrawal: toAddress,
+                withdrawal_extra_id: toCurrencyExtraId,
+                return: refundAddress,
+                return_extra_id: refundExtraId,
+                affiliate_id: LetsExchangeSwapProvider.AFFILIATE_ID,
+            };
+            if (amountIsToReceive) {
+                requestBody.withdrawal_amount = amount;
+            } else {
+                requestBody.deposit_amount = amount;
+            }
+            if (fixed) {
+                requestBody.rate_id = rawSwapData.rate_id;
+            }
+            const response = await axios.post(
+                `${this._URL}/v1/transaction${amountIsToReceive ? "-revert" : `?float=${!fixed}`}`,
+                requestBody
+            );
+            const result = response.data;
+            Logger.log(`Creation result ${safeStringify(result)}`, loggerSource);
+
+            if (result?.transaction_id) {
+                const rate = BigNumber(result.rate ?? 0).isZero()
+                    ? BigNumber(result.withdrawal_amount).div(result.deposit_amount)
+                    : BigNumber(result.rate);
+
+                return {
+                    result: true,
+                    swapId: result.transaction_id,
+                    fromCoin: fromCoin,
+                    fromAmount: AmountUtils.trim(result.deposit_amount, fromCoin.digits),
+                    fromAddress: result.deposit,
+                    toCoin: toCoin,
+                    toAmount: AmountUtils.trim(result.withdrawal_amount, toCoin.digits),
+                    toAddress: result.withdrawal,
+                    fromCurrencyExtraId: result.deposit_extra_id ?? "",
+                    rate: AmountUtils.trim(rate, this._maxRateDigits),
+                    fixed: !result.is_float,
+                };
+            }
+
+            const errorMessage = `Swap creation succeeded but the response is wrong: ${safeStringify(response)}`;
+            Logger.log(errorMessage, loggerSource);
+            throw new Error(errorMessage);
+        } catch (e) {
+            Logger.logError(e, loggerSource, `Failed to create swap. Error is: ${safeStringify(e)}`);
+            const composeFailResult = reason => ({
+                result: false,
+                reason: reason,
+            });
+            const status = e?.response?.status;
+            const data = e?.response?.data;
+            if (status === 429) {
+                Logger.log(`Returning fail - RPS limit exceeded ${data}`, loggerSource);
+                return composeFailResult(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+            }
+            // TODO: [feature, low] add custom errors handling - waiting for response from letsexchange. task_id=00d2e435f6df4fb99af912135bd9ee27
+            //  422 - missing params
+            Logger.log(`Internal error for swap: ${safeStringify(e)}`, loggerSource);
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    async getExistingSwapsDetailsAndStatus(swapIds) {
+        const loggerSource = "getExistingSwapsDetailsAndStatus";
+        try {
+            if (swapIds.find(id => typeof id !== "string")) {
+                throw new Error("Swap id is not string: " + safeStringify(swapIds));
+            }
+            const response = await axios.get(`${this._URL}/v1/transactions-list?ids[]=${swapIds.join("&ids[]=")}`);
+
+            Logger.log("All swaps RAW: " + safeStringify(response.data), loggerSource);
+            const swaps = response.data
+                .map((swap, index) => {
+                    const fromCoin = this._supportedCoins.find(
+                        i => i.code === swap.coin_from && i.network === swap.coin_from_network
+                    )?.coin;
+                    const toCoin = this._supportedCoins.find(
+                        i => i.code === swap.coin_to && i.network === swap.coin_to_network
+                    )?.coin;
+                    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 = swap.expired_at ? swap.expired_at * 1000 : null;
+                    const createdAt = swap.created_at ? toUtcTimestamp(`${swap.created_at}`) : null;
+                    const isExpiredByTime = expiresAt && expiresAt < Date.now();
+                    const status = this._mapLetsExchangeStatusToRabbitStatus(swap.status, isExpiredByTime);
+                    const toDigits = status === SwapProvider.SWAP_STATUSES.REFUNDED ? fromCoin.digits : toCoin.digits;
+                    return new ExistingSwap(
+                        swapIds[index],
+                        status,
+                        createdAt,
+                        expiresAt,
+                        swap.confirmations,
+                        AmountUtils.trim(swap.rate, this._maxRateDigits),
+                        swap.is_float != null ? !swap.is_float : false,
+                        swap.return,
+                        swap.deposit,
+                        fromCoin,
+                        AmountUtils.trim(swap.deposit_amount, fromCoin.digits),
+                        swap.hash_in,
+                        swap.hash_in ? `${swap.coin_from_explorer_url}${swap.hash_in}` : null,
+                        toCoin,
+                        AmountUtils.trim(swap.withdrawal_amount, toDigits),
+                        swap.hash_out,
+                        swap.hash_out ? `${swap.coin_to_explorer_url}${swap.hash_out}` : null,
+                        swap.withdrawal,
+                        "letsexchange",
+                        swap.deposit_extra_id ?? null,
+                        swap.withdrawal_extra_id ?? null,
+                        swap.return_extra_id ?? null
+                    );
+                })
+                .flat();
+            Logger.log(`Swap details result ${safeStringify(swaps)}`, loggerSource);
+            return { result: true, swaps: swaps };
+        } catch (e) {
+            Logger.logError(e, loggerSource, `Failed to get swap details. Error is: ${safeStringify(e)}`);
+            const composeFailResult = reason => ({
+                result: false,
+                reason: reason,
+            });
+            const status = e?.response?.status;
+            const data = e?.response?.data;
+            if (status === 429) {
+                Logger.log(`Returning fail - RPS limit exceeded ${data}`, loggerSource);
+                return composeFailResult(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+            }
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    // TODO: [dev] Serg, please check this during the review to make sure I did no mistakes in statuses mapping.
+    //   I will remove these comments after the review. https://api.letsexchange.io/doc
+    // wait	The exchange has just been created and it’s waiting for coins to reach the deposit wallet
+    // confirmation	The transaction appears in mempool and now it is waiting for necessary network confirmations to start.
+    // confirmed	The user’s payment is confirmed, the exchange process is about to start.
+    // exchanging	The exchange process is running.
+    // sending	Funds are being sent to the recipient`s address.
+    // sending_confirmation	The outgoing transaction is waiting for network confirmations.
+    // success	The exchange is completed and the funds are successfully sent to the recipient’s address.
+    // aml_check_failed	The deposit was marked as risky by AML check service.
+    // overdue	The deposit receiving time for this transaction has expired.
+    // error	The transaction has failed. In most cases, the amount that was sent differs from the amount that was specified when creating the transaction.
+    // refund	The exchange failed and the coins were refunded to the user's wallet.
+    _mapLetsExchangeStatusToRabbitStatus(status, isExpiredByTime) {
+        switch (status) {
+            case "wait":
+                if (isExpiredByTime) {
+                    return SwapProvider.SWAP_STATUSES.EXPIRED;
+                }
+                return SwapProvider.SWAP_STATUSES.WAITING_FOR_PAYMENT;
+            case "confirmation":
+                return SwapProvider.SWAP_STATUSES.CONFIRMING;
+            case "confirmed":
+                return SwapProvider.SWAP_STATUSES.PAYMENT_RECEIVED;
+            case "exchanging":
+                return SwapProvider.SWAP_STATUSES.EXCHANGING;
+            case "sending":
+                return SwapProvider.SWAP_STATUSES.PAYMENT_RECEIVED;
+            case "sending_confirmation":
+                return SwapProvider.SWAP_STATUSES.EXCHANGING;
+            case "success":
+                return SwapProvider.SWAP_STATUSES.COMPLETED;
+            case "refund":
+                return SwapProvider.SWAP_STATUSES.REFUNDED;
+            case "overdue":
+                return SwapProvider.SWAP_STATUSES.EXPIRED;
+            case "aml_check_failed":
+                return SwapProvider.SWAP_STATUSES.EXCHANGING;
+            case "error":
+                return SwapProvider.SWAP_STATUSES.FAILED;
+            default:
+                throw new Error(`Unknown LetsExchange status: ${status}`);
+        }
+    }
+}