@rango-dev/widget-embedded 0.18.0 → 0.19.0

package/src/utils/swap.ts

@@ -1,13 +1,11 @@
 /* eslint-disable @typescript-eslint/no-magic-numbers */
-import type { FetchStatus } from '../store/slices/data';
+import type { LoadingStatus } from '../store/meta';
+import type { ConnectedWallet } from '../store/wallets';
+import type { ConvertedToken, SwapButtonState, Wallet } from '../types';
 import type {
-  ConvertedToken,
-  QuoteError,
-  QuoteWarning,
-  RecommendedSlippages,
-  SwapButtonState,
-  Wallet,
-} from '../types';
+  PendingSwap,
+  PendingSwapStep,
+} from '@rango-dev/queue-manager-rango-preset';
 import type { WalletType } from '@rango-dev/wallets-shared';
 import type {
   BestRouteRequest,
@@ -17,11 +15,10 @@ import type {
   SwapResult,
   Token,
 } from 'rango-sdk';
-import type { PendingSwap, PendingSwapStep } from 'rango-types';
 
 import { i18n } from '@lingui/core';
+import { PendingSwapNetworkStatus } from '@rango-dev/queue-manager-rango-preset';
 import BigNumber from 'bignumber.js';
-import { PendingSwapNetworkStatus } from 'rango-types';
 
 import { isValidAddress } from '../components/ConfirmWalletsModal/ConfirmWallets.helpers';
 import { errorMessages } from '../constants/errors';
@@ -33,11 +30,12 @@ import {
   TOKEN_AMOUNT_MAX_DECIMALS,
   TOKEN_AMOUNT_MIN_DECIMALS,
 } from '../constants/routing';
+import { useMetaStore } from '../store/meta';
+import { ButtonState } from '../types';
 
 import { removeDuplicateFrom } from './common';
-import { getBlockchainShortNameFor } from './meta';
 import { numberToString } from './numbers';
-import { getPriceImpact, getRequiredBalanceOfWallet } from './quote';
+import { getRequiredBalanceOfWallet } from './routing';
 import { getRequiredChains } from './wallets';
 
 export function getOutputRatio(
@@ -52,29 +50,25 @@ export function getOutputRatio(
   ) {
     return 0;
   }
-  return outputUsdValue
-    .div(inputUsdValue)
-    .minus(1)
-    .multipliedBy(100)
-    .toNumber();
+  return outputUsdValue.div(inputUsdValue).minus(1).multipliedBy(100);
 }
 
-export function hasHighValueLoss(
+export function outputRatioHasWarning(
   inputUsdValue: BigNumber | null,
-  priceImpact: number
+  outputRatio: BigNumber | 0
 ): boolean {
   return (
-    ((parseInt(priceImpact.toFixed(2) || '0') <= -10 &&
+    ((parseInt(outputRatio.toFixed(2) || '0') <= -10 &&
       inputUsdValue?.gte(new BigNumber(400))) ||
-      (parseInt(priceImpact.toFixed(2) || '0') <= -5 &&
+      (parseInt(outputRatio.toFixed(2) || '0') <= -5 &&
         inputUsdValue?.gte(new BigNumber(1000)))) ??
     false
   );
 }
 
-export function hasLimitError(quote: BestRouteResponse | null): boolean {
+export function hasLimitError(bestRoute: BestRouteResponse | null): boolean {
   return (
-    (quote?.result?.swaps || []).filter((swap) => {
+    (bestRoute?.result?.swaps || []).filter((swap) => {
       const minimum = !!swap.fromAmountMinValue
         ? new BigNumber(swap.fromAmountMinValue)
         : null;
@@ -89,12 +83,16 @@ export function hasLimitError(quote: BestRouteResponse | null): boolean {
     }).length > 0
   );
 }
-export function getLimitErrorMessage(quote: BestRouteResponse): {
-  swap: SwapResult;
+
+export function LimitErrorMessage(bestRoute: BestRouteResponse | null): {
+  swap: SwapResult | null;
   fromAmountRangeError: string;
   recommendation: string;
 } {
-  const swap = (quote.result?.swaps || []).filter((swap) => {
+  if (!bestRoute) {
+    return { swap: null, fromAmountRangeError: '', recommendation: '' };
+  }
+  const swap = (bestRoute?.result?.swaps || []).filter((swap) => {
     const minimum = !!swap.fromAmountMinValue
       ? new BigNumber(swap.fromAmountMinValue)
       : null;
@@ -107,7 +105,9 @@ export function getLimitErrorMessage(quote: BestRouteResponse): {
     }
     return minimum?.gt(swap.fromAmount) || maximum?.lt(swap.fromAmount);
   })[0];
-
+  if (!swap) {
+    return { swap: null, fromAmountRangeError: '', recommendation: '' };
+  }
   const minimum = !!swap.fromAmountMinValue
     ? new BigNumber(swap.fromAmountMinValue)
     : null;
@@ -177,92 +177,85 @@ export function getLimitErrorMessage(quote: BestRouteResponse): {
   return { swap, fromAmountRangeError, recommendation };
 }
 
-export function getSwapButtonState(params: {
-  fetchMetaStatus: FetchStatus;
-  anyWalletConnected: boolean;
-  fetchingQuote: boolean;
-  inputAmount: string;
-  quote: BestRouteResponse | null;
-  warning: QuoteWarning | null;
-  error: QuoteError | null;
-  needsToWarnEthOnPath: boolean;
-}): SwapButtonState {
-  const {
-    fetchMetaStatus,
-    anyWalletConnected,
-    fetchingQuote,
-    inputAmount,
-    quote,
-    warning,
-    error,
-    needsToWarnEthOnPath,
-  } = params;
-  if (fetchMetaStatus !== 'success') {
+export function getSwapButtonState(
+  loadingMetaStatus: LoadingStatus,
+  connectedWallets: ConnectedWallet[],
+  loading: boolean,
+  bestRoute: BestRouteResponse | null,
+  hasLimitError: boolean,
+  highValueLoss: boolean,
+  priceImpactCanNotBeComputed: boolean,
+  needsToWarnEthOnPath: boolean,
+  inputAmount: string
+): SwapButtonState {
+  if (loadingMetaStatus !== 'success') {
     return {
       title: swapButtonTitles().connectWallet,
-      action: 'connect-wallet',
+      state: ButtonState.WAITFORCONNECTING,
       disabled: true,
     };
   }
-  if (!anyWalletConnected) {
+  if (connectedWallets.length == 0) {
     return {
       title: swapButtonTitles().connectWallet,
-      action: 'connect-wallet',
+      state: ButtonState.WAITFORCONNECTING,
       disabled: false,
     };
   }
   if (
-    fetchingQuote ||
-    !quote ||
-    !quote.result ||
-    error ||
+    loading ||
+    !bestRoute ||
+    !bestRoute.result ||
+    hasLimitError ||
     !inputAmount ||
     inputAmount === '0'
   ) {
     return {
       title: swapButtonTitles().swap,
-      action: 'confirm-swap',
       disabled: true,
+      state: ButtonState.SWAP,
     };
-  } else if (warning) {
+  } else if (highValueLoss || priceImpactCanNotBeComputed) {
     return {
       title: swapButtonTitles().swapAnyway,
-      action: 'confirm-warning',
       disabled: false,
+      hasWarning: true,
+      state: ButtonState.NEEDTOCONFIRM,
     };
   } else if (needsToWarnEthOnPath) {
     return {
-      title: swapButtonTitles().ethWarning,
-      action: 'confirm-warning',
+      title: swapButtonTitles().ethRouteWarning,
       disabled: false,
+      hasWarning: true,
+      state: ButtonState.WARNING,
     };
   }
   return {
     title: swapButtonTitles().swap,
-    action: 'confirm-swap',
     disabled: false,
+    state: ButtonState.SWAP,
   };
 }
 
 export function canComputePriceImpact(
-  quote: BestRouteResponse | null,
+  bestRoute: BestRouteResponse | null,
   inputAmount: string,
   usdValue: BigNumber | null
 ) {
   return !(
     (!usdValue || usdValue.lte(ZERO)) &&
-    !!quote?.result &&
+    !!bestRoute?.result &&
     !!inputAmount &&
     inputAmount !== '0' &&
     parseFloat(inputAmount || '0') !== 0 &&
-    !!quote.result
+    !!bestRoute.result
   );
 }
 
-export function requiredWallets(quote: BestRouteResponse | null) {
+export function requiredWallets(route: BestRouteResponse | null) {
   const wallets: string[] = [];
 
-  quote?.result?.swaps.forEach((swap) => {
+  route?.result?.swaps.forEach((swap) => {
     const currentStepFromBlockchain = swap.from.blockchain;
     const currentStepToBlockchain = swap.to.blockchain;
     let lastAddedWallet = wallets[wallets.length - 1];
@@ -318,13 +311,15 @@ export function getUsdFeeOfStep(
 }
 
 export function getTotalFeeInUsd(
-  swaps: SwapResult[],
+  bestRoute: BestRouteResponse | null,
   allTokens: Token[]
-): BigNumber {
-  return swaps.reduce(
-    (totalFee: BigNumber, step) =>
-      totalFee.plus(getUsdFeeOfStep(step, allTokens)),
-    ZERO
+): BigNumber | null {
+  return (
+    bestRoute?.result?.swaps.reduce(
+      (totalFee: BigNumber, step) =>
+        totalFee.plus(getUsdFeeOfStep(step, allTokens)),
+      ZERO
+    ) || null
   );
 }
 
@@ -341,44 +336,10 @@ export function hasSlippageError(
   return (slippages?.filter((s) => !!s?.error)?.length || 0) > 0;
 }
 
-export function checkSlippageErrors(
-  quote: BestRouteResponse
-): RecommendedSlippages | null {
-  const recommendedSlippages: RecommendedSlippages = new Map();
-  quote.result?.swaps.forEach((swap, index) => {
-    if (swap.recommendedSlippage?.error) {
-      recommendedSlippages.set(index, swap.recommendedSlippage.slippage);
-    }
-  });
-  if (recommendedSlippages.size > 0) {
-    return recommendedSlippages;
-  }
-  return null;
-}
-
-export function checkSlippageWarnings(
-  quote: BestRouteResponse,
-  userSlippage: number
-): RecommendedSlippages | null {
-  const recommendedSlippages: RecommendedSlippages = new Map();
-  quote.result?.swaps.forEach((swap, index) => {
-    if (
-      swap.recommendedSlippage?.slippage &&
-      parseFloat(swap.recommendedSlippage.slippage) > userSlippage
-    ) {
-      recommendedSlippages.set(index, swap.recommendedSlippage.slippage);
-    }
-  });
-  if (recommendedSlippages.size > 0) {
-    return recommendedSlippages;
-  }
-  return null;
-}
-
 export function getMinRequiredSlippage(
-  quote: BestRouteResponse
+  route: BestRouteResponse
 ): string | null {
-  const slippages = quote.result?.swaps.map(
+  const slippages = route.result?.swaps.map(
     (slippage) => slippage.recommendedSlippage
   );
   return (
@@ -401,10 +362,10 @@ export function hasProperSlippage(
 }
 
 export function hasEnoughBalance(
-  quote: BestRouteResponse,
+  route: BestRouteResponse,
   selectedWallets: Wallet[]
 ) {
-  const fee = quote.validationStatus;
+  const fee = route.validationStatus;
 
   if (fee === null || fee.length === 0) {
     return true;
@@ -428,31 +389,29 @@ export function hasEnoughBalance(
 }
 
 export function hasEnoughBalanceAndProperSlippage(
-  quote: BestRouteResponse,
+  route: BestRouteResponse,
   selectedWallets: Wallet[],
   userSlippage: string,
   minRequiredSlippage: string | null
 ): boolean {
   return (
-    hasEnoughBalance(quote, selectedWallets) &&
+    hasEnoughBalance(route, selectedWallets) &&
     hasProperSlippage(userSlippage, minRequiredSlippage)
   );
 }
 
-export function createQuoteRequestBody(params: {
+export function createBestRouteRequestBody(params: {
   fromToken: Token;
   toToken: Token;
   inputAmount: string;
   wallets?: Wallet[];
   selectedWallets?: Wallet[];
-  liquiditySources?: string[];
-  excludeLiquiditySources?: boolean;
   disabledLiquiditySources: string[];
   slippage: number;
   affiliateRef: string | null;
   affiliatePercent: number | null;
   affiliateWallets: { [key: string]: string } | null;
-  initialQuote?: BestRouteResponse;
+  initialRoute?: BestRouteResponse;
   destination?: string;
 }): BestRouteRequest {
   const {
@@ -462,13 +421,11 @@ export function createQuoteRequestBody(params: {
     wallets,
     selectedWallets,
     disabledLiquiditySources,
-    liquiditySources,
-    excludeLiquiditySources,
     slippage,
     affiliateRef,
     affiliatePercent,
     affiliateWallets,
-    initialQuote,
+    initialRoute,
     destination,
   } = params;
   const selectedWalletsMap = selectedWallets?.reduce(
@@ -498,10 +455,10 @@ export function createQuoteRequestBody(params: {
     }
   });
 
-  const checkPrerequisites = !!initialQuote;
+  const checkPrerequisites = !!initialRoute;
 
   const filteredBlockchains = removeDuplicateFrom(
-    (initialQuote?.result?.swaps || []).reduce(
+    (initialRoute?.result?.swaps || []).reduce(
       (blockchains: string[], swap) => {
         blockchains.push(swap.from.blockchain, swap.to.blockchain);
         // Check if internalSwaps array exists
@@ -539,18 +496,13 @@ export function createQuoteRequestBody(params: {
     selectedWallets: selectedWalletsMap ?? {},
     slippage: slippage.toString(),
     ...(destination && { destination: destination }),
-    ...(excludeLiquiditySources && {
-      swapperGroups: disabledLiquiditySources.concat(liquiditySources ?? []),
+    ...(disabledLiquiditySources.length > 0 && {
+      swapperGroups: disabledLiquiditySources,
       swappersGroupsExclude: true,
     }),
-    ...(!excludeLiquiditySources && {
-      swapperGroups: liquiditySources?.filter(
-        (liquiditySource) => !disabledLiquiditySources.includes(liquiditySource)
-      ),
-      swappersGroupsExclude: false,
-    }),
     ...(checkPrerequisites && { blockchains: filteredBlockchains }),
   };
+
   return requestBody;
 }
 
@@ -574,42 +526,49 @@ export function getWalletsForNewSwap(selectedWallets: Wallet[]) {
   return wallets;
 }
 
-export function getQuoteOutputAmount(quote: BestRouteResponse) {
-  return quote.result?.outputAmount || null;
+export function getRouteOutputAmount(route: BestRouteResponse | null) {
+  return route?.result?.outputAmount || null;
 }
 
-export function getPercentageChange(input: string, output: string) {
-  return new BigNumber(output)
-    .div(new BigNumber(input))
+export function getPercentageChange(
+  inputUsdValue: string | number | null,
+  outputUsdValue: string | number | null
+) {
+  if (!inputUsdValue || !outputUsdValue) {
+    return null;
+  }
+  return new BigNumber(outputUsdValue)
+    .div(new BigNumber(inputUsdValue))
     .minus(1)
-    .multipliedBy(100)
-    .toNumber();
+    .multipliedBy(100);
 }
 
 export function isOutputAmountChangedALot(
-  oldQuote: BestRouteResponse,
-  newQuote: BestRouteResponse
+  oldRoute: BestRouteResponse,
+  newRoute: BestRouteResponse
 ) {
-  const oldOutputAmount = getQuoteOutputAmount(oldQuote);
-  const newOutputAmount = getQuoteOutputAmount(newQuote);
+  const oldOutputAmount = getRouteOutputAmount(oldRoute);
+  const newOutputAmount = getRouteOutputAmount(newRoute);
   if (!oldOutputAmount || !newOutputAmount) {
     return false;
   }
-  const percentageChange = getPriceImpact(oldOutputAmount, newOutputAmount);
+  const percentageChange = getPercentageChange(
+    oldOutputAmount,
+    newOutputAmount
+  );
   if (!percentageChange) {
     return true;
   }
 
-  return percentageChange <= -1;
+  return percentageChange.toNumber() <= -1;
 }
 
-export function generateBalanceWarnings(
-  quote: BestRouteResponse,
-  selectedWallets: Wallet[],
-  blockchains: BlockchainMeta[]
+export function getBalanceWarnings(
+  route: BestRouteResponse,
+  selectedWallets: Wallet[]
 ) {
-  const fee = quote.validationStatus;
-  const requiredWallets = getRequiredChains(quote);
+  const fee = route.validationStatus;
+  const requiredWallets = getRequiredChains(route);
   const walletsSortedByRequiredWallets = selectedWallets.sort(
     (selectedWallet1, selectedWallet2) =>
       requiredWallets.indexOf(selectedWallet1.chain) -
@@ -651,10 +610,7 @@ export function generateBalanceWarnings(
           symbol,
           reason,
           currentAmount,
-          blockchain: getBlockchainShortNameFor(
-            asset.asset.blockchain,
-            blockchains
-          ),
+          blockchain: asset.asset.blockchain,
         },
       });
       return warningMessage;
@@ -758,19 +714,29 @@ export function shouldRetrySwap(pendingSwap: PendingSwap) {
     new Date().getTime() - parseInt(pendingSwap.finishTime) < 4 * 3600 * 1000
   );
 }
+export function isValidCustomDestination(
+  blockchain: string,
+  address: string
+): boolean {
+  const blockchains = useMetaStore.getState().meta.blockchains;
+  const regex =
+    blockchains.find((chain) => chain.name === blockchain)?.addressPatterns ||
+    [];
+  return regex.filter((r) => new RegExp(r).test(address)).length > 0;
+}
 
 export function confirmSwapDisabled(
   fetching: boolean,
   showCustomDestination: boolean,
   customDestination: string,
-  quote: BestRouteResponse | null,
+  bestRoute: BestRouteResponse | null,
   selectedWallets: { walletType: string; chain: string }[],
   lastStepToBlockchain?: BlockchainMeta
 ) {
   return (
     fetching ||
     (!showCustomDestination &&
-      !requiredWallets(quote).every((chain) =>
+      !requiredWallets(bestRoute).every((chain) =>
         selectedWallets.map((wallet) => wallet.chain).includes(chain)
       )) ||
     (!!showCustomDestination && !customDestination) ||

package/src/utils/time.ts

@@ -1,4 +1,4 @@
-import type { PendingSwap } from 'rango-types';
+import type { PendingSwap } from '@rango-dev/queue-manager-rango-preset';
 
 import { i18n } from '@lingui/core';