@rango-dev/widget-embedded 0.1.10-next.92 → 0.1.10-next.94

package/src/utils/numbers.ts

@@ -1,7 +1,8 @@
 import { BigNumber } from 'bignumber.js';
 import { BestRouteResponse } from 'rango-sdk';
 
-export const percentToString = (p: number, fractions = 0): string => (p * 100).toFixed(fractions);
+export const percentToString = (p: number, fractions = 0): string =>
+  (p * 100).toFixed(fractions);
 export const secondsToString = (s: number): string => {
   const seconds = (s % 60).toString().padStart(2, '0');
   const minutes = parseInt((s / 60).toString())
@@ -13,7 +14,7 @@ export const secondsToString = (s: number): string => {
 export const numberToString = (
   number: BigNumber | string | null,
   minDecimals: number | null = null,
-  maxDecimals: number | null = null,
+  maxDecimals: number | null = null
 ): string => {
   if (number === null) return '';
   if (number === '') return '';
@@ -30,39 +31,57 @@ export const numberToString = (
   if (n.gte(10000)) return n.toFormat(0, roundingMode);
   if (n.gte(1000))
     return n.toFormat(
-      Math.min(maxI, Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 1))),
-      roundingMode,
+      Math.min(
+        maxI,
+        Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 1))
+      ),
+      roundingMode
     );
   if (n.gte(100))
     return n.toFormat(
-      Math.min(maxI, Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 1))),
-      roundingMode,
+      Math.min(
+        maxI,
+        Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 1))
+      ),
+      roundingMode
     );
   if (n.gte(1))
     return n.toFormat(
-      Math.min(maxI, Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 2))),
-      roundingMode,
+      Math.min(
+        maxI,
+        Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 2))
+      ),
+      roundingMode
     );
   if (n.gte(0.01))
     return n.toFormat(
-      Math.min(maxI, Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 4))),
-      roundingMode,
+      Math.min(
+        maxI,
+        Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 4))
+      ),
+      roundingMode
     );
   for (let i = minDecimals || 4; i < 17; i++)
     if (n.gte(Math.pow(10, -i)))
       return n.toFormat(
-        Math.min(maxI, Math.min(maxDecimals || 100, Math.max(minDecimals || 0, i))),
-        roundingMode,
+        Math.min(
+          maxI,
+          Math.min(maxDecimals || 100, Math.max(minDecimals || 0, i))
+        ),
+        roundingMode
       );
   if (n.isEqualTo(0)) return '0';
 
   return n.toFormat(
     Math.min(maxI, Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 8))),
-    roundingMode,
+    roundingMode
   );
 };
 
