@rango-dev/widget-embedded 0.18.0 → 0.19.0

package/src/hooks/useConfirmSwap/useConfirmSwap.helpers.ts

@@ -1,172 +0,0 @@
-import type { ConfirmSwapFetchResult } from './useConfirmSwap.types';
-import type { ConfirmSwapWarnings, Wallet } from '../../types';
-import type { BestRouteResponse, BlockchainMeta, Token } from 'rango-sdk';
-
-import { errorMessages } from '../../constants/errors';
-import { QuoteErrorType, QuoteUpdateType } from '../../types';
-import { numberToString } from '../../utils/numbers';
-import {
-  generateQuoteWarnings,
-  getPriceImpact,
-  isNumberOfSwapsChanged,
-  isQuoteChanged,
-  isQuoteInternalCoinsUpdated,
-  isQuoteSwappersUpdated,
-} from '../../utils/quote';
-import {
-  checkSlippageErrors,
-  generateBalanceWarnings,
-  getLimitErrorMessage,
-  getMinRequiredSlippage,
-  getQuoteOutputAmount,
-  hasLimitError,
-  isOutputAmountChangedALot,
-} from '../../utils/swap';
-
-/**
- * A request can be successful but in body of the response, it can be some case which is considered as failed.
- */
-export function throwErrorIfResponseIsNotValid(response: BestRouteResponse) {
-  if (!response.result) {
-    throw new Error(errorMessages().noResultError.title, {
-      cause: {
-        type: QuoteErrorType.NO_RESULT,
-        diagnosisMessage: response.diagnosisMessages?.[0],
-      },
-    });
-  }
-  const limitError = hasLimitError(response);
-  if (limitError) {
-    const { swap, recommendation, fromAmountRangeError } =
-      getLimitErrorMessage(response);
-
-    throw new Error('bridge limit error', {
-      cause: {
-        type: QuoteErrorType.BRIDGE_LIMIT,
-        swap: swap,
-        recommendation,
-        fromAmountRangeError,
-      },
-    });
-  }
-
-  const recommendedSlippages = checkSlippageErrors(response);
-
-  if (recommendedSlippages) {
-    const minRequiredSlippage = getMinRequiredSlippage(response);
-    throw new Error('', {
-      cause: {
-        type: QuoteErrorType.INSUFFICIENT_SLIPPAGE,
-        recommendedSlippages,
-        minRequiredSlippage,
-      },
-    });
-  }
-
-  return response;
-}
-
-export function generateWarnings(
-  previousQuote: BestRouteResponse | undefined,
-  currentQuote: BestRouteResponse,
-  params: {
-    fromToken: Token;
-    toToken: Token;
-    meta: { blockchains: BlockchainMeta[]; tokens: Token[] };
-    selectedWallets: Wallet[];
-    userSlippage: number;
-  }
-): ConfirmSwapWarnings {
-  let quoteChanged = false;
-  if (previousQuote) {
-    quoteChanged = isQuoteChanged(previousQuote, currentQuote);
-  }
-  const output: ConfirmSwapWarnings = {
-    quote: null,
-    quoteUpdate: null,
-    balance: null,
-  };
-
-  const quoteWarning = generateQuoteWarnings(currentQuote, {
-    fromToken: params.fromToken,
-    toToken: params.toToken,
-    tokens: params.meta.tokens,
-    userSlippage: params.userSlippage,
-  });
-
-  if (quoteWarning) {
-    output.quote = quoteWarning;
-  }
-
-  if (previousQuote && quoteChanged) {
-    if (isOutputAmountChangedALot(previousQuote, currentQuote)) {
-      output.quoteUpdate = {
-        type: QuoteUpdateType.QUOTE_AND_OUTPUT_AMOUNT_UPDATED,
-        newOutputAmount: numberToString(getQuoteOutputAmount(currentQuote)),
-        percentageChange: numberToString(
-          getPriceImpact(
-            getQuoteOutputAmount(previousQuote) ?? '',
-            getQuoteOutputAmount(currentQuote) ?? ''
-          ),
-          null,
-          2
-        ),
-      };
-    } else if (isNumberOfSwapsChanged(previousQuote, currentQuote)) {
-      output.quoteUpdate = {
-        type: QuoteUpdateType.QUOTE_UPDATED,
-      };
-    } else if (isQuoteSwappersUpdated(previousQuote, currentQuote)) {
-      output.quoteUpdate = {
-        type: QuoteUpdateType.QUOTE_SWAPPERS_UPDATED,
-      };
-    } else if (isQuoteInternalCoinsUpdated(previousQuote, currentQuote)) {
-      output.quoteUpdate = {
-        type: QuoteUpdateType.QUOTE_COINS_UPDATED,
-      };
-    }
-  }
-
-  const balanceWarnings = generateBalanceWarnings(
-    currentQuote,
-    params.selectedWallets,
-    params.meta.blockchains
-  );
-  const enoughBalance = balanceWarnings.length === 0;
-
-  if (!enoughBalance) {
-    output.balance = {
-      messages: balanceWarnings,
-    };
-  }
-
-  return output;
-}
-
-export function handleQuoteErrors(error: any): ConfirmSwapFetchResult {
-  if (error?.code === 'ERR_CANCELED') {
-    return {
-      swap: null,
-      error: {
-        type: QuoteErrorType.REQUEST_CANCELED,
-      },
-      warnings: null,
-    };
-  }
-
-  if (error.cause) {
-    return {
-      swap: null,
-      error: error.cause,
-      warnings: null,
-    };
-  }
-
-  return {
-    swap: null,
-    error: {
-      type: QuoteErrorType.REQUEST_FAILED,
-    },
-    warnings: null,
-  };
-}

