@rango-dev/widget-embedded 0.1.10-next.98 → 0.1.10

package/dist/widget-embedded.cjs.production.min.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,10 +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 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 i18n = _interopDefault(require('i18next'));
 var Backend = _interopDefault(require('i18next-http-backend'));
 var LanguageDetector = _interopDefault(require('i18next-browser-languagedetector'));
 
@@ -39,7 +41,6 @@ const navigationRoutes = {
   swaps: '/swaps',
   wallets: '/wallets',
   confirmSwap: '/confirm-swap',
-  confirmWallets: '/confirm-wallets',
   swapDetails: '/swaps/:requestId'
 };
 
@@ -69,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');
@@ -335,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;
@@ -345,7 +362,7 @@ function getDefaultToken(sortedTokens, otherToken) {
   return selectedToken;
 }
 function sortWalletsBasedOnState(wallets) {
-  return wallets.sort((a, b) => Number(b.state === ui.WalletState.CONNECTED) - Number(a.state === ui.WalletState.CONNECTED) || Number(b.state === ui.WalletState.DISCONNECTED) - Number(a.state === ui.WalletState.DISCONNECTED));
+  return wallets.sort((a, b) => Number(b.state === ui.WalletState.CONNECTED) - Number(a.state === ui.WalletState.CONNECTED) || Number(b.state === ui.WalletState.DISCONNECTED || b.state === ui.WalletState.CONNECTING) - Number(a.state === ui.WalletState.DISCONNECTED || a.state === ui.WalletState.CONNECTING));
 }
 
 function getOutputRatio(inputUsdValue, outputUsdValue) {
@@ -413,7 +430,7 @@ function LimitErrorMessage(bestRoute) {
     recommendation
   };
 }
