@rango-dev/widget-embedded 0.17.1-next.2 → 0.17.1-next.21

package/src/utils/swap.ts

@@ -1,7 +1,13 @@
 /* eslint-disable @typescript-eslint/no-magic-numbers */
-import type { LoadingStatus } from '../store/meta';
-import type { ConnectedWallet } from '../store/wallets';
-import type { ConvertedToken, SwapButtonState, Wallet } from '../types';
+import type { FetchStatus } from '../store/slices/data';
+import type {
+  ConvertedToken,
+  QuoteError,
+  QuoteWarning,
+  RecommendedSlippages,
+  SwapButtonState,
+  Wallet,
+} from '../types';
 import type {
   PendingSwap,
   PendingSwapStep,
@@ -30,12 +36,11 @@ import {
   TOKEN_AMOUNT_MAX_DECIMALS,
   TOKEN_AMOUNT_MIN_DECIMALS,
 } from '../constants/routing';
-import { useMetaStore } from '../store/meta';
-import { ButtonState } from '../types';
 
 import { removeDuplicateFrom } from './common';
+import { getBlockchainShortNameFor } from './meta';
 import { numberToString } from './numbers';
-import { getRequiredBalanceOfWallet } from './routing';
+import { getPriceImpact, getRequiredBalanceOfWallet } from './quote';
 import { getRequiredChains } from './wallets';
 
 export function getOutputRatio(
@@ -50,25 +55,29 @@ export function getOutputRatio(
   ) {
     return 0;
   }
-  return outputUsdValue.div(inputUsdValue).minus(1).multipliedBy(100);
+  return outputUsdValue
+    .div(inputUsdValue)
+    .minus(1)
+    .multipliedBy(100)
+    .toNumber();
 }
 
-export function outputRatioHasWarning(
+export function hasHighValueLoss(
   inputUsdValue: BigNumber | null,
-  outputRatio: BigNumber | 0
+  priceImpact: number
 ): boolean {
   return (
-    ((parseInt(outputRatio.toFixed(2) || '0') <= -10 &&
+    ((parseInt(priceImpact.toFixed(2) || '0') <= -10 &&
       inputUsdValue?.gte(new BigNumber(400))) ||
-      (parseInt(outputRatio.toFixed(2) || '0') <= -5 &&
+      (parseInt(priceImpact.toFixed(2) || '0') <= -5 &&
         inputUsdValue?.gte(new BigNumber(1000)))) ??
     false
   );
 }
 
-export function hasLimitError(bestRoute: BestRouteResponse | null): boolean {
+export function hasLimitError(quote: BestRouteResponse | null): boolean {
   return (
-    (bestRoute?.result?.swaps || []).filter((swap) => {
+    (quote?.result?.swaps || []).filter((swap) => {
       const minimum = !!swap.fromAmountMinValue
         ? new BigNumber(swap.fromAmountMinValue)
         : null;
@@ -83,16 +92,12 @@ export function hasLimitError(bestRoute: BestRouteResponse | null): boolean {
     }).length > 0
   );
 }
-
-export function LimitErrorMessage(bestRoute: BestRouteResponse | null): {
-  swap: SwapResult | null;
+export function getLimitErrorMessage(quote: BestRouteResponse): {
+  swap: SwapResult;
   fromAmountRangeError: string;
   recommendation: string;
 } {
-  if (!bestRoute) {
-    return { swap: null, fromAmountRangeError: '', recommendation: '' };
-  }
-  const swap = (bestRoute?.result?.swaps || []).filter((swap) => {
+  const swap = (quote.result?.swaps || []).filter((swap) => {
     const minimum = !!swap.fromAmountMinValue
       ? new BigNumber(swap.fromAmountMinValue)
       : null;
@@ -105,9 +110,7 @@ export function LimitErrorMessage(bestRoute: BestRouteResponse | null): {
     }
     return minimum?.gt(swap.fromAmount) || maximum?.lt(swap.fromAmount);
   })[0];
-  if (!swap) {
-    return { swap: null, fromAmountRangeError: '', recommendation: '' };
-  }
+
   const minimum = !!swap.fromAmountMinValue
     ? new BigNumber(swap.fromAmountMinValue)
     : null;
@@ -177,85 +180,92 @@ export function LimitErrorMessage(bestRoute: BestRouteResponse | null): {
   return { swap, fromAmountRangeError, recommendation };
 }
 
-export function getSwapButtonState(
-  loadingMetaStatus: LoadingStatus,
-  connectedWallets: ConnectedWallet[],
-  loading: boolean,
-  bestRoute: BestRouteResponse | null,
-  hasLimitError: boolean,
-  highValueLoss: boolean,
-  priceImpactCanNotBeComputed: boolean,
-  needsToWarnEthOnPath: boolean,
-  inputAmount: string
-): SwapButtonState {
-  if (loadingMetaStatus !== 'success') {
+export function getSwapButtonState(params: {
+  fetchMetaStatus: FetchStatus;
+  anyWalletConnected: boolean;
+  fetchingQuote: boolean;
+  inputAmount: string;
+  quote: BestRouteResponse | null;
+  warning: QuoteWarning | null;
+  error: QuoteError | null;
+  needsToWarnEthOnPath: boolean;
+}): SwapButtonState {
+  const {
+    fetchMetaStatus,
+    anyWalletConnected,
+    fetchingQuote,
+    inputAmount,
+    quote,
+    warning,
+    error,
+    needsToWarnEthOnPath,
+  } = params;
+  if (fetchMetaStatus !== 'success') {
     return {
       title: swapButtonTitles().connectWallet,
-      state: ButtonState.WAITFORCONNECTING,
+      action: 'connect-wallet',
       disabled: true,
     };
   }
-  if (connectedWallets.length == 0) {
+  if (!anyWalletConnected) {
     return {
       title: swapButtonTitles().connectWallet,
-      state: ButtonState.WAITFORCONNECTING,
+      action: 'connect-wallet',
       disabled: false,
     };
   }
   if (
-    loading ||
-    !bestRoute ||
-    !bestRoute.result ||
-    hasLimitError ||
+    fetchingQuote ||
+    !quote ||
+    !quote.result ||
+    error ||
     !inputAmount ||
     inputAmount === '0'
   ) {
     return {
       title: swapButtonTitles().swap,
+      action: 'confirm-swap',
       disabled: true,
-      state: ButtonState.SWAP,
     };
-  } else if (highValueLoss || priceImpactCanNotBeComputed) {
+  } else if (warning) {
     return {
       title: swapButtonTitles().swapAnyway,
+      action: 'confirm-warning',
       disabled: false,
-      hasWarning: true,
-      state: ButtonState.NEEDTOCONFIRM,
     };
   } else if (needsToWarnEthOnPath) {
     return {
-      title: swapButtonTitles().ethRouteWarning,
+      title: swapButtonTitles().ethWarning,
+      action: 'confirm-warning',
       disabled: false,
-      hasWarning: true,
-      state: ButtonState.WARNING,
     };
   }
   return {
     title: swapButtonTitles().swap,
+    action: 'confirm-swap',
     disabled: false,
-    state: ButtonState.SWAP,
   };
 }
 
 export function canComputePriceImpact(
-  bestRoute: BestRouteResponse | null,
+  quote: BestRouteResponse | null,
   inputAmount: string,
   usdValue: BigNumber | null
 ) {
   return !(
     (!usdValue || usdValue.lte(ZERO)) &&
-    !!bestRoute?.result &&
+    !!quote?.result &&
     !!inputAmount &&
     inputAmount !== '0' &&
     parseFloat(inputAmount || '0') !== 0 &&
-    !!bestRoute.result
+    !!quote.result
   );
 }
 
-export function requiredWallets(route: BestRouteResponse | null) {
+export function requiredWallets(quote: BestRouteResponse | null) {
   const wallets: string[] = [];
 
-  route?.result?.swaps.forEach((swap) => {
+  quote?.result?.swaps.forEach((swap) => {
     const currentStepFromBlockchain = swap.from.blockchain;
     const currentStepToBlockchain = swap.to.blockchain;
     let lastAddedWallet = wallets[wallets.length - 1];
@@ -311,15 +321,13 @@ export function getUsdFeeOfStep(
 }
 
 export function getTotalFeeInUsd(
-  bestRoute: BestRouteResponse | null,
+  swaps: SwapResult[],
   allTokens: Token[]
-): BigNumber | null {
-  return (
-    bestRoute?.result?.swaps.reduce(
-      (totalFee: BigNumber, step) =>
-        totalFee.plus(getUsdFeeOfStep(step, allTokens)),
-      ZERO
-    ) || null
+): BigNumber {
+  return swaps.reduce(
+    (totalFee: BigNumber, step) =>
+      totalFee.plus(getUsdFeeOfStep(step, allTokens)),
+    ZERO
   );
 }
 
@@ -336,10 +344,44 @@ export function hasSlippageError(
   return (slippages?.filter((s) => !!s?.error)?.length || 0) > 0;
 }
 
+export function checkSlippageErrors(
+  quote: BestRouteResponse
+): RecommendedSlippages | null {
+  const recommendedSlippages: RecommendedSlippages = new Map();
+  quote.result?.swaps.forEach((swap, index) => {
+    if (swap.recommendedSlippage?.error) {
+      recommendedSlippages.set(index, swap.recommendedSlippage.slippage);
+    }
+  });
+  if (recommendedSlippages.size > 0) {
+    return recommendedSlippages;
+  }
+  return null;
+}
+
+export function checkSlippageWarnings(
+  quote: BestRouteResponse,
+  userSlippage: number
+): RecommendedSlippages | null {
+  const recommendedSlippages: RecommendedSlippages = new Map();
+  quote.result?.swaps.forEach((swap, index) => {
+    if (
+      swap.recommendedSlippage?.slippage &&
+      parseFloat(swap.recommendedSlippage.slippage) > userSlippage
+    ) {
+      recommendedSlippages.set(index, swap.recommendedSlippage.slippage);
+    }
+  });
+  if (recommendedSlippages.size > 0) {
+    return recommendedSlippages;
+  }
+  return null;
+}
+
 export function getMinRequiredSlippage(
-  route: BestRouteResponse
+  quote: BestRouteResponse
 ): string | null {
-  const slippages = route.result?.swaps.map(
+  const slippages = quote.result?.swaps.map(
     (slippage) => slippage.recommendedSlippage
   );
   return (
@@ -362,10 +404,10 @@ export function hasProperSlippage(
 }
 
 export function hasEnoughBalance(
-  route: BestRouteResponse,
+  quote: BestRouteResponse,
   selectedWallets: Wallet[]
 ) {
-  const fee = route.validationStatus;
+  const fee = quote.validationStatus;
 
   if (fee === null || fee.length === 0) {
     return true;
@@ -389,29 +431,31 @@ export function hasEnoughBalance(
 }
 
 export function hasEnoughBalanceAndProperSlippage(
-  route: BestRouteResponse,
+  quote: BestRouteResponse,
   selectedWallets: Wallet[],
   userSlippage: string,
   minRequiredSlippage: string | null
 ): boolean {
   return (
-    hasEnoughBalance(route, selectedWallets) &&
+    hasEnoughBalance(quote, selectedWallets) &&
     hasProperSlippage(userSlippage, minRequiredSlippage)
   );
 }
 
-export function createBestRouteRequestBody(params: {
+export function createQuoteRequestBody(params: {
   fromToken: Token;
   toToken: Token;
   inputAmount: string;
   wallets?: Wallet[];
   selectedWallets?: Wallet[];
+  liquiditySources?: string[];
+  excludeLiquiditySources?: boolean;
   disabledLiquiditySources: string[];
   slippage: number;
   affiliateRef: string | null;
   affiliatePercent: number | null;
   affiliateWallets: { [key: string]: string } | null;
-  initialRoute?: BestRouteResponse;
+  initialQuote?: BestRouteResponse;
   destination?: string;
 }): BestRouteRequest {
   const {
@@ -421,11 +465,13 @@ export function createBestRouteRequestBody(params: {
     wallets,
     selectedWallets,
     disabledLiquiditySources,
+    liquiditySources,
+    excludeLiquiditySources,
     slippage,
     affiliateRef,
     affiliatePercent,
     affiliateWallets,
-    initialRoute,
+    initialQuote,
     destination,
   } = params;
   const selectedWalletsMap = selectedWallets?.reduce(
@@ -455,10 +501,10 @@ export function createBestRouteRequestBody(params: {
     }
   });
 
-  const checkPrerequisites = !!initialRoute;
+  const checkPrerequisites = !!initialQuote;
 
   const filteredBlockchains = removeDuplicateFrom(
-    (initialRoute?.result?.swaps || []).reduce(
+    (initialQuote?.result?.swaps || []).reduce(
       (blockchains: string[], swap) => {
         blockchains.push(swap.from.blockchain, swap.to.blockchain);
         // Check if internalSwaps array exists
@@ -496,13 +542,18 @@ export function createBestRouteRequestBody(params: {
     selectedWallets: selectedWalletsMap ?? {},
     slippage: slippage.toString(),
     ...(destination && { destination: destination }),
-    ...(disabledLiquiditySources.length > 0 && {
-      swapperGroups: disabledLiquiditySources,
+    ...(excludeLiquiditySources && {
+      swapperGroups: disabledLiquiditySources.concat(liquiditySources ?? []),
       swappersGroupsExclude: true,
     }),
+    ...(!excludeLiquiditySources && {
+      swapperGroups: liquiditySources?.filter(
+        (liquiditySource) => !disabledLiquiditySources.includes(liquiditySource)
+      ),
+      swappersGroupsExclude: false,
+    }),
     ...(checkPrerequisites && { blockchains: filteredBlockchains }),
   };
-
   return requestBody;
 }
 
@@ -526,49 +577,42 @@ export function getWalletsForNewSwap(selectedWallets: Wallet[]) {
   return wallets;
 }
 
-export function getRouteOutputAmount(route: BestRouteResponse | null) {
-  return route?.result?.outputAmount || null;
+export function getQuoteOutputAmount(quote: BestRouteResponse) {
+  return quote.result?.outputAmount || null;
 }
 
-export function getPercentageChange(
-  inputUsdValue: string | number | null,
-  outputUsdValue: string | number | null
-) {
-  if (!inputUsdValue || !outputUsdValue) {
-    return null;
-  }
-  return new BigNumber(outputUsdValue)
-    .div(new BigNumber(inputUsdValue))
+export function getPercentageChange(input: string, output: string) {
+  return new BigNumber(output)
+    .div(new BigNumber(input))
     .minus(1)
-    .multipliedBy(100);
+    .multipliedBy(100)
+    .toNumber();
 }
 
 export function isOutputAmountChangedALot(
-  oldRoute: BestRouteResponse,
-  newRoute: BestRouteResponse
+  oldQuote: BestRouteResponse,
+  newQuote: BestRouteResponse
 ) {
-  const oldOutputAmount = getRouteOutputAmount(oldRoute);
-  const newOutputAmount = getRouteOutputAmount(newRoute);
+  const oldOutputAmount = getQuoteOutputAmount(oldQuote);
+  const newOutputAmount = getQuoteOutputAmount(newQuote);
   if (!oldOutputAmount || !newOutputAmount) {
     return false;
   }
-  const percentageChange = getPercentageChange(
-    oldOutputAmount,
-    newOutputAmount
-  );
+  const percentageChange = getPriceImpact(oldOutputAmount, newOutputAmount);
   if (!percentageChange) {
     return true;
   }
 
-  return percentageChange.toNumber() <= -1;
+  return percentageChange <= -1;
 }
 
-export function getBalanceWarnings(
-  route: BestRouteResponse,
-  selectedWallets: Wallet[]
+export function generateBalanceWarnings(
+  quote: BestRouteResponse,
+  selectedWallets: Wallet[],
+  blockchains: BlockchainMeta[]
 ) {
-  const fee = route.validationStatus;
-  const requiredWallets = getRequiredChains(route);
+  const fee = quote.validationStatus;
+  const requiredWallets = getRequiredChains(quote);
   const walletsSortedByRequiredWallets = selectedWallets.sort(
     (selectedWallet1, selectedWallet2) =>
       requiredWallets.indexOf(selectedWallet1.chain) -
@@ -610,7 +654,10 @@ export function getBalanceWarnings(
           symbol,
           reason,
           currentAmount,
-          blockchain: asset.asset.blockchain,
+          blockchain: getBlockchainShortNameFor(
+            asset.asset.blockchain,
+            blockchains
+          ),
         },
       });
       return warningMessage;
@@ -714,29 +761,19 @@ export function shouldRetrySwap(pendingSwap: PendingSwap) {
     new Date().getTime() - parseInt(pendingSwap.finishTime) < 4 * 3600 * 1000
   );
 }
-export function isValidCustomDestination(
-  blockchain: string,
-  address: string
-): boolean {
-  const blockchains = useMetaStore.getState().meta.blockchains;
-  const regex =
-    blockchains.find((chain) => chain.name === blockchain)?.addressPatterns ||
-    [];
-  return regex.filter((r) => new RegExp(r).test(address)).length > 0;
-}
 
 export function confirmSwapDisabled(
   fetching: boolean,
   showCustomDestination: boolean,
   customDestination: string,
-  bestRoute: BestRouteResponse | null,
+  quote: BestRouteResponse | null,
   selectedWallets: { walletType: string; chain: string }[],
   lastStepToBlockchain?: BlockchainMeta
 ) {
   return (
     fetching ||
     (!showCustomDestination &&
-      !requiredWallets(bestRoute).every((chain) =>
+      !requiredWallets(quote).every((chain) =>
         selectedWallets.map((wallet) => wallet.chain).includes(chain)
       )) ||
     (!!showCustomDestination && !customDestination) ||

package/src/utils/wallets.ts

@@ -55,8 +55,11 @@ export function mapWalletTypesToWalletInfo(
   return list
     .filter((wallet) => !EXCLUDED_WALLETS.includes(wallet as WalletTypes))
     .filter((wallet) => {
-      const { supportedChains, hideWhenNotInstalled } = getWalletInfo(wallet);
-      if (hideWhenNotInstalled && !getState(wallet).installed) {
+      const { supportedChains, isContractWallet } = getWalletInfo(wallet);
+      const { installed, network } = getState(wallet);
+      const filterContractWallets =
+        isContractWallet && (!installed || (!!chain && network !== chain));
+      if (filterContractWallets) {
         return false;
       }
       if (chain) {
@@ -97,7 +100,8 @@ export function prepareAccountsForWalletStore(
   wallet: WalletType,
   accounts: string[],
   evmBasedChains: string[],
-  supportedChainNames: Network[] | null
+  supportedChainNames: Network[] | null,
+  isContractWallet: boolean
 ): Wallet[] {
   const result: Wallet[] = [];
 
@@ -151,21 +155,29 @@ export function prepareAccountsForWalletStore(
 
     // If it's an evm network, we will add the address to all the evm chains.
     if (isEvmBasedChain || isUnknownAndEvmBased) {
-      /*
-       * all evm chains are not supported in wallets, so we are adding
-       * only to those that are supported by wallet.
-       */
-      const evmChainsSupportedByWallet = supportedBlockchains.filter((chain) =>
-        evmBasedChains.includes(chain)
-      );
-
-      evmChainsSupportedByWallet.forEach((network) => {
+      if (isContractWallet) {
         /*
-         * EVM addresses are not case sensitive.
-         * Some wallets like Binance-chain return some letters in uppercase which produces bugs in our wallet state.
+         * for contract wallets like Safe wallet, we should add only account for the
+         * current connected blockchain not all of the supported blockchains
          */
         addAccount(network, address.toLowerCase());
-      });
+      } else {
+        /*
+         * all evm chains are not supported in wallets, so we are adding
+         * only to those that are supported by wallet.
+         */
+        const evmChainsSupportedByWallet = supportedBlockchains.filter(
+          (chain) => evmBasedChains.includes(chain)
+        );
+
+        evmChainsSupportedByWallet.forEach((network) => {
+          /*
+           * EVM addresses are not case sensitive.
+           * Some wallets like Binance-chain return some letters in uppercase which produces bugs in our wallet state.
+           */
+          addAccount(network, address.toLowerCase());
+        });
+      }
     } else {
       addAccount(network, address);
     }
@@ -174,10 +186,10 @@ export function prepareAccountsForWalletStore(
   return result;
 }
 
-export function getRequiredChains(route: BestRouteResponse | null) {
+export function getRequiredChains(quote: BestRouteResponse | null) {
   const wallets: string[] = [];
 
-  route?.result?.swaps.forEach((swap) => {
+  quote?.result?.swaps.forEach((swap) => {
     const currentStepFromBlockchain = swap.from.blockchain;
     const currentStepToBlockchain = swap.to.blockchain;
     if (!wallets.includes(currentStepFromBlockchain)) {

package/dist/Wallets.d.ts

@@ -1,17 +0,0 @@
-import type { WidgetConfig } from './types';
-import type { ProvidersOptions } from './utils/providers';
-import type { EventHandler } from '@rango-dev/wallets-react';
-import type { PropsWithChildren } from 'react';
-import React from 'react';
-type OnConnectHandler = (key: string) => void;
-interface WidgetContextInterface {
-    onConnectWallet(handler: OnConnectHandler): void;
-}
-export declare const WidgetContext: React.Context<WidgetContextInterface>;
-export declare function WidgetWallets(props: PropsWithChildren<{
-    providers: WidgetConfig['wallets'];
-    options?: ProvidersOptions;
-    onUpdateState?: EventHandler;
-}>): React.JSX.Element;
-export {};
-//# sourceMappingURL=Wallets.d.ts.map

package/dist/Wallets.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Wallets.d.ts","sourceRoot":"","sources":["../src/Wallets.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAI/C,OAAO,KAAgC,MAAM,OAAO,CAAC;AAUrD,KAAK,gBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;AAC9C,UAAU,sBAAsB;IAC9B,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAAC;CAClD;AAED,eAAO,MAAM,aAAa,uCAIxB,CAAC;AAEH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,iBAAiB,CAAC;IACvB,SAAS,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,aAAa,CAAC,EAAE,YAAY,CAAC;CAC9B,CAAC,qBA+EH"}

package/dist/Widget.d.ts

@@ -1,9 +0,0 @@
-import type { WidgetConfig } from './types';
-import type { PropsWithChildren } from 'react';
-import React from 'react';
-export type WidgetProps = {
-    config?: WidgetConfig;
-};
-export declare function Main(props: PropsWithChildren<WidgetProps>): React.JSX.Element;
-export declare function Widget(props: PropsWithChildren<WidgetProps>): React.JSX.Element;
-//# sourceMappingURL=Widget.d.ts.map

package/dist/Widget.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Widget.d.ts","sourceRoot":"","sources":["../src/Widget.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAG/C,OAAO,KAAmD,MAAM,OAAO,CAAC;AAiCxE,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB,CAAC;AAEF,wBAAgB,IAAI,CAAC,KAAK,EAAE,iBAAiB,CAAC,WAAW,CAAC,qBAoDzD;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,iBAAiB,CAAC,WAAW,CAAC,qBAsB3D"}

package/dist/components/NoRoutes/NoRoutes.d.ts

@@ -1,4 +0,0 @@
-import type { PropTypes } from './NoRoutes.types';
-import React from 'react';
-export declare function NoRoutes(props: PropTypes): React.JSX.Element;
-//# sourceMappingURL=NoRoutes.d.ts.map

package/dist/components/NoRoutes/NoRoutes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NoRoutes.d.ts","sourceRoot":"","sources":["../../../src/components/NoRoutes/NoRoutes.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAUlD,OAAO,KAAK,MAAM,OAAO,CAAC;AAS1B,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,qBA6DxC"}

package/dist/components/NoRoutes/NoRoutes.helper.d.ts

@@ -1,3 +0,0 @@
-import type { Info } from './NoRoutes.types';
-export declare function makeInfo(diagnosisMessage: string | null, disabledLiquiditySources: string[], hasError: boolean, toggleAllLiquiditySources: (shouldReset: boolean) => void, refetchBestRoute: () => void): Info;
-//# sourceMappingURL=NoRoutes.helper.d.ts.map

package/dist/components/NoRoutes/NoRoutes.helper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NoRoutes.helper.d.ts","sourceRoot":"","sources":["../../../src/components/NoRoutes/NoRoutes.helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAM7C,wBAAgB,QAAQ,CACtB,gBAAgB,EAAE,MAAM,GAAG,IAAI,EAC/B,wBAAwB,EAAE,MAAM,EAAE,EAClC,QAAQ,EAAE,OAAO,EACjB,yBAAyB,EAAE,CAAC,WAAW,EAAE,OAAO,KAAK,IAAI,EACzD,gBAAgB,EAAE,MAAM,IAAI,GAC3B,IAAI,CAuCN"}

package/dist/components/NoRoutes/NoRoutes.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NoRoutes.types.d.ts","sourceRoot":"","sources":["../../../src/components/NoRoutes/NoRoutes.types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;CAC5B,CAAC;AAEF,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;CACrB"}

package/dist/components/NoRoutes/index.d.ts

@@ -1,2 +0,0 @@
-export { NoRoutes } from './NoRoutes';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/NoRoutes/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/NoRoutes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/dist/components/RouteErrors/RouteErrors.d.ts

@@ -1,4 +0,0 @@
-import type { PropTypes } from './RouteErrors.types';
-import React from 'react';
-export declare function RouteErrors(props: PropTypes): React.JSX.Element;
-//# sourceMappingURL=RouteErrors.d.ts.map

package/dist/components/RouteErrors/RouteErrors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RouteErrors.d.ts","sourceRoot":"","sources":["../../../src/components/RouteErrors/RouteErrors.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,KAAK,MAAM,OAAO,CAAC;AAW1B,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,qBAgE3C"}

package/dist/components/RouteErrors/RouteErrors.styles.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RouteErrors.styles.d.ts","sourceRoot":"","sources":["../../../src/components/RouteErrors/RouteErrors.styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAGjB,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAMf,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAMf,CAAC;AAEH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAIjB,CAAC"}