package/src/hooks/useConfirmSwap/useConfirmSwap.ts

@@ -1,137 +0,0 @@
-import type { ConfirmSwap, Params } from './useConfirmSwap.types';
-import type { PendingSwapSettings } from '../../types';
-import type { BestRouteResponse } from 'rango-sdk';
-
-import { calculatePendingSwap } from '@rango-dev/queue-manager-rango-preset';
-import { useEffect } from 'react';
-
-import { useAppStore } from '../../store/AppStore';
-import { useQuoteStore } from '../../store/quote';
-import { useWalletsStore } from '../../store/wallets';
-import { isFeatureEnabled } from '../../utils/settings';
-import { createQuoteRequestBody, getWalletsForNewSwap } from '../../utils/swap';
-import { useFetchQuote } from '../useFetchQuote';
-
-import {
-  generateWarnings,
-  handleQuoteErrors,
-  throwErrorIfResponseIsNotValid,
-} from './useConfirmSwap.helpers';
-
-export function useConfirmSwap(): ConfirmSwap {
-  const {
-    fromToken,
-    toToken,
-    inputAmount,
-    setQuote,
-    quote: initialQuote,
-    customDestination: customDestinationFromStore,
-    setQuoteWarningsConfirmed,
-  } = useQuoteStore();
-
-  const {
-    slippage,
-    customSlippage,
-    affiliatePercent,
-    affiliateRef,
-    affiliateWallets,
-    disabledLiquiditySources,
-  } = useAppStore();
-  const { connectedWallets } = useWalletsStore();
-  const blockchains = useAppStore().blockchains();
-  const tokens = useAppStore().tokens();
-  const { features } = useAppStore().config;
-  const { enableNewLiquiditySources } = useAppStore().config;
-
-  const userSlippage = customSlippage || slippage;
-
-  const { fetch: fetchQuote, cancelFetch, loading } = useFetchQuote();
-
-  useEffect(() => cancelFetch, []);
-
-  const fetch: ConfirmSwap['fetch'] = async (params: Params) => {
-    const selectedWallets = params.selectedWallets;
-    const customDestination =
-      params?.customDestination ?? customDestinationFromStore;
-
-    if (!fromToken || !toToken || !inputAmount) {
-      return {
-        quote: null,
-        swap: null,
-        error: null,
-        warnings: null,
-      };
-    }
-
-    const requestBody = createQuoteRequestBody({
-      fromToken,
-      toToken,
-      inputAmount,
-      wallets: connectedWallets,
-      selectedWallets,
-      excludeLiquiditySources: enableNewLiquiditySources,
-      disabledLiquiditySources,
-      slippage: userSlippage,
-      affiliateRef,
-      affiliatePercent,
-      affiliateWallets,
-      initialQuote: initialQuote ?? undefined,
-      destination: customDestination,
-    });
-    if (isFeatureEnabled('experimentalRoute', features)) {
-      requestBody.experimental = true;
-    }
-    let currentQuote: BestRouteResponse;
-    try {
-      currentQuote = await fetchQuote(requestBody).then((response) =>
-        throwErrorIfResponseIsNotValid(response)
-      );
-      setQuote(currentQuote);
-    } catch (error: any) {
-      const confirmSwapResult = handleQuoteErrors(error);
-      return confirmSwapResult;
-    }
-
-    const swapSettings: PendingSwapSettings = {
-      slippage: userSlippage.toString(),
-      disabledSwappersGroups: disabledLiquiditySources,
-    };
-    const swap = calculatePendingSwap(
-      inputAmount.toString(),
-      currentQuote,
-      getWalletsForNewSwap(selectedWallets),
-      swapSettings,
-      false,
-      { blockchains, tokens }
-    );
-
-    const confirmSwapWarnings = generateWarnings(
-      initialQuote ?? undefined,
-      currentQuote,
-      {
-        fromToken,
-        toToken,
-        meta: { blockchains, tokens },
-        selectedWallets,
-        userSlippage,
-      }
-    );
-
-    if (confirmSwapWarnings.quoteUpdate) {
-      setQuoteWarningsConfirmed(false);
-    }
-
-    return {
-      quote: currentQuote,
-      swap,
-      error: null,
-      warnings: confirmSwapWarnings,
-    };
-  };
-
-  return {
-    loading,
-    fetch,
-    cancelFetch,
-  };
-}

