@rango-dev/widget-embedded 0.17.1-next.3 → 0.17.1-next.30

package/src/hooks/useConfirmSwap/useConfirmSwap.helpers.ts

@@ -1,12 +1,13 @@
 import type { ConfirmSwapFetchResult } from './useConfirmSwap.types';
 import type { ConfirmSwapWarnings, Wallet } from '../../types';
-import type { BestRouteResponse, Token } from 'rango-sdk';
+import type { BestRouteResponse, BlockchainMeta, Token } from 'rango-sdk';
 
 import { errorMessages } from '../../constants/errors';
 import { QuoteErrorType, QuoteUpdateType } from '../../types';
 import { numberToString } from '../../utils/numbers';
 import {
   generateQuoteWarnings,
+  getPriceImpact,
   isNumberOfSwapsChanged,
   isQuoteChanged,
   isQuoteInternalCoinsUpdated,
@@ -14,10 +15,9 @@ import {
 } from '../../utils/quote';
 import {
   checkSlippageErrors,
-  getBalanceWarnings,
+  generateBalanceWarnings,
   getLimitErrorMessage,
   getMinRequiredSlippage,
-  getPercentageChange,
   getQuoteOutputAmount,
   hasLimitError,
   isOutputAmountChangedALot,
@@ -67,17 +67,20 @@ export function throwErrorIfResponseIsNotValid(response: BestRouteResponse) {
 }
 
 export function generateWarnings(
-  previousQuote: BestRouteResponse,
+  previousQuote: BestRouteResponse | undefined,
   currentQuote: BestRouteResponse,
   params: {
     fromToken: Token;
     toToken: Token;
-    tokens: Token[];
+    meta: { blockchains: BlockchainMeta[]; tokens: Token[] };
     selectedWallets: Wallet[];
     userSlippage: number;
   }
 ): ConfirmSwapWarnings {
-  const quoteChanged = isQuoteChanged(previousQuote, currentQuote);
+  let quoteChanged = false;
+  if (previousQuote) {
+    quoteChanged = isQuoteChanged(previousQuote, currentQuote);
+  }
   const output: ConfirmSwapWarnings = {
     quote: null,
     quoteUpdate: null,
@@ -87,7 +90,7 @@ export function generateWarnings(
   const quoteWarning = generateQuoteWarnings(currentQuote, {
     fromToken: params.fromToken,
     toToken: params.toToken,
-    tokens: params.tokens,
+    tokens: params.meta.tokens,
     userSlippage: params.userSlippage,
   });
 
@@ -95,13 +98,13 @@ export function generateWarnings(
     output.quote = quoteWarning;
   }
 
-  if (quoteChanged) {
+  if (previousQuote && quoteChanged) {
     if (isOutputAmountChangedALot(previousQuote, currentQuote)) {
       output.quoteUpdate = {
         type: QuoteUpdateType.QUOTE_AND_OUTPUT_AMOUNT_UPDATED,
         newOutputAmount: numberToString(getQuoteOutputAmount(currentQuote)),
         percentageChange: numberToString(
-          getPercentageChange(
+          getPriceImpact(
             getQuoteOutputAmount(previousQuote) ?? '',
             getQuoteOutputAmount(currentQuote) ?? ''
           ),
@@ -124,9 +127,10 @@ export function generateWarnings(
     }
   }
 
-  const balanceWarnings = getBalanceWarnings(
+  const balanceWarnings = generateBalanceWarnings(
     currentQuote,
-    params.selectedWallets
+    params.selectedWallets,
+    params.meta.blockchains
   );
   const enoughBalance = balanceWarnings.length === 0;
 

package/src/hooks/useConfirmSwap/useConfirmSwap.ts

@@ -5,11 +5,10 @@ import type { BestRouteResponse } from 'rango-sdk';
 import { calculatePendingSwap } from '@rango-dev/queue-manager-rango-preset';
 import { useEffect } from 'react';
 
-import { useMetaStore } from '../../store/meta';
+import { useAppStore } from '../../store/AppStore';
 import { useQuoteStore } from '../../store/quote';
-import { useSettingsStore } from '../../store/settings';
 import { useWalletsStore } from '../../store/wallets';
-import { QuoteErrorType } from '../../types';
+import { isFeatureEnabled } from '../../utils/settings';
 import { createQuoteRequestBody, getWalletsForNewSwap } from '../../utils/swap';
 import { useFetchQuote } from '../useFetchQuote';
 
@@ -25,7 +24,6 @@ export function useConfirmSwap(): ConfirmSwap {
     toToken,
     inputAmount,
     setQuote,
-    resetQuote,
     quote: initialQuote,
     customDestination: customDestinationFromStore,
     setQuoteWarningsConfirmed,
@@ -38,10 +36,12 @@ export function useConfirmSwap(): ConfirmSwap {
     affiliateRef,
     affiliateWallets,
     disabledLiquiditySources,
-  } = useSettingsStore();
+  } = useAppStore();
   const { connectedWallets } = useWalletsStore();
-
-  const { meta } = useMetaStore();
+  const blockchains = useAppStore().blockchains();
+  const tokens = useAppStore().tokens();
+  const { features } = useAppStore().config;
+  const { enableNewLiquiditySources } = useAppStore().config;
 
   const userSlippage = customSlippage || slippage;
 
@@ -54,7 +54,7 @@ export function useConfirmSwap(): ConfirmSwap {
     const customDestination =
       params?.customDestination ?? customDestinationFromStore;
 
-    if (!fromToken || !toToken || !inputAmount || !initialQuote) {
+    if (!fromToken || !toToken || !inputAmount) {
       return {
         quote: null,
         swap: null,
@@ -69,15 +69,18 @@ export function useConfirmSwap(): ConfirmSwap {
       inputAmount,
       wallets: connectedWallets,
       selectedWallets,
+      excludeLiquiditySources: enableNewLiquiditySources,
       disabledLiquiditySources,
       slippage: userSlippage,
       affiliateRef,
       affiliatePercent,
       affiliateWallets,
-      initialQuote: initialQuote,
+      initialQuote: initialQuote ?? undefined,
       destination: customDestination,
     });
-
+    if (isFeatureEnabled('experimentalRoute', features)) {
+      requestBody.experimental = true;
+    }
     let currentQuote: BestRouteResponse;
     try {
       currentQuote = await fetchQuote(requestBody).then((response) =>
@@ -86,12 +89,6 @@ export function useConfirmSwap(): ConfirmSwap {
       setQuote(currentQuote);
     } catch (error: any) {
       const confirmSwapResult = handleQuoteErrors(error);
-      if (
-        confirmSwapResult.error?.type === QuoteErrorType.NO_RESULT ||
-        confirmSwapResult.error?.type === QuoteErrorType.REQUEST_FAILED
-      ) {
-        resetQuote();
-      }
       return confirmSwapResult;
     }
 
@@ -105,16 +102,20 @@ export function useConfirmSwap(): ConfirmSwap {
       getWalletsForNewSwap(selectedWallets),
       swapSettings,
       false,
-      meta
+      { blockchains, tokens }
     );
 
-    const confirmSwapWarnings = generateWarnings(initialQuote, currentQuote, {
-      fromToken,
-      toToken,
-      tokens: meta.tokens,
-      selectedWallets,
-      userSlippage,
-    });
+    const confirmSwapWarnings = generateWarnings(
+      initialQuote ?? undefined,
+      currentQuote,
+      {
+        fromToken,
+        toToken,
+        meta: { blockchains, tokens },
+        selectedWallets,
+        userSlippage,
+      }
+    );
 
     if (confirmSwapWarnings.quoteUpdate) {
       setQuoteWarningsConfirmed(false);

package/src/hooks/useConfirmSwap/useConfirmSwap.types.ts

@@ -1,5 +1,5 @@
 import type { ConfirmSwapWarnings, QuoteError, Wallet } from '../../types';
-import type { PendingSwap } from 'rango-types/lib';
+import type { PendingSwap } from 'rango-types';
 
 export type ConfirmSwapFetchResult = {
   swap: PendingSwap | null;

package/src/hooks/useForceAutoConnect.ts

@@ -0,0 +1,27 @@
+import { useWallets } from '@rango-dev/wallets-react';
+import { useEffect, useRef } from 'react';
+
+import { SearchParams } from '../constants/searchParams';
+import { useAppStore } from '../store/AppStore';
+
+export function useForceAutoConnect(): void {
+  const { connect, state } = useWallets();
+  const initiated = useRef<{ [key: string]: boolean }>({});
+  const { fetchStatus } = useAppStore();
+  const walletType =
+    new URLSearchParams(location.search).get(SearchParams.AUTO_CONNECT) || '';
+  const walletState = state(walletType);
+
+  useEffect(() => {
+    const shouldTryConnect =
+      fetchStatus === 'success' &&
+      walletType &&
+      walletState.installed &&
+      !walletState.connecting &&
+      !walletState.connected;
+    if (shouldTryConnect && !initiated.current[walletType]) {
+      initiated.current[walletType] = true;
+      void connect(walletType);
+    }
+  }, [walletState, fetchStatus]);
+}

package/src/hooks/useLanguage.ts

@@ -3,18 +3,17 @@ import type { LanguageItem } from '../constants/languages';
 import { type Language } from '@rango-dev/ui';
 
 import { DEFAULT_LANGUAGE, LANGUAGES } from '../constants/languages';
-import { useSettingsStore } from '../store/settings';
+import { useAppStore } from '../store/AppStore';
 
 interface UseLanguage {
   languages: LanguageItem[];
   defaultLanguage: Language;
   activeLanguage: Language;
-  changeLanguage: (language: Language) => void;
+  changeLanguage: (language?: Language) => void;
 }
 
 export function useLanguage(): UseLanguage {
-  const language = useSettingsStore.use.language();
-  const setLanguage = useSettingsStore.use.setLanguage();
+  const { setLanguage, language } = useAppStore();
   const languages = LANGUAGES;
   const defaultLanguage = DEFAULT_LANGUAGE;
 
@@ -22,6 +21,6 @@ export function useLanguage(): UseLanguage {
     activeLanguage: language,
     languages,
     defaultLanguage,
-    changeLanguage: setLanguage,
+    changeLanguage: (language) => setLanguage(language || DEFAULT_LANGUAGE),
   };
 }

package/src/hooks/useNavigateBack.ts

@@ -1,55 +1,6 @@
-import { useInRouterContext, useNavigate } from 'react-router-dom';
+import { useNavigate } from 'react-router-dom';
 
-import { navigationRoutes } from '../constants/navigationRoutes';
-import { useQuoteStore } from '../store/quote';
-
-export function useNavigateBack() {
-  const isRouterInContext = useInRouterContext();
+export function useNavigateBack(): () => void {
   const navigate = useNavigate();
-  const quoteWalletsConfirmed = useQuoteStore.use.quoteWalletsConfirmed();
-
-  navigationRoutes;
-
-  const navigateBackFrom = (currentRoute: string) => {
-    if (currentRoute === navigationRoutes.swapDetails) {
-      return navigate('/' + navigationRoutes.swaps, { replace: true });
-    }
-
-    if (
-      !isRouterInContext ||
-      (window.history.state && window.history.state.idx > 0)
-    ) {
-      // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-      navigate(-1);
-    } else {
-      if (
-        [navigationRoutes.settings, navigationRoutes.wallets].includes(
-          currentRoute
-        ) &&
-        quoteWalletsConfirmed
-      ) {
-        return navigate('/' + navigationRoutes.confirmSwap, { replace: true });
-      }
-      if (
-        [
-          navigationRoutes.fromSwap,
-          navigationRoutes.toSwap,
-          navigationRoutes.settings,
-          navigationRoutes.wallets,
-          navigationRoutes.swaps,
-          navigationRoutes.confirmSwap,
-        ].includes(currentRoute)
-      ) {
-        navigate(navigationRoutes.home, { replace: true });
-      } else if (currentRoute === navigationRoutes.fromBlockchain) {
-        navigate('/' + navigationRoutes.fromSwap, { replace: true });
-      } else if (currentRoute === navigationRoutes.toBlockchain) {
-        navigate('/' + navigationRoutes.fromSwap, { replace: true });
-      } else if (currentRoute === navigationRoutes.liquiditySources) {
-        navigate('/' + navigationRoutes.settings, { replace: true });
-      }
-    }
-  };
-
-  return { navigateBackFrom };
+  return () => navigate(-1);
 }

package/src/hooks/usePrepareBlockchainList/usePrepareBlockchainList.constants.ts

@@ -1 +1 @@
-export const MOST_USED_BLOCKChAINS = ['ETH', 'COSMOS', 'OSMOSIS'];
+export const MOST_USED_BLOCKCHAINS = ['ETH', 'COSMOS', 'OSMOSIS'];

package/src/hooks/usePrepareBlockchainList/usePrepareBlockchainList.helpers.ts

@@ -1,13 +1,16 @@
-import type { PrepareListOptions } from './usePrepareBlockchainList.types';
+import type {
+  PrepareListOptions,
+  PrepareOutput,
+} from './usePrepareBlockchainList.types';
 import type { BlockchainMeta } from 'rango-sdk';
 
-import { MOST_USED_BLOCKChAINS } from './usePrepareBlockchainList.constants';
+import { MOST_USED_BLOCKCHAINS } from './usePrepareBlockchainList.constants';
 
 export function prepare(
   blockchains: BlockchainMeta[],
   preferredBlockchains: string[],
   options?: PrepareListOptions
-) {
+): PrepareOutput {
   /*
    * TODO:
    * We copying the `blockchains` which can causes performance penalties but we should because we are mutating the original object.
@@ -25,17 +28,37 @@ export function prepare(
     let preferredBlockchainsWithoutMainList = preferredBlockchains;
 
     if (preferredBlockchains.length <= options.limit) {
-      /*
-       * For first X (limit) numbers, we need to remove them from preferred if exists.
+      /**
+       *
+       * if we want to show 10 items (aka `options.limit`)
+       * and have these items as our preferred list: [x,y,z]
+       * and these as our main list: [A, B, C, D, E, F, G, H, I, J]
+       * the final list will be like this: [...preferred, ...mainList].
+       *
+       * Since we have a limit (e.g. 10) on our list (preferred + mainList),
+       * we only should check those items from main list that will be in final list.
+       *
+       * finalListWithoutLimit = [x,y,z, A, B, C, D, E, F, G, H, I, J]
+       * finalListWithLimit = [x,y,z, A, B, C, D, E, F, G]
+       *
+       * As you can see, [H, I, J] will not be in our list.
+       *
+       * The following code only check preffred blockchain
+       * shouldn't be in first 7 of 10 items in main list. (Since, the last 3 items will not be in the final list and we should check those.)
        */
-      for (let i = 0; i < options.limit; i++) {
+      const howManyItemsShouldBeCheckedFromMainList =
+        options.limit - preferredBlockchains.length;
+
+      for (let i = 0; i <= howManyItemsShouldBeCheckedFromMainList; i++) {
         const blockchain = list[i];
+
         preferredBlockchainsWithoutMainList =
           preferredBlockchainsWithoutMainList.filter((preferredBlockchain) => {
             return blockchain.name !== preferredBlockchain;
           });
       }
     }
+
     list.sort(
       generateSortByPreferredBlockchainsFor(preferredBlockchainsWithoutMainList)
     );
@@ -57,7 +80,7 @@ export function sortByMostUsedBlockchains(
   a: BlockchainMeta,
   b: BlockchainMeta
 ) {
-  const mostUsed = MOST_USED_BLOCKChAINS;
+  const mostUsed = MOST_USED_BLOCKCHAINS;
   const aIndexInMostUsed = mostUsed.findIndex((token) => token === a.name);
   const bIndexInMostUsed = mostUsed.findIndex((token) => token === b.name);
   const aIsMostUsed = aIndexInMostUsed > -1;
@@ -106,3 +129,10 @@ export function generateSortByPreferredBlockchainsFor(
     return 0;
   };
 }
+
+export function isInVisibleList(
+  blockchain: string,
+  prepareOutput: PrepareOutput
+): boolean {
+  return !!prepareOutput.list.find((item) => item.name === blockchain);
+}

package/src/hooks/usePrepareBlockchainList/usePrepareBlockchainList.mock.ts

@@ -2,6 +2,66 @@ import type { BlockchainMeta } from 'rango-sdk';
 
 import { TransactionType } from 'rango-sdk';
 
+export const sampleDefaultBlockchainNames = [
+  'ETH',
+  'COSMOS',
+  'OSMOSIS',
+  'BSC',
+  'ARBITRUM',
+  'POLYGON',
+  'ZKSYNC',
+  'STARKNET',
+  'OPTIMISM',
+  'AVAX_CCHAIN',
+  'POLYGONZK',
+  'LINEA',
+  'TRON',
+  'BTC',
+  'NEUTRON',
+  'NOBLE',
+  'SOLANA',
+  'CRONOS',
+  'BNB',
+  'AURORA',
+  'MAYA',
+  'THOR',
+  'BOBA',
+  'MOONBEAM',
+  'MOONRIVER',
+  'OKC',
+  'BOBA_AVALANCHE',
+  'LTC',
+  'BCH',
+  'HECO',
+  'STARGAZE',
+  'CRYPTO_ORG',
+  'CHIHUAHUA',
+  'BANDCHAIN',
+  'COMDEX',
+  'REGEN',
+  'IRIS',
+  'EMONEY',
+  'JUNO',
+  'STRIDE',
+  'MARS',
+  'TERRA',
+  'BITSONG',
+  'AKASH',
+  'KI',
+  'PERSISTENCE',
+  'MEDIBLOC',
+  'KUJIRA',
+  'SENTINEL',
+  'INJECTIVE',
+  'SECRET',
+  'KONSTELLATION',
+  'STARNAME',
+  'BITCANNA',
+  'UMEE',
+  'DESMOS',
+  'LUMNETWORK',
+];
+
 export const sampleBlockchains: BlockchainMeta[] = [
   {
     name: 'ETH',

package/src/hooks/usePrepareBlockchainList/usePrepareBlockchainList.test.ts

@@ -2,7 +2,7 @@ import type { BlockchainMeta } from 'rango-sdk';
 
 import { beforeEach, describe, expect, it } from 'vitest';
 
-import { MOST_USED_BLOCKChAINS } from './usePrepareBlockchainList.constants';
+import { MOST_USED_BLOCKCHAINS } from './usePrepareBlockchainList.constants';
 import {
   generateSortByPreferredBlockchainsFor,
   prepare,
@@ -20,8 +20,8 @@ describe('usePrepareBlockchainList', () => {
   it('should sort blockchains by most used ones.', () => {
     const sortedBlockchainsList = sample.sort(sortByMostUsedBlockchains);
 
-    const mostUsedCount = MOST_USED_BLOCKChAINS.length;
-    const expected = MOST_USED_BLOCKChAINS;
+    const mostUsedCount = MOST_USED_BLOCKCHAINS.length;
+    const expected = MOST_USED_BLOCKCHAINS;
     const received = sortedBlockchainsList
       .map((blockchain) => blockchain.name)
       .slice(0, mostUsedCount);
@@ -270,4 +270,79 @@ describe('usePrepareBlockchainList', () => {
       ...received.more.map((blockchain) => blockchain.name),
     ]);
   });
+
+  it.only('Last item of the main list should be moved to front if it selected again.', () => {
+    const listLimit = 10;
+    const preferredBlockchains = ['AVAX_CCHAIN', 'BTC'];
+    const expected = [
+      'AVAX_CCHAIN',
+      'BTC',
+      'ETH',
+      'COSMOS',
+      'OSMOSIS',
+      'BSC',
+      'ARBITRUM',
+      'POLYGON',
+      'ZKSYNC',
+      'STARKNET',
+      'OPTIMISM',
+      'POLYGONZK',
+      'LINEA',
+      'TRON',
+      'NEUTRON',
+      'NOBLE',
+      'SOLANA',
+      'CRONOS',
+      'BNB',
+      'AURORA',
+      'MAYA',
+      'THOR',
+      'BOBA',
+      'MOONBEAM',
+      'MOONRIVER',
+      'OKC',
+      'BOBA_AVALANCHE',
+      'LTC',
+      'BCH',
+      'HECO',
+      'STARGAZE',
+      'CRYPTO_ORG',
+      'CHIHUAHUA',
+      'BANDCHAIN',
+      'COMDEX',
+      'REGEN',
+      'IRIS',
+      'EMONEY',
+      'JUNO',
+      'STRIDE',
+      'MARS',
+      'TERRA',
+      'BITSONG',
+      'AKASH',
+      'KI',
+      'PERSISTENCE',
+      'MEDIBLOC',
+      'KUJIRA',
+      'SENTINEL',
+      'INJECTIVE',
+      'SECRET',
+      'KONSTELLATION',
+      'STARNAME',
+      'BITCANNA',
+      'UMEE',
+      'DESMOS',
+      'LUMNETWORK',
+    ];
+
+    const output = prepare(sample, preferredBlockchains, {
+      limit: listLimit,
+    });
+
+    const received = [
+      ...output.list.map((blockchain) => blockchain.name),
+      ...output.more.map((blockchain) => blockchain.name),
+    ];
+
+    expect(expected).toEqual(received);
+  });
 });

package/src/hooks/usePrepareBlockchainList/usePrepareBlockchainList.ts

@@ -1,14 +1,14 @@
 import type {
   PrepareListOptions,
-  PrepareListOutput,
+  UsePrepareList,
 } from './usePrepareBlockchainList.types';
 import type { BlockchainMeta } from 'rango-sdk';
 
 import { useEffect } from 'react';
 
-import { useSettingsStore } from '../../store/settings';
+import { useAppStore } from '../../store/AppStore';
 
-import { prepare } from './usePrepareBlockchainList.helpers';
+import { isInVisibleList, prepare } from './usePrepareBlockchainList.helpers';
 
 /**
  *
@@ -19,12 +19,21 @@ import { prepare } from './usePrepareBlockchainList.helpers';
 export function usePrepareBlockchainList(
   blockchains: BlockchainMeta[],
   options?: PrepareListOptions
-): PrepareListOutput {
-  const { preferredBlockchains, addPreferredBlockchain } = useSettingsStore();
+): UsePrepareList {
+  const { preferredBlockchains, addPreferredBlockchain } = useAppStore();
 
   useEffect(() => {
     if (options?.selected) {
-      addPreferredBlockchain(options?.selected);
+      const output = prepare(blockchains, preferredBlockchains, options);
+
+      /**
+       * We only add a new blockchain to preferred when it's not in the main list
+       * In this way we can guarantee we will be able to regenerate the same list always.
+       * And also it helps us to avoid jumping for the last item of the main list (e.g. tenth item of our list).
+       */
+      if (!isInVisibleList(options.selected, output)) {
+        addPreferredBlockchain(options?.selected);
+      }
     }
   }, [options?.selected]);
 

package/src/hooks/usePrepareBlockchainList/usePrepareBlockchainList.types.ts

@@ -5,8 +5,13 @@ export interface PrepareListOptions {
   selected?: string;
 }
 
-export interface PrepareListOutput {
+export interface PrepareOutput {
   list: BlockchainMeta[];
   more: BlockchainMeta[];
+}
+
+export interface UsePrepareList {
+  list: PrepareOutput['list'];
+  more: PrepareOutput['more'];
   history: string[];
 }