-export const convertBigNumberToHex = (value: BigNumber, decimals: number): string => {
+export const convertBigNumberToHex = (
+  value: BigNumber,
+  decimals: number
+): string => {
   return '0x' + value.shiftedBy(decimals).toString(16);
 };
 
@@ -100,13 +119,15 @@ export const totalArrivalTime = (data: BestRouteResponse | null) =>
 
 export const rawFees = (data: BestRouteResponse): string =>
   (
-    data?.result?.swaps?.flatMap((s) => s.fee.map((f) => ({ swapperId: s.swapperId, fee: f }))) ||
-    []
+    data?.result?.swaps?.flatMap((s) =>
+      s.fee.map((f) => ({ swapperId: s.swapperId, fee: f }))
+    ) || []
   )
     .reduce((partialSum, a) => partialSum + parseFloat(a.fee.amount), 0)
     .toFixed(3);
 
-export const decimalNumber = (number = '0', toFixed: number) => parseFloat(number).toFixed(toFixed);
+export const decimalNumber = (number = '0', toFixed: number) =>
+  parseFloat(number).toFixed(toFixed);
 
 export const containsText = (text: string, searchText: string) =>
   text.toLowerCase().indexOf(searchText.toLowerCase()) > -1;

package/src/utils/routing.ts

@@ -3,57 +3,148 @@ import {
   SimulationValidationStatus,
 } from '@rango-dev/ui/dist/types/swaps';
 import BigNumber from 'bignumber.js';
-import { BestRouteResponse } from 'rango-sdk';
+import { BestRouteResponse, BlockchainMeta, Token } from 'rango-sdk';
 import { areEqual } from './common';
 import { SelectedWallet } from './wallets';
+import { BestRouteParams } from '../types';
+import { TokenMeta } from '@rango-dev/ui/dist/types/meta';
+import { numberToString } from './numbers';
+import { getUsdFeeOfStep } from './swap';
+import { BestRouteWithFee } from '@rango-dev/ui';
 
-export const getBestRouteToTokenUsdPrice = (
-  bestRoute: BestRouteResponse | null,
-): number | null | undefined =>
-  bestRoute?.result?.swaps[bestRoute?.result?.swaps.length - 1].to.usdPrice;
+export function searchParamsToToken(
+  tokens: Token[],
+  searchParams: string | null,
+  chain: BlockchainMeta | null
+): Token | null {
+  if (!chain) return null;
+  return (
+    tokens.find((token) => {
+      const symbolAndAddress = searchParams?.split('--');
+      if (symbolAndAddress?.length === 1)
+        return (
+          token.symbol === symbolAndAddress[0] &&
+          token.address === null &&
+          token.blockchain === chain.name
+        );
+      return (
+        token.symbol === symbolAndAddress?.[0] &&
+        token.address === symbolAndAddress?.[1] &&
+        token.blockchain === chain.name
+      );
+    }) || null
+  );
+}
+
+export function getBestRouteToTokenUsdPrice(
+  bestRoute: BestRouteResponse | null
+): number | null | undefined {
+  return bestRoute?.result?.swaps[bestRoute?.result?.swaps.length - 1].to
+    .usdPrice;
+}
 
-export function isNumberOfSwapsChanged(route1: BestRouteResponse, route2: BestRouteResponse) {
+export function isNumberOfSwapsChanged(
+  route1: BestRouteResponse,
+  route2: BestRouteResponse
+) {
   const route1Swaps = route1.result?.swaps || [];
   const route2Swaps = route2.result?.swaps || [];
   return route1Swaps.length !== route2Swaps.length;
 }
 
-export function isRouteSwappersUpdated(route1: BestRouteResponse, route2: BestRouteResponse) {
-  const route1Swappers = route1.result?.swaps.map((swap) => swap.swapperId) || [];
-  const route2Swappers = route2.result?.swaps.map((swap) => swap.swapperId) || [];
+export function isRouteSwappersUpdated(
+  route1: BestRouteResponse,
+  route2: BestRouteResponse
+) {
+  const route1Swappers =
+    route1.result?.swaps.map((swap) => swap.swapperId) || [];
+  const route2Swappers =
+    route2.result?.swaps.map((swap) => swap.swapperId) || [];
   return !areEqual(route1Swappers, route2Swappers);
 }
 
-export function isRouteInternalCoinsUpdated(route1: BestRouteResponse, route2: BestRouteResponse) {
-  const route1InternalCoins = route1.result?.swaps.map((swap) => swap.to.symbol) || [];
-  const route2InternalCoins = route2.result?.swaps.map((swap) => swap.to.symbol) || [];
+export function isRouteInternalCoinsUpdated(
+  route1: BestRouteResponse,
+  route2: BestRouteResponse
+) {
+  const route1InternalCoins =
+    route1.result?.swaps.map((swap) => swap.to.symbol) || [];
+  const route2InternalCoins =
+    route2.result?.swaps.map((swap) => swap.to.symbol) || [];
   return !areEqual(route1InternalCoins, route2InternalCoins);
 }
 
-export const isRouteChanged = (route1: BestRouteResponse, route2: BestRouteResponse): boolean => {
+export function isRouteChanged(
+  route1: BestRouteResponse,
+  route2: BestRouteResponse
+): boolean {
   return (
     isNumberOfSwapsChanged(route1, route2) ||
     isRouteSwappersUpdated(route1, route2) ||
     isRouteInternalCoinsUpdated(route1, route2)
   );
-};
+}
 
-export const outToRatioHasWarning = (fromUsdValue: BigNumber | null, outToInRatio: BigNumber | 0) =>
-  (parseInt(outToInRatio?.toFixed(2) || '0') <= -10 &&
-    (fromUsdValue === null || fromUsdValue.gte(new BigNumber(200)))) ||
-  (parseInt(outToInRatio?.toFixed(2) || '0') <= -5 &&
-    (fromUsdValue === null || fromUsdValue.gte(new BigNumber(1000))));
+export function outToRatioHasWarning(
+  fromUsdValue: BigNumber | null,
+  outToInRatio: BigNumber | 0
+) {
+  return (
+    (parseInt(outToInRatio?.toFixed(2) || '0') <= -10 &&
+      (fromUsdValue === null || fromUsdValue.gte(new BigNumber(200)))) ||
+    (parseInt(outToInRatio?.toFixed(2) || '0') <= -5 &&
+      (fromUsdValue === null || fromUsdValue.gte(new BigNumber(1000))))
+  );
+}
 
-export const getRequiredBalanceOfWallet = (
+export function getRequiredBalanceOfWallet(
   selectedWallet: SelectedWallet,
-  fee: SimulationValidationStatus[] | null,
-): SimulationAssetAndAmount[] | null => {
+  fee: SimulationValidationStatus[] | null
+): SimulationAssetAndAmount[] | null {
   if (fee === null) return null;
   const relatedFeeStatus = fee
     ?.find((item) => item.blockchain === selectedWallet.chain)
     ?.wallets.find(
-      (wallet) => wallet.address?.toLowerCase() === selectedWallet.address.toLowerCase(),
+      (wallet) =>
+        wallet.address?.toLowerCase() === selectedWallet.address.toLowerCase()
     );
   if (!relatedFeeStatus) return null;
   return relatedFeeStatus.requiredAssets;
-};
+}
+
+export function isRouteParametersChanged(
+  prevParams: BestRouteParams,
+  currentParams: BestRouteParams
+) {
+  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
+  );
+}
+
+export function getBestRouteWithCalculatedFees(
+  bestRoute: BestRouteResponse | null,
+  tokens: TokenMeta[]
+): BestRouteWithFee | null {
+  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 },
+  };
+}

package/src/utils/swap.ts

@@ -248,10 +248,10 @@ export function calculatePendingSwap(
           transferTransaction: null,
           diagnosisUrl: null,
           internalSteps: null,
-          fromBlockchainLogo: fromBlockchain.logo,
-          toBlockchainLogo: toBlockchain.logo,
-          swapperLogo: swapper?.logo,
-          swapperType: swapperType,
+          fromBlockchainLogo: fromBlockchain?.logo || '',
+          toBlockchainLogo: toBlockchain?.logo || '',
+          swapperLogo: swapper?.logo || '',
+          swapperType: swapperType || '',
         };
       }) || [],
   };
