@rabbitio/ui-kit 1.0.0-beta.64 → 1.0.0-beta.66

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

@@ -14,12 +14,7 @@ import { FALLBACK_ASSET_ICON_URL } from "../../constants/globalConstants.jsx";
 export const BANNED_PARTNERS = ["stealthex", "changee", "coincraddle"];
 
 export class SwapspaceSwapProvider extends SwapProvider {
-    constructor(
-        apiKeysProxyUrl,
-        cache,
-        customCoinBuilder = (coin, network) => null,
-        useRestrictedCoinsSet = true
-    ) {
+    constructor(apiKeysProxyUrl, cache, customCoinBuilder = (coin, network) => null, useRestrictedCoinsSet = true) {
         super();
         this._supportedCoins = [];
         this._URL = `${apiKeysProxyUrl}`;
@@ -39,15 +34,10 @@ export class SwapspaceSwapProvider extends SwapProvider {
         const loggerSource = "getDepositCurrencies";
         try {
             await this._fetchSupportedCurrenciesIfNeeded();
-            Logger.log(
-                `We have ${this._supportedCoins?.length} supported coins, getting depositable`,
-                loggerSource
-            );
+            Logger.log(`We have ${this._supportedCoins?.length} supported coins, getting depositable`, loggerSource);
             return {
                 result: true,
-                coins: this._supportedCoins
-                    .filter((item) => item.deposit)
-                    .map((item) => item.coin),
+                coins: this._supportedCoins.filter(item => item.deposit).map(item => item.coin),
             };
         } catch (e) {
             if (e?.response?.status === 429) {
@@ -64,13 +54,10 @@ export class SwapspaceSwapProvider extends SwapProvider {
         const loggerSource = "getAllSupportedCurrencies";
         try {
             await this._fetchSupportedCurrenciesIfNeeded();
-            Logger.log(
-                `We have ${this._supportedCoins?.length} supported coins returning`,
-                loggerSource
-            );
+            Logger.log(`We have ${this._supportedCoins?.length} supported coins returning`, loggerSource);
             return {
                 result: true,
-                coins: this._supportedCoins.map((item) => item.coin),
+                coins: this._supportedCoins.map(item => item.coin),
             };
         } catch (e) {
             if (e?.response?.status === 429) {
@@ -87,20 +74,14 @@ export class SwapspaceSwapProvider extends SwapProvider {
         const loggerSource = "getWithdrawalCurrencies";
         try {
             await this._fetchSupportedCurrenciesIfNeeded();
-            Logger.log(
-                `We have ${this._supportedCoins?.length} supported coins, getting withdrawable`,
-                loggerSource
-            );
+            Logger.log(`We have ${this._supportedCoins?.length} supported coins, getting withdrawable`, loggerSource);
             return {
                 result: true,
                 coins: this._supportedCoins
                     .filter(
-                        (item) =>
-                            item.withdrawal &&
-                            (!exceptCurrency ||
-                                item.coin?.ticker !== exceptCurrency?.ticker)
+                        item => item.withdrawal && (!exceptCurrency || item.coin?.ticker !== exceptCurrency?.ticker)
                     )
-                    .map((item) => item.coin),
+                    .map(item => item.coin),
             };
         } catch (e) {
             if (e?.response?.status === 429) {
@@ -122,14 +103,11 @@ export class SwapspaceSwapProvider extends SwapProvider {
         try {
             let coin = coinOrTicker;
             if (!(coinOrTicker instanceof Coin)) {
-                coin = this._supportedCoins.find(
-                    (i) => i.coin.ticker === coinOrTicker
-                )?.coin;
+                coin = this._supportedCoins.find(i => i.coin.ticker === coinOrTicker)?.coin;
             }
             return (
-                this._supportedCoins.find(
-                    (item) => item.coin?.ticker === coin?.ticker
-                )?.iconURL ?? FALLBACK_ASSET_ICON_URL
+                this._supportedCoins.find(item => item.coin?.ticker === coin?.ticker)?.iconURL ??
+                FALLBACK_ASSET_ICON_URL
             );
         } catch (e) {
             improveAndRethrow(e, loggerSource);
@@ -140,22 +118,14 @@ export class SwapspaceSwapProvider extends SwapProvider {
         const loggerSource = "_fetchSupportedCurrenciesIfNeeded";
         try {
             if (!this._supportedCoins?.length) {
-                const rawResponse = await axios.get(
-                    `${this._URL}/api/v2/currencies`
-                );
-                Logger.log(
-                    `Retrieved ${rawResponse?.data?.length}`,
-                    loggerSource
-                );
+                const rawResponse = await axios.get(`${this._URL}/api/v2/currencies`);
+                Logger.log(`Retrieved ${rawResponse?.data?.length}`, loggerSource);
                 let allowedCoins = rawResponse?.data ?? [];
                 Logger.log(`Allowed cnt ${allowedCoins.length}`, loggerSource);
 
                 this._supportedCoins = allowedCoins
-                    .map((item) => {
-                        let coin = this._customCoinBuilder(
-                            item.code,
-                            item.network
-                        );
+                    .map(item => {
+                        let coin = this._customCoinBuilder(item.code, item.network);
                         if (!coin && !this.useRestrictedCoinsSet) {
                             /** Building coin object for coin that isn't supported OOB in Rabbit.
                              * We are doing this way to be able to use extended coins set for swaps.
@@ -179,9 +149,7 @@ export class SwapspaceSwapProvider extends SwapProvider {
                                 // Rolling back to original name if our processing leads in empty name
                                 name = item.name;
                             }
-                            const ticker = `${code}${
-                                code === network ? "" : network
-                            }`;
+                            const ticker = `${code}${code === network ? "" : network}`;
                             const defaultDecimalPlacesForCoinNotSupportedOOB = 8;
                             const defaultMinConfirmationsForCoinNotSupportedOOB = 1;
                             coin = new Coin(
@@ -239,11 +207,7 @@ export class SwapspaceSwapProvider extends SwapProvider {
         this._supportedCoins.sort((i1, i2) => {
             if (i1.isPopular && !i2.isPopular) return -1;
             if (i2.isPopular && !i1.isPopular) return 1;
-            return i1.coin.ticker > i2.coin.ticker
-                ? 1
-                : i1.coin.ticker < i2.coin.ticker
-                  ? -1
-                  : 0;
+            return i1.coin.ticker > i2.coin.ticker ? 1 : i1.coin.ticker < i2.coin.ticker ? -1 : 0;
         });
     }
 
@@ -255,15 +219,11 @@ export class SwapspaceSwapProvider extends SwapProvider {
             await this._fetchSupportedCurrenciesIfNeeded();
 
             // Using USDT TRC20 as usually fee in this network is smaller than ERC20 and this network is widely used for USDT
-            const usdtTrc20 = this._supportedCoins.find(
-                (i) => i.coin.ticker === "USDTTRC20"
-            )?.coin;
+            const usdtTrc20 = this._supportedCoins.find(i => i.coin.ticker === "USDTTRC20")?.coin;
             if (!usdtTrc20) {
                 return { result: false };
             }
-            const cached = this._cache.get(
-                "swapspace_usdt_rate_" + coin.ticker
-            );
+            const cached = this._cache.get("swapspace_usdt_rate_" + coin.ticker);
             if (cached != null) {
                 return {
                     result: true,
@@ -271,27 +231,15 @@ export class SwapspaceSwapProvider extends SwapProvider {
                 };
             }
 
-            Logger.log(
-                "Loading USDT->coin rate as not found in cache:",
-                coin?.ticker
-            );
-            const result = await this.getSwapInfo(
-                usdtTrc20,
-                coin,
-                "5000",
-                false
-            );
+            Logger.log("Loading USDT->coin rate as not found in cache:", coin?.ticker);
+            const result = await this.getSwapInfo(usdtTrc20, coin, "5000", false);
             if (!result.result) {
                 return { result: false };
             }
 
             // This calculation is not precise as we cannot recognize the actual fee and network fee. Just approximate.
             const standardSwapspaceFeeMultiplier = 1.004; // fee is usually 0.4%
-            const rate = BigNumber(1)
-                .div(
-                    BigNumber(result.rate).times(standardSwapspaceFeeMultiplier)
-                )
-                .toString();
+            const rate = BigNumber(1).div(BigNumber(result.rate).times(standardSwapspaceFeeMultiplier)).toString();
             this._cache.put(
                 "swapspace_usdt_rate_" + coin.ticker,
                 rate,
@@ -308,22 +256,14 @@ export class SwapspaceSwapProvider extends SwapProvider {
 
     getCoinByTickerIfPresent(ticker) {
         try {
-            const item = this._supportedCoins.find(
-                (i) => i.coin.ticker === ticker
-            );
+            const item = this._supportedCoins.find(i => i.coin.ticker === ticker);
             return item?.coin ?? null;
         } catch (e) {
             improveAndRethrow(e, "getCoinByTickerIfPresent");
         }
     }
 
-    async getSwapInfo(
-        fromCoin,
-        toCoin,
-        amountCoins,
-        fixed = false,
-        fromCoinToUsdRate = null
-    ) {
+    async getSwapInfo(fromCoin, toCoin, amountCoins, fixed = false, fromCoinToUsdRate = null) {
         const loggerSource = "getSwapInfo";
         try {
             if (
@@ -334,31 +274,19 @@ export class SwapspaceSwapProvider extends SwapProvider {
                 (fixed !== null && typeof fixed !== "boolean")
             ) {
                 throw new Error(
-                    `Wrong input params: ${amountCoins} ${fromCoin.ticker} -> ${
-                        toCoin.ticker
-                    }, ${fromCoin instanceof Coin}, ${
-                        toCoin instanceof Coin
-                    }, ${typeof fixed} ${fixed}`
+                    `Wrong input params: ${amountCoins} ${fromCoin.ticker} -> ${toCoin.ticker}, ${
+                        fromCoin instanceof Coin
+                    }, ${toCoin instanceof Coin}, ${typeof fixed} ${fixed}`
                 );
             }
-            const fromCoinSwapspaceDetails = this._supportedCoins.find(
-                (i) => i.coin?.ticker === fromCoin?.ticker
-            );
-            const toCoinSwapspaceDetails = this._supportedCoins.find(
-                (i) => i.coin?.ticker === toCoin?.ticker
-            );
+            const fromCoinSwapspaceDetails = this._supportedCoins.find(i => i.coin?.ticker === fromCoin?.ticker);
+            const toCoinSwapspaceDetails = this._supportedCoins.find(i => i.coin?.ticker === toCoin?.ticker);
             if (!fromCoinSwapspaceDetails || !toCoinSwapspaceDetails) {
                 throw new Error(
-                    "Failed to find swapspace coin details for: " +
-                        fromCoin.ticker +
-                        " -> " +
-                        toCoin.ticker
+                    "Failed to find swapspace coin details for: " + fromCoin.ticker + " -> " + toCoin.ticker
                 );
             }
-            if (
-                !fromCoinSwapspaceDetails.deposit ||
-                !toCoinSwapspaceDetails.withdrawal
-            ) {
+            if (!fromCoinSwapspaceDetails.deposit || !toCoinSwapspaceDetails.withdrawal) {
                 return {
                     result: false,
                     reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED,
@@ -371,53 +299,34 @@ export class SwapspaceSwapProvider extends SwapProvider {
             const response = await axios.get(
                 `${this._URL}/api/v2/amounts?fromCurrency=${fromCoinSwapspaceDetails.code}&fromNetwork=${fromCoinSwapspaceDetails.network}&toNetwork=${toCoinSwapspaceDetails.network}&toCurrency=${toCoinSwapspaceDetails.code}&amount=${amountCoins}&estimated=false`
             );
-            Logger.log(
-                `Retrieved ${response?.data?.length} options`,
-                loggerSource
-            );
+            Logger.log(`Retrieved ${response?.data?.length} options`, loggerSource);
             const options = Array.isArray(response.data) ? response.data : [];
-            let exchangesSupportingThePairDespiteFixedOrFloating =
-                options.filter(
-                    (exchange) =>
-                        exchange?.exists &&
-                        !BANNED_PARTNERS.find(
-                            (bannedPartner) =>
-                                bannedPartner === exchange?.partner
-                        ) &&
-                        (exchange?.fixed === false ||
-                            exchange?.fixed === true) &&
-                        (exchange.min === 0 ||
-                            exchange.max === 0 ||
-                            exchange.max > exchange.min ||
-                            ((typeof exchange.min !== "number" ||
-                                typeof exchange.max !== "number") &&
-                                exchange.toAmount > 0))
-                );
-            let exchangesSupportingThePair =
-                exchangesSupportingThePairDespiteFixedOrFloating;
+            // TODO: [feature, high] remove if possible over-engineering about toAmount = 0 options treating as supported but not available. task_id=404ae30d9a7743238af3cc0d3bae9239
+            let exchangesSupportingThePairDespiteFixedOrFloating = options.filter(
+                exchange =>
+                    exchange?.exists &&
+                    !BANNED_PARTNERS.find(bannedPartner => bannedPartner === exchange?.partner) &&
+                    (exchange?.fixed === false || exchange?.fixed === true) &&
+                    typeof exchange.min === "number" &&
+                    typeof exchange.max === "number" &&
+                    typeof exchange.toAmount === "number" &&
+                    exchange.toAmount > 0 &&
+                    (exchange.min === 0 || exchange.max === 0 || exchange.max > exchange.min)
+            );
+            let exchangesSupportingThePair = exchangesSupportingThePairDespiteFixedOrFloating;
             if (fixed != null) {
-                exchangesSupportingThePair =
-                    exchangesSupportingThePairDespiteFixedOrFloating.filter(
-                        (option) => option.fixed === fixed
-                    );
+                exchangesSupportingThePair = exchangesSupportingThePairDespiteFixedOrFloating.filter(
+                    option => option.fixed === fixed
+                );
             }
-            Logger.log(
-                `${exchangesSupportingThePair?.length} of them have exist=true`,
-                loggerSource
-            );
+            Logger.log(`${exchangesSupportingThePair?.length} of them have exist=true`, loggerSource);
             if (exchangesSupportingThePair.length === 0) {
-                if (
-                    exchangesSupportingThePairDespiteFixedOrFloating.length >
-                        0 &&
-                    fixed !== null
-                ) {
+                if (exchangesSupportingThePairDespiteFixedOrFloating.length > 0 && fixed !== null) {
                     return {
                         result: false,
                         reason: fixed
-                            ? SwapProvider.NO_SWAPS_REASONS
-                                  .NO_FIXED_BUT_HAVE_FLOATING
-                            : SwapProvider.NO_SWAPS_REASONS
-                                  .NO_FLOATING_BUT_HAVE_FIXED,
+                            ? SwapProvider.NO_SWAPS_REASONS.NO_FIXED_BUT_HAVE_FLOATING
+                            : SwapProvider.NO_SWAPS_REASONS.NO_FLOATING_BUT_HAVE_FIXED,
                     };
                 }
                 return {
@@ -426,120 +335,67 @@ export class SwapspaceSwapProvider extends SwapProvider {
                 };
             }
             const availableExchanges = exchangesSupportingThePair.filter(
-                (exchange) =>
-                    typeof exchange?.toAmount === "number" &&
-                    exchange.toAmount > 0
-            );
-            Logger.log(
-                `Available (having amountTo): ${safeStringify(
-                    availableExchanges
-                )}`,
-                loggerSource
+                exchange => typeof exchange?.toAmount === "number" && exchange.toAmount > 0
             );
+            Logger.log(`Available (having amountTo): ${safeStringify(availableExchanges)}`, loggerSource);
             // min=0 or max=0 means there is no limit for the partner
             let smallestMin = null;
-            if (
-                exchangesSupportingThePair.find((ex) =>
-                    BigNumber(ex.min).isZero()
-                ) == null
-            ) {
+            if (exchangesSupportingThePair.find(ex => BigNumber(ex.min).isZero()) == null) {
                 smallestMin = exchangesSupportingThePair.reduce((prev, cur) => {
-                    if (
-                        typeof cur.min === "number" &&
-                        (prev === null || BigNumber(cur.min).lt(prev))
-                    )
+                    if (typeof cur.min === "number" && (prev === null || BigNumber(cur.min).lt(prev)))
                         return BigNumber(cur.min);
                     return prev;
                 }, null);
             }
             let greatestMax = null;
-            if (
-                exchangesSupportingThePair.find((ex) =>
-                    BigNumber(ex.max).isZero()
-                ) == null
-            ) {
+            if (exchangesSupportingThePair.find(ex => BigNumber(ex.max).isZero()) == null) {
                 greatestMax = exchangesSupportingThePair.reduce((prev, cur) => {
-                    if (
-                        typeof cur.max === "number" &&
-                        (prev === null || BigNumber(cur.max).gt(prev))
-                    )
+                    if (typeof cur.max === "number" && (prev === null || BigNumber(cur.max).gt(prev)))
                         return BigNumber(cur.max);
                     return prev;
                 }, null);
             }
             let extraCoinsToFitMinMax = "0";
-            if (
-                typeof fromCoinToUsdRate === "string" &&
-                BigNumber(fromCoinToUsdRate).gt("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
-                );
+                extraCoinsToFitMinMax = AmountUtils.trim(extraUsdToFitMinMax.div(fromCoinToUsdRate), fromCoin.digits);
             }
             if (smallestMin instanceof BigNumber) {
-                smallestMin = AmountUtils.trim(
-                    smallestMin.plus(extraCoinsToFitMinMax),
-                    fromCoin.digits
-                );
+                smallestMin = AmountUtils.trim(smallestMin.plus(extraCoinsToFitMinMax), fromCoin.digits);
             }
             if (greatestMax instanceof BigNumber) {
                 if (greatestMax > extraCoinsToFitMinMax) {
-                    greatestMax = AmountUtils.trim(
-                        greatestMax.minus(extraCoinsToFitMinMax),
-                        fromCoin.digits
-                    );
+                    greatestMax = AmountUtils.trim(greatestMax.minus(extraCoinsToFitMinMax), fromCoin.digits);
                 } else {
                     greatestMax = "0";
                 }
             }
 
             if (availableExchanges.length) {
-                const sorted = availableExchanges.sort(
-                    (op1, op2) => op2.toAmount - op1.toAmount
-                );
+                const sorted = availableExchanges.sort((op1, op2) => op2.toAmount - op1.toAmount);
                 const bestOpt = sorted[0];
-                Logger.log(
-                    `Returning first option after sorting: ${safeStringify(
-                        bestOpt
-                    )}`,
-                    loggerSource
-                );
+                Logger.log(`Returning first option after sorting: ${safeStringify(bestOpt)}`, loggerSource);
                 let max = null;
                 let min = null;
                 if (extraCoinsToFitMinMax != null) {
                     if (typeof bestOpt.max === "number" && bestOpt.max !== 0) {
-                        max = BigNumber(bestOpt.max).minus(
-                            extraCoinsToFitMinMax
-                        );
-                        max = AmountUtils.trim(
-                            max.lt(0) ? "0" : max,
-                            fromCoin.digits
-                        );
+                        max = BigNumber(bestOpt.max).minus(extraCoinsToFitMinMax);
+                        max = AmountUtils.trim(max.lt(0) ? "0" : max, fromCoin.digits);
                     }
                     if (typeof bestOpt.min === "number" && bestOpt.min !== 0) {
-                        min = AmountUtils.trim(
-                            BigNumber(bestOpt.min).plus(extraCoinsToFitMinMax),
-                            fromCoin.digits
-                        );
+                        min = AmountUtils.trim(BigNumber(bestOpt.min).plus(extraCoinsToFitMinMax), fromCoin.digits);
                     }
                 }
 
                 const rate =
-                    bestOpt.toAmount && bestOpt.fromAmount
-                        ? BigNumber(bestOpt.toAmount).div(bestOpt.fromAmount)
-                        : null;
+                    bestOpt.toAmount && bestOpt.fromAmount ? BigNumber(bestOpt.toAmount).div(bestOpt.fromAmount) : null;
                 return {
                     result: true,
                     min: min,
                     max: max,
                     smallestMin: smallestMin,
                     greatestMax: greatestMax,
-                    rate:
-                        rate != null
-                            ? AmountUtils.trim(rate, this._maxRateDigits)
-                            : null,
+                    rate: rate != null ? AmountUtils.trim(rate, this._maxRateDigits) : null,
                     durationMinutesRange: bestOpt.duration ?? null,
                     fixed: bestOpt.fixed,
                     rawSwapData: bestOpt,
@@ -556,10 +412,7 @@ export class SwapspaceSwapProvider extends SwapProvider {
                 smallestMin: smallestMin,
                 greatestMax: greatestMax,
             };
-            Logger.log(
-                `Returning result ${safeStringify(result)}`,
-                loggerSource
-            );
+            Logger.log(`Returning result ${safeStringify(result)}`, loggerSource);
             return result;
         } catch (e) {
             if (e?.response?.status === 429) {
@@ -568,12 +421,7 @@ export class SwapspaceSwapProvider extends SwapProvider {
                     reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
                 };
             }
-            Logger.log(
-                `Internal swapspace/rabbit error when getting swap options ${safeStringify(
-                    e
-                )}`,
-                loggerSource
-            );
+            Logger.log(`Internal swapspace/rabbit error when getting swap options ${safeStringify(e)}`, loggerSource);
             improveAndRethrow(e, loggerSource);
         }
     }
@@ -615,23 +463,16 @@ export class SwapspaceSwapProvider extends SwapProvider {
                 typeof rawSwapData?.toNetwork !== "string" ||
                 typeof rawSwapData?.id !== "string" // can be just empty
             ) {
-                throw new Error(
-                    `Invalid raw swap data: ${safeStringify(rawSwapData)}`
-                );
+                throw new Error(`Invalid raw swap data: ${safeStringify(rawSwapData)}`);
             }
 
-            const [fromCurrencyHasExtraId, toCurrencyHasExtraId] =
-                this._supportedCoins.reduce(
-                    (prev, coinData) => [
-                        coinData.coin.ticker === fromCoin.ticker
-                            ? coinData.hasExtraId
-                            : prev[0],
-                        coinData.coin.ticker === toCoin.ticker
-                            ? coinData.hasExtraId
-                            : prev[1],
-                    ],
-                    [false, false]
-                );
+            const [fromCurrencyHasExtraId, toCurrencyHasExtraId] = this._supportedCoins.reduce(
+                (prev, coinData) => [
+                    coinData.coin.ticker === fromCoin.ticker ? coinData.hasExtraId : prev[0],
+                    coinData.coin.ticker === toCoin.ticker ? coinData.hasExtraId : prev[1],
+                ],
+                [false, false]
+            );
             await this._fetchSupportedCurrenciesIfNeeded();
             const requestData = {
                 partner: partner,
@@ -644,27 +485,16 @@ export class SwapspaceSwapProvider extends SwapProvider {
                 fixed: fixed,
                 extraId: toCurrencyHasExtraId ? toCurrencyExtraId ?? "" : "",
                 // This param is not documented. But the refund is usually manual so this is not critical.
-                refundExtraId: fromCurrencyHasExtraId
-                    ? refundExtraId ?? ""
-                    : "",
+                refundExtraId: fromCurrencyHasExtraId ? refundExtraId ?? "" : "",
                 rateId: rawSwapData?.id,
                 userIp: clientIpAddress,
                 refund: refundAddress,
             };
 
-            Logger.log(
-                `Sending create request: ${safeStringify(requestData)}`,
-                loggerSource
-            );
-            const response = await axios.post(
-                `${this._URL}/api/v2/exchange`,
-                requestData
-            );
+            Logger.log(`Sending create request: ${safeStringify(requestData)}`, loggerSource);
+            const response = await axios.post(`${this._URL}/api/v2/exchange`, requestData);
             const result = response.data;
-            Logger.log(
-                `Creation result ${safeStringify(result)}`,
-                loggerSource
-            );
+            Logger.log(`Creation result ${safeStringify(result)}`, loggerSource);
 
             if (result?.id) {
                 if (
@@ -679,9 +509,7 @@ export class SwapspaceSwapProvider extends SwapProvider {
                  * rate 0/null/undefined we calculate it manually */
                 let rate = result.rate;
                 if (typeof rate !== "number" || BigNumber(rate).isZero()) {
-                    rate = BigNumber(result?.to?.amount).div(
-                        result?.from?.amount
-                    );
+                    rate = BigNumber(result?.to?.amount).div(result?.from?.amount);
                 } else {
                     rate = BigNumber(rate);
                 }
@@ -690,34 +518,22 @@ export class SwapspaceSwapProvider extends SwapProvider {
                     result: true,
                     swapId: result?.id,
                     fromCoin: fromCoin,
-                    fromAmount: AmountUtils.trim(
-                        result?.from?.amount,
-                        fromCoin.digits
-                    ),
+                    fromAmount: AmountUtils.trim(result?.from?.amount, fromCoin.digits),
                     fromAddress: result?.from?.address,
                     toCoin: toCoin,
-                    toAmount: AmountUtils.trim(
-                        result?.to?.amount,
-                        toCoin.digits
-                    ),
+                    toAmount: AmountUtils.trim(result?.to?.amount, toCoin.digits),
                     toAddress: result?.to?.address,
                     fromCurrencyExtraId: result?.from?.extraId ?? "",
                     rate: AmountUtils.trim(rate, this._maxRateDigits),
                     fixed: result.fixed,
                 };
             }
-            const errorMessage = `Swap creation succeeded but the response is wrong: ${safeStringify(
-                response
-            )}`;
+            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) => ({
+            Logger.logError(e, loggerSource, `Failed to create swap. Error is: ${safeStringify(e)}`);
+            const composeFailResult = reason => ({
                 result: false,
                 reason: reason,
                 partner: partner,
@@ -725,13 +541,8 @@ export class SwapspaceSwapProvider extends SwapProvider {
             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
-                );
+                Logger.log(`Returning fail - RPS limit exceeded ${data}`, loggerSource);
+                return composeFailResult(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
             }
             const texts422 = [
                 "Pair cannot be processed by",
@@ -743,23 +554,12 @@ export class SwapspaceSwapProvider extends SwapProvider {
             if (
                 typeof data === "string" &&
                 ((status === 403 && data.includes(text403)) ||
-                    (status === 422 &&
-                        texts422.find((text) => data.includes(text))))
+                    (status === 422 && texts422.find(text => data.includes(text))))
             ) {
-                Logger.log(
-                    `Returning retriable fail: ${status} - ${data}, ${partner}`,
-                    loggerSource
-                );
-                return composeFailResult(
-                    SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL
-                );
+                Logger.log(`Returning retriable fail: ${status} - ${data}, ${partner}`, loggerSource);
+                return composeFailResult(SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
             }
-            Logger.log(
-                `Internal swapspace/rabbit error for ${partner}: ${safeStringify(
-                    e
-                )}`,
-                loggerSource
-            );
+            Logger.log(`Internal swapspace/rabbit error for ${partner}: ${safeStringify(e)}`, loggerSource);
             improveAndRethrow(e, loggerSource);
         }
     }
@@ -795,60 +595,38 @@ export class SwapspaceSwapProvider extends SwapProvider {
     async getExistingSwapsDetailsAndStatus(swapIds) {
         const loggerSource = "getExistingSwapsDetailsAndStatus";
         try {
-            if (swapIds.find((id) => typeof id !== "string")) {
-                throw new Error(
-                    "Swap id is not string: " + safeStringify(swapIds)
-                );
+            if (swapIds.find(id => typeof id !== "string")) {
+                throw new Error("Swap id is not string: " + safeStringify(swapIds));
             }
-            const getNotFailingOn404 = async (swapId) => {
+            const getNotFailingOn404 = async swapId => {
                 try {
-                    return await axios.get(
-                        `${this._URL}/api/v2/exchange/${swapId}`
-                    );
+                    return await axios.get(`${this._URL}/api/v2/exchange/${swapId}`);
                 } catch (error) {
                     if (error?.response?.status === 404) return [];
                     throw error;
                 }
             };
-            const responses = await Promise.all(
-                swapIds.map((swapId) => getNotFailingOn404(swapId))
-            );
+            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: " + JSON.stringify(wo404.map(r => r.data)), loggerSource);
             const swaps = wo404
-                .map((r) => r.data)
+                .map(r => r.data)
                 .map((swap, index) => {
                     const fromCoin = this._supportedCoins.find(
-                        (i) =>
-                            i.code === swap.from.code &&
-                            i.network === swap.from.network
+                        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
+                        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
                     }
 
-                    const toUtcTimestamp = (timeStr) =>
-                        Date.parse(
-                            timeStr.match(/.+[Zz]$/) ? timeStr : `${timeStr}Z`
-                        );
+                    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 status = this._mapSwapspaceStatusToRabbitStatus(swap.status, isExpiredByTime);
+                    const toDigits = status === SwapProvider.SWAP_STATUSES.REFUNDED ? fromCoin.digits : toCoin.digits;
                     const addressToSendCoinsToSwapspace = swap.from.address;
                     return new ExistingSwap(
                         swapIds[index],
@@ -876,31 +654,19 @@ export class SwapspaceSwapProvider extends SwapProvider {
                     );
                 })
                 .flat();
-            Logger.log(
-                `Swap details result ${safeStringify(swaps)}`,
-                loggerSource
-            );
+            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) => ({
+            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
-                );
+                Logger.log(`Returning fail - RPS limit exceeded ${data}`, loggerSource);
+                return composeFailResult(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
             }
             improveAndRethrow(e, loggerSource);
         }
@@ -908,17 +674,12 @@ export class SwapspaceSwapProvider extends SwapProvider {
 
     isAddressValidForAsset(asset, address) {
         try {
-            const assetData = this._supportedCoins.find(
-                (i) => i.coin?.ticker === asset?.ticker
-            );
+            const assetData = this._supportedCoins.find(i => i.coin?.ticker === asset?.ticker);
             if (assetData) {
                 let corrected = assetData.validationRegexp.trim();
+                corrected = corrected[0] === "/" ? corrected.slice(1) : corrected;
                 corrected =
-                    corrected[0] === "/" ? corrected.slice(1) : corrected;
-                corrected =
-                    corrected[corrected.length - 1] === "/"
-                        ? corrected.slice(0, corrected.length - 1)
-                        : corrected;
+                    corrected[corrected.length - 1] === "/" ? corrected.slice(0, corrected.length - 1) : corrected;
                 return address.match(corrected) != null;
             }
         } catch (e) {
@@ -929,14 +690,9 @@ export class SwapspaceSwapProvider extends SwapProvider {
 
     getExtraIdNameIfPresent(asset) {
         try {
-            const assetData = this._supportedCoins.find(
-                (i) => i.coin?.ticker === asset?.ticker
-            );
+            const assetData = this._supportedCoins.find(i => i.coin?.ticker === asset?.ticker);
             if (assetData?.hasExtraId) {
-                if (
-                    assetData?.extraIdName == null ||
-                    assetData?.extraIdName === ""
-                ) {
+                if (assetData?.extraIdName == null || assetData?.extraIdName === "") {
                     // We return some default name if the extraIdName is empty
                     return "ID";
                 }