@rango-dev/widget-embedded 0.17.1-next.8 → 0.18.0

package/src/utils/swap.ts

@@ -1,16 +1,13 @@
 /* eslint-disable @typescript-eslint/no-magic-numbers */
 import type { FetchStatus } from '../store/slices/data';
-import type { ConnectedWallet } from '../store/wallets';
 import type {
   ConvertedToken,
+  QuoteError,
+  QuoteWarning,
   RecommendedSlippages,
   SwapButtonState,
   Wallet,
 } from '../types';
-import type {
-  PendingSwap,
-  PendingSwapStep,
-} from '@rango-dev/queue-manager-rango-preset';
 import type { WalletType } from '@rango-dev/wallets-shared';
 import type {
   BestRouteRequest,
@@ -20,10 +17,11 @@ import type {
   SwapResult,
   Token,
 } from 'rango-sdk';
+import type { PendingSwap, PendingSwapStep } from 'rango-types';
 
 import { i18n } from '@lingui/core';
-import { PendingSwapNetworkStatus } from '@rango-dev/queue-manager-rango-preset';
 import BigNumber from 'bignumber.js';
+import { PendingSwapNetworkStatus } from 'rango-types';
 
 import { isValidAddress } from '../components/ConfirmWalletsModal/ConfirmWallets.helpers';
 import { errorMessages } from '../constants/errors';
@@ -35,11 +33,11 @@ import {
   TOKEN_AMOUNT_MAX_DECIMALS,
   TOKEN_AMOUNT_MIN_DECIMALS,
 } from '../constants/routing';
-import { ButtonState } from '../types';
 
 import { removeDuplicateFrom } from './common';
+import { getBlockchainShortNameFor } from './meta';
 import { numberToString } from './numbers';
-import { getRequiredBalanceOfWallet } from './quote';
+import { getPriceImpact, getRequiredBalanceOfWallet } from './quote';
 import { getRequiredChains } from './wallets';
 
 export function getOutputRatio(
@@ -179,63 +177,70 @@ export function getLimitErrorMessage(quote: BestRouteResponse): {
   return { swap, fromAmountRangeError, recommendation };
 }
 
-export function getSwapButtonState(
-  loadingMetaStatus: FetchStatus,
-  connectedWallets: ConnectedWallet[],
-  loading: boolean,
-  quote: 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 ||
+    fetchingQuote ||
     !quote ||
     !quote.result ||
-    hasLimitError ||
+    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().ethWarning,
+      action: 'confirm-warning',
       disabled: false,
-      hasWarning: true,
-      state: ButtonState.WARNING,
     };
   }
   return {
     title: swapButtonTitles().swap,
+    action: 'confirm-swap',
     disabled: false,
-    state: ButtonState.SWAP,
   };
 }
 