-function getSwapButtonState(loadingMetaStatus, accounts, loading, bestRoute, hasLimitError, highValueLoss, priceImpactCanNotBeComputed, needsToWarnEthOnPath) {
+function getSwapButtonState(loadingMetaStatus, accounts, loading, bestRoute, hasLimitError, highValueLoss, priceImpactCanNotBeComputed, needsToWarnEthOnPath, inputIsZero) {
   if (loadingMetaStatus !== 'success') return {
     title: 'Connect Wallet',
     disabled: true
@@ -425,6 +442,9 @@ function getSwapButtonState(loadingMetaStatus, accounts, loading, bestRoute, has
   if (loading) return {
     title: 'Finding Best Route...',
     disabled: true
+  };else if (inputIsZero) return {
+    title: 'Enter an amount',
+    disabled: true
   };else if (!bestRoute) return {
     title: 'Swap',
     disabled: true
@@ -458,6 +478,7 @@ function calculatePendingSwap(inputAmount, bestRoute, wallets, settings, validat
     finishTime: null,
     requestId: bestRoute.requestId || '',
     inputAmount: inputAmount,
+    //@ts-ignore
     wallets,
     status: 'running',
     isPaused: false,
@@ -472,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];
@@ -557,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) {
@@ -574,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,
@@ -591,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;
 }
@@ -634,6 +658,65 @@ function getBalanceWarnings(route, selectedWallets) {
     return warningMessage;
   });
 }
+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;
@@ -671,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;
@@ -837,7 +911,7 @@ const useWalletsStore = /*#__PURE__*/createSelectors( /*#__PURE__*/zustand.creat
       }
     });
     return {
-      selectedWallets: state.selectedWallets.concat(selectedWallets)
+      selectedWallets: selectedWallets
     };
   }),
   setSelectedWallet: wallet => set(state => ({
@@ -869,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 => ({
@@ -888,9 +963,10 @@ 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 = new BigNumber__default(outputAmount || ZERO).multipliedBy(getBestRouteToTokenUsdPrice(bestRoute) || state.toToken?.usdPrice || 0);
+      outputUsdValue = calcOutputUsdValue(bestRoute.result?.outputAmount, getBestRouteToTokenUsdPrice(bestRoute) || state.toToken?.usdPrice);
     }
     return {
       bestRoute,
@@ -944,6 +1020,7 @@ const useBestRouteStore = /*#__PURE__*/createSelectors( /*#__PURE__*/zustand.cre
     toToken: token
   })),
   setInputAmount: amount => {
+    console.log(amount, typeof amount);
     set(state => ({
       inputAmount: amount,
       ...(!amount && {
@@ -955,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) => {
@@ -970,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,
@@ -1000,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;
     }
@@ -1015,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;
     }
@@ -1040,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
   })
 })));
 
@@ -1085,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];
@@ -1178,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: "Retry"
-  }, React__default.createElement(ui.Button, {
-    variant: "ghost",
-    onClick: onClickRefresh
-  }, React__default.createElement(ui.RetryIcon, {
-    size: 28
-  }))), 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',
@@ -1246,13 +1330,42 @@ const Box = /*#__PURE__*/ui.styled('div', {
 });
 const Container = /*#__PURE__*/ui.styled('div', {
   boxSizing: 'border-box',
-  backgroundColor: '$neutrals300',
   borderRadius: '$5',
-  padding: '$8 0',
+  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: '$8 $16'
+    padding: '$2 0',
+    '.selectors': {
+      width: '35%',
+      '._text': {
+        whiteSpace: 'nowrap',
+        overflow: 'hidden',
+        textOverflow: 'ellipsis'
+      }
+    },
+    '.amount': {
+      width: '30%'
+    }
   }
 });
 const StyledImage = /*#__PURE__*/ui.styled('img', {
@@ -1262,7 +1375,10 @@ const StyledImage = /*#__PURE__*/ui.styled('img', {
 const Options = /*#__PURE__*/ui.styled('div', {
   display: 'flex',
   justifyContent: 'flex-end',
-  padding: '0 $8'
+  '.balance': {
+    display: 'flex',
+    alignItems: 'center'
+  }
 });
 const ImagePlaceholder = /*#__PURE__*/ui.styled('span', {
   width: '24px',
@@ -1271,10 +1387,9 @@ const ImagePlaceholder = /*#__PURE__*/ui.styled('span', {
   borderRadius: '99999px'
 });
 const OutputContainer = /*#__PURE__*/ui.styled('div', {
+  windth: '100%',
   height: '$48',
   borderRadius: '$5',
-  flexGrow: 1,
-  width: '70%',
   backgroundColor: '$background',
   border: '1px solid transparent',
   position: 'relative',
@@ -1314,21 +1429,34 @@ function TokenInfo(props) {
     color: "error",
     size: 24
   }), React__default.createElement(ui.AngleDownIcon, null));
-  return React__default.createElement(Box, null, React__default.createElement("div", null, React__default.createElement(ui.Typography, {
-    variant: "body2"
-  }, t(type))), React__default.createElement(Container, null, props.type === 'From' && React__default.createElement(Options, null, React__default.createElement("div", {
+  return React__default.createElement(Box, null, React__default.createElement(Container, {
+    type: props.type === 'From' ? 'filled' : 'outlined'
+  }, React__default.createElement("div", {
+    className: "head"
+  }, React__default.createElement(ui.Typography, {
+    variant: "body2",
+    color: "neutrals800"
+  }, t(type)), props.type === 'From' ? React__default.createElement(Options, null, React__default.createElement("div", {
     className: "balance",
     onClick: () => {
       if (tokenBalance !== '0') setInputAmount(tokenBalanceReal.split(',').join(''));
     }
-  }, React__default.createElement(ui.Button, {
-    variant: "ghost",
-    size: "small"
   }, React__default.createElement(ui.Typography, {
-    variant: "body2"
-  }, `${t('Max')}: ${tokenBalance} ${fromToken?.symbol || ''}`)))), React__default.createElement("div", {
+    variant: "body3",
+    color: "neutrals600"
+  }, `${t('Balance')}: ${tokenBalance} ${fromToken?.symbol || ''}`), React__default.createElement(ui.Spacer, {
+    size: 4
+  }), React__default.createElement(ui.Button, {
+    type: "primary",
+    variant: "ghost",
+    size: "compact"
+  }, t('Max')))) : React__default.createElement(ui.Typography, {
+    variant: "caption",
+    color: "neutrals600"
+  }, `$${numberToString(props.outputUsdValue)}`)), React__default.createElement("div", {
     className: "form"
   }, React__default.createElement(ui.Button, {
+    className: "selectors",
     onClick: () => {
       navigate(`/${props.type.toLowerCase()}-chain`);
     },
@@ -1340,11 +1468,11 @@ function TokenInfo(props) {
     }) : React__default.createElement(ImagePlaceholder, null),
     suffix: ItemSuffix,
     align: "start",
-    size: "large",
-    style: {
-      marginRight: '.5rem'
-    }
-  }, loadingStatus === 'success' && chain ? chain.displayName : t('Chain')), React__default.createElement(ui.Button, {
+    size: "large"
+  }, loadingStatus === 'success' && chain ? chain.displayName : t('Chain')), React__default.createElement(ui.Spacer, {
+    size: 12
+  }), React__default.createElement(ui.Button, {
+    className: "selectors",
     onClick: () => {
       navigate(`/${props.type.toLowerCase()}-token`);
     },
@@ -1356,17 +1484,17 @@ function TokenInfo(props) {
     }) : React__default.createElement(ImagePlaceholder, null),
     suffix: ItemSuffix,
     size: "large",
-    align: "start",
-    style: {
-      marginRight: '.5rem'
-    }
-  }, loadingStatus === 'success' && token ? token.symbol : t('Token')), props.type === 'From' ? React__default.createElement(ui.TextField, {
+    align: "start"
+  }, loadingStatus === 'success' && token ? token.symbol : t('Token')), React__default.createElement(ui.Spacer, {
+    size: 12
+  }), React__default.createElement("div", {
+    className: "amount"
+  }, props.type === 'From' ? React__default.createElement(ui.TextField, {
     type: "number",
     size: "large",
     autoFocus: true,
     placeholder: "0",
     style: {
-      width: '70%',
       position: 'relative',
       backgroundColor: '$background !important'
     },
@@ -1377,23 +1505,16 @@ function TokenInfo(props) {
         bottom: '2px'
       }
     }, React__default.createElement(ui.Typography, {
-      variant: "caption"
+      variant: "caption",
+      color: "neutrals800"
     }, `$${numberToString(inputUsdValue)}`)),
     value: props.inputAmount || '',
     onChange: props.type === 'From' ? event => {
       props.onAmountChange(event.target.value);
     } : undefined
   }) : React__default.createElement(OutputContainer, null, React__default.createElement(ui.Typography, {
-    variant: "body1"
-  }, bestRoute ? `≈ ${numberToString(props.outputAmount)}` : inputAmount ? '?' : '0'), React__default.createElement("span", {
-    style: {
-      position: 'absolute',
-      right: '4px',
-      bottom: '2px'
-    }
-  }, React__default.createElement(ui.Typography, {
-    variant: "caption"
-  }, `$${numberToString(props.outputUsdValue)}`))))));
+    variant: "h4"
+  }, bestRoute ? `≈ ${numberToString(props.outputAmount)}` : inputAmount ? '?' : '0'))))));
 }
 
 const Container$1 = /*#__PURE__*/theme.styled('div', {
@@ -1489,18 +1610,52 @@ 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',
-  justifyContent: 'center',
-  alignItems: 'center'
+  flexDirection: 'column'
 });
