@rango-dev/widget-embedded 0.12.1-next.2 → 0.12.1-next.21

package/src/utils/numbers.ts

@@ -1,5 +1,8 @@
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+
+import type { BestRouteResponse } from 'rango-sdk';
+
 import { BigNumber } from 'bignumber.js';
-import { BestRouteResponse } from 'rango-sdk';
 
 export const percentToString = (p: number, fractions = 0): string =>
   (p * 100).toFixed(fractions);
@@ -17,8 +20,12 @@ export const numberToString = (
   minDecimals: number | null = null,
   maxDecimals: number | null = null
 ): string => {
-  if (number === null || number === undefined) return '';
-  if (number === '') return '';
+  if (number === null || number === undefined) {
+    return '';
+  }
+  if (number === '') {
+    return '';
+  }
   const n = new BigNumber(number);
   const roundingMode = 1;
   let maxI = 1000;
@@ -29,8 +36,10 @@ export const numberToString = (
     }
   }
 
-  if (n.gte(10000)) return n.toFormat(0, roundingMode);
-  if (n.gte(1000))
+  if (n.gte(10000)) {
+    return n.toFormat(0, roundingMode);
+  }
+  if (n.gte(1000)) {
     return n.toFormat(
       Math.min(
         maxI,
@@ -38,7 +47,8 @@ export const numberToString = (
       ),
       roundingMode
     );
-  if (n.gte(100))
+  }
+  if (n.gte(100)) {
     return n.toFormat(
       Math.min(
         maxI,
@@ -46,7 +56,8 @@ export const numberToString = (
       ),
       roundingMode
     );
-  if (n.gte(1))
+  }
+  if (n.gte(1)) {
     return n.toFormat(
       Math.min(
         maxI,
@@ -54,7 +65,8 @@ export const numberToString = (
       ),
       roundingMode
     );
-  if (n.gte(0.01))
+  }
+  if (n.gte(0.01)) {
     return n.toFormat(
       Math.min(
         maxI,
@@ -62,8 +74,9 @@ export const numberToString = (
       ),
       roundingMode
     );
-  for (let i = minDecimals || 4; i < 17; i++)
-    if (n.gte(Math.pow(10, -i)))
+  }
+  for (let i = minDecimals || 4; i < 17; i++) {
+    if (n.gte(Math.pow(10, -i))) {
       return n.toFormat(
         Math.min(
           maxI,
@@ -71,7 +84,11 @@ export const numberToString = (
         ),
         roundingMode
       );
-  if (n.isEqualTo(0)) return '0';
+    }
+  }
+  if (n.isEqualTo(0)) {
+    return '0';
+  }
 
   return n.toFormat(
     Math.min(maxI, Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 8))),
@@ -94,18 +111,32 @@ export const uint8ArrayToHex = (buffer: Uint8Array): string => {
 };
 
 export function dollarToConciseString(num: number | undefined): string {
-  if (!num) return '-';
-  if (num < 1) return ' < 1$';
-  if (num < 1000) return numberToString(new BigNumber(num)) + '$';
-  if (num < 10_000) return parseInt((num / 100).toString()) / 10 + 'K';
-  if (num < 1_000_000) return parseInt((num / 1000).toString()) + 'K';
-  if (num < 100_000_000) return parseInt((num / 100000).toString()) / 10 + 'M';
+  if (!num) {
+    return '-';
+  }
+  if (num < 1) {
+    return ' < 1$';
+  }
+  if (num < 1000) {
+    return numberToString(new BigNumber(num)) + '$';
+  }
+  if (num < 10_000) {
+    return parseInt((num / 100).toString()) / 10 + 'K';
+  }
+  if (num < 1_000_000) {
+    return parseInt((num / 1000).toString()) + 'K';
+  }
+  if (num < 100_000_000) {
+    return parseInt((num / 100000).toString()) / 10 + 'M';
+  }
   return parseInt((num / 1000000).toString()) + 'M';
 }
 
 export function removeExtraDecimals(num: string, maxDecimals: number): string {
   try {
-    if (!num.includes('.')) return num;
+    if (!num.includes('.')) {
+      return num;
+    }
     const [b, f] = num.split('.');
     if (f && f.length > maxDecimals) {
       return `${b}.${f.substring(0, maxDecimals)}`;
@@ -134,3 +165,17 @@ export const containsText = (text: string, searchText: string) =>
 export const isPositiveNumber = (text?: string) =>
   !!text && parseFloat(text) > 0;
 10;
+
+export function limitDecimalPlaces(
+  numberString: string,
+  maxDecimalPlaces = 4
+): string {
+  const number = parseFloat(numberString);
+  if (isNaN(number)) {
+    return numberString;
+  } // Return the original string if it's not a valid number
+
+  const multiplier = Math.pow(10, maxDecimalPlaces);
+  const roundedNumber = Math.round(number * multiplier) / multiplier;
+  return roundedNumber.toString();
+}

package/src/utils/routing.ts

@@ -1,29 +1,50 @@
-import {
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+import type { BestRouteEqualityParams, Wallet } from '../types';
+import type { PendingSwap } from '@rango-dev/queue-manager-rango-preset';
+import type { PriceImpactWarningLevel } from '@rango-dev/ui';
+import type {
   SimulationAssetAndAmount,
   SimulationValidationStatus,
 } from '@rango-dev/ui/dist/widget/ui/src/types/swaps';
+import type {
+  Asset,
+  BestRouteResponse,
+  BlockchainMeta,
+  Token,
+} from 'rango-sdk';
+
 import BigNumber from 'bignumber.js';
-import { BestRouteResponse, BlockchainMeta, Token } from 'rango-sdk';
+
+import {
+  GAS_FEE_MAX_DECIMALS,
+  GAS_FEE_MIN_DECIMALS,
+  HIGHT_PRICE_IMPACT,
+  LOW_PRICE_IMPACT,
+  TOKEN_AMOUNT_MAX_DECIMALS,
+  TOKEN_AMOUNT_MIN_DECIMALS,
+} from '../constants/routing';
+
 import { areEqual } from './common';
-import { BestRouteEqualityParams, Wallet } from '../types';
 import { numberToString } from './numbers';
-import { PendingSwap } from '@rango-dev/queue-manager-rango-preset';
 
 export function searchParamsToToken(
   tokens: Token[],
   searchParams: string | null,
   chain: BlockchainMeta | null
 ): Token | null {
-  if (!chain) return null;
+  if (!chain) {
+    return null;
+  }
   return (
     tokens.find((token) => {
       const symbolAndAddress = searchParams?.split('--');
-      if (symbolAndAddress?.length === 1)
+      if (symbolAndAddress?.length === 1) {
         return (
           token.symbol === symbolAndAddress[0] &&
           token.address === null &&
           token.blockchain === chain.name
         );
+      }
       return (
         token.symbol === symbolAndAddress?.[0] &&
         token.address === symbolAndAddress?.[1] &&
@@ -98,14 +119,18 @@ export function getRequiredBalanceOfWallet(
   selectedWallet: Wallet,
   fee: SimulationValidationStatus[] | null
 ): SimulationAssetAndAmount[] | null {
-  if (fee === null) return null;
+  if (fee === null) {
+    return null;
+  }
   const relatedFeeStatus = fee
     ?.find((item) => item.blockchain === selectedWallet.chain)
     ?.wallets.find(
       (wallet) =>
         wallet.address?.toLowerCase() === selectedWallet.address.toLowerCase()
     );
-  if (!relatedFeeStatus) return null;
+  if (!relatedFeeStatus) {
+    return null;
+  }
   return relatedFeeStatus.requiredAssets;
 }
 
@@ -115,8 +140,8 @@ export function isRouteParametersChanged(params: BestRouteEqualityParams) {
     return (
       !!currentState.fromToken &&
       !!currentState.toToken &&
-      (prevState.fromChain?.name !== currentState.fromChain?.name ||
-        prevState.toChain?.name !== currentState.toChain?.name ||
+      (prevState.fromBlockchain?.name !== currentState.fromBlockchain?.name ||
+        prevState.toBlockchain?.name !== currentState.toBlockchain?.name ||
         prevState.fromToken?.symbol !== currentState.fromToken?.symbol ||
         prevState.toToken?.symbol !== currentState.toToken?.symbol ||
         prevState.fromToken?.blockchain !== prevState.fromToken?.blockchain ||
@@ -139,47 +164,100 @@ export function isRouteParametersChanged(params: BestRouteEqualityParams) {
   return false;
 }
 
-export function getFormatedBestRoute(
+export function getFormattedBestRoute(
   bestRoute: BestRouteResponse | null
 ): BestRouteResponse | null {
-  if (!bestRoute) return null;
+  if (!bestRoute) {
+    return null;
+  }
 
-  const formatedSwaps = (bestRoute.result?.swaps || []).map((swap) => ({
+  const formattedSwaps = (bestRoute.result?.swaps || []).map((swap) => ({
     ...swap,
-    fromAmount: numberToString(swap.fromAmount, 6, 6),
-    toAmount: numberToString(swap.toAmount, 6, 6),
+    fromAmount: numberToString(
+      swap.fromAmount,
+      TOKEN_AMOUNT_MIN_DECIMALS,
+      TOKEN_AMOUNT_MAX_DECIMALS
+    ),
+    toAmount: numberToString(
+      swap.toAmount,
+      TOKEN_AMOUNT_MIN_DECIMALS,
+      TOKEN_AMOUNT_MAX_DECIMALS
+    ),
   }));
 
   return {
     ...bestRoute,
     ...(bestRoute.result && {
-      result: { ...bestRoute.result, swaps: formatedSwaps },
+      result: { ...bestRoute.result, swaps: formattedSwaps },
     }),
   };
 }
 
-export function getFormatedPendingSwap(pendingSwap: PendingSwap): PendingSwap {
-  const formatedSteps = pendingSwap.steps.map((step) => ({
+export function getFormattedPendingSwap(pendingSwap: PendingSwap): PendingSwap {
+  const formattedSteps = pendingSwap.steps.map((step) => ({
     ...step,
-    feeInUsd: numberToString(step.feeInUsd, 4, 4),
-    outputAmount: numberToString(step.outputAmount, 6, 6),
+    feeInUsd: numberToString(
+      step.feeInUsd,
+      GAS_FEE_MIN_DECIMALS,
+      GAS_FEE_MAX_DECIMALS
+    ),
+    outputAmount: numberToString(
+      step.outputAmount,
+      TOKEN_AMOUNT_MIN_DECIMALS,
+      TOKEN_AMOUNT_MAX_DECIMALS
+    ),
     expectedOutputAmountHumanReadable: numberToString(
       step.expectedOutputAmountHumanReadable,
-      6,
-      6
+      TOKEN_AMOUNT_MIN_DECIMALS,
+      TOKEN_AMOUNT_MAX_DECIMALS
     ),
   }));
 
   return {
     ...pendingSwap,
-    inputAmount: numberToString(pendingSwap.inputAmount, 6, 6),
-    steps: formatedSteps,
+    inputAmount: numberToString(
+      pendingSwap.inputAmount,
+      TOKEN_AMOUNT_MIN_DECIMALS,
+      TOKEN_AMOUNT_MAX_DECIMALS
+    ),
+    steps: formattedSteps,
   };
 }
 
 //todo: refactor bestRoute store and add loadingStatus
 export const getBestRouteStatus = (loading: boolean, error: boolean) => {
-  if (loading) return 'loading';
-  if (error) return 'failed';
-  else return 'success';
+  if (loading) {
+    return 'loading';
+  }
+  if (error) {
+    return 'failed';
+  }
+  return 'success';
 };
+
+export function getPriceImpactLevel(
+  priceImpact: number
+): PriceImpactWarningLevel {
+  let warningLevel: PriceImpactWarningLevel = undefined;
+  if (priceImpact <= LOW_PRICE_IMPACT && priceImpact > HIGHT_PRICE_IMPACT) {
+    warningLevel = 'low';
+  } else if (priceImpact <= HIGHT_PRICE_IMPACT) {
+    warningLevel = 'high';
+  }
+
+  return warningLevel;
+}
+
+export function findCommonTokens<T extends Asset[], R extends Asset[]>(
+  listA: T,
+  listB: R
+) {
+  const tokenToString = (token: Asset): string =>
+    `${token.symbol}-${token.blockchain}-${token.address ?? ''}`;
+
+  const set = new Set();
+
+  listA.forEach((token) => set.add(tokenToString(token)));
+
+  return listB.filter((token) => set.has(tokenToString(token))) as R;
+}

package/src/utils/settings.ts

@@ -0,0 +1,57 @@
+import { useMetaStore } from '../store/meta';
+import { useSettingsStore } from '../store/settings';
+
+import { removeDuplicateFrom } from './common';
+
+export type LiquiditySourceType = 'BRIDGE' | 'AGGREGATOR' | 'DEX';
+
+export type UniqueSwappersGroupType = {
+  id: string;
+  groupTitle: string;
+  logo: string;
+  type: LiquiditySourceType;
+  selected: boolean;
+};
+
+export function getUniqueSwappersGroups(
+  supportedSwappers?: string[]
+): UniqueSwappersGroupType[] {
+  const swappers = useMetaStore.use.meta().swappers;
+  const disabledLiquiditySources =
+    useSettingsStore.use.disabledLiquiditySources();
+
+  const uniqueSupportedSwappersGroups: Array<UniqueSwappersGroupType> = [];
+
+  const uniqueGroup = removeDuplicateFrom(swappers.map((s) => s.swapperGroup));
+
+  uniqueGroup.map((uniqueGroupItem) => {
+    const swapperItem = swappers.find(
+      (swapper) => swapper.swapperGroup === uniqueGroupItem
+    );
+
+    if (swapperItem) {
+      let isSupportedSwapper = true;
+      if (supportedSwappers) {
+        isSupportedSwapper = supportedSwappers.some(
+          (supportedItem) => supportedItem === swapperItem.title
+        );
+      }
+
+      if (isSupportedSwapper) {
+        swapperItem.types.map((swapperTypeItem) => {
+          uniqueSupportedSwappersGroups.push({
+            id: swapperItem.swapperGroup,
+            groupTitle: swapperItem.swapperGroup,
+            logo: swapperItem.logo,
+            type: swapperTypeItem,
+            selected: !disabledLiquiditySources.includes(
+              swapperItem.swapperGroup
+            ),
+          });
+        });
+      }
+    }
+  });
+
+  return uniqueSupportedSwappersGroups;
+}