@@ -359,7 +364,7 @@ export function checkSlippageWarnings(
   quote.result?.swaps.forEach((swap, index) => {
     if (
       swap.recommendedSlippage?.slippage &&
-      parseInt(swap.recommendedSlippage?.slippage) > userSlippage
+      parseFloat(swap.recommendedSlippage.slippage) > userSlippage
     ) {
       recommendedSlippages.set(index, swap.recommendedSlippage.slippage);
     }
@@ -590,10 +595,7 @@ export function isOutputAmountChangedALot(
   if (!oldOutputAmount || !newOutputAmount) {
     return false;
   }
-  const percentageChange = getPercentageChange(
-    oldOutputAmount,
-    newOutputAmount
-  );
+  const percentageChange = getPriceImpact(oldOutputAmount, newOutputAmount);
   if (!percentageChange) {
     return true;
   }
@@ -601,9 +603,10 @@ export function isOutputAmountChangedALot(
   return percentageChange <= -1;
 }
 
-export function getBalanceWarnings(
+export function generateBalanceWarnings(
   quote: BestRouteResponse,
-  selectedWallets: Wallet[]
+  selectedWallets: Wallet[],
+  blockchains: BlockchainMeta[]
 ) {
   const fee = quote.validationStatus;
   const requiredWallets = getRequiredChains(quote);
@@ -648,7 +651,10 @@ export function getBalanceWarnings(
           symbol,
           reason,
           currentAmount,
-          blockchain: asset.asset.blockchain,
+          blockchain: getBlockchainShortNameFor(
+            asset.asset.blockchain,
+            blockchains
+          ),
         },
       });
       return warningMessage;

package/src/utils/time.ts

@@ -1,4 +1,4 @@
-import type { PendingSwap } from '@rango-dev/queue-manager-rango-preset';
+import type { PendingSwap } from 'rango-types';
 
 import { i18n } from '@lingui/core';
 

package/src/utils/wallets.ts

@@ -1,8 +1,8 @@
-import type { TokenWithBalance } from '../components/TokenList';
 import type { ConnectedWallet, TokenBalance } from '../store/wallets';
-import type { Wallet } from '../types';
+import type { Balance, TokenHash, TokensBalance, Wallet } from '../types';
 import type { WalletInfo as ModalWalletInfo } from '@rango-dev/ui';
 import type {
+  Asset,
   Network,
   WalletInfo,
   WalletState,
@@ -29,6 +29,12 @@ import BigNumber from 'bignumber.js';
 import { isCosmosBlockchain } from 'rango-types';
 
 import { ZERO } from '../constants/numbers';
+import {
+  BALANCE_MAX_DECIMALS,
+  BALANCE_MIN_DECIMALS,
+  USD_VALUE_MAX_DECIMALS,
+  USD_VALUE_MIN_DECIMALS,
+} from '../constants/routing';
 import { EXCLUDED_WALLETS } from '../constants/wallets';
 
 import { numberToString } from './numbers';
@@ -218,43 +224,6 @@ export function getRequiredChains(quote: BestRouteResponse | null) {
 
 type Blockchain = { name: string; accounts: ConnectedWallet[] };
 
-export function getBalanceFromWallet(
-  connectedWallets: ConnectedWallet[],
-  chain: string,
-  symbol: string,
-  address: string | null
-): TokenBalance | null {
-  if (connectedWallets.length === 0) {
-    return null;
-  }
-
-  const selectedChainWallets = connectedWallets.filter(
-    (wallet) => wallet.chain === chain
-  );
-  if (selectedChainWallets.length === 0) {
-    return null;
-  }
-
-  return (
-    selectedChainWallets
-      .map(
-        (wallet) =>
-          wallet.balances?.find(
-            (balance) =>
-              (address !== null && balance.address === address) ||
-              (address === null &&
-                balance.address === address &&
-                balance.symbol === symbol)
-          ) || null
-      )
-      .filter((balance) => balance !== null)
-      .sort(
-        (a, b) => parseFloat(b?.amount || '0') - parseFloat(a?.amount || '1')
-      )
-      .find(() => true) || null
-  );
-}
-
 export function isAccountAndWalletMatched(
   account: Wallet,
   connectedWallet: ConnectedWallet
@@ -348,30 +317,6 @@ function numberWithThousandSeparator(number: string | number): string {
   return parts.join('.');
 }
 
-export const sortTokens = (tokens: TokenWithBalance[]): TokenWithBalance[] => {
-  const 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)
-      );
-  }
-
-  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 = (
   blockchain: string,
   symbol: string,
@@ -415,98 +360,87 @@ export const getKeplrCompatibleConnectedWallets = (
   );
 };
 
-export function getTokensWithBalance(
-  tokens: TokenWithBalance[],
-  connectedWallets: ConnectedWallet[]
-): TokenWithBalance[] {
-  return tokens.map(({ balance, ...otherProps }) => {
-    const tokenAmount = numberToString(
-      new BigNumber(
-        getBalanceFromWallet(
-          connectedWallets,
-          otherProps.blockchain,
-          otherProps.symbol,
-          otherProps.address
-        )?.amount || ZERO
-      )
-    );
-
-    let tokenUsdValue = '';
-    if (otherProps.usdPrice) {
-      tokenUsdValue = numberToString(
-        new BigNumber(
-          getBalanceFromWallet(
-            connectedWallets,
-            otherProps.blockchain,
-            otherProps.symbol,
-            otherProps.address
-          )?.amount || ZERO
-        ).multipliedBy(otherProps.usdPrice)
-      );
-    }
+export function formatBalance(balance: Balance | null): Balance | null {
+  const formattedBalance: Balance | null = balance
+    ? {
+        ...balance,
+        amount: numberToString(
+          balance.amount,
+          BALANCE_MIN_DECIMALS,
+          BALANCE_MAX_DECIMALS
+        ),
+        usdValue: numberToString(
+          balance.usdValue,
+          USD_VALUE_MIN_DECIMALS,
+          USD_VALUE_MAX_DECIMALS
+        ),
+      }
+    : null;
 
-    return {
-      ...otherProps,
-      ...(tokenAmount !== '0' && {
-        balance: { amount: tokenAmount, usdValue: tokenUsdValue },
-      }),
-    };
-  });
+  return formattedBalance;
 }
 
-export function getTokensBalanceFromWalletAndSort(
-  tokens: TokenWithBalance[],
-  connectedWallets: ConnectedWallet[]
-) {
-  const list =
-    connectedWallets.length > 0
-      ? getTokensWithBalance(tokens, connectedWallets)
-      : tokens;
-  list.sort((tokenA, tokenB) => {
-    if (tokenA.balance?.usdValue && tokenB.balance?.usdValue) {
-      return (
-        parseFloat(tokenB.balance.usdValue) -
-        parseFloat(tokenA.balance.usdValue)
-      );
-    }
-
-    if (!tokenA.balance?.usdValue && tokenB.balance?.usdValue) {
-      return 1;
-    }
+function sortTokensByBalance(
+  token1Balance: Balance | null,
+  token2Balance: Balance | null
+): number {
+  if (token1Balance?.usdValue && token2Balance?.usdValue) {
+    return (
+      parseFloat(token2Balance.usdValue) - parseFloat(token1Balance.usdValue)
+    );
+  }
 
-    if (tokenA.balance?.usdValue && !tokenB.balance?.usdValue) {
-      return -1;
-    }
+  if (!token1Balance?.usdValue && token2Balance?.usdValue) {
+    return 1;
+  }
 
-    if (!tokenA.balance?.usdValue && !tokenB.balance?.usdValue) {
-      return (
-        parseFloat(tokenB.balance?.amount || '0') -
-        parseFloat(tokenA.balance?.amount || '0')
-      );
-    }
+  if (token1Balance?.usdValue && !token2Balance?.usdValue) {
+    return -1;
+  }
 
-    return 0;
-  });
+  if (!token1Balance?.usdValue && !token2Balance?.usdValue) {
+    return (
+      parseFloat(token2Balance?.amount || '0') -
+      parseFloat(token1Balance?.amount || '0')
+    );
+  }
 
-  return list;
+  return 0;
 }
 
-export function getSortedTokens(
-  chain: BlockchainMeta | null,
-  tokens: Token[],
-  connectedWallets: ConnectedWallet[],
-  otherChainTokens: TokenWithBalance[]
-): TokenWithBalance[] {
-  const fromChainEqualsToToBlockchain =
-    chain?.name === otherChainTokens[0]?.name;
-  if (fromChainEqualsToToBlockchain) {
-    return otherChainTokens;
+function sortTokensByPinnedToken(
+  token1: Token,
+  token2: Token,
+  isTokenPinned: (token: Token) => boolean
+): number {
+  const isToken1Pinned = isTokenPinned(token1);
+  const isToken2Pinned = isTokenPinned(token2);
+
+  if (isToken1Pinned === isToken2Pinned) {
+    return 0;
   }
+  if (isToken1Pinned) {
+    return -1;
+  }
+  return 1;
+}
+export function sortTokens(
+  tokens: Token[],
+  getBalanceFor: (token: Token) => Balance | null,
+  isTokenPinned: (token: Token) => boolean
+) {
+  tokens.sort((token1, token2) => {
+    const token1Balance = getBalanceFor(token1);
+    const token2Balance = getBalanceFor(token2);
+    // Check pinned tokens
+    const isTokenPin = sortTokensByPinnedToken(token1, token2, isTokenPinned);
+
+    return isTokenPin !== 0
+      ? isTokenPin
+      : sortTokensByBalance(token1Balance, token2Balance);
+  });
 
-  const filteredTokens = tokens.filter(
-    (token) => token.blockchain === chain?.name
-  );
-  return sortTokens(getTokensWithBalance(filteredTokens, connectedWallets));
+  return tokens;
 }
 
 export function tokensAreEqual(
@@ -568,3 +502,52 @@ export function getAddress({
       connectedWallet.chain === chain
   )?.address;
 }
+
+export function createTokenHash(token: Asset): TokenHash {
+  return `${token.blockchain}-${token.symbol}-${token.address ?? ''}`;
+}
+
+export function makeTokensBalance(connectedWallets: ConnectedWallet[]) {
+  return connectedWallets
+    .flatMap((wallet) => wallet.balances)
+    .reduce((balances: TokensBalance, balance) => {
+      const currentBalance = {
+        amount: balance?.amount ?? '',
+        decimals: balance?.decimal ?? 0,
+        usdValue: balance?.usdPrice
+          ? new BigNumber(balance?.usdPrice ?? ZERO)
+              .multipliedBy(balance?.amount)
+              .toString()
+          : '',
+      };
+
+      const tokenHash = balance
+        ? createTokenHash({
+            symbol: balance.symbol,
+            blockchain: balance.chain,
+            address: balance.address,
+          })
+        : null;
+
+      const prevBalance = tokenHash ? balances[tokenHash] : null;
+
+      const shouldUpdateBalance =
+        tokenHash &&
+        (!prevBalance ||
+          (prevBalance && prevBalance.amount < currentBalance.amount));
+
+      if (shouldUpdateBalance) {
+        balances[tokenHash] = currentBalance;
+      }
+
+      return balances;
+    }, {});
+}
+
+export const isFetchingBalance = (
+  connectedWallets: ConnectedWallet[],
+  blockchain: string
+) =>
+  !!connectedWallets.find(
+    (wallet) => wallet.chain === blockchain && wallet.loading
+  );

package/dist/Wallets.d.ts

@@ -1,18 +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;
-    config: WidgetConfig;
-}>): 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,KAA2C,MAAM,OAAO,CAAC;AAUhE,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;AA4FH,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;IAC7B,MAAM,EAAE,YAAY,CAAC;CACtB,CAAC,qBAQH"}

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(): 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,sBA+CnB;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,iBAAiB,CAAC,WAAW,CAAC,qBAc3D"}

package/dist/components/LoadingSwapDetails/LoadingSwapDetailStep.d.ts

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

package/dist/components/LoadingSwapDetails/LoadingSwapDetailStep.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LoadingSwapDetailStep.d.ts","sourceRoot":"","sources":["../../../src/components/LoadingSwapDetails/LoadingSwapDetailStep.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAGzE,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,sBAAsB,qBAiClE"}

package/dist/components/LoadingSwapDetails/LoadingSwapDetails.types.d.ts

@@ -1,4 +0,0 @@
-export interface StepSkeletonPropsTypes {
-    extraInfo?: boolean;
-}
-//# sourceMappingURL=LoadingSwapDetails.types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"LoadingSwapDetails.types.d.ts","sourceRoot":"","sources":["../../../src/components/LoadingSwapDetails/LoadingSwapDetails.types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB"}

package/dist/components/Quote/QuoteSkeleton.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QuoteSkeleton.d.ts","sourceRoot":"","sources":["../../../src/components/Quote/QuoteSkeleton.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAGvD,OAAO,KAAK,MAAM,OAAO,CAAC;AAmC1B,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,qBAqE7C"}

package/dist/components/Quote/QuoteSkeleton.styles.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QuoteSkeleton.styles.d.ts","sourceRoot":"","sources":["../../../src/components/Quote/QuoteSkeleton.styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DA4FpB,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAaxB,CAAC"}

package/dist/components/Quote/QuoteSkeleton.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QuoteSkeleton.types.d.ts","sourceRoot":"","sources":["../../../src/components/Quote/QuoteSkeleton.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,OAAO,GAAG,WAAW,GAAG,cAAc,CAAC;IAC7C,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf,CAAC"}

package/dist/store/settings.d.ts

@@ -1,82 +0,0 @@
-import type { SwapperMeta } from 'rango-sdk';
-import { type Language } from '@rango-dev/ui';
-export type ThemeMode = 'auto' | 'dark' | 'light';
-export interface SettingsState {
-    /** Keeping a history of blockchains that user has selected (in Swap process) */
-    preferredBlockchains: string[];
-    slippage: number;
-    customSlippage: number | null;
-    infiniteApprove: boolean;
-    disabledLiquiditySources: string[];
-    theme: ThemeMode;
-    language: Language;
-    affiliateRef: string | null;
-    affiliatePercent: number | null;
-    affiliateWallets: {
-        [key: string]: string;
-    } | null;
-    setSlippage: (slippage: number) => void;
-    setCustomSlippage: (customSlippage: number | null) => void;
-    toggleInfiniteApprove: () => void;
-    toggleLiquiditySource: (name: string) => void;
-    setTheme: (theme: ThemeMode) => void;
-    setLanguage: (language: Language) => void;
-    toggleAllLiquiditySources: (swappers: SwapperMeta[], shouldReset?: boolean) => void;
-    setAffiliateRef: (affiliateRef: string | null) => void;
-    setAffiliatePercent: (affiliatePercent: number | null) => void;
-    setAffiliateWallets: (affiliateWallets: {
-        [key: string]: string;
-    } | null) => void;
-    addPreferredBlockchain: (blockchain: string) => void;
-}
-export declare const useSettingsStore: {
-    (): SettingsState;
-    <U>(selector: (state: SettingsState) => U, equals?: ((a: U, b: U) => boolean) | undefined): U;
-} & Omit<Omit<import("zustand").StoreApi<SettingsState>, "persist"> & {
-    persist: {
-        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<SettingsState, SettingsState>>) => void;
-        clearStorage: () => void;
-        rehydrate: () => void | Promise<void>;
-        hasHydrated: () => boolean;
-        onHydrate: (fn: (state: SettingsState) => void) => () => void;
-        onFinishHydration: (fn: (state: SettingsState) => void) => () => void;
-        getOptions: () => Partial<import("zustand/middleware").PersistOptions<SettingsState, SettingsState>>;
-    };
-}, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: SettingsState, previousSelectedState: SettingsState) => void): () => void;
-        <U_1>(selector: (state: SettingsState) => U_1, listener: (selectedState: U_1, previousSelectedState: U_1) => void, options?: {
-            equalityFn?: ((a: U_1, b: U_1) => boolean) | undefined;
-            fireImmediately?: boolean | undefined;
-        } | undefined): () => void;
-    };
-} & {
-    use: {
-        preferredBlockchains: () => string[];
-        slippage: () => number;
-        customSlippage: () => number | null;
-        infiniteApprove: () => boolean;
-        disabledLiquiditySources: () => string[];
-        theme: () => ThemeMode;
-        language: () => "en" | "es" | "ja" | "fr";
-        affiliateRef: () => string | null;
-        affiliatePercent: () => number | null;
-        affiliateWallets: () => {
-            [key: string]: string;
-        } | null;
-        setSlippage: () => (slippage: number) => void;
-        setCustomSlippage: () => (customSlippage: number | null) => void;
-        toggleInfiniteApprove: () => () => void;
-        toggleLiquiditySource: () => (name: string) => void;
-        setTheme: () => (theme: ThemeMode) => void;
-        setLanguage: () => (language: Language) => void;
-        toggleAllLiquiditySources: () => (swappers: SwapperMeta[], shouldReset?: boolean) => void;
-        setAffiliateRef: () => (affiliateRef: string | null) => void;
-        setAffiliatePercent: () => (affiliatePercent: number | null) => void;
-        setAffiliateWallets: () => (affiliateWallets: {
-            [key: string]: string;
-        } | null) => void;
-        addPreferredBlockchain: () => (blockchain: string) => void;
-    };
-};
-//# sourceMappingURL=settings.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/store/settings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAW9C,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAElD,MAAM,WAAW,aAAa;IAC5B,gFAAgF;IAChF,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,eAAe,EAAE,OAAO,CAAC;IACzB,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,gBAAgB,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAEnD,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,iBAAiB,EAAE,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAC3D,qBAAqB,EAAE,MAAM,IAAI,CAAC;IAClC,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,QAAQ,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;IACrC,WAAW,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAC;IAC1C,yBAAyB,EAAE,CACzB,QAAQ,EAAE,WAAW,EAAE,EACvB,WAAW,CAAC,EAAE,OAAO,KAClB,IAAI,CAAC;IACV,eAAe,EAAE,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IACvD,mBAAmB,EAAE,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAC/D,mBAAmB,EAAE,CACnB,gBAAgB,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,GAAG,IAAI,KAC/C,IAAI,CAAC;IACV,sBAAsB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;CACtD;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAlBH,MAAM,KAAK,IAAI;kDACH,MAAM,GAAG,IAAI,KAAK,IAAI;2CAC7B,IAAI;4CACH,MAAM,KAAK,IAAI;gCAC3B,SAAS,KAAK,IAAI;sCACZ,QAAQ,KAAK,IAAI;oDAE7B,WAAW,EAAE,gBACT,OAAO,KAClB,IAAI;8CACuB,MAAM,GAAG,IAAI,KAAK,IAAI;sDACd,MAAM,GAAG,IAAI,KAAK,IAAI;;;qBAGzD,IAAI;mDAC4B,MAAM,KAAK,IAAI;;CAqHrD,CAAC"}