@rango-dev/widget-embedded 0.1.10-next.100 → 0.1.10-next.114

package/dist/widget-embedded.cjs.development.js

@@ -8,12 +8,13 @@ var ui = require('@rango-dev/ui');
 var React = require('react');
 var React__default = _interopDefault(React);
 var reactRouter = require('react-router');
+var queueManagerRangoPreset = require('@rango-dev/queue-manager-rango-preset');
+var rangoTypes = require('rango-types');
 var reactRouterDom = require('react-router-dom');
 var zustand = require('zustand');
 var BigNumber = require('bignumber.js');
 var BigNumber__default = _interopDefault(BigNumber);
 var walletsShared = require('@rango-dev/wallets-shared');
-var rangoTypes = require('rango-types');
 var walletsCore = require('@rango-dev/wallets-core');
 var middleware = require('zustand/middleware');
 var rangoSdk = require('rango-sdk');
@@ -21,11 +22,11 @@ var shallow = require('zustand/shallow');
 var reactI18next = require('react-i18next');
 var theme = require('@rango-dev/ui/src/theme');
 var providerAll = require('@rango-dev/provider-all');
-var queueManagerReact = require('@rango-dev/queue-manager-react');
 var i18n = require('i18next');
 var i18n__default = _interopDefault(i18n);
+var queueManagerReact = require('@rango-dev/queue-manager-react');
+var dayjs = _interopDefault(require('dayjs'));
 var copy = _interopDefault(require('copy-to-clipboard'));
-var queueManagerRangoPreset = require('@rango-dev/queue-manager-rango-preset');
 var Backend = _interopDefault(require('i18next-http-backend'));
 var LanguageDetector = _interopDefault(require('i18next-browser-languagedetector'));
 
@@ -40,7 +41,6 @@ const navigationRoutes = {
   swaps: '/swaps',
   wallets: '/wallets',
   confirmSwap: '/confirm-swap',
-  confirmWallets: '/confirm-wallets',
   swapDetails: '/swaps/:requestId'
 };
 
@@ -70,6 +70,22 @@ function shadeColor(color, percent) {
   var BB = B.toString(16).length == 1 ? '0' + B.toString(16) : B.toString(16);
   return '#' + RR + GG + BB;
 }