-const SwitchButtonContainer = /*#__PURE__*/ui.styled('div', {
-  display: 'flex',
-  justifyContent: 'center',
-  alignItems: 'center',
+const FromContainer = /*#__PURE__*/ui.styled('div', {
   position: 'relative',
-  top: '11px'
+  paddingBottom: '$12'
+});
+const SwitchButtonContainer = /*#__PURE__*/ui.styled('div', {
+  position: 'absolute',
+  bottom: '-12px',
+  left: '50%',
+  transform: 'translate(-50%, 10%)'
 });
 const BestRouteContainer = /*#__PURE__*/ui.styled('div', {
   width: '100%',
@@ -1512,11 +1667,8 @@ const Alerts = /*#__PURE__*/ui.styled('div', {
 });
 function Home(props) {
   const {
-    title = 'SWAP',
-    titleSize = 18,
-    titleWeight = 600
+    title = 'SWAP'
   } = props;
-  const waningMessage = '';
   const isRouterInContext = reactRouterDom.useInRouterContext();
   const navigate = reactRouterDom.useNavigate();
   const [count, setCount] = React.useState(0);
@@ -1539,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);
@@ -1558,15 +1711,20 @@ function Home(props) {
     swap
   } = LimitErrorMessage(bestRoute);
   const priceImpactCanNotBeComputed = !canComputePriceImpact(bestRoute, inputAmount, inputUsdValue, outputUsdValue);
-  const swapButtonState = getSwapButtonState(loadingMetaStatus, accounts, fetchingBestRoute, bestRoute, hasLimitError(bestRoute), highValueLoss, priceImpactCanNotBeComputed, needsToWarnEthOnPath);
+  const inputIsZero = inputAmount === '0';
+  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
-  }), React__default.createElement(TokenInfo, {
+    suffix: React__default.createElement(HeaderButtons, {
+      onClickRefresh: !!bestRoute ? fetchBestRoute : undefined
+    })
+  }), React__default.createElement(FromContainer, null, React__default.createElement(TokenInfo, {
     type: "From",
     chain: fromChain,
     token: fromToken,
@@ -1576,14 +1734,14 @@ function Home(props) {
     variant: "ghost",
     onClick: swithFromAndTo
   }, React__default.createElement(ui.VerticalSwapIcon, {
-    size: 36
+    size: 32
   }), isRouterInContext && React__default.createElement(SwithFromAndTo, {
     count: count
-  }))), React__default.createElement(TokenInfo, {
+  })))), React__default.createElement(TokenInfo, {
     type: "To",
     chain: toChain,
     token: toToken,
-    outputAmount: outputAmount,
+    outputAmount: outputAmount ? new BigNumber__default(outputAmount) : new BigNumber__default(0),
     outputUsdValue: outputUsdValue
   }), showBestRoute && React__default.createElement(BestRouteContainer, null, React__default.createElement(ui.BestRoute, {
     error: bestRouteError,
@@ -1592,11 +1750,9 @@ function Home(props) {
     totalFee: numberToString(totalFeeInUsd, 0, 2),
     feeWarning: highFee,
     totalTime: secondsToString(totalArrivalTime(bestRoute))
-  })), (errorMessage || waningMessage || hasLimitError(bestRoute)) && React__default.createElement(Alerts, null, errorMessage && React__default.createElement(ui.Alert, {
+  })), (errorMessage || hasLimitError(bestRoute)) && React__default.createElement(Alerts, null, errorMessage && React__default.createElement(ui.Alert, {
     type: "error"
-  }, React__default.createElement(ui.Typography, {
-    variant: "body2"
-  }, errorMessage)), hasLimitError(bestRoute) && React__default.createElement(ui.Alert, {
+  }, errorMessage), hasLimitError(bestRoute) && React__default.createElement(ui.Alert, {
     type: "error",
     title: `${swap?.swapperId} Limit`
   }, React__default.createElement(React__default.Fragment, null, React__default.createElement(ui.Typography, {
@@ -1605,14 +1761,14 @@ function Home(props) {
     variant: "body2"
   }, "Yours: ", numberToString(swap?.fromAmount || null), swap?.from.symbol), React__default.createElement("br", null), React__default.createElement(ui.Typography, {
     variant: "body2"
-  }, recommendation))), waningMessage ), React__default.createElement(Footer, null, React__default.createElement(ui.Button, {
+  }, recommendation)))), React__default.createElement(Footer, null, React__default.createElement(ui.Button, {
     type: "primary",
     align: "grow",
     size: "large",
     disabled: swapButtonState.disabled,
     onClick: () => {
       if (swapButtonState.title === 'Connect Wallet') navigate(navigationRoutes.wallets);else {
-        navigate(navigationRoutes.confirmWallets, {
+        navigate(navigationRoutes.confirmSwap, {
           replace: true
         });
       }
@@ -1629,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) {
@@ -1644,56 +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));
-}
-
-const StyledButton = /*#__PURE__*/ui.styled(ui.Button, {
-  marginTop: '$8'
-});
-function ChangeSlippageButton() {
-  const navigate = reactRouterDom.useNavigate();
-  return React__default.createElement(StyledButton, {
-    type: "primary",
-    variant: "contained",
-    size: "small",
-    onClick: () => navigate(navigationRoutes.settings)
-  }, "Change Slippage");
-}
-
-function HighSlippageWarning(props) {
-  const {
-    selectedSlippage
-  } = props;
-  return React__default.createElement(ui.Alert, {
-    type: "warning"
-  }, React__default.createElement(ui.Typography, {
-    variant: "body2"
-  }, "Caution, your slippage is high (=", selectedSlippage, "). Your trade may be front run.", React__default.createElement(ChangeSlippageButton, null)));
-}
-
-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
       });
     }
   };