@@ -288,7 +288,10 @@ export const getUsdPrice = (
   return token?.usdPrice || null;
 };
 
-function getUsdFeeOfStep(step: SwapResult, allTokens: Token[]): BigNumber {
+export function getUsdFeeOfStep(
+  step: SwapResult,
+  allTokens: Token[]
+): BigNumber {
   let totalFeeInUsd = ZERO;
   for (let i = 0; i < step.fee.length; i++) {
     const fee = step.fee[i];
@@ -332,7 +335,9 @@ export function hasSlippageError(
   return (slippages?.filter((s) => !!s?.error)?.length || 0) > 0;
 }
 
-export function getMinRequiredSlippage(route: BestRouteResponse) {
+export function getMinRequiredSlippage(
+  route: BestRouteResponse
+): number | null {
   const slippages = route.result?.swaps.map(
     (slippage) => slippage.recommendedSlippage
   );
@@ -350,7 +355,8 @@ export function hasProperSlippage(
   minRequiredSlippage: number | null
 ) {
   if (!minRequiredSlippage) return true;
-  return parseFloat(userSlippage) > minRequiredSlippage;
+  //@ts-ignore
+  return parseFloat(userSlippage) >= parseFloat(minRequiredSlippage);
 }
 
 export function hasEnoughBalance(
@@ -465,14 +471,15 @@ export function getWalletsForNewSwap(selectedWallets: SelectedWallet[]) {
   return wallets;
 }
 
-export function getRouteOutputAmount(route: BestRouteResponse) {
-  return route.result?.outputAmount || null;
+export function getRouteOutputAmount(route: BestRouteResponse | null) {
+  return route?.result?.outputAmount || null;
 }
 
 export function getPercentageChange(
-  oldValue: string | number,
-  newValue: string | number
+  oldValue: string | number | null,
+  newValue: string | number | null
 ) {
+  if (!oldValue || !newValue) return null;
   return new BigNumber(newValue)
     .div(new BigNumber(oldValue))
     .minus(1)
@@ -490,6 +497,7 @@ export function isOutputAmountChangedALot(
     oldOutputAmount,
     newOutputAmount
   );
+  if (!percentageChange) return true;
 
   return percentageChange.toNumber() <= -1;
 }

package/src/utils/wallets.ts

@@ -3,9 +3,10 @@ import {
   isEvmAddress,
   KEPLR_COMPATIBLE_WALLETS,
   Network,
-  WalletInfo,
   WalletState,
   WalletType,
+  detectInstallLink,
+  WalletInfo,
 } from '@rango-dev/wallets-shared';
 
 import {
@@ -55,19 +56,25 @@ export function getlistWallet(
     WalletType.UNKNOWN,
     WalletType.TERRA_STATION,
     WalletType.LEAP,
-  ];  
+  ];
 
   return list
     .filter((wallet) => !excludedWallets.includes(wallet))
     .map((type) => {
-      const { name, img: image, installLink } = getWalletInfo(type);
+      const {
+        name,
+        img: image,
+        installLink,
+        showOnMobile,
+      } = getWalletInfo(type);
       const state = getStateWallet(getState(type));
       return {
         name,
         image,
-        installLink,
+        installLink: detectInstallLink(installLink),
         state,
         type,
+        showOnMobile: typeof showOnMobile === 'undefined' ? false : true,
       };
     });
 }
@@ -320,76 +327,28 @@ function numberWithThousandSeperator(number: string | number): string {
   return parts.join('.');
 }
 
-export const sortedTokens = (
-  tokens: TokenWithBalance[],
-  position: 'from' | 'to',
-  balance: Balance[]
-): TokenWithBalance[] => {
-  if (!tokens) return [];
-  const walletSymbols = new Set(
-    (balance || [])
-      .flatMap((a) => a.balances || [])
-      .filter((b) => (new BigNumber(b?.rawAmount) || ZERO).gt(0))
-      .map((b) => `${b?.chain}.${b?.symbol}.${b?.address}`)
-  );
-  let sortedList = [
-    ...tokens.filter(
-      (t) => !t.address && walletSymbols.size && position === 'to'
-    ),
-    ...tokens
-      .filter(
-        (t) =>
-          !(position === 'to' && !t.address) &&
-          walletSymbols.has(`${t.blockchain}.${t.symbol}.${t.address}`)
-      )
-      .sort((tokenA, tokenB) => compareBalance(tokenA, tokenB, balance)),
-    ...tokens.filter(
-      (t) =>
-        !walletSymbols.has(`${t.blockchain}.${t.symbol}.${t.address}`) &&
-        !t.address &&
-        (!walletSymbols.size || position === 'from')
-    ),
-    ...tokens.filter(
-      (t) =>
-        !walletSymbols.has(`${t.blockchain}.${t.symbol}.${t.address}`) &&
-        t.address &&
-        !t.isSecondaryCoin
-    ),
-    ...tokens.filter(
-      (t) =>
-        !walletSymbols.has(`${t.blockchain}.${t.symbol}.${t.address}`) &&
-        t.isSecondaryCoin
-    ),
-  ];
-
-  return sortedList;
-};
+export const sortTokens = (tokens: TokenWithBalance[]): TokenWithBalance[] => {
+  let walletConnected = !!tokens.some((token) => token.balance);
+  if (!walletConnected) {
+    return tokens
+      .filter((token) => !token.address)
+      .concat(
+        tokens.filter((token) => token.address && !token.isSecondaryCoin),
+        tokens.filter((token) => token.isSecondaryCoin)
+      );
+  }
 
-const compareBalance = (
-  tokenA: TokenWithBalance,
-  tokenB: TokenWithBalance,
-  wallet: Balance[]
-): number => {
-  if (!tokenA.usdPrice || !tokenB.usdPrice) return 0;
-
-  const tokenAUsdValue = new BigNumber(
-    getBalanceFromWallet(
-      wallet,
-      tokenA.blockchain,
-      tokenA.symbol,
-      tokenA.address
-    )?.amount || ZERO
-  ).multipliedBy(tokenA.usdPrice);
-  const tokenBUsdValue = new BigNumber(
-    getBalanceFromWallet(
-      wallet,
-      tokenB.blockchain,
-      tokenB.symbol,
-      tokenB.address
-    )?.amount || ZERO
-  ).multipliedBy(tokenB.usdPrice);
-  if (tokenAUsdValue.gt(tokenBUsdValue)) return -1;
-  return 1;
+  return tokens
+    .filter((token) => !!token.balance)
+    .sort(
+      (tokenA, tokenB) =>
+        parseFloat(tokenB.balance?.usdValue || '0') -
+        parseFloat(tokenA.balance?.usdValue || '0')
+    )
+    .concat(
+      tokens.filter((token) => !token.balance && !token.isSecondaryCoin),
+      tokens.filter((token) => !token.balance && token.isSecondaryCoin)
+    );
 };
 
 export const getUsdPrice = (
@@ -429,3 +388,88 @@ export const getKeplrCompatibleConnectedWallets = (
     connectedWalletTypes.has(compatibleWallet)
   );
 };
+
+export function getTokensWithBalance(
+  tokens: TokenWithBalance[],
+  balances: Balance[]
+): TokenWithBalance[] {
+  return tokens.map(({ balance, ...otherProps }) => {
+    const tokenAmount = numberToString(
+      new BigNumber(
+        getBalanceFromWallet(
+          balances,
+          otherProps.blockchain,
+          otherProps.symbol,
+          otherProps.address
+        )?.amount || ZERO
+      )
+    );
+
+    let tokenUsdValue = '';
+    if (otherProps.usdPrice)
+      tokenUsdValue = numberToString(
+        new BigNumber(
+          getBalanceFromWallet(
+            balances,
+            otherProps.blockchain,
+            otherProps.symbol,
+            otherProps.address
+          )?.amount || ZERO
+        ).multipliedBy(otherProps.usdPrice)
+      );
+
+    return {
+      ...otherProps,
+      ...(tokenAmount !== '0' && {
+        balance: { amount: tokenAmount, usdValue: tokenUsdValue },
+      }),
+    };
+  });
+}
+
+export function getSortedTokens(
+  chain: BlockchainMeta | null,
+  tokens: Token[],
+  balances: Balance[],
+  otherChainTokens: TokenWithBalance[]
+): TokenWithBalance[] {
+  const fromChainEqueulsToToChain = chain?.name === otherChainTokens[0]?.name;
+  if (fromChainEqueulsToToChain) return otherChainTokens;
+  const filteredTokens = tokens.filter(
+    (token) => token.blockchain === chain?.name
+  );
+  return sortTokens(getTokensWithBalance(filteredTokens, balances));
+}
+
+export function tokensAreEqual(tokenA: Token | null, tokenB: Token | null) {
+  return (
+    tokenA?.blockchain === tokenB?.blockchain &&
+    tokenA?.name === tokenB?.name &&
+    tokenA?.address === tokenB?.address
+  );
+}
+
+export function getDefaultToken(
+  sortedTokens: TokenWithBalance[],
+  otherToken: TokenWithBalance | null
+): TokenWithBalance {
+  let selectedToken: TokenWithBalance;
+  const firstToken = sortedTokens[0];
+  const secondToken = sortedTokens[1];
+  if (sortedTokens.length === 1) selectedToken = firstToken;
+  else if (tokensAreEqual(firstToken, otherToken)) selectedToken = secondToken;
+  else selectedToken = firstToken;
+  return selectedToken;
+}
+
+export function sortWalletsBasedOnState(
+  wallets: ModalWalletInfo[]
+): ModalWalletInfo[] {
+  return wallets.sort(
+    (a, b) =>
+      Number(b.state === WalletStatus.CONNECTED) -
+        Number(a.state === WalletStatus.CONNECTED) ||
+      Number(b.state === WalletStatus.DISCONNECTED) -
+        Number(a.state === WalletStatus.DISCONNECTED)
+  );
+}

package/dist/store/confirmSwap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"confirmSwap.d.ts","sourceRoot":"","sources":["../src/store/confirmSwap.ts"],"names":[],"mappings":"AA+BA,OAAO,EAAE,WAAW,EAAE,MAAM,6CAA6C,CAAC;AAS1E,eAAO,MAAM,mBAAmB,KAS/B,CAAC;AAEF,oBAAY,qBAAqB;IAC/B,QAAQ,IAAA;IACR,kCAAkC,IAAA;IAClC,cAAc,IAAA;IACd,qBAAqB,IAAA;CACtB;AAED,oBAAY,gBAAgB,GACxB;IACE,IAAI,EAAE,qBAAqB,CAAC,cAAc,CAAC;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GACD;IACE,IAAI,EAAE,qBAAqB,CAAC,qBAAqB,CAAC;IAClD,mBAAmB,EAAE,MAAM,CAAC;CAC7B,GACD;IACE,IAAI,EAAE,OAAO,CACX,qBAAqB,EACnB,qBAAqB,CAAC,cAAc,GACpC,qBAAqB,CAAC,qBAAqB,CAC9C,CAAC;CACH,CAAC;AAEN,oBAAY,mBAAmB,GAC3B;IACE,IAAI,EAAE,uBAAuB,CAAC,+BAA+B,CAAC;IAC9D,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,GACD;IAAE,IAAI,EAAE,uBAAuB,CAAC,oBAAoB,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,GAC1E;IACE,IAAI,EAAE,OAAO,CACX,uBAAuB,EACrB,uBAAuB,CAAC,+BAA+B,GACvD,uBAAuB,CAAC,oBAAoB,CAC/C,CAAC;CACH,CAAC;AAEN,oBAAY,uBAAuB;IACjC,aAAa,IAAA;IACb,sBAAsB,IAAA;IACtB,mBAAmB,IAAA;IACnB,+BAA+B,IAAA;IAC/B,oBAAoB,IAAA;CACrB;AAED,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,WAAW,GAAG,SAAS,CAmPnE,CAAC"}