+function debounce(fn, time) {
+  let timeoutId;
+  return wrapper;
+  function wrapper() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      fn(...args);
+    }, time);
+  }
+}
 
 const secondsToString = s => {
   const seconds = (s % 60).toString().padStart(2, '0');
@@ -336,7 +352,7 @@ function getSortedTokens(chain, tokens, balances, otherChainTokens) {
   return sortTokens(getTokensWithBalance(filteredTokens, balances));
 }
 function tokensAreEqual(tokenA, tokenB) {
-  return tokenA?.blockchain === tokenB?.blockchain && tokenA?.name === tokenB?.name && tokenA?.address === tokenB?.address;
+  return tokenA?.blockchain === tokenB?.blockchain && tokenA?.symbol === tokenB?.symbol && tokenA?.address === tokenB?.address;
 }
 function getDefaultToken(sortedTokens, otherToken) {
   let selectedToken;
@@ -462,6 +478,7 @@ function calculatePendingSwap(inputAmount, bestRoute, wallets, settings, validat
     finishTime: null,
     requestId: bestRoute.requestId || '',
     inputAmount: inputAmount,
+    //@ts-ignore
     wallets,
     status: 'running',
     isPaused: false,
@@ -476,6 +493,7 @@ function calculatePendingSwap(inputAmount, bestRoute, wallets, settings, validat
     settings: settings,
     simulationResult: simulationResult,
     validateBalanceOrFee,
+    //@ts-ignore
     steps: bestRoute.result?.swaps?.map((swap, index) => {
       const swapper = meta.swappers.find(swapper => swapper.id === swap.swapperId);
       const swapperType = swapper?.types[0];
@@ -561,11 +579,10 @@ function hasHighFee(totalFeeInUsd) {
 }
 function getMinRequiredSlippage(route) {
   const slippages = route.result?.swaps.map(slippage => slippage.recommendedSlippage);
-  return slippages?.map(s => parseFloat(s?.slippage || '0'))?.filter(s => s > 0)?.sort((a, b) => b - a)?.find(() => true) || null;
+  return slippages?.map(s => s?.slippage || '0')?.filter(s => parseFloat(s) > 0)?.sort((a, b) => parseFloat(b) - parseFloat(a))?.find(() => true) || null;
 }
 function hasProperSlippage(userSlippage, minRequiredSlippage) {
   if (!minRequiredSlippage) return true;
-  //@ts-ignore
   return parseFloat(userSlippage) >= parseFloat(minRequiredSlippage);
 }
 function createBestRouteRequestBody(fromToken, toToken, inputAmount, wallets, selectedWallets, disabledLiquiditySources, slippage, checkPrerequisites) {
@@ -578,6 +595,7 @@ function createBestRouteRequestBody(fromToken, toToken, inputAmount, wallets, se
       addresses: [wallet.address]
     });
   });
+  const filteredBlockchains = selectedWallets.map(wallet => wallet.chain);
   const requestBody = {
     amount: inputAmount.toString(),
     checkPrerequisites,
@@ -595,8 +613,10 @@ function createBestRouteRequestBody(fromToken, toToken, inputAmount, wallets, se
     selectedWallets: selectedWalletsMap,
     swapperGroups: disabledLiquiditySources,
     swappersGroupsExclude: true,
-    //@ts-ignore
-    slippage: slippage.toString()
+    slippage: slippage.toString(),
+    ...(checkPrerequisites && {
+      blockchains: filteredBlockchains
+    })
   };
   return requestBody;
 }
@@ -642,6 +662,61 @@ function calcOutputUsdValue(outputAmount, tokenPrice) {
   const amount = !!outputAmount ? new BigNumber__default(outputAmount) : ZERO;
   return amount.multipliedBy(tokenPrice || 0);
 }
+function isNetworkStatusInWarningState(pendingSwapStep) {
+  return !!pendingSwapStep && pendingSwapStep.networkStatus !== null && pendingSwapStep.networkStatus !== queueManagerRangoPreset.PendingSwapNetworkStatus.NetworkChanged;
+}
+function getSwapMessages(pendingSwap, currentStep) {
+  const textForRemove = 'bellow button or';
+  let message = pendingSwap.extraMessage;
+  let detailedMessage = pendingSwap.extraMessageDetail;
+  if (pendingSwap.networkStatusExtraMessageDetail?.includes(textForRemove)) {
+    pendingSwap.networkStatusExtraMessageDetail = pendingSwap.networkStatusExtraMessageDetail.replace(textForRemove, '');
+  }
+  const networkWarningState = isNetworkStatusInWarningState(currentStep);
+  if (networkWarningState) {
+    message = pendingSwap.networkStatusExtraMessage || '';
+    detailedMessage = pendingSwap.networkStatusExtraMessageDetail || '';
+    switch (currentStep?.networkStatus) {
+      case queueManagerRangoPreset.PendingSwapNetworkStatus.WaitingForConnectingWallet:
+        message = message || 'Waiting for connecting wallet';
+        break;
+      case queueManagerRangoPreset.PendingSwapNetworkStatus.WaitingForQueue:
+        message = message || 'Waiting for other running tasks to be finished';
+        break;
+      case queueManagerRangoPreset.PendingSwapNetworkStatus.WaitingForNetworkChange:
+        message = message || 'Waiting for changing wallet network';
+        break;
+    }
+  }
+  detailedMessage = detailedMessage || '';
+  message = message || '';
+  const isRpc = message?.indexOf('code') !== -1 && message?.indexOf('reason') !== -1;
+  return {
+    shortMessage: message,
+    detailedMessage: {
+      content: detailedMessage,
+      long: isRpc
+    }
+  };
+}
+function getLastConvertedTokenInFailedSwap(pendingSwap) {
+  let resultToken = null;
+  if (pendingSwap.status === 'failed') {
+    const lastSuccessStep = pendingSwap.steps.slice().reverse().filter(step => step.status === 'success')[0];
+    if (lastSuccessStep) {
+      resultToken = {
+        blockchain: lastSuccessStep.toBlockchain,
+        symbol: lastSuccessStep.toSymbol,
+        outputAmount: lastSuccessStep.outputAmount,
+        address: lastSuccessStep.toSymbolAddress
+      };
+    }
+  }
+  return resultToken;
+}
+function shouldRetrySwap(pendingSwap) {
+  return pendingSwap.status === 'failed' && !!pendingSwap.finishTime && new Date().getTime() - parseInt(pendingSwap.finishTime) < 4 * 3600 * 1000;
+}
 
 function searchParamsToToken(tokens, searchParams, chain) {
   if (!chain) return null;
@@ -679,22 +754,13 @@ function getRequiredBalanceOfWallet(selectedWallet, fee) {
   return relatedFeeStatus.requiredAssets;
 }
 function isRouteParametersChanged(prevParams, currentParams) {
-  return prevParams.fromChain?.name !== currentParams.fromChain?.name || prevParams.toChain?.name !== currentParams.toChain?.name || prevParams.fromToken?.symbol !== currentParams.fromToken?.symbol || prevParams.toToken?.symbol !== currentParams.toToken?.symbol || prevParams.fromToken?.blockchain !== currentParams.fromToken?.blockchain || prevParams.toToken?.blockchain !== currentParams.toToken?.blockchain || prevParams.fromToken?.address !== currentParams.fromToken?.address || prevParams.toToken?.address !== currentParams.toToken?.address || prevParams.inputAmount !== currentParams.inputAmount || prevParams.slippage !== currentParams.slippage || prevParams.customSlippage !== currentParams.customSlippage || prevParams.disabledLiquiditySources?.length !== currentParams.disabledLiquiditySources?.length;
-}
-function getBestRouteWithCalculatedFees(bestRoute, tokens) {
-  if (!bestRoute || !bestRoute.result) return null;
-  const swapsWithFee = (bestRoute?.result?.swaps || []).map(swap => ({
-    ...swap,
-    feeInUsd: numberToString(getUsdFeeOfStep(swap, tokens), 0, 2)
-  }));
-  return {
-    ...bestRoute,
-    result: {
-      ...bestRoute.result,
-      swaps: swapsWithFee
-    }
-  };
+  return !!currentParams.fromToken && !!currentParams.toToken && (prevParams.fromChain?.name !== currentParams.fromChain?.name || prevParams.toChain?.name !== currentParams.toChain?.name || prevParams.fromToken?.symbol !== currentParams.fromToken?.symbol || prevParams.toToken?.symbol !== currentParams.toToken?.symbol || prevParams.fromToken?.blockchain !== currentParams.fromToken?.blockchain || prevParams.toToken?.blockchain !== currentParams.toToken?.blockchain || prevParams.fromToken?.address !== currentParams.fromToken?.address || prevParams.toToken?.address !== currentParams.toToken?.address || prevParams.inputAmount !== currentParams.inputAmount || prevParams.slippage !== currentParams.slippage || prevParams.customSlippage !== currentParams.customSlippage || prevParams.disabledLiquiditySources?.length !== currentParams.disabledLiquiditySources?.length);
 }
+//todo: refactor bestRoute store and add loadingStatus
+const getBestRouteStatus = (loading, error) => {
+  if (loading) return 'loading';
+  if (error) return 'failed';else return 'success';
+};
 
 const createSelectors = _store => {
   let store = _store;
@@ -845,7 +911,7 @@ const useWalletsStore = /*#__PURE__*/createSelectors( /*#__PURE__*/zustand.creat
       }
     });
     return {
-      selectedWallets: state.selectedWallets.concat(selectedWallets)
+      selectedWallets: selectedWallets
     };
   }),
   setSelectedWallet: wallet => set(state => ({
@@ -877,6 +943,7 @@ useWalletsStore.subscribe(state => state.balances, balances => {
 }, {
   equalityFn: shallow.shallow
 });
+const fetchingBalanceSelector = state => !!state.balances.find(wallet => wallet.loading);
 
 const getUsdValue = (token, amount) => new BigNumber__default(amount || ZERO).multipliedBy(token?.usdPrice || 0);
 const useBestRouteStore = /*#__PURE__*/createSelectors( /*#__PURE__*/zustand.create()( /*#__PURE__*/middleware.subscribeWithSelector(set => ({
@@ -896,6 +963,7 @@ const useBestRouteStore = /*#__PURE__*/createSelectors( /*#__PURE__*/zustand.cre
   setBestRoute: bestRoute => set(state => {
     let outputAmount = null;
     let outputUsdValue = ZERO;
+    if (!state.inputAmount || state.inputAmount === '0') return {};
     if (!!bestRoute) {
       outputAmount = !!bestRoute.result?.outputAmount ? new BigNumber__default(bestRoute.result?.outputAmount) : null;
       outputUsdValue = calcOutputUsdValue(bestRoute.result?.outputAmount, getBestRouteToTokenUsdPrice(bestRoute) || state.toToken?.usdPrice);
@@ -952,6 +1020,7 @@ const useBestRouteStore = /*#__PURE__*/createSelectors( /*#__PURE__*/zustand.cre
     toToken: token
   })),
   setInputAmount: amount => {
+    console.log(amount, typeof amount);
     set(state => ({
       inputAmount: amount,
       ...(!amount && {
@@ -963,6 +1032,47 @@ const useBestRouteStore = /*#__PURE__*/createSelectors( /*#__PURE__*/zustand.cre
         inputUsdValue: getUsdValue(state.fromToken, amount)
       })
     }));
+  },
+  retry: pendingSwap => {
+    const {
+      tokens,
+      blockchains
+    } = useMetaStore.getState().meta;
+    const balances = useWalletsStore.getState().balances;
+    const failedIndex = pendingSwap.status === 'failed' ? pendingSwap.steps.findIndex(s => s.status === 'failed') : null;
+    if (failedIndex === null || failedIndex < 0) return;
+    const firstStep = pendingSwap.steps[0];
+    const lastStep = pendingSwap.steps[pendingSwap.steps.length - 1];
+    const fromChain = blockchains.find(blockchain => blockchain.name === firstStep.fromBlockchain) || null;
+    const toChain = blockchains.find(blockchain => blockchain.name === lastStep.toBlockchain) || null;
+    const fromToken = tokens.find(token => tokensAreEqual(token, {
+      blockchain: firstStep.fromBlockchain,
+      symbol: firstStep.fromSymbol,
+      address: firstStep.fromSymbolAddress
+    }));
+    const toToken = tokens.find(token => tokensAreEqual(token, {
+      blockchain: lastStep.toBlockchain,
+      symbol: lastStep.toSymbol,
+      address: lastStep.toSymbolAddress
+    }));
+    const sortedSourceTokens = getSortedTokens(fromChain, tokens, balances, []);
+    const sortedDestinationTokens = getSortedTokens(toChain, tokens, balances, []);
+    const inputAmount = pendingSwap.inputAmount;
+    set({
+      fromChain,
+      fromToken,
+      inputAmount,
+      outputAmount: null,
+      inputUsdValue: getUsdValue(fromToken || null, inputAmount),
+      outputUsdValue: new BigNumber__default(0),
+      toChain,
+      toToken,
+      bestRoute: null,
+      loading: false,
+      error: '',
+      sourceTokens: sortedSourceTokens,
+      destinationTokens: sortedDestinationTokens
+    });
   }
 }))));
 const bestRoute = (bestRouteStore, settingsStore) => {
@@ -978,12 +1088,12 @@ const bestRoute = (bestRouteStore, settingsStore) => {
       customSlippage,
       disabledLiquiditySources
     } = settingsStore.getState();
-    if (!fromToken || !toToken || !inputAmount) return;
+    if (!fromToken || !toToken || !inputAmount || inputAmount === '0') return;
     abortController?.abort();
     abortController = new AbortController();
     const userSlippage = !!customSlippage ? customSlippage : slippage;
     const requestBody = createBestRouteRequestBody(fromToken, toToken, inputAmount, [], [], disabledLiquiditySources, userSlippage, false);
-    bestRouteStore.setState({
+    if (!bestRouteStore.getState().loading) bestRouteStore.setState({
       loading: true,
       bestRoute: null,
       outputAmount: null,
@@ -1008,13 +1118,36 @@ const bestRoute = (bestRouteStore, settingsStore) => {
       });
     });
   };
+  const debouncedFetchBestRoute = debounce(fetchBestRoute, 600);
+  const bestRouteParamsListener = () => {
+    const {
+      fromToken,
+      toToken,
+      inputAmount,
+      inputUsdValue
+    } = useBestRouteStore.getState();
+    if (!inputAmount || inputAmount === '0') return;
+    if (tokensAreEqual(fromToken, toToken)) return bestRouteStore.setState({
+      loading: false,
+      bestRoute: null,
+      outputAmount: new BigNumber__default(inputAmount),
+      outputUsdValue: inputUsdValue
+    });
+    if (!bestRouteStore.getState().loading) bestRouteStore.setState({
+      loading: true,
+      bestRoute: null,
+      outputAmount: null,
+      outputUsdValue: new BigNumber__default(0)
+    });
+    debouncedFetchBestRoute();
+  };
   useBestRouteStore.subscribe(state => ({
     fromChain: state.fromChain,
     fromToken: state.fromToken,
     toChain: state.toChain,
     toToken: state.toToken,
     inputAmount: state.inputAmount
-  }), fetchBestRoute.bind(null), {
+  }), bestRouteParamsListener, {
     equalityFn: (prevState, state) => {
       if (isRouteParametersChanged(prevState, state)) return false;else return true;
     }
@@ -1023,7 +1156,7 @@ const bestRoute = (bestRouteStore, settingsStore) => {
     slippage: state.slippage,
     customSlippage: state.customSlippage,
     disabledLiquiditySources: state.disabledLiquiditySources
-  }), fetchBestRoute.bind(null), {
+  }), bestRouteParamsListener, {
     equalityFn: (prevState, state) => {
       if (isRouteParametersChanged(prevState, state)) return false;else return true;
     }
@@ -1048,11 +1181,15 @@ var SearchParams;
 const useUiStore = /*#__PURE__*/createSelectors( /*#__PURE__*/zustand.create()(set => ({
   connectWalletsButtonDisabled: false,
   selectedSwapRequestId: null,
+  currentPage: '',
   toggleConnectWalletsButton: () => set(state => ({
     connectWalletsButtonDisabled: !state.connectWalletsButtonDisabled
   })),
   setSelectedSwap: requestId => set({
     selectedSwapRequestId: requestId
+  }),
+  setCurrentPage: path => set({
+    currentPage: path
   })
 })));
 
@@ -1093,7 +1230,7 @@ function UpdateUrl() {
       toChainString = '',
       toTokenString = '',
       fromAmount = '';
-    if (loadingStatus !== 'success' && ![navigationRoutes.confirmWallets, navigationRoutes.confirmSwap].includes(location.pathname)) {
+    if (loadingStatus !== 'success' && location.pathname != navigationRoutes.confirmSwap) {
       fromChainString = searchParamsRef.current[SearchParams.FROM_CHAIN];
       fromTokenString = searchParamsRef.current[SearchParams.FROM_TOKEN];
       toChainString = searchParamsRef.current[SearchParams.TO_CHAIN];
@@ -1186,67 +1323,6 @@ function UpdateUrl() {
   return null;
 }
 
-const ButtonsContainer = /*#__PURE__*/ui.styled('div', {
-  display: 'flex'
-});
-function HeaderButtons(props) {
-  const {
-    onClickRefresh
-  } = props;
-  const navigate = reactRouterDom.useNavigate();
-  return React__default.createElement(ButtonsContainer, null, React__default.createElement(ui.Tooltip, {
-    content: "Refresh"
-  }, React__default.createElement(ui.Button, {
-    variant: "ghost",
-    onClick: onClickRefresh
-  }, React__default.createElement(ui.RetryIcon, {
-    size: 24
-  }))), React__default.createElement(ui.Tooltip, {
-    content: "Transactions History"
-  }, React__default.createElement(ui.Button, {
-    variant: "ghost",
-    onClick: () => navigate(navigationRoutes.swaps)
-  }, React__default.createElement(ui.HistoryIcon, {
-    size: 24
-  }))), React__default.createElement(ui.Tooltip, {
-    content: "Settings"
-  }, React__default.createElement(ui.Button, {
-    variant: "ghost",
-    onClick: () => navigate(navigationRoutes.settings)
-  }, React__default.createElement(ui.SettingsIcon, {
-    size: 24
-  }))));
-}
-
-const HeaderContainer = /*#__PURE__*/ui.styled('div', {
-  display: 'flex',
-  justifyContent: 'space-between',
-  alignItems: 'center',
-  width: '100%',
-  padding: '$16 0'
-});
-function Header(props) {
-  const {
-    onClickRefresh,
-    title,
-    titleSize,
-    titleWeight
-  } = props;
-  const {
-    t
-  } = reactI18next.useTranslation();
-  const titleStyle = ui.css({
-    fontSize: `${titleSize}px !important`,
-    fontWeight: `${titleWeight} !important`
-  });
-  return React__default.createElement(HeaderContainer, null, React__default.createElement(ui.Typography, {
-    variant: "h4",
-    className: titleStyle()
-  }, title ? t(title.toLocaleLowerCase()) : ''), React__default.createElement(HeaderButtons, {
-    onClickRefresh: onClickRefresh
-  }));
-}
-
 const Box = /*#__PURE__*/ui.styled('div', {
   display: 'flex',
   flexDirection: 'column',
@@ -1534,6 +1610,39 @@ const errorMessages = {
   genericServerError: 'Error connecting server, please reload the app and try again'
 };
 
+const ButtonsContainer = /*#__PURE__*/ui.styled('div', {
+  display: 'flex'
+});
+function HeaderButtons(props) {
+  const {
+    onClickRefresh
+  } = props;
+  const navigate = reactRouterDom.useNavigate();
+  return React__default.createElement(ButtonsContainer, null, React__default.createElement(ui.Tooltip, {
+    content: "Refresh"
+  }, React__default.createElement(ui.Button, {
+    variant: "ghost",
+    onClick: onClickRefresh,
+    disabled: !onClickRefresh
+  }, React__default.createElement(ui.RetryIcon, {
+    size: 24
+  }))), React__default.createElement(ui.Tooltip, {
+    content: "Transactions History"
+  }, React__default.createElement(ui.Button, {
+    variant: "ghost",
+    onClick: () => navigate(navigationRoutes.swaps)
+  }, React__default.createElement(ui.HistoryIcon, {
+    size: 24
+  }))), React__default.createElement(ui.Tooltip, {
+    content: "Settings"
+  }, React__default.createElement(ui.Button, {
+    variant: "ghost",
+    onClick: () => navigate(navigationRoutes.settings)
+  }, React__default.createElement(ui.SettingsIcon, {
+    size: 24
+  }))));
+}
+
 const Container$2 = /*#__PURE__*/ui.styled('div', {
   display: 'flex',
   flexDirection: 'column'
@@ -1558,9 +1667,7 @@ const Alerts = /*#__PURE__*/ui.styled('div', {
 });
 function Home(props) {
   const {
-    title = 'SWAP',
-    titleSize = 18,
-    titleWeight = 600
+    title = 'SWAP'
   } = props;
   const isRouterInContext = reactRouterDom.useInRouterContext();
   const navigate = reactRouterDom.useNavigate();
@@ -1584,6 +1691,7 @@ function Home(props) {
   const bestRouteError = useBestRouteStore.use.error();
   const loadingMetaStatus = useMetaStore.use.loadingStatus();
   const accounts = useWalletsStore.use.accounts();
+  const setCurrentPage = useUiStore.use.setCurrentPage();
   const swithFromAndTo = () => {
     setFromChain(toChain);
     setFromToken(toToken);
@@ -1607,11 +1715,15 @@ function Home(props) {
   const swapButtonState = getSwapButtonState(loadingMetaStatus, accounts, fetchingBestRoute, bestRoute, hasLimitError(bestRoute), highValueLoss, priceImpactCanNotBeComputed, needsToWarnEthOnPath, inputIsZero);
   const totalFeeInUsd = getTotalFeeInUsd(bestRoute, tokens);
   const highFee = hasHighFee(totalFeeInUsd);
-  return React__default.createElement(Container$2, null, React__default.createElement(Header, {
+  React.useEffect(() => {
+    setCurrentPage(navigationRoutes.home);
+    return setCurrentPage.bind(null, '');
+  }, []);
+  return React__default.createElement(Container$2, null, React__default.createElement(ui.Header, {
     title: title,
-    titleSize: titleSize,
-    titleWeight: titleWeight,
-    onClickRefresh: fetchBestRoute
+    suffix: React__default.createElement(HeaderButtons, {
+      onClickRefresh: !!bestRoute ? fetchBestRoute : undefined
+    })
   }), React__default.createElement(FromContainer, null, React__default.createElement(TokenInfo, {
     type: "From",
     chain: fromChain,
@@ -1622,7 +1734,7 @@ function Home(props) {
     variant: "ghost",
     onClick: swithFromAndTo
   }, React__default.createElement(ui.VerticalSwapIcon, {
-    size: 24
+    size: 32
   }), isRouterInContext && React__default.createElement(SwithFromAndTo, {
     count: count
   })))), React__default.createElement(TokenInfo, {
@@ -1656,7 +1768,7 @@ function Home(props) {
     disabled: swapButtonState.disabled,
     onClick: () => {
       if (swapButtonState.title === 'Connect Wallet') navigate(navigationRoutes.wallets);else {
-        navigate(navigationRoutes.confirmWallets, {
+        navigate(navigationRoutes.confirmSwap, {
           replace: true
         });
       }
@@ -1673,12 +1785,12 @@ const Route = _ref => {
   const navigate = reactRouter.useNavigate();
   const ref = React.useRef(true);
   React.useEffect(() => {
-    if ([navigationRoutes.confirmWallets, navigationRoutes.confirmSwap].includes(location.pathname) && ref.current) navigate(navigationRoutes.home + location.search, {
+    if (location.pathname === navigationRoutes.confirmSwap && ref.current) navigate(navigationRoutes.home + location.search, {
       state: 'redirect'
     });
     ref.current = false;
   }, []);
-  if ([navigationRoutes.confirmWallets, navigationRoutes.confirmSwap].includes(location.pathname) && ref.current) return React__default.createElement(Home, Object.assign({}, props));
+  if (location.pathname === navigationRoutes.confirmSwap && ref.current) return React__default.createElement(Home, Object.assign({}, props));
   return React__default.createElement(React__default.Fragment, null, " ", children);
 };
 function AppRouter(_ref2) {
@@ -1688,52 +1800,34 @@ function AppRouter(_ref2) {
   } = _ref2;
   const isRouterInContext = reactRouter.useInRouterContext();
   const Router = isRouterInContext ? Route : reactRouter.MemoryRouter;
-  return React__default.createElement(React__default.Fragment, null, React__default.createElement(Router, Object.assign({}, props), children), isRouterInContext && React__default.createElement(UpdateUrl, null));
-}
-
-function ChangeSlippageButton() {
-  const navigate = reactRouterDom.useNavigate();
-  return React__default.createElement(ui.Button, {
-    type: "primary",
-    variant: "outlined",
-    size: "small",
-    onClick: () => navigate(navigationRoutes.settings)
-  }, "Change Slippage");
-}
-
-function HighSlippageWarning(props) {
-  const {
-    selectedSlippage
-  } = props;
-  return React__default.createElement(ui.Alert, {
-    type: "warning",
-    footer: React__default.createElement(ChangeSlippageButton, null)
-  }, "Caution, your slippage is high (=", selectedSlippage, "). Your trade may be front run.");
-}
-
-function ConfirmSwapExtraMessages(props) {
   const {
-    selectedSlippage
-  } = props;
-  const highSlippage = selectedSlippage >= HIGH_SLIPPAGE;
-  return React__default.createElement(React__default.Fragment, null, highSlippage && React__default.createElement(HighSlippageWarning, {
-    selectedSlippage: selectedSlippage
-  }));
+    blockchains
+  } = useMetaStore.use.meta();
+  const evmChains = blockchains.filter(rangoTypes.isEvmBlockchain);
+  queueManagerRangoPreset.useQueueManager({
+    lastConnectedWallet: props.lastConnectedWallet,
+    clearDisconnectedWallet: props.clearDisconnectedWallet,
+    disconnectedWallet: props.disconnectedWallet,
+    evmChains,
+    notifier: () => {}
+  });
+  return React__default.createElement(React__default.Fragment, null, React__default.createElement(Router, Object.assign({}, props), children), isRouterInContext && React__default.createElement(UpdateUrl, null));
 }
 
 function useNavigateBack() {
   const isRouterInContext = reactRouterDom.useInRouterContext();
   const navigate = reactRouterDom.useNavigate();
   const navigateBackFrom = currentRoute => {
+    if (currentRoute === navigationRoutes.swapDetails) return navigate(navigationRoutes.swaps, {
+      replace: true
+    });
     if (!isRouterInContext || window.history.state && window.history.state.idx > 0) navigate(-1);else {
-      if ([navigationRoutes.fromChain, navigationRoutes.fromToken, navigationRoutes.toChain, navigationRoutes.toToken, navigationRoutes.settings, navigationRoutes.wallets, navigationRoutes.swaps, navigationRoutes.confirmWallets].includes(currentRoute)) navigate(navigationRoutes.home, {
+      if ([navigationRoutes.fromChain, navigationRoutes.fromToken, navigationRoutes.toChain, navigationRoutes.toToken, navigationRoutes.settings, navigationRoutes.wallets, navigationRoutes.swaps, navigationRoutes.confirmSwap].includes(currentRoute)) navigate(navigationRoutes.home, {
         replace: true
       });else if (currentRoute === navigationRoutes.liquiditySources) navigate(navigationRoutes.settings, {
         replace: true
       });else if (currentRoute === navigationRoutes.swapDetails) navigate(navigationRoutes.swaps, {
         replace: true
-      });else if (currentRoute === navigationRoutes.confirmSwap) navigate(navigationRoutes.confirmWallets, {
-        replace: true
       });
     }
   };
@@ -1742,122 +1836,192 @@ function useNavigateBack() {
   };
 }
 
-var ConfirmSwapErrorTypes;
-(function (ConfirmSwapErrorTypes) {
-  ConfirmSwapErrorTypes[ConfirmSwapErrorTypes["NO_ROUTE"] = 0] = "NO_ROUTE";
-  ConfirmSwapErrorTypes[ConfirmSwapErrorTypes["ROUTE_UPDATED_WITH_HIGH_VALUE_LOSS"] = 1] = "ROUTE_UPDATED_WITH_HIGH_VALUE_LOSS";
-  ConfirmSwapErrorTypes[ConfirmSwapErrorTypes["REQUEST_FAILED"] = 2] = "REQUEST_FAILED";
-  ConfirmSwapErrorTypes[ConfirmSwapErrorTypes["INSUFFICIENT_SLIPPAGE"] = 3] = "INSUFFICIENT_SLIPPAGE";
-})(ConfirmSwapErrorTypes || (ConfirmSwapErrorTypes = {}));
-var ConfirmSwapWarningTypes;
-(function (ConfirmSwapWarningTypes) {
-  ConfirmSwapWarningTypes[ConfirmSwapWarningTypes["ROUTE_UPDATED"] = 0] = "ROUTE_UPDATED";
-  ConfirmSwapWarningTypes[ConfirmSwapWarningTypes["ROUTE_SWAPPERS_UPDATED"] = 1] = "ROUTE_SWAPPERS_UPDATED";
-  ConfirmSwapWarningTypes[ConfirmSwapWarningTypes["ROUTE_COINS_UPDATED"] = 2] = "ROUTE_COINS_UPDATED";
-  ConfirmSwapWarningTypes[ConfirmSwapWarningTypes["ROUTE_AND_OUTPUT_AMOUNT_UPDATED"] = 3] = "ROUTE_AND_OUTPUT_AMOUNT_UPDATED";
-  ConfirmSwapWarningTypes[ConfirmSwapWarningTypes["INSUFFICIENT_BALANCE"] = 4] = "INSUFFICIENT_BALANCE";
-})(ConfirmSwapWarningTypes || (ConfirmSwapWarningTypes = {}));
-
-function MinRequiredSlippage(_ref) {
-  let {
-    minRequiredSlippage
-  } = _ref;
-  return React__default.createElement(ui.Typography, {
-    variant: "body2"
-  }, "We recommend you to increase slippage to at least \u00A0", minRequiredSlippage, "\u00A0 for this route.", React__default.createElement(ChangeSlippageButton, null));
-}
-
-function ConfirmSwapErrors(errors) {
-  return errors.flatMap(error => {
-    switch (error.type) {
-      case ConfirmSwapErrorTypes.NO_ROUTE:
-        return React__default.createElement(ui.Typography, {
-          variant: "body2"
-        }, "No routes found. Please try again later.");
-      case ConfirmSwapErrorTypes.REQUEST_FAILED:
-        return React__default.createElement(ui.Typography, {
-          variant: "body2"
-        }, `Failed to confirm swap ${error.status ? `'status': ${error.status})` : ''}, please try again.`);
-      case ConfirmSwapErrorTypes.ROUTE_UPDATED_WITH_HIGH_VALUE_LOSS:
-        return React__default.createElement(ui.Typography, {
-          variant: "body2"
-        }, "Route updated and price impact is too high, try again later!");
-      case ConfirmSwapErrorTypes.INSUFFICIENT_SLIPPAGE:
-        return React__default.createElement(MinRequiredSlippage, {
-          minRequiredSlippage: error.minRequiredSlippage
-        });
-      default:
-        return [];
-    }
-  });
-}
-
-const List = /*#__PURE__*/ui.styled('ul', {
-  variants: {
-    showListStyle: {
-      true: {
-        paddingLeft: '$24'
-      }
-    }
-  }
+const Box$1 = /*#__PURE__*/ui.styled('div', {
+  display: 'flex',
+  flexDirection: 'column',
+  width: '100%'
 });
-const ListItem = /*#__PURE__*/ui.styled('li', {
+const Container$3 = /*#__PURE__*/ui.styled('div', {
+  boxSizing: 'border-box',
+  borderRadius: '$5',
+  padding: '$8 $16 $16 $16',
   variants: {
-    showListStyle: {
-      true: {
-        listStyleType: 'disc',
-        listStylePosition: 'outside'
+    type: {
+      filled: {
+        backgroundColor: '$neutrals300'
+      },
+      outlined: {
+        border: '1px solid $neutrals300'
       }
     }
-  }
-});
-const Message = /*#__PURE__*/ui.styled(ui.Typography, {
-  display: 'block'
-});
-function BalanceWarnings(_ref) {
-  let {
-    messages
-  } = _ref;
-  const showListStyle = messages.length > 1;
-  return React__default.createElement(List, {
-    showListStyle: showListStyle
-  }, messages.map(warning => React__default.createElement(ListItem, {
-    showListStyle: showListStyle
-  }, React__default.createElement(Message, {
-    variant: "body2"
-  }, warning))));
+  },
+  defaultVariants: {
+    type: 'filled'
+  },
+  '.head': {
+    display: 'flex',
+    justifyContent: 'space-between',
+    alignItems: 'center',
+    minHeight: '32px'
+  },
+  '.form': {
+    display: 'flex',
+    width: '100%',
+    padding: '$2 0',
+    '.selectors': {
+      width: '35%',
+      '._text': {
+        whiteSpace: 'nowrap',
+        overflow: 'hidden',
+        textOverflow: 'ellipsis'
+      }
+    },
+    '.amount': {
+      width: '30%'
+    }
+  }
+});
+const StyledImage$1 = /*#__PURE__*/ui.styled('img', {
+  width: '$24',
+  maxHeight: '$24'
+});
+const ImagePlaceholder$1 = /*#__PURE__*/ui.styled('span', {
+  width: '24px',
+  height: '24px',
+  backgroundColor: '$neutrals300',
+  borderRadius: '99999px'
+});
+const OutputContainer$1 = /*#__PURE__*/ui.styled('div', {
+  windth: '100%',
+  height: '$48',
+  borderRadius: '$5',
+  backgroundColor: '$background',
+  border: '1px solid transparent',
+  position: 'relative',
+  display: 'flex',
+  alignItems: 'center',
+  paddingLeft: '$8',
+  paddingRight: '$8'
+});
+function TokenPreview(props) {
+  const {
+    chain,
+    token,
+    loadingStatus
+  } = props;
+  const {
+    t
+  } = reactI18next.useTranslation();
+  const ItemSuffix = React__default.createElement("div", {
+    style: {
+      display: 'flex',
+      justifyContent: 'center',
+      alignItems: 'center'
+    }
+  }, loadingStatus === 'failed' && React__default.createElement(ui.InfoCircleIcon, {
+    color: "error",
+    size: 24
+  }));
+  return React__default.createElement(Box$1, null, React__default.createElement(Container$3, {
+    type: 'outlined'
+  }, React__default.createElement("div", {
+    className: "head"
+  }, React__default.createElement(ui.Typography, {
+    variant: "body2",
+    color: "neutrals800"
+  }, props.label), props.usdValue && React__default.createElement(ui.Typography, {
+    variant: "caption",
+    color: "neutrals600"
+  }, `$${numberToString(props.usdValue)}`)), React__default.createElement("div", {
+    className: "form"
+  }, React__default.createElement(ui.Button, {
+    className: "selectors",
+    variant: "outlined",
+    loading: loadingStatus === 'loading',
+    prefix: loadingStatus === 'success' && chain ? React__default.createElement(StyledImage$1, {
+      src: chain.logo
+    }) : React__default.createElement(ImagePlaceholder$1, null),
+    suffix: ItemSuffix,
+    align: "start",
+    size: "large"
+  }, loadingStatus === 'success' && chain ? chain.displayName : t('Chain')), React__default.createElement(ui.Spacer, {
+    size: 12
+  }), React__default.createElement(ui.Button, {
+    className: "selectors",
+    variant: "outlined",
+    loading: loadingStatus === 'loading',
+    prefix: loadingStatus === 'success' && token ? React__default.createElement(StyledImage$1, {
+      src: token.image
+    }) : React__default.createElement(ImagePlaceholder$1, null),
+    suffix: ItemSuffix,
+    size: "large",
+    align: "start"
+  }, loadingStatus === 'success' && token ? token.symbol : t('Token')), React__default.createElement(ui.Spacer, {
+    size: 12
+  }), React__default.createElement("div", {
+    className: "amount"
+  }, React__default.createElement(OutputContainer$1, null, React__default.createElement(ui.Typography, {
+    variant: "h4"
+  }, props.amount))))));
 }
 
-function ConfirmSwapWarnings(warnings) {
-  return warnings.flatMap(warning => {
-    switch (warning.type) {
-      case ConfirmSwapWarningTypes.ROUTE_UPDATED:
-        return React__default.createElement(ui.Typography, {
-          variant: "body2"
-        }, "Route has been updated.");
-      case ConfirmSwapWarningTypes.ROUTE_AND_OUTPUT_AMOUNT_UPDATED:
-        return React__default.createElement(ui.Typography, {
-          variant: "body2"
-        }, `Output amount changed to ${warning.newOutputAmount} 
-      (${warning.percentageChange}% change).`);
-      case ConfirmSwapWarningTypes.ROUTE_SWAPPERS_UPDATED:
-        return React__default.createElement(ui.Typography, {
-          variant: "body2"
-        }, "Route swappers has been updated.");
-      case ConfirmSwapWarningTypes.ROUTE_COINS_UPDATED:
-        return React__default.createElement(ui.Typography, {
-          variant: "body2"
-        }, "Route internal coins has been updated.");
-      case ConfirmSwapWarningTypes.INSUFFICIENT_BALANCE:
-        return React__default.createElement(BalanceWarnings, {
-          messages: warning.messages
-        });
-      default:
-        return [];
-    }
-  });
+const Container$4 = /*#__PURE__*/ui.styled('div', {
+  display: 'flex',
+  alignItems: 'center',
+  justifyContent: 'space-between',
+  padding: '$8',
+  borderRadius: '$5',
+  backgroundColor: '$neutrals300',
+  color: '$neutrals800',
+  fontSize: '$12',
+  '.routes': {
+    display: 'flex',
+    alignItems: 'center'
+  },
+  '.fee': {
+    display: 'flex',
+    alignItems: 'center'
+  }
+});
+function RoutesOverview(props) {
+  if (!props.routes) return null;
+  const swaps = props.routes.result?.swaps;
+  return React__default.createElement(Container$4, null, React__default.createElement("div", {
+    className: "routes"
+  }, swaps?.map((swap, idx) => {
+    const isLast = idx + 1 == swaps.length;
+    return React__default.createElement(React__default.Fragment, null, React__default.createElement("div", {
+      className: "route"
+    }, swap.from.symbol), React__default.createElement(ui.ChevronRightIcon, {
+      size: 12
+    }), isLast ? React__default.createElement("div", {
+      className: "route"
+    }, swap.to.symbol) : null);
+  })), props.totalFee ? React__default.createElement("div", {
+    className: "fee"
+  }, React__default.createElement(ui.GasIcon, {
+    size: 12
+  }), React__default.createElement(ui.Spacer, {
+    size: 4
+  }), "$", props.totalFee) : null);
 }
 
+var ConfirmSwapErrorTypes;
+(function (ConfirmSwapErrorTypes) {
+  ConfirmSwapErrorTypes[ConfirmSwapErrorTypes["NO_ROUTE"] = 0] = "NO_ROUTE";
+  ConfirmSwapErrorTypes[ConfirmSwapErrorTypes["ROUTE_UPDATED_WITH_HIGH_VALUE_LOSS"] = 1] = "ROUTE_UPDATED_WITH_HIGH_VALUE_LOSS";
+  ConfirmSwapErrorTypes[ConfirmSwapErrorTypes["REQUEST_FAILED"] = 2] = "REQUEST_FAILED";
+  ConfirmSwapErrorTypes[ConfirmSwapErrorTypes["INSUFFICIENT_SLIPPAGE"] = 3] = "INSUFFICIENT_SLIPPAGE";
+})(ConfirmSwapErrorTypes || (ConfirmSwapErrorTypes = {}));
+var ConfirmSwapWarningTypes;
+(function (ConfirmSwapWarningTypes) {
+  ConfirmSwapWarningTypes[ConfirmSwapWarningTypes["ROUTE_UPDATED"] = 0] = "ROUTE_UPDATED";
+  ConfirmSwapWarningTypes[ConfirmSwapWarningTypes["ROUTE_SWAPPERS_UPDATED"] = 1] = "ROUTE_SWAPPERS_UPDATED";
+  ConfirmSwapWarningTypes[ConfirmSwapWarningTypes["ROUTE_COINS_UPDATED"] = 2] = "ROUTE_COINS_UPDATED";
+  ConfirmSwapWarningTypes[ConfirmSwapWarningTypes["ROUTE_AND_OUTPUT_AMOUNT_UPDATED"] = 3] = "ROUTE_AND_OUTPUT_AMOUNT_UPDATED";
+  ConfirmSwapWarningTypes[ConfirmSwapWarningTypes["INSUFFICIENT_BALANCE"] = 4] = "INSUFFICIENT_BALANCE";
+})(ConfirmSwapWarningTypes || (ConfirmSwapWarningTypes = {}));
+
 function useConfirmSwap() {
   const fromToken = useBestRouteStore.use.fromToken();
   const toToken = useBestRouteStore.use.toToken();
@@ -1898,6 +2062,7 @@ function useConfirmSwap() {
       proceedAnywayRef.current = false;
       if (confiremedRouteRef.current) {
         const newSwap = calculatePendingSwap(inputAmount.toString(), confiremedRouteRef.current, getWalletsForNewSwap(selectedWallets), swapSettings, false, meta);
+        //@ts-ignore
         return newSwap;
       }
       return;
@@ -1960,6 +2125,7 @@ function useConfirmSwap() {
           disabledSwappersGroups: disabledLiquiditySources
         };
         const newSwap = calculatePendingSwap(inputAmount.toString(), confiremedRoute, getWalletsForNewSwap(selectedWallets), swapSettings, false, meta);
+        //@ts-ignore
         return newSwap;
       } else if (!proceedAnywayRef.current) {
         proceedAnywayRef.current = true;
@@ -1989,62 +2155,262 @@ function useConfirmSwap() {
   };
 }
 
-function ConfirmSwapPage() {
-  const setSelectedSwap = useUiStore.use.setSelectedSwap();
-  const {
-    navigateBackFrom
-  } = useNavigateBack();
-  const {
-    manager
-  } = queueManagerReact.useManager();
+function ChangeSlippageButton() {
   const navigate = reactRouterDom.useNavigate();
-  const bestRoute = useBestRouteStore.use.bestRoute();
-  const fetchingBestRoute = useBestRouteStore.use.loading();
-  const {
-    tokens
-  } = useMetaStore.use.meta();
-  const slippage = useSettingsStore.use.slippage();
-  const customSlippage = useSettingsStore.use.customSlippage();
-  const selectedSlippage = customSlippage || slippage;
-  const {
-    loading,
-    errors,
-    warnings,
-    confirmSwap
-  } = useConfirmSwap();
-  const showHighSlippageWarning = !errors.find(error => error.type === ConfirmSwapErrorTypes.INSUFFICIENT_SLIPPAGE);
-  return React__default.createElement(ui.ConfirmSwap, {
-    onConfirm: () => {
-      confirmSwap?.().then(swap => {
-        if (swap) {
-          manager?.create('swap', {
-            swapDetails: swap
-          }, {
-            id: swap.requestId
-          });
-          setSelectedSwap(swap.requestId);
-          navigate(navigationRoutes.swaps + `/${swap.requestId}`, {
-            replace: true
-          });
-        }
-      });
-    },
-    onBack: navigateBackFrom.bind(null, navigationRoutes.confirmSwap),
-    bestRoute: getBestRouteWithCalculatedFees(bestRoute, tokens),
-    loading: loading,
-    errors: ConfirmSwapErrors(errors),
-    warnings: ConfirmSwapWarnings(warnings),
-    extraMessages: showHighSlippageWarning && React__default.createElement(ConfirmSwapExtraMessages, {
-      selectedSlippage: selectedSlippage
-    }),
-    confirmButtonTitle: warnings.length > 0 || errors.length > 0 ? 'Proceed anyway!' : 'Confirm swap!',
-    confirmButtonDisabled: fetchingBestRoute
-  });
+  return React__default.createElement(ui.Button, {
+    type: "primary",
+    variant: "outlined",
+    size: "small",
+    onClick: () => navigate(navigationRoutes.settings)
+  }, "Change Slippage");
 }
 
-const getPendingSwaps = manager => {
-  const result = [];
-  manager?.getAll().forEach((q, id) => {
+const StyledMessage = /*#__PURE__*/ui.styled(ui.Typography, {
+  color: '$error500 !important'
+});
+function MinRequiredSlippage(_ref) {
+  let {
+    minRequiredSlippage
+  } = _ref;
+  return React__default.createElement(StyledMessage, {
+    variant: "body2"
+  }, "We recommend you to increase slippage to at least \u00A0", minRequiredSlippage, "\u00A0 for this route.", React__default.createElement(ui.Spacer, {
+    size: 8,
+    direction: "vertical"
+  }), React__default.createElement(ChangeSlippageButton, null));
+}
+
+function ConfirmSwapErrors(errors) {
+  return errors.flatMap(error => {
+    switch (error.type) {
+      case ConfirmSwapErrorTypes.NO_ROUTE:
+        return React__default.createElement(ui.Typography, {
+          variant: "body2"
+        }, "No routes found. Please try again later.");
+      case ConfirmSwapErrorTypes.REQUEST_FAILED:
+        return React__default.createElement(ui.Typography, {
+          variant: "body2"
+        }, `Failed to confirm swap ${error.status ? `'status': ${error.status})` : ''}, please try again.`);
+      case ConfirmSwapErrorTypes.ROUTE_UPDATED_WITH_HIGH_VALUE_LOSS:
+        return React__default.createElement(ui.Typography, {
+          variant: "body2"
+        }, "Route updated and price impact is too high, try again later!");
+      case ConfirmSwapErrorTypes.INSUFFICIENT_SLIPPAGE:
+        return React__default.createElement(MinRequiredSlippage, {
+          minRequiredSlippage: error.minRequiredSlippage
+        });
+      default:
+        return [];
+    }
+  });
+}
+
+const List = /*#__PURE__*/ui.styled('ul', {
+  variants: {
+    showListStyle: {
+      true: {
+        paddingLeft: '$24'
+      }
+    }
+  }
+});
+const ListItem = /*#__PURE__*/ui.styled('li', {
+  variants: {
+    showListStyle: {
+      true: {
+        listStyleType: 'disc',
+        listStylePosition: 'outside'
+      }
+    }
+  }
+});
+const Message = /*#__PURE__*/ui.styled(ui.Typography, {
+  display: 'block',
+  color: '$warning500 !important'
+});
+function BalanceWarnings(_ref) {
+  let {
+    messages
+  } = _ref;
+  const showListStyle = messages.length > 1;
+  return React__default.createElement(List, {
+    showListStyle: showListStyle
+  }, messages.map(warning => React__default.createElement(ListItem, {
+    showListStyle: showListStyle
+  }, React__default.createElement(Message, {
+    variant: "body2"
+  }, warning))));
+}
+
+function ConfirmSwapWarnings(warnings) {
+  return warnings.flatMap(warning => {
+    switch (warning.type) {
+      case ConfirmSwapWarningTypes.ROUTE_UPDATED:
+        return React__default.createElement(ui.Typography, {
+          variant: "body2"
+        }, "Route has been updated.");
+      case ConfirmSwapWarningTypes.ROUTE_AND_OUTPUT_AMOUNT_UPDATED:
+        return React__default.createElement(ui.Typography, {
+          variant: "body2"
+        }, `Output amount changed to ${warning.newOutputAmount} 
+      (${warning.percentageChange}% change).`);
+      case ConfirmSwapWarningTypes.ROUTE_SWAPPERS_UPDATED:
+        return React__default.createElement(ui.Typography, {
+          variant: "body2"
+        }, "Route swappers has been updated.");
+      case ConfirmSwapWarningTypes.ROUTE_COINS_UPDATED:
+        return React__default.createElement(ui.Typography, {
+          variant: "body2"
+        }, "Route internal coins has been updated.");
+      case ConfirmSwapWarningTypes.INSUFFICIENT_BALANCE:
+        return React__default.createElement(BalanceWarnings, {
+          messages: warning.messages
+        });
+      default:
+        return [];
+    }
+  });
+}
+
+function HighSlippageWarning(props) {
+  const {
+    selectedSlippage
+  } = props;
+  return React__default.createElement(ui.Alert, {
+    type: "warning",
+    footer: React__default.createElement(ChangeSlippageButton, null)
+  }, "Caution, your slippage is high (=", selectedSlippage, "). Your trade may be front run.");
+}
+
+function ConfirmSwapExtraMessages(props) {
+  const {
+    selectedSlippage
+  } = props;
+  const highSlippage = selectedSlippage >= HIGH_SLIPPAGE;
+  return React__default.createElement(React__default.Fragment, null, highSlippage && React__default.createElement(HighSlippageWarning, {
+    selectedSlippage: selectedSlippage
+  }));
+}
+
+function ConfirmSwapPage() {
+  const navigate = reactRouterDom.useNavigate();
+  const {
+    navigateBackFrom
+  } = useNavigateBack();
+  const bestRoute = useBestRouteStore.use.bestRoute();
+  const fetchingBestRoute = useBestRouteStore.use.loading();
+  const fetchingBestRouteError = useBestRouteStore.use.error();
+  const setSelectedSwap = useUiStore.use.setSelectedSwap();
+  const {
+    blockchains,
+    tokens
+  } = useMetaStore.use.meta();
+  const accounts = useWalletsStore.use.accounts();
+  const selectedWallets = useWalletsStore.use.selectedWallets();
+  const initSelectedWallets = useWalletsStore.use.initSelectedWallets();
+  const setSelectedWallet = useWalletsStore.use.setSelectedWallet();
+  const slippage = useSettingsStore.use.slippage();
+  const customSlippage = useSettingsStore.use.customSlippage();
+  const bestRouteloadingStatus = getBestRouteStatus(fetchingBestRoute, !!fetchingBestRouteError);
+  const {
+    manager
+  } = queueManagerReact.useManager();
+  const {
+    loading,
+    errors,
+    warnings,
+    confirmSwap
+  } = useConfirmSwap();
+  const selectedSlippage = customSlippage || slippage;
+  const showHighSlippageWarning = !errors.find(error => error.type === ConfirmSwapErrorTypes.INSUFFICIENT_SLIPPAGE);
+  const {
+    getWalletInfo,
+    connect
+  } = walletsCore.useWallets();
+  const confirmDisabled = fetchingBestRoute || !requiredWallets(bestRoute).every(chain => selectedWallets.map(wallet => wallet.chain).includes(chain));
+  const firstStep = bestRoute?.result?.swaps[0];
+  const lastStep = bestRoute?.result?.swaps[bestRoute?.result?.swaps.length - 1];
+  const fromAmount = decimalNumber(firstStep?.fromAmount, 3);
+  const toAmount = decimalNumber(lastStep?.toAmount, 3);
+  React.useEffect(() => {
+    initSelectedWallets();
+  }, []);
+  const selectableWallets = getSelectableWallets(accounts, selectedWallets, getWalletInfo);
+  const handleConnectChain = wallet => {
+    const network = wallet;
+    getKeplrCompatibleConnectedWallets(selectableWallets).forEach(compatibleWallet => connect?.(compatibleWallet, network));
+  };
+  const totalFeeInUsd = getTotalFeeInUsd(bestRoute, tokens);
+  return React__default.createElement(ui.ConfirmSwap, {
+    requiredWallets: getRequiredChains(bestRoute),
+    selectableWallets: selectableWallets,
+    onBack: navigateBackFrom.bind(null, navigationRoutes.confirmSwap),
+    onConfirm: () => {
+      confirmSwap?.().then(swap => {
+        if (swap) {
+          manager?.create('swap', {
+            swapDetails: swap
+          }, {
+            id: swap.requestId
+          });
+          setSelectedSwap(swap.requestId);
+          navigate(navigationRoutes.swaps + `/${swap.requestId}`, {
+            replace: true
+          });
+        }
+      });
+    },
+    onChange: wallet => setSelectedWallet(wallet),
+    confirmDisabled: confirmDisabled,
+    handleConnectChain: wallet => handleConnectChain(wallet),
+    isExperimentalChain: wallet => getKeplrCompatibleConnectedWallets(selectableWallets).length > 0 ? isExperimentalChain(blockchains, wallet) : false,
+    previewInputs: React__default.createElement(React__default.Fragment, null, React__default.createElement(TokenPreview, {
+      chain: {
+        displayName: firstStep?.from.blockchain || '',
+        logo: firstStep?.from.blockchainLogo || ''
+      },
+      token: {
+        symbol: firstStep?.from.symbol || '',
+        image: firstStep?.from.logo || ''
+      },
+      usdValue: calcOutputUsdValue(fromAmount, firstStep?.from.usdPrice),
+      amount: fromAmount,
+      label: i18n.t('From'),
+      loadingStatus: bestRouteloadingStatus
+    }), React__default.createElement(ui.Spacer, {
+      size: 12,
+      direction: "vertical"
+    }), React__default.createElement(TokenPreview, {
+      chain: {
+        displayName: lastStep?.to.blockchain || '',
+        logo: lastStep?.to.blockchainLogo || ''
+      },
+      token: {
+        symbol: lastStep?.to.symbol || '',
+        image: lastStep?.to.logo || ''
+      },
+      usdValue: calcOutputUsdValue(toAmount, lastStep?.to.usdPrice),
+      amount: toAmount,
+      label: i18n.t('To'),
+      loadingStatus: bestRouteloadingStatus
+    })),
+    previewRoutes: React__default.createElement(RoutesOverview, {
+      routes: bestRoute,
+      totalFee: numberToString(totalFeeInUsd, 0, 2)
+    }),
+    loading: loading,
+    errors: ConfirmSwapErrors(errors),
+    warnings: ConfirmSwapWarnings(warnings),
+    extraMessages: showHighSlippageWarning && React__default.createElement(ConfirmSwapExtraMessages, {
+      selectedSlippage: selectedSlippage
+    }),
+    confirmButtonTitle: warnings.length > 0 || errors.length > 0 ? 'Proceed anyway!' : 'Confirm swap!'
+  });
+}
+
+const getPendingSwaps = manager => {
+  const result = [];
+  manager?.getAll().forEach((q, id) => {
     const storage = q.list.getStorage();
     if (storage?.swapDetails) {
       result.push({
@@ -2056,6 +2422,31 @@ const getPendingSwaps = manager => {
   return result.sort((a, b) => Number(b.swap.creationTime) - Number(a.swap.creationTime));
 };
 
+const groupSwapsByDate = swaps => {
+  const output = new Map([['today', {
+    title: 'Today',
+    swaps: []
+  }], ['week', {
+    title: 'This week',
+    swaps: []
+  }], ['month', {
+    title: 'This month',
+    swaps: []
+  }], ['year', {
+    title: 'This year',
+    swaps: []
+  }], ['history', {
+    title: 'History',
+    swaps: []
+  }]]);
+  const now = dayjs();
+  swaps.forEach(swap => {
+    const swapDate = dayjs(Number(swap.creationTime));
+    if (now.isSame(swapDate, 'day')) output.get('today')?.swaps.push(swap);else if (now.isSame(swapDate, 'week')) output.get('week')?.swaps.push(swap);else if (now.isSame(swapDate, 'month')) output.get('month')?.swaps.push(swap);else if (now.isSame(swapDate, 'year')) output.get('year')?.swaps.push(swap);else output.get('history')?.swaps.push(swap);
+  });
+  return Array.from(output.values());
+};
+
 function HistoryPage() {
   const setSelectedSwap = useUiStore.use.setSelectedSwap();
   const navigate = reactRouterDom.useNavigate();
@@ -2071,16 +2462,14 @@ function HistoryPage() {
     } = _ref;
     return swap;
   });
-  return React__default.createElement(ui.History
-  //todo: move PendingSwap type to rango-types
-  //@ts-ignore
-  , {
-    //todo: move PendingSwap type to rango-types
-    //@ts-ignore
+  return React__default.createElement(ui.History, {
     list: pendingSwaps,
+    groupBy: groupSwapsByDate,
     onSwapClick: requestId => {
       setSelectedSwap(requestId);
-      navigate(navigationRoutes.swaps + `/${requestId}`);
+      navigate(navigationRoutes.swaps + `/${requestId}`, {
+        replace: true
+      });
     },
     onBack: navigateBackFrom.bind(null, navigationRoutes.swaps)
   });
@@ -2091,6 +2480,7 @@ function LiquiditySourcePage(_ref) {
     supportedSwappers
   } = _ref;
   const swappers = useMetaStore.use.meta().swappers;
+  const loadingMetaStatus = useMetaStore.use.loadingStatus();
   const toggleLiquiditySource = useSettingsStore.use.toggleLiquiditySource();
   const disabledLiquiditySources = useSettingsStore.use.disabledLiquiditySources();
   const toggleAllLiquiditySources = useSettingsStore.use.toggleAllLiquiditySources();
@@ -2116,7 +2506,8 @@ function LiquiditySourcePage(_ref) {
     toggleAll: toggleAllLiquiditySources,
     list: supportedSwappers !== 'all' ? uniqueSwappersGroups.filter(item => supportedSwappers.filter(s => s.title === item.title && s.type === item.type).length > 0) : uniqueSwappersGroups,
     onChange: liquiditySource => toggleLiquiditySource(liquiditySource.title),
-    onBack: navigateBackFrom.bind(null, navigationRoutes.liquiditySources)
+    onBack: navigateBackFrom.bind(null, navigationRoutes.liquiditySources),
+    loadingStatus: loadingMetaStatus
   });
 }
 
@@ -2159,403 +2550,168 @@ function SelectTokenPage(props) {
   const destinationTokens = useBestRouteStore.use.destinationTokens();
   const supportedSourceTokens = supportedTokens === 'all' ? sourceTokens : sourceTokens.filter(token => supportedTokens.some(supportedToken => tokensAreEqual(supportedToken, token)));
   const supportedDestinationTokens = supportedTokens === 'all' ? destinationTokens : destinationTokens.filter(token => supportedTokens.some(supportedToken => tokensAreEqual(supportedToken, token)));
-  console.log(supportedSourceTokens);
   const fromToken = useBestRouteStore.use.fromToken();
   const toToken = useBestRouteStore.use.toToken();
   const setFromToken = useBestRouteStore.use.setFromToken();
   const setToToken = useBestRouteStore.use.setToToken();
+  const loadingMetaStatus = useMetaStore.use.loadingStatus();
   return React__default.createElement(ui.TokenSelector, {
     type: type === 'from' ? 'Source' : 'Destination',
     list: type == 'from' ? supportedSourceTokens : supportedDestinationTokens,
     selected: type === 'from' ? fromToken : toToken,
     onChange: token => {
-      if (type === 'from') setFromToken(token);else setToToken(token);
-      navigateBackFrom(navigationRoutes.fromToken);
-    },
-    onBack: navigateBackFrom.bind(null, navigationRoutes.fromToken)
-  });
-}
-
-function SettingsPage(_ref) {
-  let {
-    supportedSwappers
-  } = _ref;
-  const slippage = useSettingsStore.use.slippage();
-  const setSlippage = useSettingsStore.use.setSlippage();
-  const disabledLiquiditySources = useSettingsStore.use.disabledLiquiditySources();
-  const customSlippage = useSettingsStore.use.customSlippage();
-  const setCustomSlippage = useSettingsStore.use.setCustomSlippage();
-  const theme = useSettingsStore.use.theme();
-  const setTheme = useSettingsStore.use.setTheme();
-  const swappers = useMetaStore.use.meta().swappers;
-  const navigate = reactRouterDom.useNavigate();
-  const {
-    navigateBackFrom
-  } = useNavigateBack();
-  const infiniteApprove = useSettingsStore.use.infiniteApprove();
-  const toggleInfiniteApprove = useSettingsStore.use.toggleInfiniteApprove();
-  const uniqueSwappersGroups = [];
-  removeDuplicateFrom(swappers.map(s => s.swapperGroup)).map(swapperGroup => {
-    return swappers.find(s => s.swapperGroup === swapperGroup);
-  }).find(s => {
-    if (s) {
-      for (const type of s.types) {
-        uniqueSwappersGroups.push({
-          title: s.swapperGroup,
-          logo: s.logo,
-          type,
-          selected: !disabledLiquiditySources.includes(s.swapperGroup)
-        });
-      }
-    }
-  });
-  supportedSwappers !== 'all' && uniqueSwappersGroups.filter(item => supportedSwappers.filter(s => s.title === item.title && s.type === item.type).length > 0);
-  const supportedUniqueSwappersGroups = supportedSwappers !== 'all' ? uniqueSwappersGroups.filter(item => supportedSwappers.filter(s => s.title === item.title && s.type === item.type).length > 0) : uniqueSwappersGroups;
-  return React__default.createElement(ui.Settings, {
-    slippages: SLIPPAGES,
-    selectedSlippage: slippage,
-    onSlippageChange: slippage => setSlippage(slippage),
-    onLiquiditySourcesClick: () => navigate(navigationRoutes.liquiditySources),
-    onBack: navigateBackFrom.bind(null, navigationRoutes.settings),
-    liquiditySources: supportedUniqueSwappersGroups,
-    selectedLiquiditySources: supportedUniqueSwappersGroups.filter(s => s.selected),
-    customSlippage: customSlippage || NaN,
-    onCustomSlippageChange: setCustomSlippage,
-    minSlippage: MIN_SLIPPGAE,
-    maxSlippage: MAX_SLIPPAGE,
-    selectedTheme: theme,
-    onThemeChange: setTheme,
-    infiniteApprove: infiniteApprove,
-    toggleInfiniteApprove: toggleInfiniteApprove
-  });
-}
-
-const ListContainer = /*#__PURE__*/ui.styled('div', {
-  display: 'grid',
-  gap: '.5rem',
-  gridTemplateColumns: ' repeat(2, minmax(0, 1fr))',
-  height: '450px',
-  alignContent: 'baseline',
-  padding: '0.5rem'
-});
-const AlertContainer = /*#__PURE__*/ui.styled('div', {
-  paddingBottom: '$16'
-});
-function WalletsPage(_ref) {
-  let {
-    supportedWallets,
-    multiWallets
-  } = _ref;
-  const {
-    navigateBackFrom
-  } = useNavigateBack();
-  const {
-    state,
-    disconnect,
-    getWalletInfo,
-    connect
-  } = walletsCore.useWallets();
-  const wallets = getlistWallet(state, getWalletInfo, supportedWallets === 'all' ? Object.values(walletsShared.WalletType) : supportedWallets);
-  const walletsRef = React.useRef();
-  let sortedWallets = walletsShared.detectMobileScreens() ? wallets.filter(wallet => wallet.showOnMobile) : wallets;
-  sortedWallets = sortWalletsBasedOnState(sortedWallets);
-  const [walletErrorMessage, setWalletErrorMessage] = React.useState('');
-  const toggleConnectWalletsButton = useUiStore.use.toggleConnectWalletsButton();
-  const {
-    t
-  } = reactI18next.useTranslation();
-  const onSelectWallet = async type => {
-    const wallet = state(type);
-    try {
-      if (walletErrorMessage) setWalletErrorMessage('');
-      if (wallet.connected) {
-        await disconnect(type);
-      } else {
-        if (!multiWallets && !!wallets.find(w => w.state === ui.WalletState.CONNECTED)) {
-          return;
-        }
-        await connect(type);
-      }
-    } catch (e) {
-      setWalletErrorMessage('Error: ' + e?.message);
-    }
-  };
-  const disconnectConnectingWallets = () => {
-    const connectingWallets = walletsRef.current?.filter(wallet => wallet.state === ui.WalletState.CONNECTING) || [];
-    for (const wallet of connectingWallets) {
-      disconnect(wallet.type);
-    }
-  };
-  React.useEffect(() => {
-    toggleConnectWalletsButton();
-    return () => {
-      disconnectConnectingWallets();
-      toggleConnectWalletsButton();
-    };
-  }, []);
-  React.useEffect(() => {
-    walletsRef.current = wallets;
-  }, [wallets]);
-  return React__default.createElement(ui.SecondaryPage, {
-    title: t('Select Wallet') || '',
-    textField: false,
-    onBack: navigateBackFrom.bind(null, navigationRoutes.wallets)
-  }, React__default.createElement(React__default.Fragment, null, walletErrorMessage && React__default.createElement(AlertContainer, null, React__default.createElement(ui.Alert, {
-    type: "error"
-  }, walletErrorMessage)), React__default.createElement(ListContainer, null, sortedWallets.map((wallet, index) => React__default.createElement(ui.Wallet, Object.assign({}, wallet, {
-    key: `${index}-${wallet.type}`,
-    onClick: onSelectWallet
-  }))))));
-}
-
-const Box$1 = /*#__PURE__*/ui.styled('div', {
-  display: 'flex',
-  flexDirection: 'column',
-  width: '100%'
-});
-const Container$3 = /*#__PURE__*/ui.styled('div', {
-  boxSizing: 'border-box',
-  borderRadius: '$5',
-  padding: '$8 $16 $16 $16',
-  variants: {
-    type: {
-      filled: {
-        backgroundColor: '$neutrals300'
-      },
-      outlined: {
-        border: '1px solid $neutrals300'
-      }
-    }
-  },
-  defaultVariants: {
-    type: 'filled'
-  },
-  '.head': {
-    display: 'flex',
-    justifyContent: 'space-between',
-    alignItems: 'center',
-    minHeight: '32px'
-  },
-  '.form': {
-    display: 'flex',
-    width: '100%',
-    padding: '$2 0',
-    '.selectors': {
-      width: '35%',
-      '._text': {
-        whiteSpace: 'nowrap',
-        overflow: 'hidden',
-        textOverflow: 'ellipsis'
-      }
-    },
-    '.amount': {
-      width: '30%'
-    }
-  }
-});
-const StyledImage$1 = /*#__PURE__*/ui.styled('img', {
-  width: '$24',
-  maxHeight: '$24'
-});
-const ImagePlaceholder$1 = /*#__PURE__*/ui.styled('span', {
-  width: '24px',
-  height: '24px',
-  backgroundColor: '$neutrals300',
-  borderRadius: '99999px'
-});
-const OutputContainer$1 = /*#__PURE__*/ui.styled('div', {
-  windth: '100%',
-  height: '$48',
-  borderRadius: '$5',
-  backgroundColor: '$background',
-  border: '1px solid transparent',
-  position: 'relative',
-  display: 'flex',
-  alignItems: 'center',
-  paddingLeft: '$8',
-  paddingRight: '$8'
-});
-function TokenPreview(props) {
-  const {
-    chain,
-    token,
-    loadingStatus
-  } = props;
-  const {
-    t
-  } = reactI18next.useTranslation();
-  const ItemSuffix = React__default.createElement("div", {
-    style: {
-      display: 'flex',
-      justifyContent: 'center',
-      alignItems: 'center'
-    }
-  }, loadingStatus === 'failed' && React__default.createElement(ui.InfoCircleIcon, {
-    color: "error",
-    size: 24
-  }));
-  return React__default.createElement(Box$1, null, React__default.createElement(Container$3, {
-    type: 'outlined'
-  }, React__default.createElement("div", {
-    className: "head"
-  }, React__default.createElement(ui.Typography, {
-    variant: "body2",
-    color: "neutrals800"
-  }, props.label), React__default.createElement(ui.Typography, {
-    variant: "caption",
-    color: "neutrals600"
-  }, `$${numberToString(props.usdValue)}`)), React__default.createElement("div", {
-    className: "form"
-  }, React__default.createElement(ui.Button, {
-    className: "selectors",
-    variant: "outlined",
-    loading: loadingStatus === 'loading',
-    prefix: loadingStatus === 'success' && chain ? React__default.createElement(StyledImage$1, {
-      src: chain.logo
-    }) : React__default.createElement(ImagePlaceholder$1, null),
-    suffix: ItemSuffix,
-    align: "start",
-    size: "large"
-  }, loadingStatus === 'success' && chain ? chain.displayName : t('Chain')), React__default.createElement(ui.Spacer, {
-    size: 12
-  }), React__default.createElement(ui.Button, {
-    className: "selectors",
-    variant: "outlined",
-    loading: loadingStatus === 'loading',
-    prefix: loadingStatus === 'success' && token ? React__default.createElement(StyledImage$1, {
-      src: token.image
-    }) : React__default.createElement(ImagePlaceholder$1, null),
-    suffix: ItemSuffix,
-    size: "large",
-    align: "start"
-  }, loadingStatus === 'success' && token ? token.symbol : t('Token')), React__default.createElement(ui.Spacer, {
-    size: 12
-  }), React__default.createElement("div", {
-    className: "amount"
-  }, React__default.createElement(OutputContainer$1, null, React__default.createElement(ui.Typography, {
-    variant: "h4"
-  }, props.amount))))));
-}
-
-const Container$4 = /*#__PURE__*/ui.styled('div', {
-  display: 'flex',
-  alignItems: 'center',
-  justifyContent: 'space-between',
-  padding: '$8',
-  borderRadius: '$5',
-  backgroundColor: '$neutrals300',
-  color: '$neutrals800',
-  fontSize: '$12',
-  '.routes': {
-    display: 'flex',
-    alignItems: 'center'
-  },
-  '.fee': {
-    display: 'flex',
-    alignItems: 'center'
-  }
-});
-function RoutesOverview(props) {
-  if (!props.routes) return null;
-  const swaps = props.routes.result?.swaps;
-  return React__default.createElement(Container$4, null, React__default.createElement("div", {
-    className: "routes"
-  }, swaps?.map((swap, idx) => {
-    const isLast = idx + 1 == swaps.length;
-    return React__default.createElement(React__default.Fragment, null, React__default.createElement("div", {
-      className: "route"
-    }, swap.from.symbol), React__default.createElement(ui.ChevronRightIcon, {
-      size: 12
-    }), isLast ? React__default.createElement("div", {
-      className: "route"
-    }, swap.to.symbol) : null);
-  })), props.totalFee ? React__default.createElement("div", {
-    className: "fee"
-  }, React__default.createElement(ui.GasIcon, {
-    size: 12
-  }), React__default.createElement(ui.Spacer, {
-    size: 4
-  }), "$", props.totalFee) : null);
+      if (type === 'from') setFromToken(token);else setToToken(token);
+      navigateBackFrom(navigationRoutes.fromToken);
+    },
+    onBack: navigateBackFrom.bind(null, navigationRoutes.fromToken),
+    loadingStatus: loadingMetaStatus
+  });
 }
 
-function ConfirmWalletsPage() {
+function SettingsPage(_ref) {
+  let {
+    supportedSwappers
+  } = _ref;
+  const slippage = useSettingsStore.use.slippage();
+  const setSlippage = useSettingsStore.use.setSlippage();
+  const disabledLiquiditySources = useSettingsStore.use.disabledLiquiditySources();
+  const customSlippage = useSettingsStore.use.customSlippage();
+  const setCustomSlippage = useSettingsStore.use.setCustomSlippage();
+  const theme = useSettingsStore.use.theme();
+  const setTheme = useSettingsStore.use.setTheme();
+  const swappers = useMetaStore.use.meta().swappers;
   const navigate = reactRouterDom.useNavigate();
   const {
     navigateBackFrom
   } = useNavigateBack();
-  const bestRoute = useBestRouteStore.use.bestRoute();
+  const infiniteApprove = useSettingsStore.use.infiniteApprove();
+  const toggleInfiniteApprove = useSettingsStore.use.toggleInfiniteApprove();
+  const loadingMetaStatus = useMetaStore.use.loadingStatus();
+  const uniqueSwappersGroups = [];
+  removeDuplicateFrom(swappers.map(s => s.swapperGroup)).map(swapperGroup => {
+    return swappers.find(s => s.swapperGroup === swapperGroup);
+  }).find(s => {
+    if (s) {
+      for (const type of s.types) {
+        uniqueSwappersGroups.push({
+          title: s.swapperGroup,
+          logo: s.logo,
+          type,
+          selected: !disabledLiquiditySources.includes(s.swapperGroup)
+        });
+      }
+    }
+  });
+  supportedSwappers !== 'all' && uniqueSwappersGroups.filter(item => supportedSwappers.filter(s => s.title === item.title && s.type === item.type).length > 0);
+  const supportedUniqueSwappersGroups = supportedSwappers !== 'all' ? uniqueSwappersGroups.filter(item => supportedSwappers.filter(s => s.title === item.title && s.type === item.type).length > 0) : uniqueSwappersGroups;
+  return React__default.createElement(ui.Settings, {
+    slippages: SLIPPAGES,
+    selectedSlippage: slippage,
+    onSlippageChange: slippage => setSlippage(slippage),
+    onLiquiditySourcesClick: () => navigate(navigationRoutes.liquiditySources),
+    onBack: navigateBackFrom.bind(null, navigationRoutes.settings),
+    liquiditySources: supportedUniqueSwappersGroups,
+    selectedLiquiditySources: supportedUniqueSwappersGroups.filter(s => s.selected),
+    customSlippage: customSlippage || NaN,
+    onCustomSlippageChange: setCustomSlippage,
+    minSlippage: MIN_SLIPPGAE,
+    maxSlippage: MAX_SLIPPAGE,
+    selectedTheme: theme,
+    onThemeChange: setTheme,
+    infiniteApprove: infiniteApprove,
+    toggleInfiniteApprove: toggleInfiniteApprove,
+    loadingStatus: loadingMetaStatus
+  });
+}
+
+const ListContainer = /*#__PURE__*/ui.styled('div', {
+  display: 'grid',
+  gap: '.5rem',
+  gridTemplateColumns: ' repeat(2, minmax(0, 1fr))',
+  alignContent: 'baseline',
+  padding: '0.5rem',
+  overflowY: 'auto'
+});
+const LoaderContainer = /*#__PURE__*/ui.styled('div', {
+  display: 'flex',
+  justifyContent: 'center',
+  width: '100%',
+  position: 'absolute',
+  top: '50%'
+});
+const AlertContainer = /*#__PURE__*/ui.styled('div', {
+  paddingBottom: '$16'
+});
+function WalletsPage(_ref) {
+  let {
+    supportedWallets,
+    multiWallets
+  } = _ref;
   const {
-    blockchains,
-    tokens
-  } = useMetaStore.use.meta();
-  const accounts = useWalletsStore.use.accounts();
-  const selectedWallets = useWalletsStore.use.selectedWallets();
-  const initSelectedWallets = useWalletsStore.use.initSelectedWallets();
-  const setSelectedWallet = useWalletsStore.use.setSelectedWallet();
+    navigateBackFrom
+  } = useNavigateBack();
   const {
+    state,
+    disconnect,
     getWalletInfo,
     connect
   } = walletsCore.useWallets();
-  const confirmDisabled = !requiredWallets(bestRoute).every(chain => selectedWallets.map(wallet => wallet.chain).includes(chain));
-  const firstStep = bestRoute?.result?.swaps[0];
-  const lastStep = bestRoute?.result?.swaps[bestRoute?.result?.swaps.length - 1];
-  const fromAmount = decimalNumber(firstStep?.fromAmount, 3);
-  const toAmount = decimalNumber(lastStep?.toAmount, 3);
+  const wallets = getlistWallet(state, getWalletInfo, supportedWallets === 'all' ? Object.values(walletsShared.WalletType) : supportedWallets);
+  const walletsRef = React.useRef();
+  let sortedWallets = walletsShared.detectMobileScreens() ? wallets.filter(wallet => wallet.showOnMobile) : wallets;
+  sortedWallets = sortWalletsBasedOnState(sortedWallets);
+  const [walletErrorMessage, setWalletErrorMessage] = React.useState('');
+  const toggleConnectWalletsButton = useUiStore.use.toggleConnectWalletsButton();
+  const loadingMetaStatus = useMetaStore.use.loadingStatus();
+  const {
+    t
+  } = reactI18next.useTranslation();
+  const onSelectWallet = async type => {
+    const wallet = state(type);
+    try {
+      if (walletErrorMessage) setWalletErrorMessage('');
+      if (wallet.connected) {
+        await disconnect(type);
+      } else {
+        if (!multiWallets && !!wallets.find(w => w.state === ui.WalletState.CONNECTED)) {
+          return;
+        }
+        await connect(type);
+      }
+    } catch (e) {
+      setWalletErrorMessage('Error: ' + e?.message);
+    }
+  };
+  const disconnectConnectingWallets = () => {
+    const connectingWallets = walletsRef.current?.filter(wallet => wallet.state === ui.WalletState.CONNECTING) || [];
+    for (const wallet of connectingWallets) {
+      disconnect(wallet.type);
+    }
+  };
   React.useEffect(() => {
-    initSelectedWallets();
+    toggleConnectWalletsButton();
+    return () => {
+      disconnectConnectingWallets();
+      toggleConnectWalletsButton();
+    };
   }, []);
-  const selectableWallets = getSelectableWallets(accounts, selectedWallets, getWalletInfo);
-  const handleConnectChain = wallet => {
-    const network = wallet;
-    getKeplrCompatibleConnectedWallets(selectableWallets).forEach(compatibleWallet => connect?.(compatibleWallet, network));
-  };
-  const totalFeeInUsd = getTotalFeeInUsd(bestRoute, tokens);
-  return React__default.createElement(ui.ConfirmWallets, {
-    requiredWallets: getRequiredChains(bestRoute),
-    selectableWallets: selectableWallets,
-    onBack: navigateBackFrom.bind(null, navigationRoutes.confirmWallets),
-    onConfirm: () => navigate(navigationRoutes.confirmSwap, {
-      replace: true
-    }),
-    onChange: wallet => setSelectedWallet(wallet),
-    confirmDisabled: confirmDisabled,
-    handleConnectChain: wallet => handleConnectChain(wallet),
-    isExperimentalChain: wallet => getKeplrCompatibleConnectedWallets(selectableWallets).length > 0 ? isExperimentalChain(blockchains, wallet) : false,
-    previewInputs: React__default.createElement(React__default.Fragment, null, React__default.createElement(TokenPreview, {
-      chain: {
-        displayName: firstStep?.from.blockchain || '',
-        logo: firstStep?.from.blockchainLogo || ''
-      },
-      token: {
-        symbol: firstStep?.from.symbol || '',
-        image: firstStep?.from.logo || ''
-      },
-      usdValue: calcOutputUsdValue(fromAmount, firstStep?.from.usdPrice),
-      amount: fromAmount,
-      label: i18n.t('From'),
-      loadingStatus: 'success'
-    }), React__default.createElement(ui.Spacer, {
-      size: 12,
-      direction: "vertical"
-    }), React__default.createElement(TokenPreview, {
-      chain: {
-        displayName: lastStep?.to.blockchain || '',
-        logo: lastStep?.to.blockchainLogo || ''
-      },
-      token: {
-        symbol: lastStep?.to.symbol || '',
-        image: lastStep?.to.logo || ''
-      },
-      usdValue: calcOutputUsdValue(toAmount, lastStep?.to.usdPrice),
-      amount: toAmount,
-      label: i18n.t('To'),
-      loadingStatus: 'success'
-    })),
-    previewRoutes: React__default.createElement(RoutesOverview, {
-      routes: bestRoute,
-      totalFee: numberToString(totalFeeInUsd, 0, 2)
-    })
-  });
+  React.useEffect(() => {
+    walletsRef.current = wallets;
+  }, [wallets]);
+  return React__default.createElement(ui.SecondaryPage, {
+    title: t('Select Wallet') || '',
+    textField: false,
+    onBack: navigateBackFrom.bind(null, navigationRoutes.wallets)
+  }, React__default.createElement(React__default.Fragment, null, walletErrorMessage && React__default.createElement(AlertContainer, null, React__default.createElement(ui.Alert, {
+    type: "error"
+  }, walletErrorMessage)), loadingMetaStatus === 'loading' && React__default.createElement(LoaderContainer, {
+    className: "loader"
+  }, React__default.createElement(ui.Spinner, {
+    size: 24
+  })), loadingMetaStatus === 'failed' && React__default.createElement(ui.LoadingFailedAlert, null), React__default.createElement(ListContainer, null, loadingMetaStatus === 'success' && sortedWallets.map((wallet, index) => React__default.createElement(ui.Wallet, Object.assign({}, wallet, {
+    key: `${index}-${wallet.type}`,
+    onClick: onSelectWallet
+  }))))));
 }
 
 function useCopyToClipboard(resetInterval) {
@@ -2576,15 +2732,87 @@ function useCopyToClipboard(resetInterval) {
   return [isCopied, handleCopy];
 }
 
+function timeSince(timeMillis) {
+  const seconds = Math.floor((new Date().getTime() - timeMillis) / 1000);
+  let intervalType;
+  let interval = Math.floor(seconds / 31536000);
+  if (interval >= 1) {
+    intervalType = 'year';
+  } else {
+    interval = Math.floor(seconds / 2592000);
+    if (interval >= 1) {
+      intervalType = 'month';
+    } else {
+      interval = Math.floor(seconds / 86400);
+      if (interval >= 1) {
+        intervalType = 'day';
+      } else {
+        interval = Math.floor(seconds / 3600);
+        if (interval >= 1) {
+          intervalType = 'hour';
+        } else {
+          interval = Math.floor(seconds / 60);
+          if (interval >= 1) {
+            intervalType = 'minute';
+          } else {
+            interval = seconds;
+            intervalType = 'second';
+          }
+        }
+      }
+    }
+  }
+  if (interval > 1 || interval === 0) {
+    intervalType += 's';
+  }
+  return interval + ' ' + intervalType;
+}
+function getSwapDate(pendingSwap) {
+  return pendingSwap.finishTime ? `Finished ${timeSince(parseInt(pendingSwap.finishTime))} ago @ ${new Date(parseInt(pendingSwap.finishTime)).toLocaleString()}` : `Started ${timeSince(parseInt(pendingSwap.creationTime))} ago @ ${new Date(parseInt(pendingSwap.creationTime)).toLocaleString()}`;
+}
+
+const PlaceholderContainer = /*#__PURE__*/ui.styled('div', {
+  height: '450px'
+});
+function SwapDetailsPlaceholder(props) {
+  const {
+    requestId,
+    loading,
+    onBack
+  } = props;
+  return React__default.createElement(ui.SecondaryPage, {
+    title: "Swap Details",
+    textField: false,
+    onBack: onBack
+  }, React__default.createElement(PlaceholderContainer, null, loading ? React__default.createElement(LoaderContainer, null, React__default.createElement(ui.Spinner, {
+    size: 24
+  })) : React__default.createElement(ui.Alert, {
+    type: "secondary",
+    title: `Swap with request ID = ${requestId} not found.`
+  })));
+}
+
 function SwapDetailsPage() {
   const selectedSwapRequestId = useUiStore.use.selectedSwapRequestId();
+  const {
+    canSwitchNetworkTo,
+    connect
+  } = walletsCore.useWallets();
+  const retry = useBestRouteStore.use.retry();
+  const navigate = reactRouterDom.useNavigate();
   const {
     navigateBackFrom
   } = useNavigateBack();
+  const [isCopied, handleCopy] = useCopyToClipboard(2000);
   const {
     manager
   } = queueManagerReact.useManager();
-  const [isCopied, handleCopy] = useCopyToClipboard(2000);
+  const [loading, setLoading] = React.useState(true);
+  React.useEffect(() => {
+    setTimeout(() => {
+      setLoading(false);
+    }, 5000);
+  }, []);
   const pendingSwaps = getPendingSwaps(manager);
   const selectedSwap = pendingSwaps.find(_ref => {
     let {
@@ -2592,92 +2820,161 @@ function SwapDetailsPage() {
     } = _ref;
     return swap.requestId === selectedSwapRequestId;
   });
-  //TODO: implement swap cancellation (move queueManager logic to queueManager/rango-preset)
   const onCancel = () => {
-    const swap = selectedSwap ? manager?.get(selectedSwap.id) : undefined;
+    const swap = manager?.get(selectedSwap?.id);
     if (swap) queueManagerRangoPreset.cancelSwap(swap);
   };
-  return React__default.createElement(ui.SwapHistory, {
+  const swap = selectedSwap?.swap;
+  if (!swap) return React__default.createElement(SwapDetailsPlaceholder, {
+    requestId: selectedSwapRequestId || '',
+    loading: loading,
+    onBack: navigateBackFrom.bind(null, navigationRoutes.swapDetails)
+  });
+  const firstStep = swap.steps[0];
+  const lastStep = swap.steps[swap.steps.length - 1];
+  const fromAmount = numberToString(swap.inputAmount);
+  const toAmount = numberToString(swap.simulationResult.outputAmount);
+  const currentStep = queueManagerRangoPreset.getCurrentStep(swap);
+  const currentStepBlockchain = currentStep ? queueManagerRangoPreset.getCurrentBlockchainOfOrNull(swap, currentStep) : null;
+  const currentStepWallet = currentStep ? queueManagerRangoPreset.getRelatedWalletOrNull(swap, currentStep) : null;
+  const currentStepNetworkStatus = currentStep?.networkStatus;
+  const swapMessages = getSwapMessages(swap, currentStep);
+  const networkWarningState = isNetworkStatusInWarningState(currentStep);
+  const swapDate = getSwapDate(swap);
+  const shouldRetry = shouldRetrySwap(swap);
+  const switchNetwork = !!currentStepBlockchain && !!currentStepWallet?.walletType && currentStepNetworkStatus === queueManagerRangoPreset.PendingSwapNetworkStatus.WaitingForNetworkChange && canSwitchNetworkTo(currentStepWallet?.walletType, currentStepBlockchain) ? connect.bind(null, currentStepWallet.walletType, currentStepBlockchain) : undefined;
+  const lastConvertedTokenInFailedSwap = getLastConvertedTokenInFailedSwap(swap);
+  return React__default.createElement(ui.SwapHistory, Object.assign({
     onBack: navigateBackFrom.bind(null, navigationRoutes.swapDetails),
+    previewInputs: React__default.createElement(React__default.Fragment, null, React__default.createElement(TokenPreview, {
+      chain: {
+        displayName: firstStep?.fromBlockchain || '',
+        // @ts-ignore
+        logo: firstStep?.fromBlockchainLogo || ''
+      },
+      token: {
+        symbol: firstStep?.fromSymbol || '',
+        image: firstStep?.fromLogo || ''
+      },
+      amount: fromAmount,
+      label: i18n.t('From'),
+      loadingStatus: 'success'
+    }), React__default.createElement(ui.Spacer, {
+      size: 12,
+      direction: "vertical"
+    }), React__default.createElement(TokenPreview, {
+      chain: {
+        displayName: lastStep?.toBlockchain || '',
+        // @ts-ignore
+        logo: lastStep?.toBlockchainLogo || ''
+      },
+      token: {
+        symbol: lastStep?.toSymbol || '',
+        image: lastStep?.toLogo || ''
+      },
+      amount: toAmount,
+      label: i18n.t('To'),
+      loadingStatus: 'success'
+    })),
     //todo: move PendingSwap type to rango-types
     //@ts-ignore
-    pendingSwap: selectedSwap?.swap,
+    pendingSwap: swap,
     onCopy: handleCopy,
     isCopied: isCopied,
-    onCancel: onCancel
-  });
+    onCancel: onCancel,
+    shortMessage: swapMessages.shortMessage,
+    detailedMessage: swapMessages.detailedMessage,
+    currentStepBlockchain: currentStepBlockchain || '',
+    switchNetwork: switchNetwork,
+    type: networkWarningState ? 'warning' : swap.extraMessageSeverity || undefined,
+    date: swapDate
+  }, shouldRetry && {
+    onRetry: () => {
+      retry(swap);
+      setTimeout(() => {
+        navigate(navigationRoutes.home);
+      }, 0);
+    }
+  }, lastConvertedTokenInFailedSwap && {
+    lastConvertedTokenInFailedSwap: {
+      blockchain: lastConvertedTokenInFailedSwap.blockchain,
+      outputAmount: lastConvertedTokenInFailedSwap.outputAmount || '',
+      symbol: lastConvertedTokenInFailedSwap.symbol
+    }
+  }));
 }
 
+const getAbsolutePath = path => path.replace('/', '');
 function AppRoutes(props) {
   const {
     configs
   } = props;
   return reactRouterDom.useRoutes([{
-    path: navigationRoutes.home,
+    path: getAbsolutePath(navigationRoutes.home),
     element: React__default.createElement(Home, {
       title: configs?.title,
       titleSize: configs?.titleSize,
       titleWeight: configs?.titleWeight
     })
   }, {
-    path: navigationRoutes.fromChain,
+    path: getAbsolutePath(navigationRoutes.fromChain),
     element: React__default.createElement(SelectChainPage, {
       type: "from",
       supportedChains: configs?.fromChains || 'all'
     })
   }, {
-    path: navigationRoutes.toChain,
+    path: getAbsolutePath(navigationRoutes.toChain),
     element: React__default.createElement(SelectChainPage, {
       type: "to",
       supportedChains: configs?.toChains || 'all'
     })
   }, {
-    path: navigationRoutes.fromToken + '/*',
+    path: getAbsolutePath(navigationRoutes.fromToken),
     element: React__default.createElement(SelectTokenPage, {
       type: "from",
       supportedTokens: configs?.fromTokens || 'all'
     })
   }, {
-    path: navigationRoutes.toToken,
+    path: getAbsolutePath(navigationRoutes.toToken),
     element: React__default.createElement(SelectTokenPage, {
       type: "to",
       supportedTokens: configs?.toTokens || 'all'
     })
   }, {
-    path: navigationRoutes.settings,
+    path: getAbsolutePath(navigationRoutes.settings),
     element: React__default.createElement(SettingsPage, {
       supportedSwappers: configs?.liquiditySources || 'all'
     })
   }, {
-    path: navigationRoutes.liquiditySources,
+    path: getAbsolutePath(navigationRoutes.liquiditySources),
     element: React__default.createElement(LiquiditySourcePage, {
       supportedSwappers: configs?.liquiditySources || 'all'
     })
   }, {
-    path: navigationRoutes.swaps,
+    path: getAbsolutePath(navigationRoutes.swaps),
     element: React__default.createElement(HistoryPage, null)
   }, {
     path: navigationRoutes.swapDetails,
     element: React__default.createElement(SwapDetailsPage, null)
   }, {
-    path: navigationRoutes.wallets,
+    path: getAbsolutePath(navigationRoutes.wallets),
     element: React__default.createElement(WalletsPage, {
       supportedWallets: configs?.wallets || 'all',
       multiWallets: typeof configs?.multiWallets === 'undefined' ? true : configs.multiWallets
     })
   }, {
-    path: navigationRoutes.confirmSwap,
+    path: getAbsolutePath(navigationRoutes.confirmSwap),
     element: React__default.createElement(ConfirmSwapPage, null)
-  }, {
-    path: navigationRoutes.confirmWallets,
-    element: React__default.createElement(ConfirmWalletsPage, null)
   }]);
 }
 
-const Header$1 = /*#__PURE__*/ui.styled('div', {
+const Header = /*#__PURE__*/ui.styled('div', {
   display: 'flex',
   width: '100%',
-  justifyContent: 'end'
+  justifyContent: 'end',
+  '.balance': {
+    display: 'flex'
+  }
 });
 const WalletImage = /*#__PURE__*/ui.styled('img', {
   width: '$24',
@@ -2707,6 +3004,8 @@ function Layout(_ref) {
   const setInputAmount = useBestRouteStore.use.setInputAmount();
   const totalBalance = calculateWalletUsdValue(balances);
   const connectWalletsButtonDisabled = useUiStore.use.connectWalletsButtonDisabled();
+  const loadingMetaStatus = useMetaStore.use.loadingStatus();
+  const fetchingBalance = useWalletsStore(fetchingBalanceSelector);
   const {
     t
   } = reactI18next.useTranslation();
@@ -2721,22 +3020,32 @@ function Layout(_ref) {
     setFromToken(configs?.fromToken || null);
     setFromChain(configs?.fromChain || null);
   }, [configs?.fromToken, configs?.fromChain]);
-  return React__default.createElement(React__default.Fragment, null, React__default.createElement(Header$1, null, React__default.createElement(ui.Button, {
+  React.useEffect(() => {
+    setToChain(null);
+    setFromChain(null);
+    setFromToken(null);
+    setToToken(null);
+  }, [configs?.fromChains, configs?.toChains, configs?.fromTokens, configs?.toTokens]);
+  return React__default.createElement(React__default.Fragment, null, React__default.createElement(Header, null, React__default.createElement(ui.Button, {
     size: "small",
     suffix: React__default.createElement(ui.AddWalletIcon, {
       size: 20
     }),
     variant: "ghost",
     flexContent: true,
+    loading: loadingMetaStatus === 'loading',
+    disabled: loadingMetaStatus === 'failed',
     onClick: () => {
       if (!connectWalletsButtonDisabled) navigate(navigationRoutes.wallets);
     }
   }, connectedWalletsImages?.length ? connectedWalletsImages.map((walletImage, index) => React__default.createElement(WalletImage, {
     key: index,
     src: walletImage
-  })) : React__default.createElement(React__default.Fragment, null), React__default.createElement(ui.Typography, {
+  })) : React__default.createElement(React__default.Fragment, null), React__default.createElement("div", {
+    className: "balance"
+  }, React__default.createElement(ui.Typography, {
     variant: "body2"
-  }, !accounts?.length ? t('Connect Wallet') : `$${totalBalance || 0}`))), React__default.createElement(AppRoutes, {
+  }, !accounts?.length ? t('Connect Wallet') : `$${totalBalance || 0}`), fetchingBalance && React__default.createElement(ui.Spinner, null)))), React__default.createElement(AppRoutes, {
     configs: configs
   }));
 }
@@ -2744,10 +3053,12 @@ function Layout(_ref) {
 const globalStyles = /*#__PURE__*/ui.globalCss({
   '*': {
     '&::-webkit-scrollbar': {
-      width: '$8'
+      width: '$8',
+      height: '$8'
     },
     '&::-webkit-scrollbar-thumb': {
-      backgroundColor: '$neutrals400'
+      backgroundColor: '$neutrals400',
+      borderRadius: '$10'
     },
     '&::-webkit-scrollbar-thumb:hover': {
       backgroundColor: '$neutrals500'
@@ -3021,7 +3332,9 @@ function QueueManager(props) {
     //@ts-ignore
     queuesDefs: [queueManagerRangoPreset.swapQueueDef],
     context: context,
-    onPersistedDataLoaded: _manager => {},
+    onPersistedDataLoaded: manager => {
+      queueManagerRangoPreset.checkWaitingForNetworkChange(manager);
+    },
     isPaused: false
   }, props.children);
 }
@@ -3049,8 +3362,10 @@ const SwapBox = _ref => {
     changeLanguage
   } = useSelectLanguage();
   const clearConnectedWallet = useWalletsStore.use.clearConnectedWallet();
+  const [lastConnectedWalletWithNetwork, setLastConnectedWalletWithNetwork] = React.useState('');
+  const [disconnectedWallet, setDisconnectedWallet] = React.useState();
   const evmBasedChainNames = blockchains.filter(rangoSdk.isEvmBlockchain).map(chain => chain.name);
-  const onUpdateState = (type, event, value, _, supportedChains) => {
+  const onUpdateState = (type, event, value, state, supportedChains) => {
     if (event === walletsCore.Events.ACCOUNTS) {
       if (value) {
         const supportedChainNames = walletAndSupportedChainsNames(supportedChains);
@@ -3060,6 +3375,16 @@ const SwapBox = _ref => {
         disconnectWallet(type);
       }
     }
+    if (event === walletsCore.Events.ACCOUNTS && state.connected) {
+      const key = `${type}-${state.network}-${value}`;
+      if (state.connected) {
+        setLastConnectedWalletWithNetwork(key);
+      }
+    }
+    if (event === walletsCore.Events.NETWORK && state.network) {
+      const key = `${type}-${state.network}`;
+      setLastConnectedWalletWithNetwork(key);
+    }
   };
   let providers = providerAll.allProviders();
   React.useEffect(() => {
@@ -3091,7 +3416,12 @@ const SwapBox = _ref => {
   }, React__default.createElement(AppRouter, {
     title: configs.title,
     titleSize: configs.titleSize,
-    titleWeight: configs.titleWeight
+    titleWeight: configs.titleWeight,
+    lastConnectedWallet: lastConnectedWalletWithNetwork,
+    disconnectedWallet: disconnectedWallet,
+    clearDisconnectedWallet: () => {
+      setDisconnectedWallet(undefined);
+    }
   }, React__default.createElement(Layout, {
     configs: configs
   }))))));