package/src/hooks/useConfirmSwap/useConfirmSwap.types.ts

@@ -1,19 +0,0 @@
-import type { ConfirmSwapWarnings, QuoteError, Wallet } from '../../types';
-import type { PendingSwap } from 'rango-types';
-
-export type ConfirmSwapFetchResult = {
-  swap: PendingSwap | null;
-  error: QuoteError | null;
-  warnings: ConfirmSwapWarnings | null;
-};
-
-export type ConfirmSwap = {
-  loading: boolean;
-  fetch: (params: Params) => Promise<ConfirmSwapFetchResult>;
-  cancelFetch: () => void;
-};
-
-export type Params = {
-  selectedWallets: Wallet[];
-  customDestination?: string;
-};

package/src/hooks/useForceAutoConnect.ts

@@ -1,27 +0,0 @@
-import { useWallets } from '@rango-dev/wallets-react';
-import { useEffect, useRef } from 'react';
-
-import { SearchParams } from '../constants/searchParams';
-import { useAppStore } from '../store/AppStore';
-
-export function useForceAutoConnect(): void {
-  const { connect, state } = useWallets();
-  const initiated = useRef<{ [key: string]: boolean }>({});
-  const { fetchStatus } = useAppStore();
-  const walletType =
-    new URLSearchParams(location.search).get(SearchParams.AUTO_CONNECT) || '';
-  const walletState = state(walletType);
-
-  useEffect(() => {
-    const shouldTryConnect =
-      fetchStatus === 'success' &&
-      walletType &&
-      walletState.installed &&
-      !walletState.connecting &&
-      !walletState.connected;
-    if (shouldTryConnect && !initiated.current[walletType]) {
-      initiated.current[walletType] = true;
-      void connect(walletType);
-    }
-  }, [walletState, fetchStatus]);
-}

package/src/store/AppStore.tsx

@@ -1,41 +0,0 @@
-import type { WidgetConfig } from '../types';
-import type { PropsWithChildren } from 'react';
-
-import React, { createContext, useContext, useEffect, useRef } from 'react';
-
-import { createAppStore } from './app';
-
-type AppStore = ReturnType<typeof createAppStore>;
-type AppStoreProviderProps = PropsWithChildren<{ config?: WidgetConfig }>;
-
-export const AppStoreContext = createContext<AppStore | null>(null);
-
-export function useAppStore() {
-  const store = useContext(AppStoreContext);
-
-  useEffect(() => {
-    if (store && !store.persist.hasHydrated()) {
-      void store.persist.rehydrate();
-    }
-  }, []);
-
-  if (!store) {
-    throw new Error('Missing AppStoreContext.Provider in the tree');
-  }
-
-  return store();
-}
-
-export function AppStoreProvider(props: AppStoreProviderProps) {
-  const appStoreRef = useRef<AppStore>();
-
-  if (!appStoreRef.current) {
-    appStoreRef.current = createAppStore(props.config);
-  }
-
-  return (
-    <AppStoreContext.Provider value={appStoreRef.current}>
-      {props.children}
-    </AppStoreContext.Provider>
-  );
-}

package/src/store/slices/settings.ts

