@rango-dev/widget-embedded 0.17.1-next.0 → 0.17.1-next.10

package/src/containers/WidgetInfo/WidgetInfo.types.ts

@@ -0,0 +1,5 @@
+import type { PendingSwapWithQueueID } from '@rango-dev/queue-manager-rango-preset';
+
+export interface WidgetInfoContextInterface {
+  swaps?: PendingSwapWithQueueID[];
+}

package/src/containers/WidgetInfo/index.ts

@@ -0,0 +1 @@
+export { WidgetInfo, useWidget } from './WidgetInfo';

package/src/containers/WidgetProvider/WidgetProvider.tsx

@@ -0,0 +1,19 @@
+import type { PropTypes } from './WidgetProvider.types';
+import type { PropsWithChildren } from 'react';
+
+import React from 'react';
+
+import QueueManager from '../../QueueManager';
+import { WidgetWallets } from '../Wallets';
+import { WidgetInfo } from '../WidgetInfo';
+
+export function WidgetProvider(props: PropsWithChildren<PropTypes>) {
+  const { onUpdateState, config } = props;
+  return (
+    <WidgetWallets config={config} onUpdateState={onUpdateState}>
+      <QueueManager apiKey={config.apiKey}>
+        <WidgetInfo>{props.children}</WidgetInfo>
+      </QueueManager>
+    </WidgetWallets>
+  );
+}

package/src/containers/WidgetProvider/WidgetProvider.types.ts

@@ -0,0 +1,7 @@
+import type { WidgetConfig } from '../../types';
+import type { EventHandler } from '@rango-dev/wallets-react';
+
+export type PropTypes = {
+  onUpdateState?: EventHandler;
+  config: WidgetConfig;
+};

package/src/containers/WidgetProvider/index.ts

@@ -0,0 +1 @@
+export { WidgetProvider } from './WidgetProvider';

package/src/hooks/useConfirmSwap/index.ts

@@ -0,0 +1 @@
+export { useConfirmSwap } from './useConfirmSwap';

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