@@ -1702,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', {
+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: {
-    showListStyle: {
-      true: {
-        paddingLeft: '$24'
+    type: {
+      filled: {
+        backgroundColor: '$neutrals300'
+      },
+      outlined: {
+        border: '1px solid $neutrals300'
       }
     }
-  }
-});
-const ListItem = /*#__PURE__*/ui.styled('li', {
-  variants: {
-    showListStyle: {
-      true: {
-        listStyleType: 'disc',
-        listStylePosition: 'outside'
+  },
+  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 Message = /*#__PURE__*/ui.styled(ui.Typography, {
-  display: 'block'
+const StyledImage$1 = /*#__PURE__*/ui.styled('img', {
+  width: '$24',
+  maxHeight: '$24'
 });
-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))));
+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();
@@ -1858,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;
@@ -1920,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;
@@ -1949,31 +2155,196 @@ function useConfirmSwap() {
   };
 }
 
+function ChangeSlippageButton() {
+  const navigate = reactRouterDom.useNavigate();
+  return React__default.createElement(ui.Button, {
+    type: "primary",
+    variant: "outlined",
+    size: "small",
+    onClick: () => navigate(navigationRoutes.settings)
+  }, "Change Slippage");
+}
+
+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 setSelectedSwap = useUiStore.use.setSelectedSwap();
+  const navigate = reactRouterDom.useNavigate();
   const {
     navigateBackFrom
   } = useNavigateBack();
-  const {
-    manager
-  } = queueManagerReact.useManager();
-  const navigate = reactRouterDom.useNavigate();
   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 selectedSlippage = customSlippage || slippage;
+  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) {
@@ -1989,16 +2360,51 @@ function ConfirmSwapPage() {
         }
       });
     },
