@rango-dev/widget-embedded 0.37.1-next.2 → 0.38.0

package/src/utils/providers.ts

@@ -1,12 +1,7 @@
 import type { WidgetConfig } from '../types';
-import type { LegacyProviderInterface } from '@rango-dev/wallets-core/legacy';
+import type { ProviderInterface } from '@rango-dev/wallets-react';
 
-import {
-  defineVersions,
-  pickVersion,
-  Provider,
-  type VersionedProviders,
-} from '@rango-dev/wallets-core';
+import { allProviders } from '@rango-dev/provider-all';
 
 export interface ProvidersOptions {
   walletConnectProjectId?: WidgetConfig['walletConnectProjectId'];
@@ -15,118 +10,71 @@ export interface ProvidersOptions {
   >['walletConnectListedDesktopWalletLink'];
   trezorManifest: WidgetConfig['trezorManifest'];
   tonConnect: WidgetConfig['tonConnect'];
-  experimentalWallet?: 'enabled' | 'disabled';
 }
 
 /**
  *
  * Generate a list of providers by passing a provider name (e.g. metamask) or a custom provider which implemented ProviderInterface.
- * @returns BothProvidersInterface[] a list of BothProvidersInterface
+ * @returns ProviderInterface[] a list of ProviderInterface
  *
  */
-type BothProvidersInterface = LegacyProviderInterface | Provider;
-export function matchAndGenerateProviders({
-  allProviders,
-  configWallets,
-  options,
-}: {
-  allProviders: VersionedProviders[];
-  configWallets: WidgetConfig['wallets'];
-  options?: ProvidersOptions;
-}): VersionedProviders[] {
-  if (configWallets) {
-    /*
-     * If `wallets`  is included in widget config,
-     * allProviders should be filtered based on wallets list
-     */
-    const selectedProviders: VersionedProviders[] = [];
+export function matchAndGenerateProviders(
+  providers: WidgetConfig['wallets'],
+  options?: ProvidersOptions
+): ProviderInterface[] {
+  const all = allProviders({
+    walletconnect2: {
+      WC_PROJECT_ID: options?.walletConnectProjectId || '',
+      DISABLE_MODAL_AND_OPEN_LINK:
+        options?.walletConnectListedDesktopWalletLink,
+    },
+    selectedProviders: providers,
+    trezor: options?.trezorManifest
+      ? { manifest: options.trezorManifest }
+      : undefined,
+    tonConnect: options?.tonConnect?.manifestUrl
+      ? { manifestUrl: options?.tonConnect.manifestUrl }
+      : undefined,
+  });
+
+  if (providers) {
+    const selectedProviders: ProviderInterface[] = [];
 
-    configWallets.forEach((requestedWallet) => {
+    providers.forEach((requestedProvider) => {
       /*
        * There are two types of provider we get, the first one is only passing the wallet name
        * then we will match the wallet name with our providers (@rango-dev/provider-*).
        * The second way is passing a custom provider which implemented ProviderInterface.
        */
-      if (typeof requestedWallet === 'string') {
-        const result = allProviders.find((provider) => {
-          /*
-           * To find a provider in allProviders,
-           * a version of each provider should be picked
-           * and validated based on that version scheme.
-           * If the corresponding provider to a wallet was found in allProvider,
-           * it will be add to selected providers.
-           */
-          const versionedProvider = pickProviderVersionWithFallbackToLegacy(
-            provider,
-            options
-          );
-          if (versionedProvider instanceof Provider) {
-            return versionedProvider.id === requestedWallet;
-          }
-          return versionedProvider.config.type === requestedWallet;
+      if (typeof requestedProvider === 'string') {
+        const result: ProviderInterface | undefined = all.find((provider) => {
+          return provider.config.type === requestedProvider;
         });
-
-        /*
-         * A provider may have multiple versions
-         * (e.g., 0.0, also known as legacy, and 1.0, also known as hub).
-         * We should ensure that all existing versions of a provider are added to selectedProviders.
-         */
         if (result) {
           selectedProviders.push(result);
         } else {
           console.warn(
-            // A provider name is included in config but was not found in allProviders
-            `Couldn't find ${requestedWallet} provider. Please make sure you are passing the correct name.`
+            `Couldn't find ${requestedProvider} provider. Please make sure you are passing the correct name.`
           );
         }
       } else {
         // It's a custom provider so we directly push it to the list.
-        if (requestedWallet instanceof Provider) {
-          selectedProviders.push(
-            defineVersions().version('1.0.0', requestedWallet).build()
-          );
-        } else {
-          selectedProviders.push(
-            defineVersions().version('0.0.0', requestedWallet).build()
-          );
-        }
+        selectedProviders.push(requestedProvider);
       }
     });
-
     return selectedProviders;
   }
 
-  return allProviders;
-}
-
-function pickProviderVersionWithFallbackToLegacy(
-  provider: VersionedProviders,
-  options?: ProvidersOptions
-): BothProvidersInterface {
-  const { experimentalWallet = 'enabled' } = options || {};
-  const version = experimentalWallet == 'disabled' ? '0.0.0' : '1.0.0';
-
-  try {
-    return pickVersion(provider, version)[1];
-  } catch {
-    // Fallback to legacy version, if target version doesn't exists.
-    return pickVersion(provider, '0.0.0')[1];
-  }
+  return all;
 }
 
 export function configWalletsToWalletName(
-  providers: VersionedProviders[],
+  config: WidgetConfig['wallets'],
   options?: ProvidersOptions
 ): string[] {
-  const names = providers
-    .map((provider) =>
-      pickProviderVersionWithFallbackToLegacy(provider, options)
-    )
-    .map((provider) => {
-      if (provider instanceof Provider) {
-        return provider.id;
-      }
-      return provider.config.type;
-    });
+  const providers = matchAndGenerateProviders(config, options);
+  const names = providers.map((provider) => {
+    return provider.config.type;
+  });
   return names;
 }

package/src/utils/quote.ts

@@ -15,6 +15,7 @@ import type {
   MultiRouteSimulationResult,
   PreferenceType,
   RouteTag,
+  Token,
 } from 'rango-sdk';
 import type { PendingSwap } from 'rango-types';
 
@@ -28,19 +29,30 @@ import { QuoteWarningType } from '../types';
 
 import { areEqual } from './common';
 import { createTokenHash, findBlockchain } from './meta';
-import { numberToString } from './numbers';
 import {
+  calcOutputUsdValue,
   checkSlippageWarnings,
   getMinRequiredSlippage,
   getPercentageChange,
   getTotalFeeInUsd,
-  getUsdInputFrom,
-  getUsdOutputFrom,
   hasHighValueLoss,
   hasProperSlippage,
-  isOutputAmountChangedExcessively,
 } from './swap';
 
+export function getQuoteToTokenUsdPrice(
+  quote: SelectedQuote | null
+): number | null | undefined {
+  const swaps = quote?.swaps || [];
+  return swaps[swaps.length - 1].to.usdPrice;
+}
+
+export function getQuoteFromTokenUsdPrice(
+  quote: SelectedQuote | null
+): number | null | undefined {
+  const swaps = quote?.swaps || [];
+  return swaps[0].from.usdPrice;
+}
+
 export function isNumberOfSwapsChanged(
   quoteA: SelectedQuote,
   quoteB: SelectedQuote
@@ -183,73 +195,56 @@ export function createRetryQuote(
   };
 }
 
-export function generateQuoteWarnings(params: {
-  previousQuote?: SelectedQuote;
-  currentQuote: SelectedQuote;
-  findToken: FindToken;
-  userSlippage: number;
-}): QuoteWarning | null {
-  const { previousQuote, currentQuote, findToken, userSlippage } = params;
-  const usdInput = getUsdInputFrom(currentQuote);
-  const usdOutput = getUsdOutputFrom(currentQuote);
-
-  if (!!currentQuote && usdInput && usdOutput) {
+export function generateQuoteWarnings(
+  quote: SelectedQuote,
+  params: {
+    fromToken: Token;
+    toToken: Token;
+    findToken: FindToken;
+    userSlippage: number;
+  }
+): QuoteWarning | null {
+  const { fromToken, toToken, findToken, userSlippage } = params;
+  const inputUsdValue = calcOutputUsdValue(
+    quote.requestAmount,
+    getQuoteFromTokenUsdPrice(quote) || fromToken?.usdPrice
+  );
+  const outputUsdValue = calcOutputUsdValue(
+    quote.outputAmount,
+    getQuoteToTokenUsdPrice(quote) || toToken?.usdPrice
+  );
+
+  if (!!quote && inputUsdValue && outputUsdValue) {
     const priceImpact = getPriceImpact(
-      usdInput.toString(),
-      usdOutput.toString()
+      inputUsdValue.toString(),
+      outputUsdValue.toString()
     );
     const highValueLoss =
-      !!priceImpact && hasHighValueLoss(usdInput, priceImpact);
+      !!priceImpact && hasHighValueLoss(inputUsdValue, priceImpact);
 
     if (highValueLoss) {
-      const totalFee = getTotalFeeInUsd(currentQuote?.swaps, findToken);
+      const totalFee = getTotalFeeInUsd(quote?.swaps, findToken);
       const warningLevel = getPriceImpactLevel(priceImpact);
       return {
         type: QuoteWarningType.HIGH_VALUE_LOSS,
-        inputUsdValue: usdInput,
-        outputUsdValue: usdOutput,
+        inputUsdValue,
+        outputUsdValue,
         priceImpact,
         totalFee,
         warningLevel,
       };
     }
-  }
-
-  if (
-    previousQuote &&
-    isOutputAmountChangedExcessively(previousQuote, currentQuote)
-  ) {
-    return {
-      type: QuoteWarningType.EXCESSIVE_OUTPUT_AMOUNT_CHANGE,
-      usdValueChange: numberToString(
-        getUsdOutputFrom(currentQuote)
-          ?.minus(getUsdOutputFrom(previousQuote) ?? 0)
-          .toString() ?? '0',
-        null,
-        2
-      ),
-      percentageChange: numberToString(
-        getPriceImpact(
-          getUsdOutputFrom(previousQuote) ?? '1',
-          getUsdOutputFrom(currentQuote) ?? '1'
-        ),
-        null,
-        2
-      ),
-    };
-  }
-
-  if (currentQuote && (!usdInput || !usdOutput)) {
+  } else if (quote && (!inputUsdValue || !outputUsdValue)) {
     return { type: QuoteWarningType.UNKNOWN_PRICE };
   }
 
-  const minRequiredSlippage = getMinRequiredSlippage(currentQuote.swaps);
+  const minRequiredSlippage = getMinRequiredSlippage(quote.swaps);
   const highSlippage = userSlippage > HIGH_SLIPPAGE;
 
   if (!hasProperSlippage(params.userSlippage.toString(), minRequiredSlippage)) {
     return {
       type: QuoteWarningType.INSUFFICIENT_SLIPPAGE,
-      recommendedSlippages: checkSlippageWarnings(currentQuote, userSlippage),
+      recommendedSlippages: checkSlippageWarnings(quote, userSlippage),
       minRequiredSlippage: minRequiredSlippage,
     };
   } else if (
@@ -265,13 +260,6 @@ export function generateQuoteWarnings(params: {
   return null;
 }
 
-export function isQuoteWarningConfirmationRequired(warning: QuoteWarning) {
-  const WARNINGS_NOT_REQUIRING_CONFIRMATION = [
-    QuoteWarningType.EXCESSIVE_OUTPUT_AMOUNT_CHANGE,
-  ];
-  return !WARNINGS_NOT_REQUIRING_CONFIRMATION.includes(warning.type);
-}
-
 export function getPriceImpact(
   inputUsdValue: BigNumber | string | null,
   outputUsdValue: BigNumber | string | null

package/src/utils/settings.ts

@@ -72,10 +72,6 @@ export function isFeatureHidden(feature: keyof Features, features?: Features) {
   return features?.[feature] === 'hidden';
 }
 
-export function isFeatureEnabled(feature: keyof Features, features?: Features) {
-  return features?.[feature] === 'enabled';
-}
-
 export function isRoutingEnabled(item: keyof Routing, routing?: Routing) {
   return routing?.[item] === 'enabled';
 }

package/src/utils/swap.ts

@@ -1,5 +1,7 @@
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+import type { FeesGroup, NameOfFees } from '../constants/quote';
 import type { FetchStatus, FindToken } from '../store/slices/data';
-import type { ConnectedWallet } from '../store/slices/wallets';
+import type { ConnectedWallet } from '../store/wallets';
 import type {
   ConvertedToken,
   QuoteError,
@@ -32,14 +34,6 @@ import { PendingSwapNetworkStatus } from 'rango-types';
 import { errorMessages } from '../constants/errors';
 import { swapButtonTitles } from '../constants/messages';
 import { ZERO } from '../constants/numbers';
-import {
-  type FeesGroup,
-  HIGH_FEE_THRESHOLD_USD,
-  HIGH_VALUE_LOSS_CRITERIA,
-  type NameOfFees,
-  OUTPUT_CHANGE_WARNING_CRITERIA,
-  PERCENT_MULTIPLIER,
-} from '../constants/quote';
 import {
   BALANCE_MAX_DECIMALS,
   BALANCE_MIN_DECIMALS,
@@ -49,7 +43,7 @@ import {
 
 import { getBlockchainShortNameFor, isValidTokenAddress } from './meta';
 import { numberToString } from './numbers';
-import { getRequiredBalanceOfWallet } from './quote';
+import { getPriceImpact, getRequiredBalanceOfWallet } from './quote';
 import { getQuoteWallets } from './wallets';
 
 export function getOutputRatio(
@@ -67,7 +61,7 @@ export function getOutputRatio(
   return outputUsdValue
     .div(inputUsdValue)
     .minus(1)
-    .multipliedBy(PERCENT_MULTIPLIER)
+    .multipliedBy(100)
     .toNumber();
 }
 
@@ -75,16 +69,12 @@ export function hasHighValueLoss(
   inputUsdValue: BigNumber | null,
   priceImpact: number
 ): boolean {
-  if (!inputUsdValue) {
-    return false;
-  }
-
-  const formattedPriceImpact = parseInt(priceImpact.toFixed(2) || '0');
-
-  return HIGH_VALUE_LOSS_CRITERIA.some(
-    ({ threshold, minInput }) =>
-      formattedPriceImpact <= threshold &&
-      inputUsdValue.gte(new BigNumber(minInput))
+  return (
+    ((parseInt(priceImpact.toFixed(2) || '0') <= -10 &&
+      inputUsdValue?.gte(new BigNumber(400))) ||
+      (parseInt(priceImpact.toFixed(2) || '0') <= -5 &&
+        inputUsdValue?.gte(new BigNumber(1000)))) ??
+    false
   );
 }
 
@@ -338,7 +328,7 @@ export function hasHighFee(totalFeeInUsd: BigNumber | null) {
   if (!totalFeeInUsd) {
     return false;
   }
-  return !totalFeeInUsd.lt(new BigNumber(HIGH_FEE_THRESHOLD_USD));
+  return !totalFeeInUsd.lt(new BigNumber(30));
 }
 
 export function hasSlippageError(
@@ -490,7 +480,8 @@ export function createQuoteRequestBody(params: {
       addresses: [wallet.address],
     });
   });
-
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
   const requestBody: BestRouteRequest = {
     amount: inputAmount.toString(),
     affiliateRef: affiliateRef ?? undefined,
@@ -544,52 +535,33 @@ export function getWalletsForNewSwap(selectedWallets: Wallet[]) {
   return wallets;
 }
 
-export function getUsdInputFrom(quote: SelectedQuote): BigNumber | undefined {
-  const inputAmount = quote.requestAmount;
-  const inputTokenUsdPrice = quote.swaps[0].from.usdPrice;
-  if (!inputAmount || !inputTokenUsdPrice) {
-    return;
-  }
-  return new BigNumber(inputAmount).multipliedBy(inputTokenUsdPrice);
-}
-
-export function getUsdOutputFrom(quote: SelectedQuote): BigNumber | undefined {
-  const outputAmount = quote?.outputAmount || null;
-  const outputTokenUsdPrice = quote.swaps[quote.swaps.length - 1].to.usdPrice;
-  if (!outputAmount || !outputTokenUsdPrice) {
-    return;
-  }
-  return new BigNumber(outputAmount).multipliedBy(outputTokenUsdPrice);
+export function getQuoteOutputAmount(quote: SelectedQuote) {
+  return quote?.outputAmount || null;
 }
 
 export function getPercentageChange(input: string, output: string) {
   return new BigNumber(output)
     .div(new BigNumber(input))
     .minus(1)
-    .multipliedBy(PERCENT_MULTIPLIER)
+    .multipliedBy(100)
     .toNumber();
 }
 
-export function isOutputAmountChangedExcessively(
-  previousQuote: SelectedQuote,
-  currentQuote: SelectedQuote
+export function isOutputAmountChangedALot(
+  oldQuote: SelectedQuote,
+  newQuote: SelectedQuote
 ) {
-  const usdInput = getUsdInputFrom(previousQuote);
-  const previousUsdOutput = getUsdOutputFrom(previousQuote);
-  const currentUsdOutput = getUsdOutputFrom(currentQuote);
-  if (!usdInput || !previousUsdOutput || !currentUsdOutput) {
+  const oldOutputAmount = getQuoteOutputAmount(oldQuote);
+  const newOutputAmount = getQuoteOutputAmount(newQuote);
+  if (!oldOutputAmount || !newOutputAmount) {
     return false;
   }
+  const percentageChange = getPriceImpact(oldOutputAmount, newOutputAmount);
+  if (!percentageChange) {
+    return true;
+  }
 
-  const percentageChange = getPercentageChange(
-    previousUsdOutput.toString(),
-    currentUsdOutput.toString()
-  );
-
-  return OUTPUT_CHANGE_WARNING_CRITERIA.some(
-    ({ threshold, minInput }) =>
-      percentageChange <= threshold && usdInput.isGreaterThanOrEqualTo(minInput)
-  );
+  return percentageChange <= -1;
 }
 
 export function generateBalanceWarnings(
@@ -651,6 +623,15 @@ export function generateBalanceWarnings(
     });
 }
 
+export function calcOutputUsdValue(
+  outputAmount?: string,
+  tokenPrice?: number | null
+) {
+  const amount = !!outputAmount ? new BigNumber(outputAmount) : ZERO;
+
+  return amount.multipliedBy(tokenPrice || 0);
+}
+
 export function isNetworkStatusInWarningState(
   pendingSwapStep: PendingSwapStep | null
 ): boolean {