@@ -1,168 +0,0 @@
-import type { ConfigSlice } from './config';
-import type { WidgetConfig } from '../../types';
-import type { SwapperMeta } from 'rango-sdk';
-import type { StateCreator } from 'zustand';
-
-import { type Language } from '@rango-dev/ui';
-
-import { BLOCKCHAIN_LIST_SIZE } from '../../constants/configs';
-import { DEFAULT_LANGUAGE } from '../../constants/languages';
-import { DEFAULT_SLIPPAGE } from '../../constants/swapSettings';
-import { removeDuplicateFrom } from '../../utils/common';
-import { isFeatureHidden } from '../../utils/settings';
-
-export type ThemeMode = 'auto' | 'dark' | 'light';
-
-export interface SettingsSlice {
-  theme: ThemeMode;
-  language: Language;
-  disabledLiquiditySources: string[];
-  /** Keeping a history of blockchains that user has selected (in Swap process) */
-  preferredBlockchains: string[];
-  slippage: number;
-  customSlippage: number | null;
-  infiniteApprove: boolean;
-  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;
-  updateSettings: (config: WidgetConfig) => void;
-}
-
-export const createSettingsSlice: StateCreator<
-  SettingsSlice & ConfigSlice,
-  [],
-  [],
-  SettingsSlice
-> = (set, get) => ({
-  disabledLiquiditySources: [],
-  theme: 'auto',
-  language: DEFAULT_LANGUAGE,
-  preferredBlockchains: [],
-  slippage: DEFAULT_SLIPPAGE,
-  customSlippage: null,
-  infiniteApprove: false,
-  affiliateRef: null,
-  affiliatePercent: null,
-  affiliateWallets: null,
-
-  addPreferredBlockchain: (blockchain) => {
-    const currentPreferredBlockchains = get().preferredBlockchains;
-
-    const noNeedToDoAnything = currentPreferredBlockchains.find(
-      (preferredBlockchain, index) => {
-        const isSameBlockchain = preferredBlockchain === blockchain;
-        const isInVisibleList = index <= BLOCKCHAIN_LIST_SIZE - 1;
-
-        return isSameBlockchain && isInVisibleList;
-      }
-    );
-
-    if (noNeedToDoAnything) {
-      return;
-    }
-
-    const nextPreferredBlockchains: string[] =
-      currentPreferredBlockchains.filter((preferredBlockchain) => {
-        const isSameBlockchain = preferredBlockchain === blockchain;
-
-        return !isSameBlockchain;
-      });
-
-    set(() => ({
-      preferredBlockchains: [blockchain, ...nextPreferredBlockchains],
-    }));
-  },
-  setSlippage: (slippage) =>
-    set(() => ({
-      slippage: slippage,
-    })),
-  setCustomSlippage: (customSlippage) =>
-    set(() => ({
-      customSlippage: customSlippage,
-    })),
-  setAffiliateRef: (affiliateRef) =>
-    set(() => ({
-      affiliateRef,
-    })),
-  setAffiliatePercent: (affiliatePercent) =>
-    set(() => ({
-      affiliatePercent,
-    })),
-
-  setAffiliateWallets: (affiliateWallets) =>
-    set(() => ({
-      affiliateWallets,
-    })),
-  toggleAllLiquiditySources: (swappers, shouldReset) =>
-    set((state) => {
-      if (shouldReset) {
-        return { disabledLiquiditySources: [] };
-      }
-      const swappersGroup = removeDuplicateFrom(
-        swappers.map((swapper) => swapper.swapperGroup)
-      );
-
-      if (swappersGroup.length === state.disabledLiquiditySources.length) {
-        return { disabledLiquiditySources: [] };
-      }
-
-      return {
-        disabledLiquiditySources: swappersGroup,
-      };
-    }),
-  toggleInfiniteApprove: () =>
-    set((state) => ({
-      infiniteApprove: !state.infiniteApprove,
-    })),
-  toggleLiquiditySource: (name) =>
-    set((state) => {
-      if (state.disabledLiquiditySources.includes(name)) {
-        return {
-          disabledLiquiditySources: state.disabledLiquiditySources.filter(
-            (liquiditySource) => liquiditySource != name
-          ),
-        };
-      }
-      return {
-        disabledLiquiditySources: state.disabledLiquiditySources.concat(name),
-      };
-    }),
-  setTheme: (theme) =>
-    set(() => ({
-      theme,
-    })),
-  setLanguage: (language) =>
-    set(() => ({
-      language,
-    })),
-  updateSettings: (nextConfig: WidgetConfig) => {
-    const { features } = nextConfig;
-
-    const isThemeHidden = isFeatureHidden('theme', features);
-    const isLanguageHidden = isFeatureHidden('language', features);
-    const isLiquidityHidden = isFeatureHidden('liquiditySource', features);
-
-    set({
-      ...(isThemeHidden && { theme: 'auto' }),
-      ...(isLanguageHidden && { language: DEFAULT_LANGUAGE }),
-      ...(isLiquidityHidden && { disabledLiquiditySources: [] }),
-    });
-  },
-});