@@ -0,0 +1,168 @@
+import type { ConfirmSwapFetchResult } from './useConfirmSwap.types';
+import type { ConfirmSwapWarnings, Wallet } from '../../types';
+import type { BestRouteResponse, Token } from 'rango-sdk';
+
+import { errorMessages } from '../../constants/errors';
+import { QuoteErrorType, QuoteUpdateType } from '../../types';
+import { numberToString } from '../../utils/numbers';
+import {
+  generateQuoteWarnings,
+  isNumberOfSwapsChanged,
+  isQuoteChanged,
+  isQuoteInternalCoinsUpdated,
+  isQuoteSwappersUpdated,
+} from '../../utils/quote';
+import {
+  checkSlippageErrors,
+  getBalanceWarnings,
+  getLimitErrorMessage,
+  getMinRequiredSlippage,
+  getPercentageChange,
+  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,
+  currentQuote: BestRouteResponse,
+  params: {
+    fromToken: Token;
+    toToken: Token;
+    tokens: Token[];
+    selectedWallets: Wallet[];
+    userSlippage: number;
+  }
+): ConfirmSwapWarnings {
+  const 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.tokens,
+    userSlippage: params.userSlippage,
+  });
+
+  if (quoteWarning) {
+    output.quote = quoteWarning;
+  }
+
+  if (quoteChanged) {
+    if (isOutputAmountChangedALot(previousQuote, currentQuote)) {
+      output.quoteUpdate = {
+        type: QuoteUpdateType.QUOTE_AND_OUTPUT_AMOUNT_UPDATED,
+        newOutputAmount: numberToString(getQuoteOutputAmount(currentQuote)),
+        percentageChange: numberToString(
+          getPercentageChange(
+            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 = getBalanceWarnings(
+    currentQuote,
+    params.selectedWallets
+  );
+  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

@@ -0,0 +1,136 @@
+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 { useSettingsStore } from '../../store/settings';
+import { useWalletsStore } from '../../store/wallets';
+import { QuoteErrorType } from '../../types';
+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,
+    resetQuote,
+    quote: initialQuote,
+    customDestination: customDestinationFromStore,
+    setQuoteWarningsConfirmed,
+  } = useQuoteStore();
+
+  const {
+    slippage,
+    customSlippage,
+    affiliatePercent,
+    affiliateRef,
+    affiliateWallets,
+    disabledLiquiditySources,
+  } = useSettingsStore();
+  const { connectedWallets } = useWalletsStore();
+  const blockchains = useAppStore().blockchains();
+  const tokens = useAppStore().tokens();
+
+  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 || !initialQuote) {
+      return {
+        quote: null,
+        swap: null,
+        error: null,
+        warnings: null,
+      };
+    }
+
+    const requestBody = createQuoteRequestBody({
+      fromToken,
+      toToken,
+      inputAmount,
+      wallets: connectedWallets,
+      selectedWallets,
+      disabledLiquiditySources,
+      slippage: userSlippage,
+      affiliateRef,
+      affiliatePercent,
+      affiliateWallets,
+      initialQuote: initialQuote,
+      destination: customDestination,
+    });
+
+    let currentQuote: BestRouteResponse;
+    try {
+      currentQuote = await fetchQuote(requestBody).then((response) =>
+        throwErrorIfResponseIsNotValid(response)
+      );
+      setQuote(currentQuote);
+    } catch (error: any) {
+      const confirmSwapResult = handleQuoteErrors(error);
+      if (
+        confirmSwapResult.error?.type === QuoteErrorType.NO_RESULT ||
+        confirmSwapResult.error?.type === QuoteErrorType.REQUEST_FAILED
+      ) {
+        resetQuote();
+      }
+      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, currentQuote, {
+      fromToken,
+      toToken,
+      tokens: 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

@@ -0,0 +1,19 @@
+import type { ConfirmSwapWarnings, QuoteError, Wallet } from '../../types';
+import type { PendingSwap } from 'rango-types/lib';
+
+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/{useFetchBestRoute.ts → useFetchQuote.ts}

@@ -4,18 +4,18 @@ import { useRef, useState } from 'react';
 
 import { httpService } from '../services/httpService';
 
-interface UseFetchBestRoute {
+interface UseFetchQuote {
   fetch: (requestBody: BestRouteRequest) => Promise<BestRouteResponse>;
   cancelFetch: () => void;
   loading: boolean;
 }
 
-export function useFetchBestRoute(): UseFetchBestRoute {
+export function useFetchQuote(): UseFetchQuote {
   const [loading, setLoading] = useState(false);
   const abortController = useRef<AbortController | null>(null);
   const cancel = () => abortController.current?.abort();
 
-  const fetch: UseFetchBestRoute['fetch'] = async (requestBody) => {
+  const fetch: UseFetchQuote['fetch'] = async (requestBody) => {
     cancel();
     abortController.current = new AbortController();
 

package/src/hooks/useForceAutoConnect.ts

@@ -0,0 +1,27 @@
+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/hooks/useNavigateBack.ts

@@ -1,12 +1,12 @@
 import { useInRouterContext, useNavigate } from 'react-router-dom';
 
 import { navigationRoutes } from '../constants/navigationRoutes';
-import { useBestRouteStore } from '../store/bestRoute';
+import { useQuoteStore } from '../store/quote';
 
 export function useNavigateBack() {
   const isRouterInContext = useInRouterContext();
   const navigate = useNavigate();
-  const routeWalletsConfirmed = useBestRouteStore.use.routeWalletsConfirmed();
+  const quoteWalletsConfirmed = useQuoteStore.use.quoteWalletsConfirmed();
 
   navigationRoutes;
 
@@ -26,7 +26,7 @@ export function useNavigateBack() {
         [navigationRoutes.settings, navigationRoutes.wallets].includes(
           currentRoute
         ) &&
-        routeWalletsConfirmed
+        quoteWalletsConfirmed
       ) {
         return navigate('/' + navigationRoutes.confirmSwap, { replace: true });
       }

package/src/hooks/useSwapInput.ts

@@ -1,37 +1,48 @@
+import type { QuoteError, QuoteWarning } from '../types';
+
 import { useEffect, useRef, useState } from 'react';
 
-import { useBestRouteStore } from '../store/bestRoute';
+import { useAppStore } from '../store/AppStore';
+import { useQuoteStore } from '../store/quote';
 import { useSettingsStore } from '../store/settings';
+import { QuoteErrorType } from '../types';
 import { debounce } from '../utils/common';
 import { isPositiveNumber } from '../utils/numbers';
-import { createBestRouteRequestBody } from '../utils/swap';
+import { generateQuoteWarnings } from '../utils/quote';
+import { createQuoteRequestBody } from '../utils/swap';
 import { tokensAreEqual } from '../utils/wallets';
 
-import { useFetchBestRoute } from './useFetchBestRoute';
+import {
+  handleQuoteErrors,
+  throwErrorIfResponseIsNotValid,
+} from './useConfirmSwap/useConfirmSwap.helpers';
+import { useFetchQuote } from './useFetchQuote';
 
 const DEBOUNCE_DELAY = 600;
 
 type UseSwapInput = {
   fetch: () => void;
   loading: boolean;
-  error: string;
+  error: QuoteError | null;
+  warning: QuoteWarning | null;
 };
 
 /**
- * a hook for fetching best route based on from and to input values
+ * a hook for fetching quote based on from and to input values
  * we use this hook in home page
  */
 export function useSwapInput(): UseSwapInput {
-  const { fetch: fetchBestRoute, cancelFetch } = useFetchBestRoute();
-  const [loading, setLoading] = useState(false);
+  const { fetch: fetchQuote, cancelFetch } = useFetchQuote();
+  const { liquiditySources, enableNewLiquiditySources } = useAppStore().config;
+  const tokens = useAppStore().tokens();
   const {
     fromToken,
     toToken,
     inputAmount,
     inputUsdValue,
-    resetRoute,
-    setRoute,
-  } = useBestRouteStore();
+    resetQuote,
+    setQuote,
+  } = useQuoteStore();
   const {
     slippage,
     customSlippage,
@@ -40,7 +51,9 @@ export function useSwapInput(): UseSwapInput {
     affiliateWallets,
     disabledLiquiditySources,
   } = useSettingsStore();
-  const [error, setError] = useState('');
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<QuoteError | null>(null);
+  const [warning, setWarning] = useState<QuoteWarning | null>(null);
   const prevDisabledLiquiditySources = useRef(disabledLiquiditySources);
   const userSlippage = customSlippage ?? slippage;
   const hasTokensValue = !fromToken || !toToken;
@@ -49,31 +62,53 @@ export function useSwapInput(): UseSwapInput {
     tokensAreEqual(fromToken, toToken) ||
     !isPositiveNumber(inputAmount);
 
+  const resetState = (loading: boolean) => {
+    setLoading(loading);
+    setError(null);
+    setWarning(null);
+  };
+
   const fetch: UseSwapInput['fetch'] = () => {
     if (!loading) {
-      setLoading(true);
+      resetState(true);
     }
     if (!shouldSkipRequest) {
-      resetRoute();
-      const requestBody = createBestRouteRequestBody({
+      resetQuote();
+      const requestBody = createQuoteRequestBody({
         fromToken,
         toToken,
         inputAmount,
+        liquiditySources,
+        excludeLiquiditySources: enableNewLiquiditySources,
         disabledLiquiditySources,
         slippage: userSlippage,
         affiliateRef,
         affiliatePercent,
         affiliateWallets,
       });
-      fetchBestRoute(requestBody)
+      fetchQuote(requestBody)
         .then((res) => {
           setLoading(false);
-          setRoute(res);
+          setQuote(res);
+          throwErrorIfResponseIsNotValid(res);
+          const quoteWarning = generateQuoteWarnings(res, {
+            fromToken,
+            toToken,
+            userSlippage,
+            tokens,
+          });
+          setWarning(quoteWarning);
         })
         .catch((error) => {
-          resetRoute();
-          if (error?.code !== 'ERR_CANCELED') {
-            setError(error.message);
+          const { error: quoteError } = handleQuoteErrors(error);
+          if (
+            quoteError?.type === QuoteErrorType.NO_RESULT ||
+            quoteError?.type === QuoteErrorType.REQUEST_FAILED
+          ) {
+            resetQuote();
+          }
+          if (quoteError?.type !== QuoteErrorType.REQUEST_CANCELED) {
+            setError(quoteError);
             setLoading(false);
           }
         });
@@ -88,15 +123,15 @@ export function useSwapInput(): UseSwapInput {
 
   useEffect(() => {
     if (!isPositiveNumber(inputAmount) || inputUsdValue?.eq(0)) {
-      setLoading(false);
+      resetState(false);
       cancelFetch();
       return;
     }
     if (shouldSkipRequest) {
       return;
     }
-    resetRoute();
-    setLoading(true);
+    resetQuote();
+    resetState(true);
     debouncedFetch();
     return cancelFetch;
   }, [inputAmount, shouldSkipRequest]);
@@ -112,5 +147,5 @@ export function useSwapInput(): UseSwapInput {
     return cancelFetch;
   }, [disabledLiquiditySources.length]);
 
-  return { fetch, loading, error };
+  return { fetch, loading, error, warning };
 }