@lifi/widget 2.9.3 → 3.0.0-alpha.0

package/cjs/hooks/useProcessMessage.d.ts

@@ -1,11 +1,11 @@
-import type { EVMChain, LifiStep, Process } from '@lifi/sdk';
+import type { EVMChain, LiFiStep, Process } from '@lifi/sdk';
 import type { TFunction } from 'i18next';
 import type { WidgetSubvariant } from '../types';
-export declare const useProcessMessage: (step?: LifiStep, process?: Process) => {
+export declare const useProcessMessage: (step?: LiFiStep, process?: Process) => {
     title?: string | undefined;
     message?: string | undefined;
 };
-export declare function getProcessMessage(t: TFunction, getChainById: (chainId: number) => EVMChain | undefined, step: LifiStep, process: Process, subvariant?: WidgetSubvariant): {
+export declare function getProcessMessage(t: TFunction, getChainById: (chainId: number) => EVMChain | undefined, step: LiFiStep, process: Process, subvariant?: WidgetSubvariant): {
     title?: string;
     message?: string;
 };

package/cjs/hooks/useProcessMessage.js

@@ -5,11 +5,11 @@ const sdk_1 = require("@lifi/sdk");
 const react_i18next_1 = require("react-i18next");
 const providers_1 = require("../providers");
 const utils_1 = require("../utils");
-const useChains_1 = require("./useChains");
+const useAvailableChains_1 = require("./useAvailableChains");
 const useProcessMessage = (step, process) => {
     const { subvariant } = (0, providers_1.useWidgetConfig)();
     const { t } = (0, react_i18next_1.useTranslation)();
-    const { getChainById } = (0, useChains_1.useChains)();
+    const { getChainById } = (0, useAvailableChains_1.useAvailableChains)();
     if (!step || !process) {
         return {};
     }
@@ -77,72 +77,76 @@ const processSubstatusMessages = {
 };
 function getProcessMessage(t, getChainById, step, process, subvariant) {
     if (process.error && process.status === 'FAILED') {
-        const getTransactionNotSentMessage = () => t(`error.message.transactionNotSent`, {
-            amount: (0, utils_1.formatTokenAmount)(step.action.fromAmount, step.action.fromToken.decimals),
+        const getDefaultErrorMessage = (key) => `${t(key ?? 'error.message.transactionNotSent')} ${t('error.message.remainInYourWallet', {
+            amount: (0, utils_1.formatTokenAmount)(BigInt(step.action.fromAmount), step.action.fromToken.decimals),
             tokenSymbol: step.action.fromToken.symbol,
             chainName: getChainById(step.action.fromChainId)?.name ?? '',
-        });
+        })}`;
         let title = '';
         let message = '';
         switch (process.error.code) {
-            case sdk_1.LifiErrorCode.AllowanceRequired:
+            case sdk_1.LiFiErrorCode.AllowanceRequired:
                 title = t(`error.title.allowanceRequired`);
                 message = t(`error.message.allowanceRequired`, {
                     tokenSymbol: step.action.fromToken.symbol,
                 });
                 break;
-            case sdk_1.LifiErrorCode.BalanceError:
+            case sdk_1.LiFiErrorCode.BalanceError:
                 title = t(`error.title.balanceIsTooLow`);
-                message = getTransactionNotSentMessage();
+                message = getDefaultErrorMessage();
                 break;
-            case sdk_1.LifiErrorCode.ChainSwitchError:
+            case sdk_1.LiFiErrorCode.ChainSwitchError:
                 title = t(`error.title.chainSwitch`);
-                message = getTransactionNotSentMessage();
+                message = getDefaultErrorMessage();
                 break;
-            case sdk_1.LifiErrorCode.GasLimitError:
+            case sdk_1.LiFiErrorCode.GasLimitError:
                 title = t(`error.title.gasLimitIsTooLow`);
-                message = getTransactionNotSentMessage();
+                message = getDefaultErrorMessage();
                 break;
-            case sdk_1.LifiErrorCode.InsufficientFunds:
+            case sdk_1.LiFiErrorCode.InsufficientFunds:
                 title = t(`error.title.insufficientFunds`);
-                message = `${t(`error.message.insufficientFunds`)} ${getTransactionNotSentMessage()}`;
+                message = `${t(`error.message.insufficientFunds`)} ${getDefaultErrorMessage()}`;
                 break;
-            case sdk_1.LifiErrorCode.SlippageError:
+            case sdk_1.LiFiErrorCode.SlippageError:
                 title = t(`error.title.slippageNotMet`);
                 message = t(`error.message.slippageThreshold`);
                 break;
-            case sdk_1.LifiErrorCode.TransactionFailed:
+            case sdk_1.LiFiErrorCode.TransactionFailed:
                 title = t(`error.title.transactionFailed`);
                 message = t(`error.message.transactionFailed`);
                 break;
-            case sdk_1.LifiErrorCode.TransactionUnderpriced:
+            case sdk_1.LiFiErrorCode.TransactionUnderpriced:
                 title = t(`error.title.transactionUnderpriced`);
-                message = getTransactionNotSentMessage();
+                message = getDefaultErrorMessage();
                 break;
-            case sdk_1.LifiErrorCode.TransactionUnprepared:
+            case sdk_1.LiFiErrorCode.TransactionUnprepared:
                 title = t(`error.title.transactionUnprepared`);
-                message = getTransactionNotSentMessage();
+                message = getDefaultErrorMessage();
                 break;
-            case sdk_1.LifiErrorCode.TransactionCanceled:
+            case sdk_1.LiFiErrorCode.TransactionCanceled:
                 title = t(`error.title.transactionCanceled`);
-                message = getTransactionNotSentMessage();
+                message = getDefaultErrorMessage('error.message.transactionCanceled');
                 break;
-            case sdk_1.LifiErrorCode.TransactionRejected:
-                title = t(`error.title.transactionRejected`);
-                message = t(`error.message.transactionRejected`, {
-                    amount: (0, utils_1.formatTokenAmount)(step.action.fromAmount, step.action.fromToken.decimals),
+            case sdk_1.LiFiErrorCode.ExchangeRateUpdateCanceled:
+                title = t(`error.title.exchangeRateUpdateCanceled`);
+                message = getDefaultErrorMessage();
+                break;
+            case sdk_1.LiFiErrorCode.SignatureRejected:
+                title = t(`error.title.signatureRejected`);
+                message = t(`error.message.signatureRejected`, {
+                    amount: (0, utils_1.formatTokenAmount)(BigInt(step.action.fromAmount), step.action.fromToken.decimals),
                     tokenSymbol: step.action.fromToken.symbol,
                     chainName: getChainById(step.action.fromChainId)?.name ?? '',
                 });
                 break;
-            case sdk_1.LifiErrorCode.ProviderUnavailable:
+            case sdk_1.LiFiErrorCode.ProviderUnavailable:
             default:
                 title = t(`error.title.unknown`);
                 if (process.txLink) {
                     message = t(`error.message.transactionFailed`);
                 }
                 else {
-                    message = t(`error.message.unknown`);
+                    message = process.error.message || t(`error.message.unknown`);
                 }
                 break;
         }

package/cjs/hooks/useRequiredToAddress.d.ts

@@ -0,0 +1 @@
+export declare const useRequiredToAddress: () => boolean | undefined;

package/cjs/hooks/useRequiredToAddress.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRequiredToAddress = void 0;
+const react_hook_form_1 = require("react-hook-form");
+const hooks_1 = require("../hooks");
+const providers_1 = require("../providers");
+const types_1 = require("../types");
+const useRequiredToAddress = () => {
+    const { requiredUI } = (0, providers_1.useWidgetConfig)();
+    const [fromChainId, toChainId] = (0, react_hook_form_1.useWatch)({
+        name: [providers_1.FormKey.FromChain, providers_1.FormKey.ToChain],
+    });
+    const { chain: fromChain } = (0, hooks_1.useChain)(fromChainId);
+    const { chain: toChain } = (0, hooks_1.useChain)(toChainId);
+    const differentChainType = fromChain && toChain && fromChain.chainType !== toChain.chainType;
+    const requiredToAddress = requiredUI?.includes(types_1.RequiredUI.ToAddress) || differentChainType;
+    return requiredToAddress;
+};
+exports.useRequiredToAddress = useRequiredToAddress;

package/cjs/hooks/useRouteExecution.d.ts

@@ -1,4 +1,4 @@
-import type { ExchangeRateUpdateParams, Route } from '@lifi/sdk';
+import type { ExchangeRateUpdateParams } from '@lifi/sdk';
 interface RouteExecutionProps {
     routeId: string;
     executeInBackground?: boolean;
@@ -8,7 +8,7 @@ export declare const useRouteExecution: ({ routeId, executeInBackground, onAccep
     executeRoute: () => void;
     restartRoute: () => void;
     deleteRoute: () => void;
-    route: Route | undefined;
+    route: import("@lifi/sdk").RouteExtended | undefined;
     status: import("../stores").RouteExecutionStatus | undefined;
 };
 export {};

package/cjs/hooks/useRouteExecution.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useRouteExecution = void 0;
+const sdk_1 = require("@lifi/sdk");
 const react_query_1 = require("@tanstack/react-query");
 const react_1 = require("react");
 const shallow_1 = require("zustand/shallow");
-const providers_1 = require("../providers");
 const stores_1 = require("../stores");
 const events_1 = require("../types/events");
+const useAccount_1 = require("./useAccount");
 const useWidgetEvents_1 = require("./useWidgetEvents");
 const useRouteExecution = ({ routeId, executeInBackground, onAcceptExchangeRateUpdate, }) => {
-    const lifi = (0, providers_1.useLiFi)();
     const queryClient = (0, react_query_1.useQueryClient)();
-    const { account, switchChain } = (0, providers_1.useWallet)();
+    const { account } = (0, useAccount_1.useAccount)();
     const resumedAfterMount = (0, react_1.useRef)(false);
     const emitter = (0, useWidgetEvents_1.useWidgetEvents)();
     const routeExecutionStoreContext = (0, stores_1.useRouteExecutionStoreContext)();
@@ -42,20 +42,6 @@ const useRouteExecution = ({ routeId, executeInBackground, onAcceptExchangeRateU
         }
         console.log('Route updated.', clonedUpdatedRoute);
     };
-    const switchChainHook = async (requiredChainId) => {
-        if (!account.isActive || !account.signer) {
-            return account.signer;
-        }
-        const currentChainId = await account.signer.getChainId();
-        if (currentChainId !== requiredChainId) {
-            const signer = await switchChain(requiredChainId);
-            if (!signer) {
-                throw new Error('Chain was not switched.');
-            }
-            return signer;
-        }
-        return account.signer;
-    };
     const acceptExchangeRateUpdateHook = async (params) => {
         if (!onAcceptExchangeRateUpdate) {
             return false;
@@ -63,22 +49,22 @@ const useRouteExecution = ({ routeId, executeInBackground, onAcceptExchangeRateU
         const accepted = await new Promise((resolve) => onAcceptExchangeRateUpdate(resolve, params));
         return accepted;
     };
-    const executeRouteMutation = (0, react_query_1.useMutation)(() => {
-        if (!account.signer) {
-            throw Error('Account signer not found.');
-        }
-        if (!routeExecution?.route) {
-            throw Error('Execution route not found.');
-        }
-        queryClient.removeQueries(['routes'], { exact: false });
-        return lifi.executeRoute(account.signer, routeExecution.route, {
-            updateRouteHook,
-            switchChainHook,
-            acceptExchangeRateUpdateHook,
-            infiniteApproval: false,
-            executeInBackground,
-        });
-    }, {
+    const executeRouteMutation = (0, react_query_1.useMutation)({
+        mutationFn: () => {
+            if (!account.isConnected) {
+                throw Error('Account is not connected.');
+            }
+            if (!routeExecution?.route) {
+                throw Error('Execution route not found.');
+            }
+            queryClient.removeQueries({ queryKey: ['routes'], exact: false });
+            return (0, sdk_1.executeRoute)(routeExecution.route, {
+                updateRouteHook,
+                acceptExchangeRateUpdateHook,
+                infiniteApproval: false,
+                executeInBackground,
+            });
+        },
         onMutate: () => {
             console.log('Execution started.', routeId);
             if (routeExecution) {
@@ -86,26 +72,26 @@ const useRouteExecution = ({ routeId, executeInBackground, onAcceptExchangeRateU
             }
         },
     });
-    const resumeRouteMutation = (0, react_query_1.useMutation)((resumedRoute) => {
-        if (!account.signer) {
-            throw Error('Account signer not found.');
-        }
-        if (!routeExecution?.route) {
-            throw Error('Execution route not found.');
-        }
-        return lifi.resumeRoute(account.signer, resumedRoute ?? routeExecution.route, {
-            updateRouteHook,
-            switchChainHook,
-            acceptExchangeRateUpdateHook,
-            infiniteApproval: false,
-            executeInBackground,
-        });
-    }, {
+    const resumeRouteMutation = (0, react_query_1.useMutation)({
+        mutationFn: (resumedRoute) => {
+            if (!account.isConnected) {
+                throw Error('Account is not connected.');
+            }
+            if (!routeExecution?.route) {
+                throw Error('Execution route not found.');
+            }
+            return (0, sdk_1.resumeRoute)(resumedRoute ?? routeExecution.route, {
+                updateRouteHook,
+                acceptExchangeRateUpdateHook,
+                infiniteApproval: false,
+                executeInBackground,
+            });
+        },
         onMutate: () => {
             console.log('Resumed to execution.', routeId);
         },
     });
-    const executeRoute = (0, react_1.useCallback)(() => {
+    const _executeRoute = (0, react_1.useCallback)(() => {
         executeRouteMutation.mutateAsync(undefined, {
             onError: (error) => {
                 console.warn('Execution failed!', routeId, error);
@@ -115,7 +101,7 @@ const useRouteExecution = ({ routeId, executeInBackground, onAcceptExchangeRateU
             },
         });
     }, [executeRouteMutation, routeId]);
-    const resumeRoute = (0, react_1.useCallback)((route) => {
+    const _resumeRoute = (0, react_1.useCallback)((route) => {
         resumeRouteMutation.mutateAsync(route, {
             onError: (error) => {
                 console.warn('Resumed execution failed.', routeId, error);
@@ -127,9 +113,9 @@ const useRouteExecution = ({ routeId, executeInBackground, onAcceptExchangeRateU
     }, [resumeRouteMutation, routeId]);
     const restartRouteMutation = (0, react_1.useCallback)(() => {
         restartRoute(routeId);
-        resumeRoute(routeExecution?.route);
+        _resumeRoute(routeExecution?.route);
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [resumeRoute, routeExecution?.route, routeId]);
+    }, [_resumeRoute, routeExecution?.route, routeId]);
     const deleteRouteMutation = (0, react_1.useCallback)(() => {
         deleteRoute(routeId);
         // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -138,26 +124,26 @@ const useRouteExecution = ({ routeId, executeInBackground, onAcceptExchangeRateU
     (0, react_1.useEffect)(() => {
         // Check if route is eligible for automatic resuming
         if ((0, stores_1.isRouteActive)(routeExecution?.route) &&
-            account.isActive &&
+            account.isConnected &&
             !resumedAfterMount.current) {
             resumedAfterMount.current = true;
-            resumeRoute();
+            _resumeRoute();
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [account.isActive]);
+    }, [account.isConnected]);
     (0, react_1.useEffect)(() => {
         return () => {
             const route = routeExecutionStoreContext.getState().routes[routeId]?.route;
             if (!route || !(0, stores_1.isRouteActive)(route)) {
                 return;
             }
-            lifi.updateRouteExecution(route, { executeInBackground: true });
+            (0, sdk_1.updateRouteExecution)(route, { executeInBackground: true });
             console.log('Move route execution to background.', routeId);
             resumedAfterMount.current = false;
         };
-    }, [lifi, routeExecutionStoreContext, routeId]);
+    }, [routeExecutionStoreContext, routeId]);
     return {
-        executeRoute,
+        executeRoute: _executeRoute,
         restartRoute: restartRouteMutation,
         deleteRoute: deleteRouteMutation,
         route: routeExecution?.route,

package/cjs/hooks/useRoutes.d.ts

@@ -9,6 +9,6 @@ export declare const useRoutes: ({ insurableRoute }?: RoutesProps) => {
     isFetched: boolean;
     dataUpdatedAt: number;
     refetchTime: number;
-    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<RoutesResponse, unknown>>;
+    refetch: (options?: import("@tanstack/query-core/build/legacy/queryClient-IoYjXsnV").Z | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-IoYjXsnV").ac<RoutesResponse, Error>>;
 };
 export {};