-    onBack: navigateBackFrom.bind(null, navigationRoutes.confirmSwap),
-    bestRoute: getBestRouteWithCalculatedFees(bestRoute, tokens),
+    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!',
-    confirmButtonDisabled: fetchingBestRoute
+    confirmButtonTitle: warnings.length > 0 || errors.length > 0 ? 'Proceed anyway!' : 'Confirm swap!'
   });
 }
 
@@ -2016,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();
@@ -2031,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)
   });
@@ -2051,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();
@@ -2076,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
   });
 }
 
@@ -2119,11 +2550,11 @@ 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,
@@ -2132,7 +2563,8 @@ function SelectTokenPage(props) {
       if (type === 'from') setFromToken(token);else setToToken(token);
       navigateBackFrom(navigationRoutes.fromToken);
     },
-    onBack: navigateBackFrom.bind(null, navigationRoutes.fromToken)
+    onBack: navigateBackFrom.bind(null, navigationRoutes.fromToken),
+    loadingStatus: loadingMetaStatus
   });
 }
 
@@ -2154,6 +2586,7 @@ function SettingsPage(_ref) {
   } = useNavigateBack();
   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);
@@ -2186,7 +2619,8 @@ function SettingsPage(_ref) {
     selectedTheme: theme,
     onThemeChange: setTheme,
     infiniteApprove: infiniteApprove,
-    toggleInfiniteApprove: toggleInfiniteApprove
+    toggleInfiniteApprove: toggleInfiniteApprove,
+    loadingStatus: loadingMetaStatus
   });
 }
 