package/src/types/quote.ts

@@ -1,107 +0,0 @@
-/* eslint-disable @typescript-eslint/prefer-enum-initializers */
-
-import type { PriceImpactWarningLevel } from '@rango-dev/ui';
-import type BigNumber from 'bignumber.js';
-import type { SwapResult } from 'rango-sdk';
-
-export enum QuoteErrorType {
-  NO_RESULT,
-  REQUEST_FAILED,
-  REQUEST_CANCELED,
-  BRIDGE_LIMIT,
-  INSUFFICIENT_SLIPPAGE,
-}
-
-export type NoResultError = {
-  type: QuoteErrorType.NO_RESULT;
-  diagnosisMessage?: string;
-};
-
-export type BridgeLimitError = {
-  type: QuoteErrorType.BRIDGE_LIMIT;
-  swap: SwapResult;
-  recommendation: string;
-  fromAmountRangeError: string;
-};
-
-export type InsufficientSlippageError = {
-  type: QuoteErrorType.INSUFFICIENT_SLIPPAGE;
-  recommendedSlippages: RecommendedSlippages | null;
-  minRequiredSlippage: string | null;
-};
-
-export type QuoteRequestFailed = { type: QuoteErrorType.REQUEST_FAILED };
-export type QuoteRequestCanceled = { type: QuoteErrorType.REQUEST_CANCELED };
-
-export type QuoteError =
-  | NoResultError
-  | BridgeLimitError
-  | InsufficientSlippageError
-  | QuoteRequestFailed
-  | QuoteRequestCanceled;
-
-export enum QuoteWarningType {
-  HIGH_VALUE_LOSS,
-  UNKNOWN_PRICE,
-  INSUFFICIENT_SLIPPAGE,
-  HIGH_SLIPPAGE,
-}
-
-export enum QuoteUpdateType {
-  QUOTE_UPDATED,
-  QUOTE_SWAPPERS_UPDATED,
-  QUOTE_COINS_UPDATED,
-  QUOTE_AND_OUTPUT_AMOUNT_UPDATED,
-  QUOTE_UPDATED_WITH_HIGH_VALUE_LOSS,
-}
-
-export type QuoteUpdateWarning =
-  | {
-      type: QuoteUpdateType.QUOTE_AND_OUTPUT_AMOUNT_UPDATED;
-      newOutputAmount: string;
-      percentageChange: string;
-    }
-  | {
-      type: Exclude<
-        QuoteUpdateType,
-        QuoteUpdateType.QUOTE_AND_OUTPUT_AMOUNT_UPDATED
-      >;
-    };
-
-export type RecommendedSlippages = Map<number, string>;
-
-export type InsufficientSlippageWarning = {
-  type: QuoteWarningType.INSUFFICIENT_SLIPPAGE;
-  recommendedSlippages: RecommendedSlippages | null;
-  minRequiredSlippage: string | null;
-};
-
-export type HighSlippageWarning = {
-  type: QuoteWarningType.HIGH_SLIPPAGE;
-  slippage: string | null;
-};
-
-export type HighValueLossWarning = {
-  type: QuoteWarningType.HIGH_VALUE_LOSS;
-  warningLevel: PriceImpactWarningLevel;
-  inputUsdValue: BigNumber;
-  outputUsdValue: BigNumber;
-  totalFee: BigNumber;
-  priceImpact: number;
-};
-
-export type UnknownPriceWarning = {
-  type: QuoteWarningType.UNKNOWN_PRICE;
-};
-
-export type QuoteWarning =
-  | HighValueLossWarning
-  | InsufficientSlippageWarning
-  | HighSlippageWarning
-  | UnknownPriceWarning;
-
-export type ConfirmSwapWarnings = {
-  quote: QuoteWarning | null;
-  quoteUpdate: QuoteUpdateWarning | null;
-  balance: { messages: string[] } | null;
-};