@rango-dev/widget-embedded 0.1.10-next.80 → 0.1.10-next.81

package/src/utils/swap.ts

@@ -1,27 +1,55 @@
 import { PendingSwap } from '@rango-dev/ui/dist/containers/History/types';
-import { WalletTypeAndAddress, SwapSavedSettings } from '@rango-dev/ui/dist/types/swaps';
+import {
+  WalletTypeAndAddress,
+  SwapSavedSettings,
+} from '@rango-dev/ui/dist/types/swaps';
 import BigNumber from 'bignumber.js';
-import { BestRouteResponse } from 'rango-sdk';
+import {
+  BestRouteRequest,
+  BestRouteResponse,
+  RecommendedSlippage,
+  SwapResult,
+  MetaResponse,
+  Token,
+} from 'rango-sdk';
 import { Account } from '../store/wallets';
 import { ZERO } from '../constants/numbers';
+import { numberToString } from './numbers';
+import { WalletType } from '@rango-dev/wallets-shared';
+import { getRequiredBalanceOfWallet } from './routing';
+import { getRequiredChains, SelectedWallet } from './wallets';
+import { SwapButtonState } from '../types';
+import { LoadingStatus } from '../store/meta';
 
-export function getOutputRatio(inputUsdValue: BigNumber, outputUsdValue: BigNumber) {
+export function getOutputRatio(
+  inputUsdValue: BigNumber,
+  outputUsdValue: BigNumber
+) {
   if (inputUsdValue.lte(ZERO) || outputUsdValue.lte(ZERO)) return 0;
   return outputUsdValue.div(inputUsdValue).minus(1).multipliedBy(100);
 }
 
-export function outputRatioHasWarning(inputUsdValue: BigNumber, outputRatio: BigNumber | 0) {
+export function outputRatioHasWarning(
+  inputUsdValue: BigNumber,
+  outputRatio: BigNumber | 0
+) {
   return (
-    (parseInt(outputRatio.toFixed(2) || '0') <= -10 && inputUsdValue.gte(new BigNumber(400))) ||
-    (parseInt(outputRatio.toFixed(2) || '0') <= -5 && inputUsdValue.gte(new BigNumber(1000)))
+    (parseInt(outputRatio.toFixed(2) || '0') <= -10 &&
+      inputUsdValue.gte(new BigNumber(400))) ||
+    (parseInt(outputRatio.toFixed(2) || '0') <= -5 &&
+      inputUsdValue.gte(new BigNumber(1000)))
   );
 }
 
 export function hasLimitError(bestRoute: BestRouteResponse | null): boolean {
   return (
     (bestRoute?.result?.swaps || []).filter((swap) => {
-      const minimum = !!swap.fromAmountMinValue ? new BigNumber(swap.fromAmountMinValue) : null;
-      const maximum = !!swap.fromAmountMaxValue ? new BigNumber(swap.fromAmountMaxValue) : null;
+      const minimum = !!swap.fromAmountMinValue
+        ? new BigNumber(swap.fromAmountMinValue)
+        : null;
+      const maximum = !!swap.fromAmountMaxValue
+        ? new BigNumber(swap.fromAmountMaxValue)
+        : null;
       const isExclusive = swap.fromAmountRestrictionType === 'EXCLUSIVE';
       if (isExclusive) {
         return minimum?.gte(swap.fromAmount) || maximum?.lte(swap.fromAmount);
@@ -32,36 +60,112 @@ export function hasLimitError(bestRoute: BestRouteResponse | null): boolean {
   );
 }
 
-export function getSwapButtonTitle(
+export function LimitErrorMessage(bestRoute: BestRouteResponse | null): {
+  swap: SwapResult | null;
+  fromAmountRangeError: string;
+  recommendation: string;
+} {
+  if (!bestRoute)
+    return { swap: null, fromAmountRangeError: '', recommendation: '' };
+  const swap = (bestRoute?.result?.swaps || []).filter((swap) => {
+    const minimum = !!swap.fromAmountMinValue
+      ? new BigNumber(swap.fromAmountMinValue)
+      : null;
+    const maximum = !!swap.fromAmountMaxValue
+      ? new BigNumber(swap.fromAmountMaxValue)
+      : null;
+    const isExclusive = swap.fromAmountRestrictionType === 'EXCLUSIVE';
+    if (isExclusive) {
+      return minimum?.gte(swap.fromAmount) || maximum?.lte(swap.fromAmount);
+    } else {
+      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;
+  const maximum = !!swap.fromAmountMaxValue
+    ? new BigNumber(swap.fromAmountMaxValue)
+    : null;
+  const isExclusive = swap.fromAmountRestrictionType === 'EXCLUSIVE';
+
+  let fromAmountRangeError = '';
+  let recommendation = '';
+  if (!isExclusive && !!minimum && minimum.gt(swap.fromAmount)) {
+    fromAmountRangeError = `Required: >= ${numberToString(minimum)} ${
+      swap.from.symbol
+    }`;
+    recommendation = 'Increase your swap amount';
+  } else if (isExclusive && !!minimum && minimum.gte(swap.fromAmount)) {
+    fromAmountRangeError = `Required: > ${numberToString(minimum)} ${
+      swap.from.symbol
+    }`;
+    recommendation = 'Increase your swap amount';
+  }
+
+  if (!isExclusive && !!maximum && maximum.lt(swap.fromAmount)) {
+    fromAmountRangeError = `Required: <= ${numberToString(maximum)} ${
+      swap.from.symbol
+    }`;
+    recommendation = 'Decrease your swap amount';
+  } else if (isExclusive && !!maximum && maximum.lte(swap.fromAmount)) {
+    fromAmountRangeError = `Required: < ${numberToString(maximum)} ${
+      swap.from.symbol
+    }`;
+    recommendation = 'Decrease your swap amount';
+  }
+
+  return { swap, fromAmountRangeError, recommendation };
+}
+
+export function getSwapButtonState(
+  loadingMetaStatus: LoadingStatus,
   accounts: Account[],
   loading: boolean,
+  bestRoute: BestRouteResponse | null,
   hasLimitError: boolean,
   highValueLoss: boolean,
   priceImpactCanNotBeComputed: boolean,
-  needsToWarnEthOnPath: boolean,
-): string {
-  if (loading) return 'Finding Best Route...';
-
-  if (accounts.length == 0) return 'Connect Wallet';
-  else if (hasLimitError) return 'Limit Error';
-  else if (highValueLoss) return 'Price impact is too high!';
-  else if (priceImpactCanNotBeComputed) return 'USD price is unknown, price impact might be high!';
-  else if (needsToWarnEthOnPath) return 'The route goes through Ethereum. Continue?';
-  else return 'Swap';
+  needsToWarnEthOnPath: boolean
+): SwapButtonState {
+  if (loadingMetaStatus !== 'success')
+    return { title: 'Connect Wallet', disabled: true };
+  if (accounts.length == 0) return { title: 'Connect Wallet', disabled: false };
+  if (loading) return { title: 'Finding Best Route...', disabled: true };
+  else if (!bestRoute) return { title: 'Swap', disabled: true };
+  else if (hasLimitError) return { title: 'Limit Error', disabled: true };
+  else if (highValueLoss)
+    return { title: 'Price impact is too high!', disabled: true };
+  else if (priceImpactCanNotBeComputed)
+    return {
+      title: 'USD price is unknown, price impact might be high!',
+      disabled: false,
+      hasWarning: true,
+    };
+  else if (needsToWarnEthOnPath)
+    return {
+      title: 'The route goes through Ethereum. Continue?',
+      disabled: false,
+      hasWarning: true,
+    };
+  else return { title: 'Swap', disabled: false };
 }
 
 export function canComputePriceImpact(
   bestRoute: BestRouteResponse | null,
   inputAmount: string,
   inputUsdValue: BigNumber,
-  outputUsdValue: BigNumber,
+  outputUsdValue: BigNumber
 ) {
   return !(
     (inputUsdValue.lte(ZERO) || outputUsdValue.lte(ZERO)) &&
     !!bestRoute?.result &&
     !!inputAmount &&
     inputAmount !== '0' &&
-    parseFloat(inputAmount || '0') !== 0
+    parseFloat(inputAmount || '0') !== 0 &&
+    !!bestRoute.result
   );
 }
 
@@ -69,8 +173,9 @@ export function calculatePendingSwap(
   inputAmount: string,
   bestRoute: BestRouteResponse,
   wallets: { [p: string]: WalletTypeAndAddress },
-  settings: SwapSavedSettings,
+  settings: Omit<SwapSavedSettings, 'disabledSwappersIds'>,
   validateBalanceOrFee: boolean,
+  meta: MetaResponse
 ): PendingSwap {
   const simulationResult = bestRoute.result;
   if (!simulationResult) throw Error('Simulation result should not be null');
@@ -90,53 +195,65 @@ export function calculatePendingSwap(
     networkStatusExtraMessage: null,
     networkStatusExtraMessageDetail: null,
     lastNotificationTime: null,
+    //@ts-ignore
     settings: settings,
     simulationResult: simulationResult,
     validateBalanceOrFee,
-    //TODO: finalize PendingSwap type and remove ts-ignore
-    //@ts-ignore
     steps:
-      bestRoute.result?.swaps?.map((s, i) => ({
-        id: i + 1,
-        fromBlockchain: s.from.blockchain,
-        fromSymbol: s.from.symbol,
-        fromSymbolAddress: s.from.address,
-        fromDecimals: s.from.decimals,
-        fromAmountPrecision: s.fromAmountPrecision,
-        fromAmountMinValue: s.fromAmountMinValue,
-        fromAmountMaxValue: s.fromAmountMaxValue,
-        toBlockchain: s.to.blockchain,
-        fromLogo: s.from.logo,
-        toSymbol: s.to.symbol,
-        toSymbolAddress: s.to.address,
-        toDecimals: s.to.decimals,
-        toLogo: s.to.logo,
-        startTransactionTime: new Date().getTime(),
-        swapperId: s.swapperId,
-        expectedOutputAmountHumanReadable: s.toAmount,
-        outputAmount: null,
-        status: 'created',
-        networkStatus: null,
-        executedTransactionId: null,
-        externalTransactionId: null,
-        explorerUrl: null,
-        trackingCode: null,
-        cosmosTransaction: null,
-        solanaTransaction: null,
-        starknetTransaction: null,
-        starknetApprovalTransaction: null,
-        tronTransaction: null,
-        tronApprovalTransaction: null,
-        evmTransaction: null,
-        evmApprovalTransaction: null,
-        transferTransaction: null,
-        diagnosisUrl: null,
-        internalSteps: null,
-        fromBlockchainLogo: '',
-        toBlockchainLogo: '',
-        swapperLogo: '',
-        swapperType: '',
-      })) || [],
+      bestRoute.result?.swaps?.map((swap, index) => {
+        const swapper = meta.swappers.find(
+          (swapper) => swapper.id === swap.swapperId
+        );
+        const swapperType = swapper?.types[0];
+        const fromBlockchain = meta.blockchains.find(
+          (blockchain) => blockchain.name === swap.from.blockchain
+        );
+        const toBlockchain = meta.blockchains.find(
+          (blockchain) => blockchain.name === swap.to.blockchain
+        );
+        return {
+          id: index + 1,
+          fromBlockchain: swap.from.blockchain,
+          fromSymbol: swap.from.symbol,
+          fromSymbolAddress: swap.from.address,
+          fromDecimals: swap.from.decimals,
+          fromAmountPrecision: swap.fromAmountPrecision,
+          fromAmountMinValue: swap.fromAmountMinValue,
+          fromAmountMaxValue: swap.fromAmountMaxValue,
+          toBlockchain: swap.to.blockchain,
+          fromLogo: swap.from.logo,
+          toSymbol: swap.to.symbol,
+          toSymbolAddress: swap.to.address,
+          toDecimals: swap.to.decimals,
+          toLogo: swap.to.logo,
+          startTransactionTime: new Date().getTime(),
+          swapperId: swap.swapperId,
+          feeInUsd: numberToString(getUsdFeeOfStep(swap, meta.tokens), null, 2),
+          expectedOutputAmountHumanReadable: swap.toAmount,
+          outputAmount: '',
+          status: 'created',
+          networkStatus: null,
+          executedTransactionId: null,
+          externalTransactionId: null,
+          explorerUrl: null,
+          trackingCode: null,
+          cosmosTransaction: null,
+          solanaTransaction: null,
+          starknetTransaction: null,
+          starknetApprovalTransaction: null,
+          tronTransaction: null,
+          tronApprovalTransaction: null,
+          evmTransaction: null,
+          evmApprovalTransaction: null,
+          transferTransaction: null,
+          diagnosisUrl: null,
+          internalSteps: null,
+          fromBlockchainLogo: fromBlockchain.logo,
+          toBlockchainLogo: toBlockchain.logo,
+          swapperLogo: swapper?.logo,
+          swapperType: swapperType,
+        };
+      }) || [],
   };
 }
 
@@ -147,9 +264,270 @@ export function requiredWallets(route: BestRouteResponse | null) {
     const currentStepFromBlockchain = swap.from.blockchain;
     const currentStepToBlockchain = swap.to.blockchain;
     let lastAddedWallet = wallets[wallets.length - 1];
-    if (currentStepFromBlockchain != lastAddedWallet) wallets.push(currentStepFromBlockchain);
+    if (currentStepFromBlockchain != lastAddedWallet)
+      wallets.push(currentStepFromBlockchain);
     lastAddedWallet = wallets[wallets.length - 1];
-    if (currentStepToBlockchain != lastAddedWallet) wallets.push(currentStepToBlockchain);
+    if (currentStepToBlockchain != lastAddedWallet)
+      wallets.push(currentStepToBlockchain);
+  });
+  return wallets;
+}
+
+export const getUsdPrice = (
+  blockchain: string,
+  symbol: string,
+  address: string | null,
+  allTokens: Token[]
+): number | null => {
+  const token = allTokens?.find(
+    (t) =>
+      t.blockchain === blockchain &&
+      t.symbol?.toUpperCase() === symbol?.toUpperCase() &&
+      t.address === address
+  );
+  return token?.usdPrice || null;
+};
+
+function getUsdFeeOfStep(step: SwapResult, allTokens: Token[]): BigNumber {
+  let totalFeeInUsd = ZERO;
+  for (let i = 0; i < step.fee.length; i++) {
+    const fee = step.fee[i];
+    if (fee.expenseType === 'DECREASE_FROM_OUTPUT') continue;
+
+    const unitPrice = getUsdPrice(
+      fee.asset.blockchain,
+      fee.asset.symbol,
+      fee.asset.address,
+      allTokens
+    );
+    totalFeeInUsd = totalFeeInUsd.plus(
+      new BigNumber(fee.amount).multipliedBy(unitPrice || 0)
+    );
+  }
+
+  return totalFeeInUsd;
+}
+
+export function getTotalFeeInUsd(
+  bestRoute: BestRouteResponse | null,
+  allTokens: Token[]
+): BigNumber | null {
+  return (
+    bestRoute?.result?.swaps.reduce(
+      (totalFee: BigNumber, step) =>
+        totalFee.plus(getUsdFeeOfStep(step, allTokens)),
+      ZERO
+    ) || null
+  );
+}
+
+export function hasHighFee(totalFeeInUsd: BigNumber | null) {
+  if (!totalFeeInUsd) return false;
+  return !totalFeeInUsd.lt(new BigNumber(30));
+}
+
+export function hasSlippageError(
+  slippages: (RecommendedSlippage | null)[] | undefined
+) {
+  return (slippages?.filter((s) => !!s?.error)?.length || 0) > 0;
+}
+
+export function getMinRequiredSlippage(route: BestRouteResponse) {
+  const slippages = route.result?.swaps.map(
+    (slippage) => slippage.recommendedSlippage
+  );
+  return (
+    slippages
+      ?.map((s) => s?.slippage || 0)
+      ?.filter((s) => s > 0)
+      ?.sort((a, b) => b - a)
+      ?.find(() => true) || null
+  );
+}
+
+export function hasProperSlippage(
+  userSlippage: string,
+  minRequiredSlippage: number | null
+) {
+  if (!minRequiredSlippage) return true;
+  return parseFloat(userSlippage) > minRequiredSlippage;
+}
+
+export function hasEnoughBalance(
+  route: BestRouteResponse,
+  selectedWallets: SelectedWallet[]
+) {
+  const fee = route.validationStatus;
+
+  if (fee === null || fee.length === 0) return true;
+
+  for (const wallet of selectedWallets) {
+    const requiredAssets = getRequiredBalanceOfWallet(wallet, fee);
+    if (!requiredAssets) continue;
+
+    const enoughBalanceInWallet = requiredAssets
+      .map((asset) => asset.ok)
+      .reduce((previous, current) => previous && current);
+    if (!enoughBalanceInWallet) return false;
+  }
+
+  return true;
+}
+
+export function hasEnoughBalanceAndProperSlippage(
+  route: BestRouteResponse,
+  selectedWallets: SelectedWallet[],
+  userSlippage: string,
+  minRequiredSlippage: number | null
+): boolean {
+  return (
+    hasEnoughBalance(route, selectedWallets) &&
+    hasProperSlippage(userSlippage, minRequiredSlippage)
+  );
+}
+
+export function createBestRouteRequestBody(
+  fromToken: Token,
+  toToken: Token,
+  inputAmount: string,
+  wallets: Account[],
+  selectedWallets: SelectedWallet[],
+  disabledLiquiditySources: string[],
+  slippage: number,
+  checkPrerequisites: boolean
+): BestRouteRequest {
+  const selectedWalletsMap = selectedWallets.reduce(
+    (
+      selectedWalletsMap: BestRouteRequest['selectedWallets'],
+      selectedWallet
+    ) => (
+      (selectedWalletsMap[selectedWallet.chain] = selectedWallet.address),
+      selectedWalletsMap
+    ),
+    {}
+  );
+
+  const connectedWallets: BestRouteRequest['connectedWallets'] = [];
+
+  wallets.forEach((wallet) => {
+    const chainAndAccounts = connectedWallets.find(
+      (connectedWallet) => connectedWallet.blockchain === wallet.chain
+    );
+    if (!!chainAndAccounts) chainAndAccounts.addresses.push(wallet.address);
+    else
+      connectedWallets.push({
+        blockchain: wallet.chain,
+        addresses: [wallet.address],
+      });
   });
+
+  const requestBody: BestRouteRequest = {
+    amount: inputAmount.toString(),
+    checkPrerequisites,
+    from: {
+      address: fromToken.address,
+      blockchain: fromToken.blockchain,
+      symbol: fromToken.symbol,
+    },
+    to: {
+      address: toToken.address,
+      blockchain: toToken.blockchain,
+      symbol: toToken.symbol,
+    },
+    connectedWallets,
+    selectedWallets: selectedWalletsMap,
+    swapperGroups: disabledLiquiditySources,
+    swappersGroupsExclude: true,
+    //@ts-ignore
+    slippage: slippage.toString(),
+  };
+
+  return requestBody;
+}
+
+export function getWalletsForNewSwap(selectedWallets: SelectedWallet[]) {
+  const wallets = selectedWallets.reduce(
+    (
+      selectedWalletsMap: {
+        [p: string]: { address: string; walletType: WalletType };
+      },
+      selectedWallet
+    ) => (
+      (selectedWalletsMap[selectedWallet.chain] = {
+        address: selectedWallet.address,
+        walletType: selectedWallet.walletType,
+      }),
+      selectedWalletsMap
+    ),
+    {}
+  );
+
   return wallets;
 }
+
+export function getRouteOutputAmount(route: BestRouteResponse) {
+  return route.result?.outputAmount || null;
+}
+
+export function getPercentageChange(
+  oldValue: string | number,
+  newValue: string | number
+) {
+  return new BigNumber(newValue)
+    .div(new BigNumber(oldValue))
+    .minus(1)
+    .multipliedBy(100);
+}
+
+export function isOutputAmountChangedALot(
+  oldRoute: BestRouteResponse,
+  newRoute: BestRouteResponse
+) {
+  const oldOutputAmount = getRouteOutputAmount(oldRoute);
+  const newOutputAmount = getRouteOutputAmount(newRoute);
+  if (!oldOutputAmount || !newOutputAmount) return false;
+  const percentageChange = getPercentageChange(
+    oldOutputAmount,
+    newOutputAmount
+  );
+
+  return percentageChange.toNumber() <= -1;
+}
+
+export function getBalanceWarnings(
+  route: BestRouteResponse,
+  selectedWallets: SelectedWallet[]
+) {
+  const fee = route.validationStatus;
+  const requiredWallets = getRequiredChains(route);
+  const walletsSortedByRequiredWallets = selectedWallets.sort(
+    (selectedWallet1, selectedWallet2) =>
+      requiredWallets.indexOf(selectedWallet1.chain) -
+      requiredWallets.indexOf(selectedWallet2.chain)
+  );
+  return walletsSortedByRequiredWallets
+    .flatMap((wallet) => getRequiredBalanceOfWallet(wallet, fee) || [])
+    .filter((asset) => !asset.ok)
+    .map((asset) => {
+      const symbol = asset.asset.symbol;
+      const currentAmount = numberToString(
+        new BigNumber(asset.currentAmount.amount).shiftedBy(
+          -asset.currentAmount.decimals
+        ),
+        8
+      );
+      const requiredAmount = numberToString(
+        new BigNumber(asset.requiredAmount.amount).shiftedBy(
+          -asset.requiredAmount.decimals
+        ),
+        8
+      );
+      let reason = '';
+      if (asset.reason === 'FEE') reason = ' for network fee';
+      if (asset.reason === 'INPUT_ASSET') reason = ' for swap';
+      if (asset.reason === 'FEE_AND_INPUT_ASSET')
+        reason = ' for input and network fee';
+      const warningMessage = `Needs ≈ ${requiredAmount} ${symbol}${reason}, but you have ${currentAmount} ${symbol} in your ${asset.asset.blockchain} wallet.`;
+      return warningMessage;
+    });
+}

package/src/utils/wallets.ts

@@ -12,6 +12,7 @@ import {
 import {
   WalletInfo as ModalWalletInfo,
   WalletState as WalletStatus,
+  SelectableWallet,
 } from '@rango-dev/ui';
 import {
   BestRouteResponse,
@@ -20,7 +21,6 @@ import {
   WalletDetail,
 } from 'rango-sdk';
 import { readAccountAddress } from '@rango-dev/wallets-core';
-import { SelectableWallet } from '../pages/ConfirmWalletsPage';
 import { Account, Balance, TokenBalance } from '../store/wallets';
 import { numberToString } from './numbers';
 import BigNumber from 'bignumber.js';
@@ -170,9 +170,8 @@ type Blockchain = { name: string; accounts: Balance[] };
 export function getSelectableWallets(
   accounts: Account[],
   selectedWallets: SelectedWallet[],
-  getWalletInfo: (type: WalletType) => WalletInfo,
-  requiredChains?: string[]
-) {
+  getWalletInfo: (type: WalletType) => WalletInfo
+): SelectableWallet[] {
   const connectedWallets: SelectableWallet[] = accounts.map((account) => ({
     address: account.address,
     walletType: account.walletType,
@@ -186,23 +185,9 @@ export function getSelectableWallets(
     ),
   }));
 
-  return requiredChains
-    ? connectedWallets.filter(
-        (wallet, index, array) =>
-          requiredChains.includes(wallet.chain) &&
-          array.findIndex((w) => w.address === wallet.address) === index
-      )
-    : removeDuplicateWallets(connectedWallets, 'walletType');
+  return connectedWallets;
 }
 
-const removeDuplicateWallets = (
-  arr: SelectableWallet[],
-  key: string
-): SelectableWallet[] => {
-  const map = new Map(arr.map((item) => [item[key], item]));
-  return Array.from(map.values());
-};
-
 export function getBalanceFromWallet(
   balances: Balance[],
   chain: string,

package/dist/hooks/useBestRoute.d.ts

@@ -1,8 +0,0 @@
-import { BestRouteResponse } from 'rango-sdk';
-export declare function useBestRoute(): {
-    loading: boolean;
-    error: string;
-    data: BestRouteResponse;
-    retry: () => void;
-};
-//# sourceMappingURL=useBestRoute.d.ts.map

package/dist/hooks/useBestRoute.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useBestRoute.d.ts","sourceRoot":"","sources":["../src/hooks/useBestRoute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAMhE,wBAAgB,YAAY;;;;;EA+D3B"}

package/dist/hooks/useConfirmSwap.d.ts

@@ -1,2 +0,0 @@
-export declare function useConfirmSwap(): any;
-//# sourceMappingURL=useConfirmSwap.d.ts.map

package/dist/hooks/useConfirmSwap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useConfirmSwap.d.ts","sourceRoot":"","sources":["../src/hooks/useConfirmSwap.ts"],"names":[],"mappings":"AA2BA,wBAAgB,cAAc,QAgP7B"}