@@ -2194,9 +2628,16 @@ const ListContainer = /*#__PURE__*/ui.styled('div', {
   display: 'grid',
   gap: '.5rem',
   gridTemplateColumns: ' repeat(2, minmax(0, 1fr))',
-  height: '450px',
   alignContent: 'baseline',
-  padding: '0 0.5rem'
+  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'
@@ -2216,10 +2657,12 @@ function WalletsPage(_ref) {
     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 loadingMetaStatus = useMetaStore.use.loadingStatus();
   const {
     t
   } = reactI18next.useTranslation();
@@ -2239,71 +2682,38 @@ function WalletsPage(_ref) {
       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 () => 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"
-  }, React__default.createElement(ui.Typography, {
-    variant: "body2"
-  }, walletErrorMessage))), React__default.createElement(ListContainer, null, sortedWallets.map((wallet, index) => React__default.createElement(ui.Wallet, Object.assign({}, wallet, {
+  }, 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 ConfirmWalletsPage() {
-  const navigate = reactRouterDom.useNavigate();
-  const {
-    navigateBackFrom
-  } = useNavigateBack();
-  const bestRoute = useBestRouteStore.use.bestRoute();
-  const {
-    blockchains
-  } = useMetaStore.use.meta();
-  const accounts = useWalletsStore.use.accounts();
-  const selectedWallets = useWalletsStore.use.selectedWallets();
-  const initSelectedWallets = useWalletsStore.use.initSelectedWallets();
-  const setSelectedWallet = useWalletsStore.use.setSelectedWallet();
-  const {
-    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);
-  React.useEffect(() => {
-    initSelectedWallets();
-  }, []);
-  const selectableWallets = getSelectableWallets(accounts, selectedWallets, getWalletInfo);
-  const handleConnectChain = wallet => {
-    const network = wallet;
-    getKeplrCompatibleConnectedWallets(selectableWallets).forEach(compatibleWallet => connect?.(compatibleWallet, network));
-  };
-  return React__default.createElement(ui.ConfirmWallets, {
-    requiredWallets: getRequiredChains(bestRoute),
-    selectableWallets: selectableWallets,
-    onBack: navigateBackFrom.bind(null, navigationRoutes.confirmWallets),
-    swap: bestRoute,
-    fromAmount: fromAmount,
-    toAmount: toAmount,
-    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
-  });
-}
-
 function useCopyToClipboard(resetInterval) {
   const [isCopied, setCopied] = React__default.useState(false);
   const handleCopy = React__default.useCallback(text => {
@@ -2322,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 {
@@ -2338,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',
@@ -2453,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();
@@ -2467,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
   }));
 }
@@ -2490,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'
@@ -2505,7 +3070,7 @@ const globalStyles = /*#__PURE__*/ui.globalCss({
 });
 const globalFont = fontFamily => ui.globalCss({
   '@import': ["url('https://fonts.googleapis.com/css2?family=Roboto:ital,wght@0,100;0,300;0,400;0,500;0,700;0,900;1,100;1,300;1,400;1,500;1,700;1,900&display=swap')", "url('https://fonts.cdnfonts.com/css/times-new-roman')"],
-  [`.font_${fontFamily.replace(/ /g, '')} ._text`]: {
+  body: {
     fontFamily
   }
 })();
@@ -2531,16 +3096,16 @@ function useTheme(_ref) {
     warning = '#F5A623',
     success = '#0070F3',
     fontFamily = 'Robot',
-    borderRadius = 5
+    borderRadius = 8
   } = _ref;
   const theme = useSettingsStore.use.theme();
   const fetchMeta = useMetaStore.use.fetchMeta();
   const colors = {
     neutrals200: '#FAFAFA',
-    neutrals300: '#EAEAEA',
-    neutrals400: '#999999',
-    neutrals500: '#888888',
-    neutrals600: '#666666',
+    neutrals300: '#f2f2f2',
+    neutrals400: '#dedede',
+    neutrals500: '#cccccc',
+    neutrals600: '#acacac',
     neutrals700: '#444444',
     neutrals800: '#333333',
     neutrals900: '#111111',
@@ -2584,10 +3149,10 @@ function useTheme(_ref) {
       neutrals200: '#111111',
       neutrals300: '#333333',
       neutrals400: '#444444',
-      neutrals500: '#666666',
-      neutrals600: '#888888',
-      neutrals700: '#999999',
-      neutrals800: '#EAEAEA',
+      neutrals500: '#acacac',
+      neutrals600: '#cccccc',
+      neutrals700: '#dedede',
+      neutrals800: '#f2f2f2',
       neutrals900: '#FAFAFA',
       foreground: background,
       background: foreground
@@ -2647,8 +3212,9 @@ function useSelectLanguage() {
 }
 
 var swap = "SWAP";
-var From = "From";
-var To = "To";
+var From = "You sell";
+var To = "You receive";
+var Balance = "Balance";
 var Max = "Max";
 var Chain = "Chain";
 var Token = "Token";
@@ -2660,12 +3226,13 @@ var en = {
 	"Powered By": "Powered By",
 	From: From,
 	To: To,
+	Balance: Balance,
 	Max: Max,
 	Chain: Chain,
 	Token: Token,
 	Source: Source,
 	Destination: Destination,
-	"Select Wallet": "Select Wallet"
+	"Select Wallet": "Connect Your Wallet"
 };
 
 var swap$1 = "TAKAS";
@@ -2687,7 +3254,7 @@ var tr = {
 };
 
 const languages = ['en', 'tr'];
-i18n.use(Backend)
+i18n__default.use(Backend)
 // detect user language
 .use(LanguageDetector)
 // pass the i18n instance to react-i18next.
@@ -2765,7 +3332,9 @@ function QueueManager(props) {
     //@ts-ignore
     queuesDefs: [queueManagerRangoPreset.swapQueueDef],
     context: context,
-    onPersistedDataLoaded: _manager => {},
+    onPersistedDataLoaded: manager => {
+      queueManagerRangoPreset.checkWaitingForNetworkChange(manager);
+    },
     isPaused: false
   }, props.children);
 }
@@ -2793,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);
@@ -2804,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(() => {
@@ -2835,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
   }))))));