@lifi/widget 0.0.0-preview-6cc63bac

package/dist/esm/hooks/useRouteExecution.js

@@ -0,0 +1,156 @@
+import { useWidgetEvents } from "./useWidgetEvents.js";
+import "../types/events.js";
+import { useWidgetConfig } from "../providers/WidgetProvider/WidgetProvider.js";
+import { useSDKClient } from "../providers/SDKClientProvider.js";
+import { getQueryKey } from "../utils/queries.js";
+import { getUpdatedAction, isRouteActive, isRouteDone, isRouteFailed } from "../stores/routes/utils.js";
+import { useRouteExecutionStore, useRouteExecutionStoreContext } from "../stores/routes/RouteExecutionStore.js";
+import { executeRoute, resumeRoute, updateRouteExecution } from "@lifi/sdk";
+import { useCallback, useEffect, useRef } from "react";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useAccount } from "@lifi/wallet-management";
+//#region src/hooks/useRouteExecution.ts
+const useRouteExecution = ({ routeId, executeInBackground, onAcceptExchangeRateUpdate }) => {
+	const queryClient = useQueryClient();
+	const { account } = useAccount();
+	const resumedAfterMount = useRef(false);
+	const { keyPrefix } = useWidgetConfig();
+	const sdkClient = useSDKClient();
+	const emitter = useWidgetEvents();
+	const routeExecutionStoreContext = useRouteExecutionStoreContext();
+	const routeExecution = useRouteExecutionStore((state) => state.routes[routeId]);
+	const [updateRoute, deleteRoute] = useRouteExecutionStore((state) => [state.updateRoute, state.deleteRoute]);
+	const updateRouteHook = (updatedRoute) => {
+		const routeExecution = routeExecutionStoreContext.getState().routes[updatedRoute.id];
+		if (!routeExecution) return;
+		const clonedUpdatedRoute = structuredClone(updatedRoute);
+		updateRoute(clonedUpdatedRoute);
+		const action = getUpdatedAction(routeExecution.route, clonedUpdatedRoute);
+		if (action) emitter.emit("routeExecutionUpdated", {
+			route: clonedUpdatedRoute,
+			action
+		});
+		const executionCompleted = isRouteDone(clonedUpdatedRoute);
+		const executionFailed = isRouteFailed(clonedUpdatedRoute);
+		if (executionCompleted) emitter.emit("routeExecutionCompleted", clonedUpdatedRoute);
+		if (executionFailed && action) emitter.emit("routeExecutionFailed", {
+			route: clonedUpdatedRoute,
+			action
+		});
+		if (executionCompleted || executionFailed) {
+			const invalidateKeys = [
+				[
+					getQueryKey("token-balances", keyPrefix),
+					clonedUpdatedRoute.fromAddress,
+					clonedUpdatedRoute.fromChainId
+				],
+				[
+					getQueryKey("token-balances", keyPrefix),
+					clonedUpdatedRoute.toAddress,
+					clonedUpdatedRoute.toChainId
+				],
+				[getQueryKey("transaction-history", keyPrefix)]
+			];
+			for (const key of invalidateKeys) queryClient.invalidateQueries({
+				queryKey: key,
+				exact: false,
+				refetchType: "all"
+			}, { cancelRefetch: false });
+		}
+		console.log("Route updated.", clonedUpdatedRoute);
+	};
+	const acceptExchangeRateUpdateHook = async (params) => {
+		if (!onAcceptExchangeRateUpdate) return false;
+		return await new Promise((resolve) => onAcceptExchangeRateUpdate(resolve, params));
+	};
+	const executeRouteMutation = useMutation({
+		mutationFn: () => {
+			if (!account.isConnected) throw new Error("Account is not connected.");
+			if (!routeExecution?.route) throw new Error("Execution route not found.");
+			queryClient.removeQueries({
+				queryKey: [getQueryKey("routes", keyPrefix)],
+				exact: false
+			});
+			return executeRoute(sdkClient, routeExecution.route, {
+				updateRouteHook,
+				acceptExchangeRateUpdateHook,
+				executeInBackground,
+				...sdkClient.config?.executionOptions
+			});
+		},
+		onMutate: () => {
+			console.log("Execution started.", routeId);
+			if (routeExecution) emitter.emit("routeExecutionStarted", routeExecution.route);
+		},
+		onError: (error) => {
+			console.warn("Execution failed!", routeId, error);
+		},
+		onSuccess: (route) => {
+			console.log("Executed successfully!", route);
+		}
+	});
+	const resumeRouteMutation = useMutation({
+		mutationFn: (args) => {
+			if (!account.isConnected) throw new Error("Account is not connected.");
+			if (!routeExecution?.route) throw new Error("Execution route not found.");
+			return resumeRoute(sdkClient, args?.route ?? routeExecution.route, {
+				updateRouteHook,
+				acceptExchangeRateUpdateHook,
+				executeInBackground: args?.executeInBackground ?? executeInBackground
+			});
+		},
+		onMutate: () => {
+			console.log("Resumed to execution.", routeId);
+		},
+		onError: (error) => {
+			console.warn("Resumed execution failed.", routeId, error);
+		},
+		onSuccess: (route) => {
+			console.log("Resumed execution successful.", route);
+		}
+	});
+	const _executeRoute = useCallback(() => {
+		executeRouteMutation.mutateAsync(void 0);
+	}, [executeRouteMutation]);
+	const _resumeRoute = useCallback((route) => {
+		resumeRouteMutation.mutateAsync({ route });
+	}, [resumeRouteMutation]);
+	const restartRouteMutation = useCallback(() => {
+		resumeRouteMutation.mutateAsync({
+			route: routeExecution?.route,
+			executeInBackground: false
+		});
+	}, [resumeRouteMutation, routeExecution?.route]);
+	const deleteRouteMutation = useCallback(() => {
+		deleteRoute(routeId);
+	}, [routeId]);
+	useEffect(() => {
+		const route = routeExecutionStoreContext.getState().routes[routeId]?.route;
+		if (isRouteActive(route) && account.isConnected && !resumedAfterMount.current) {
+			resumedAfterMount.current = true;
+			_resumeRoute();
+		}
+		return () => {
+			const route = routeExecutionStoreContext.getState().routes[routeId]?.route;
+			if (!route || !isRouteActive(route)) return;
+			updateRouteExecution(route, { executeInBackground: true });
+			console.log("Move route execution to background.", routeId);
+			resumedAfterMount.current = false;
+		};
+	}, [
+		account.isConnected,
+		routeExecutionStoreContext,
+		routeId
+	]);
+	return {
+		executeRoute: _executeRoute,
+		restartRoute: restartRouteMutation,
+		deleteRoute: deleteRouteMutation,
+		route: routeExecution?.route,
+		status: routeExecution?.status
+	};
+};
+//#endregion
+export { useRouteExecution };
+
+//# sourceMappingURL=useRouteExecution.js.map

package/dist/esm/hooks/useRouteExecution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRouteExecution.js","names":[],"sources":["../../../src/hooks/useRouteExecution.ts"],"sourcesContent":["import type { ExchangeRateUpdateParams, Route, RouteExtended } from '@lifi/sdk'\nimport { executeRoute, resumeRoute, updateRouteExecution } from '@lifi/sdk'\nimport { useAccount } from '@lifi/wallet-management'\nimport { useMutation, useQueryClient } from '@tanstack/react-query'\nimport { useCallback, useEffect, useRef } from 'react'\nimport { useSDKClient } from '../providers/SDKClientProvider.js'\nimport { useWidgetConfig } from '../providers/WidgetProvider/WidgetProvider.js'\nimport {\n  useRouteExecutionStore,\n  useRouteExecutionStoreContext,\n} from '../stores/routes/RouteExecutionStore.js'\nimport type { RouteExecutionStatus } from '../stores/routes/types.js'\nimport {\n  getUpdatedAction,\n  isRouteActive,\n  isRouteDone,\n  isRouteFailed,\n} from '../stores/routes/utils.js'\nimport { WidgetEvent } from '../types/events.js'\nimport { getQueryKey } from '../utils/queries.js'\nimport { useWidgetEvents } from './useWidgetEvents.js'\n\ninterface RouteExecutionProps {\n  routeId: string\n  executeInBackground?: boolean\n  onAcceptExchangeRateUpdate?(\n    resolver: (value: boolean) => void,\n    data: ExchangeRateUpdateParams\n  ): void\n}\n\nexport const useRouteExecution = ({\n  routeId,\n  executeInBackground,\n  onAcceptExchangeRateUpdate,\n}: RouteExecutionProps): {\n  executeRoute: () => void\n  restartRoute: () => void\n  deleteRoute: () => void\n  route: RouteExtended | undefined\n  status: RouteExecutionStatus | undefined\n} => {\n  const queryClient = useQueryClient()\n  const { account } = useAccount()\n  const resumedAfterMount = useRef(false)\n  const { keyPrefix } = useWidgetConfig()\n  const sdkClient = useSDKClient()\n  const emitter = useWidgetEvents()\n  const routeExecutionStoreContext = useRouteExecutionStoreContext()\n  const routeExecution = useRouteExecutionStore(\n    (state) => state.routes[routeId]\n  )\n  const [updateRoute, deleteRoute] = useRouteExecutionStore((state) => [\n    state.updateRoute,\n    state.deleteRoute,\n  ])\n\n  const updateRouteHook = (updatedRoute: Route) => {\n    const routeExecution =\n      routeExecutionStoreContext.getState().routes[updatedRoute.id]\n    if (!routeExecution) {\n      return\n    }\n    const clonedUpdatedRoute = structuredClone(updatedRoute)\n    updateRoute(clonedUpdatedRoute)\n    const action = getUpdatedAction(routeExecution.route, clonedUpdatedRoute)\n    if (action) {\n      emitter.emit(WidgetEvent.RouteExecutionUpdated, {\n        route: clonedUpdatedRoute,\n        action,\n      })\n    }\n    const executionCompleted = isRouteDone(clonedUpdatedRoute)\n    const executionFailed = isRouteFailed(clonedUpdatedRoute)\n    if (executionCompleted) {\n      emitter.emit(WidgetEvent.RouteExecutionCompleted, clonedUpdatedRoute)\n    }\n    if (executionFailed && action) {\n      emitter.emit(WidgetEvent.RouteExecutionFailed, {\n        route: clonedUpdatedRoute,\n        action,\n      })\n    }\n    if (executionCompleted || executionFailed) {\n      const invalidateKeys = [\n        [\n          getQueryKey('token-balances', keyPrefix),\n          clonedUpdatedRoute.fromAddress,\n          clonedUpdatedRoute.fromChainId,\n        ],\n        [\n          getQueryKey('token-balances', keyPrefix),\n          clonedUpdatedRoute.toAddress,\n          clonedUpdatedRoute.toChainId,\n        ],\n        [getQueryKey('transaction-history', keyPrefix)],\n      ]\n      for (const key of invalidateKeys) {\n        queryClient.invalidateQueries(\n          {\n            queryKey: key,\n            exact: false,\n            refetchType: 'all',\n          },\n          { cancelRefetch: false }\n        )\n      }\n    }\n    // biome-ignore lint/suspicious/noConsole: logs route information\n    console.log('Route updated.', clonedUpdatedRoute)\n  }\n\n  const acceptExchangeRateUpdateHook = async (\n    params: ExchangeRateUpdateParams\n  ) => {\n    if (!onAcceptExchangeRateUpdate) {\n      return false\n    }\n\n    const accepted = await new Promise<boolean>((resolve) =>\n      onAcceptExchangeRateUpdate(resolve, params)\n    )\n\n    return accepted\n  }\n\n  const executeRouteMutation = useMutation({\n    mutationFn: () => {\n      if (!account.isConnected) {\n        throw new Error('Account is not connected.')\n      }\n      if (!routeExecution?.route) {\n        throw new Error('Execution route not found.')\n      }\n      queryClient.removeQueries({\n        queryKey: [getQueryKey('routes', keyPrefix)],\n        exact: false,\n      })\n      return executeRoute(sdkClient, routeExecution.route, {\n        updateRouteHook,\n        acceptExchangeRateUpdateHook,\n        executeInBackground,\n        ...sdkClient.config?.executionOptions,\n      })\n    },\n    onMutate: () => {\n      // biome-ignore lint/suspicious/noConsole: logs route information\n      console.log('Execution started.', routeId)\n      if (routeExecution) {\n        emitter.emit(WidgetEvent.RouteExecutionStarted, routeExecution.route)\n      }\n    },\n    onError: (error) => {\n      console.warn('Execution failed!', routeId, error)\n    },\n    onSuccess: (route: Route) => {\n      // biome-ignore lint/suspicious/noConsole: logs route information\n      console.log('Executed successfully!', route)\n    },\n  })\n\n  const resumeRouteMutation = useMutation({\n    mutationFn: (args?: { route?: Route; executeInBackground?: boolean }) => {\n      if (!account.isConnected) {\n        throw new Error('Account is not connected.')\n      }\n      if (!routeExecution?.route) {\n        throw new Error('Execution route not found.')\n      }\n      return resumeRoute(sdkClient, args?.route ?? routeExecution.route, {\n        updateRouteHook,\n        acceptExchangeRateUpdateHook,\n        executeInBackground: args?.executeInBackground ?? executeInBackground,\n      })\n    },\n    onMutate: () => {\n      // biome-ignore lint/suspicious/noConsole: logs route information\n      console.log('Resumed to execution.', routeId)\n    },\n    onError: (error) => {\n      console.warn('Resumed execution failed.', routeId, error)\n    },\n    onSuccess: (route) => {\n      // biome-ignore lint/suspicious/noConsole: logs route information\n      console.log('Resumed execution successful.', route)\n    },\n  })\n\n  const _executeRoute = useCallback(() => {\n    executeRouteMutation.mutateAsync(undefined)\n  }, [executeRouteMutation])\n\n  const _resumeRoute = useCallback(\n    (route?: Route) => {\n      resumeRouteMutation.mutateAsync({ route })\n    },\n    [resumeRouteMutation]\n  )\n\n  const restartRouteMutation = useCallback(() => {\n    resumeRouteMutation.mutateAsync({\n      route: routeExecution?.route,\n      executeInBackground: false,\n    })\n  }, [resumeRouteMutation, routeExecution?.route])\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: run only when routeId changes\n  const deleteRouteMutation = useCallback(() => {\n    deleteRoute(routeId)\n  }, [routeId])\n\n  // Resume route execution after page reload\n  // biome-ignore lint/correctness/useExhaustiveDependencies: run only when routeId changes\n  useEffect(() => {\n    // Check if route is eligible for automatic resuming\n    const route = routeExecutionStoreContext.getState().routes[routeId]?.route\n    if (\n      isRouteActive(route) &&\n      account.isConnected &&\n      !resumedAfterMount.current\n    ) {\n      resumedAfterMount.current = true\n      _resumeRoute()\n    }\n\n    // Move execution to background on unmount\n    return () => {\n      const route = routeExecutionStoreContext.getState().routes[routeId]?.route\n      if (!route || !isRouteActive(route)) {\n        return\n      }\n      updateRouteExecution(route, { executeInBackground: true })\n      // biome-ignore lint/suspicious/noConsole: logs route information\n      console.log('Move route execution to background.', routeId)\n      resumedAfterMount.current = false\n    }\n  }, [account.isConnected, routeExecutionStoreContext, routeId])\n\n  return {\n    executeRoute: _executeRoute,\n    restartRoute: restartRouteMutation,\n    deleteRoute: deleteRouteMutation,\n    route: routeExecution?.route,\n    status: routeExecution?.status,\n  }\n}\n"],"mappings":"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"}

package/dist/esm/hooks/useRouteExecutionMessage.js

@@ -0,0 +1,61 @@
+import { useWidgetConfig } from "../providers/WidgetProvider/WidgetProvider.js";
+import { useAvailableChains } from "./useAvailableChains.js";
+import { getActionMessage } from "../utils/getActionMessage.js";
+import { getErrorMessage } from "../utils/getErrorMessage.js";
+import { useTranslation } from "react-i18next";
+//#region src/hooks/useRouteExecutionMessage.ts
+const useRouteExecutionMessage = (route, status) => {
+	const { mode, modeOptions } = useWidgetConfig();
+	const { t } = useTranslation();
+	const { getChainById } = useAvailableChains();
+	const transactionType = route.fromChainId === route.toChainId ? "swap" : "bridge";
+	let title;
+	let message;
+	switch (status) {
+		case 2: {
+			const activeStep = route.steps.find((s) => s.execution?.status === "PENDING" || s.execution?.status === "ACTION_REQUIRED") ?? route.steps.at(-1);
+			const lastAction = activeStep?.execution?.actions?.at(-1);
+			const actionMessage = activeStep && lastAction ? getActionMessage(t, activeStep, lastAction.type, lastAction.status, lastAction.substatus, mode, modeOptions) : void 0;
+			title = actionMessage?.title ?? t(`main.process.${transactionType}.pending`);
+			message = actionMessage?.message;
+			break;
+		}
+		case 4:
+			title = mode === "custom" ? t(`success.title.${modeOptions?.custom?.type ?? "checkout"}Successful`) : t(`success.title.${transactionType}Successful`);
+			break;
+		case 20:
+			title = t(`success.title.${transactionType}PartiallySuccessful`);
+			message = t("success.message.exchangePartiallySuccessful", {
+				tool: route.steps.at(-1)?.toolDetails.name,
+				tokenSymbol: route.steps.at(-1)?.action.toToken.symbol
+			});
+			break;
+		case 36:
+			title = t("success.title.refundIssued");
+			message = t("success.message.exchangePartiallySuccessful", {
+				tool: route.steps.at(-1)?.toolDetails.name,
+				tokenSymbol: route.steps.at(-1)?.action.toToken.symbol
+			});
+			break;
+		case 8: {
+			const step = route.steps.find((step) => step.execution?.status === "FAILED");
+			if (!step) break;
+			const actionMessage = getErrorMessage(t, getChainById, step, step.execution?.actions?.find((action) => action.status === "FAILED") || {
+				status: "FAILED",
+				type: "EXECUTION",
+				error: step.execution?.error
+			});
+			title = actionMessage.title;
+			message = actionMessage.message;
+			break;
+		}
+	}
+	return {
+		title,
+		message
+	};
+};
+//#endregion
+export { useRouteExecutionMessage };
+
+//# sourceMappingURL=useRouteExecutionMessage.js.map

package/dist/esm/hooks/useRouteExecutionMessage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRouteExecutionMessage.js","names":[],"sources":["../../../src/hooks/useRouteExecutionMessage.ts"],"sourcesContent":["import type { ExecutionActionType, RouteExtended } from '@lifi/sdk'\nimport { useTranslation } from 'react-i18next'\nimport { useWidgetConfig } from '../providers/WidgetProvider/WidgetProvider.js'\nimport { RouteExecutionStatus } from '../stores/routes/types.js'\nimport { getActionMessage } from '../utils/getActionMessage.js'\nimport { getErrorMessage } from '../utils/getErrorMessage.js'\nimport { useAvailableChains } from './useAvailableChains.js'\n\nexport const useRouteExecutionMessage = (\n  route: RouteExtended,\n  status: RouteExecutionStatus\n): { title: string | undefined; message: string | undefined } => {\n  const { mode, modeOptions } = useWidgetConfig()\n  const { t } = useTranslation()\n  const { getChainById } = useAvailableChains()\n\n  const transactionType =\n    route.fromChainId === route.toChainId ? 'swap' : 'bridge'\n\n  let title: string | undefined\n  let message: string | undefined\n\n  switch (status) {\n    case RouteExecutionStatus.Pending: {\n      // Use the first executing step, not the last one — in a multi-step route\n      // the active step is often not the last.\n      const activeStep =\n        route.steps.find(\n          (s) =>\n            s.execution?.status === 'PENDING' ||\n            s.execution?.status === 'ACTION_REQUIRED'\n        ) ?? route.steps.at(-1)\n      const lastAction = activeStep?.execution?.actions?.at(-1)\n      const actionMessage =\n        activeStep && lastAction\n          ? getActionMessage(\n              t,\n              activeStep,\n              lastAction.type,\n              lastAction.status,\n              lastAction.substatus,\n              mode,\n              modeOptions\n            )\n          : undefined\n      // Fall back to a generic title when the step has no action to describe yet\n      // (just after a restart, or before the first action exists).\n      title =\n        actionMessage?.title ?? t(`main.process.${transactionType}.pending`)\n      message = actionMessage?.message\n      break\n    }\n    case RouteExecutionStatus.Done: {\n      title =\n        mode === 'custom'\n          ? t(\n              `success.title.${modeOptions?.custom?.type ?? 'checkout'}Successful`\n            )\n          : t(`success.title.${transactionType}Successful`)\n      break\n    }\n    case RouteExecutionStatus.Done | RouteExecutionStatus.Partial: {\n      title = t(`success.title.${transactionType}PartiallySuccessful`)\n      message = t('success.message.exchangePartiallySuccessful', {\n        tool: route.steps.at(-1)?.toolDetails.name,\n        tokenSymbol: route.steps.at(-1)?.action.toToken.symbol,\n      })\n      break\n    }\n    case RouteExecutionStatus.Done | RouteExecutionStatus.Refunded: {\n      title = t('success.title.refundIssued')\n      message = t('success.message.exchangePartiallySuccessful', {\n        tool: route.steps.at(-1)?.toolDetails.name,\n        tokenSymbol: route.steps.at(-1)?.action.toToken.symbol,\n      })\n      break\n    }\n    case RouteExecutionStatus.Failed: {\n      const step = route.steps.find(\n        (step) => step.execution?.status === 'FAILED'\n      )\n      if (!step) {\n        break\n      }\n      const action = step.execution?.actions?.find(\n        (action) => action.status === 'FAILED'\n      ) || {\n        status: 'FAILED',\n        type: 'EXECUTION' as ExecutionActionType,\n        error: step.execution?.error,\n      } // synthetic action to represent a failed execution with no actions\n      const actionMessage = getErrorMessage(t, getChainById, step, action)\n      title = actionMessage.title\n      message = actionMessage.message\n      break\n    }\n  }\n\n  return { title, message }\n}\n"],"mappings":";;;;;;AAQA,MAAa,4BACX,OACA,WAC+D;CAC/D,MAAM,EAAE,MAAM,gBAAgB,gBAAgB;CAC9C,MAAM,EAAE,MAAM,eAAe;CAC7B,MAAM,EAAE,iBAAiB,mBAAmB;CAE5C,MAAM,kBACJ,MAAM,gBAAgB,MAAM,YAAY,SAAS;CAEnD,IAAI;CACJ,IAAI;CAEJ,QAAQ,QAAR;EACE,KAAA,GAAmC;GAGjC,MAAM,aACJ,MAAM,MAAM,MACT,MACC,EAAE,WAAW,WAAW,aACxB,EAAE,WAAW,WAAW,iBAC5B,KAAK,MAAM,MAAM,GAAG,EAAE;GACxB,MAAM,aAAa,YAAY,WAAW,SAAS,GAAG,EAAE;GACxD,MAAM,gBACJ,cAAc,aACV,iBACE,GACA,YACA,WAAW,MACX,WAAW,QACX,WAAW,WACX,MACA,WACF,IACA,KAAA;GAGN,QACE,eAAe,SAAS,EAAE,gBAAgB,gBAAgB,SAAS;GACrE,UAAU,eAAe;GACzB;EACF;EACA,KAAA;GACE,QACE,SAAS,WACL,EACE,iBAAiB,aAAa,QAAQ,QAAQ,WAAW,WAC3D,IACA,EAAE,iBAAiB,gBAAgB,WAAW;GACpD;EAEF,KAAA;GACE,QAAQ,EAAE,iBAAiB,gBAAgB,oBAAoB;GAC/D,UAAU,EAAE,+CAA+C;IACzD,MAAM,MAAM,MAAM,GAAG,EAAE,GAAG,YAAY;IACtC,aAAa,MAAM,MAAM,GAAG,EAAE,GAAG,OAAO,QAAQ;GAClD,CAAC;GACD;EAEF,KAAA;GACE,QAAQ,EAAE,4BAA4B;GACtC,UAAU,EAAE,+CAA+C;IACzD,MAAM,MAAM,MAAM,GAAG,EAAE,GAAG,YAAY;IACtC,aAAa,MAAM,MAAM,GAAG,EAAE,GAAG,OAAO,QAAQ;GAClD,CAAC;GACD;EAEF,KAAA,GAAkC;GAChC,MAAM,OAAO,MAAM,MAAM,MACtB,SAAS,KAAK,WAAW,WAAW,QACvC;GACA,IAAI,CAAC,MACH;GASF,MAAM,gBAAgB,gBAAgB,GAAG,cAAc,MAPxC,KAAK,WAAW,SAAS,MACrC,WAAW,OAAO,WAAW,QAChC,KAAK;IACH,QAAQ;IACR,MAAM;IACN,OAAO,KAAK,WAAW;GACzB,CACmE;GACnE,QAAQ,cAAc;GACtB,UAAU,cAAc;GACxB;EACF;CACF;CAEA,OAAO;EAAE;EAAO;CAAQ;AAC1B"}

package/dist/esm/hooks/useRouteRequiredAccountConnection.js

@@ -0,0 +1,37 @@
+import { useFieldValues } from "../stores/form/useFieldValues.js";
+import { useChain } from "./useChain.js";
+import { useMemo } from "react";
+import { useAccount } from "@lifi/wallet-management";
+//#region src/hooks/useRouteRequiredAccountConnection.ts
+const useRouteRequiredAccountConnection = (route, chain) => {
+	const { account, accounts } = useAccount({ chainType: chain?.chainType });
+	const [toAddress] = useFieldValues("toAddress");
+	const { getChainById } = useChain();
+	return useMemo(() => {
+		if (!route?.steps.length) return { connected: account.isConnected };
+		const connectedChainTypes = new Map(accounts.filter((account) => account.isConnected && account.address).map((account) => [account.chainType, account]));
+		if (!connectedChainTypes.size) return { connected: false };
+		for (const step of route.steps) {
+			const chain = getChainById(step.action.fromChainId);
+			if (!chain) continue;
+			const connectedAccount = connectedChainTypes.get(chain.chainType);
+			const isToAddressSatisfied = toAddress ? connectedAccount?.address === step.action.fromAddress : true;
+			if (!connectedAccount || !isToAddressSatisfied) return {
+				connected: false,
+				missingChain: chain,
+				missingAccountAddress: !isToAddressSatisfied ? step.action.fromAddress : void 0
+			};
+		}
+		return { connected: true };
+	}, [
+		account.isConnected,
+		route,
+		accounts,
+		getChainById,
+		toAddress
+	]);
+};
+//#endregion
+export { useRouteRequiredAccountConnection };
+
+//# sourceMappingURL=useRouteRequiredAccountConnection.js.map

package/dist/esm/hooks/useRouteRequiredAccountConnection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRouteRequiredAccountConnection.js","names":[],"sources":["../../../src/hooks/useRouteRequiredAccountConnection.ts"],"sourcesContent":["import type { ExtendedChain, Route } from '@lifi/sdk'\nimport { useAccount } from '@lifi/wallet-management'\nimport { useMemo } from 'react'\nimport { useFieldValues } from '../stores/form/useFieldValues.js'\nimport { useChain } from './useChain.js'\n\nexport const useRouteRequiredAccountConnection = (\n  route?: Route,\n  chain?: ExtendedChain\n): {\n  connected: boolean\n  missingChain?: ExtendedChain\n  missingAccountAddress?: string\n} => {\n  const { account, accounts } = useAccount({ chainType: chain?.chainType })\n  const [toAddress] = useFieldValues('toAddress')\n  const { getChainById } = useChain()\n\n  return useMemo(() => {\n    if (!route?.steps.length) {\n      return {\n        connected: account.isConnected,\n      }\n    }\n\n    const connectedChainTypes = new Map(\n      accounts\n        .filter((account) => account.isConnected && account.address)\n        .map((account) => [account.chainType, account])\n    )\n\n    if (!connectedChainTypes.size) {\n      return {\n        connected: false,\n      }\n    }\n\n    for (const step of route.steps) {\n      const chain = getChainById(step.action.fromChainId)\n      if (!chain) {\n        continue\n      }\n\n      const connectedAccount = connectedChainTypes.get(chain.chainType)\n      const isToAddressSatisfied = toAddress\n        ? connectedAccount?.address === step.action.fromAddress\n        : true\n\n      if (!connectedAccount || !isToAddressSatisfied) {\n        return {\n          connected: false,\n          missingChain: chain,\n          missingAccountAddress: !isToAddressSatisfied\n            ? step.action.fromAddress\n            : undefined,\n        }\n      }\n    }\n\n    return { connected: true }\n  }, [account.isConnected, route, accounts, getChainById, toAddress])\n}\n"],"mappings":";;;;;AAMA,MAAa,qCACX,OACA,UAKG;CACH,MAAM,EAAE,SAAS,aAAa,WAAW,EAAE,WAAW,OAAO,UAAU,CAAC;CACxE,MAAM,CAAC,aAAa,eAAe,WAAW;CAC9C,MAAM,EAAE,iBAAiB,SAAS;CAElC,OAAO,cAAc;EACnB,IAAI,CAAC,OAAO,MAAM,QAChB,OAAO,EACL,WAAW,QAAQ,YACrB;EAGF,MAAM,sBAAsB,IAAI,IAC9B,SACG,QAAQ,YAAY,QAAQ,eAAe,QAAQ,OAAO,EAC1D,KAAK,YAAY,CAAC,QAAQ,WAAW,OAAO,CAAC,CAClD;EAEA,IAAI,CAAC,oBAAoB,MACvB,OAAO,EACL,WAAW,MACb;EAGF,KAAK,MAAM,QAAQ,MAAM,OAAO;GAC9B,MAAM,QAAQ,aAAa,KAAK,OAAO,WAAW;GAClD,IAAI,CAAC,OACH;GAGF,MAAM,mBAAmB,oBAAoB,IAAI,MAAM,SAAS;GAChE,MAAM,uBAAuB,YACzB,kBAAkB,YAAY,KAAK,OAAO,cAC1C;GAEJ,IAAI,CAAC,oBAAoB,CAAC,sBACxB,OAAO;IACL,WAAW;IACX,cAAc;IACd,uBAAuB,CAAC,uBACpB,KAAK,OAAO,cACZ,KAAA;GACN;EAEJ;EAEA,OAAO,EAAE,WAAW,KAAK;CAC3B,GAAG;EAAC,QAAQ;EAAa;EAAO;EAAU;EAAc;CAAS,CAAC;AACpE"}

package/dist/esm/hooks/useRoutes.js

@@ -0,0 +1,303 @@
+import { useWidgetEvents } from "./useWidgetEvents.js";
+import "../types/events.js";
+import { useWidgetConfig } from "../providers/WidgetProvider/WidgetProvider.js";
+import { useSwapOnly } from "./useSwapOnly.js";
+import { useSDKClient } from "../providers/SDKClientProvider.js";
+import { getQueryKey } from "../utils/queries.js";
+import { useFieldValues } from "../stores/form/useFieldValues.js";
+import { useIntermediateRoutesStore } from "../stores/routes/useIntermediateRoutesStore.js";
+import { useSetExecutableRoute } from "../stores/routes/useSetExecutableRoute.js";
+import { useSettings } from "../stores/settings/useSettings.js";
+import { updateTokenInCache } from "../utils/token.js";
+import { useChain } from "./useChain.js";
+import { useDebouncedWatch } from "./useDebouncedWatch.js";
+import { useGasRefuel } from "./useGasRefuel.js";
+import { useIsBatchingSupported } from "./useIsBatchingSupported.js";
+import { useToken } from "./useToken.js";
+import { ChainType, LiFiErrorCode, convertQuoteToRoute, getContractCallsQuote, getRelayerQuote, getRoutes, parseUnits } from "@lifi/sdk";
+import { useCallback, useMemo } from "react";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useChainTypeFromAddress, useEthereumContext } from "@lifi/widget-provider";
+import { useAccount } from "@lifi/wallet-management";
+//#region src/hooks/useRoutes.ts
+const refetchTime = 6e4;
+const useRoutes = ({ observableRoute } = {}) => {
+	const { mode, modeOptions, contractTool, bridges, exchanges, feeConfig, useRelayerRoutes, keyPrefix } = useWidgetConfig();
+	const sdkClient = useSDKClient();
+	const setExecutableRoute = useSetExecutableRoute();
+	const queryClient = useQueryClient();
+	const emitter = useWidgetEvents();
+	const swapOnly = useSwapOnly();
+	const { disabledBridges, disabledExchanges, enabledBridges, enabledExchanges, enabledAutoRefuel, routePriority, slippage } = useSettings([
+		"disabledBridges",
+		"disabledExchanges",
+		"enabledBridges",
+		"enabledExchanges",
+		"enabledAutoRefuel",
+		"routePriority",
+		"slippage"
+	]);
+	const [fromTokenAmount] = useDebouncedWatch(500, "fromAmount");
+	const [fromChainId, fromTokenAddress, toAddress, toTokenAmount, toChainId, toTokenAddress, contractCalls] = useFieldValues("fromChain", "fromToken", "toAddress", "toAmount", "toChain", "toToken", "contractCalls");
+	const { token: fromToken } = useToken(fromChainId, fromTokenAddress);
+	const { token: toToken } = useToken(toChainId, toTokenAddress);
+	const { chain: fromChain } = useChain(fromChainId);
+	const { chain: toChain } = useChain(toChainId);
+	const { enabled: enabledRefuel, fromAmount: gasRecommendationFromAmount } = useGasRefuel();
+	const { getChainTypeFromAddress } = useChainTypeFromAddress();
+	const { isGaslessStep, disableMessageSigning } = useEthereumContext();
+	const { account } = useAccount({ chainType: fromChain?.chainType });
+	const { isBatchingSupported, isBatchingSupportedLoading } = useIsBatchingSupported(fromChain, account.address);
+	const hasAmount = Number(fromTokenAmount) > 0 || Number(toTokenAmount) > 0;
+	const contractCallQuoteEnabled = mode === "custom" ? Boolean(contractCalls && account.address) : true;
+	const hasToAddressAndChainTypeSatisfied = !!toChain && !!toAddress && getChainTypeFromAddress(toAddress) === toChain.chainType;
+	const isToAddressSatisfied = toAddress ? hasToAddressAndChainTypeSatisfied : true;
+	const toWalletAddress = toAddress || void 0;
+	const allowedBridges = bridges?.allow?.length || bridges?.deny?.length ? enabledBridges : void 0;
+	const allowedExchanges = exchanges?.allow?.length || exchanges?.deny?.length ? enabledExchanges : void 0;
+	const allowSwitchChain = sdkClient.config?.routeOptions?.allowSwitchChain;
+	const isEnabled = Boolean(Number(fromChain?.id)) && Boolean(Number(toChain?.id)) && Boolean(fromToken?.address) && Boolean(toToken?.address) && !Number.isNaN(slippage) && hasAmount && isToAddressSatisfied && contractCallQuoteEnabled && !isBatchingSupportedLoading;
+	const queryKey = useMemo(() => [
+		getQueryKey("routes", keyPrefix),
+		account.address,
+		fromChain?.id,
+		fromToken?.address,
+		fromTokenAmount,
+		toWalletAddress,
+		toChain?.id,
+		toToken?.address,
+		toTokenAmount,
+		contractCalls,
+		slippage,
+		swapOnly,
+		disabledBridges,
+		disabledExchanges,
+		allowedBridges,
+		allowedExchanges,
+		routePriority,
+		mode,
+		allowSwitchChain,
+		enabledRefuel && enabledAutoRefuel,
+		gasRecommendationFromAmount,
+		feeConfig?.fee,
+		disableMessageSigning,
+		!!isBatchingSupported,
+		observableRoute?.id
+	], [
+		keyPrefix,
+		account.address,
+		fromChain?.id,
+		fromToken?.address,
+		fromTokenAmount,
+		toWalletAddress,
+		toChain?.id,
+		toToken?.address,
+		toTokenAmount,
+		contractCalls,
+		slippage,
+		swapOnly,
+		disabledBridges,
+		disabledExchanges,
+		allowedBridges,
+		allowedExchanges,
+		routePriority,
+		mode,
+		allowSwitchChain,
+		enabledRefuel,
+		enabledAutoRefuel,
+		gasRecommendationFromAmount,
+		feeConfig?.fee,
+		disableMessageSigning,
+		isBatchingSupported,
+		observableRoute?.id
+	]);
+	const { getIntermediateRoutes, setIntermediateRoutes } = useIntermediateRoutesStore();
+	const { data, isLoading, isFetching, isFetched, dataUpdatedAt, refetch } = useQuery({
+		queryKey,
+		queryFn: async ({ queryKey: [_, fromAddress, fromChainId, fromTokenAddress, fromTokenAmount, toAddress, toChainId, toTokenAddress, toTokenAmount, contractCalls, slippage = void 0, swapOnly, disabledBridges, disabledExchanges, allowedBridges, allowedExchanges, routePriority, mode, allowSwitchChain, enabledRefuel, gasRecommendationFromAmount, configuredFee, disableMessageSigning, isBatchingSupported, _observableRouteId], signal }) => {
+			const fromAmount = parseUnits(fromTokenAmount, fromToken.decimals);
+			const toAmount = parseUnits(toTokenAmount, toToken.decimals);
+			const formattedSlippage = slippage ? Number.parseFloat(slippage) / 100 : void 0;
+			const allowBridges = swapOnly ? [] : observableRoute ? observableRoute.steps.flatMap((step) => step.includedSteps.reduce((toolKeys, includedStep) => {
+				if (includedStep.type === "cross") toolKeys.push(includedStep.toolDetails.key);
+				return toolKeys;
+			}, [])) : allowedBridges;
+			const allowExchanges = observableRoute ? observableRoute.steps.flatMap((step) => step.includedSteps.reduce((toolKeys, includedStep) => {
+				if (includedStep.type === "swap") toolKeys.push(includedStep.toolDetails.key);
+				return toolKeys;
+			}, [])) : allowedExchanges;
+			const calculatedFee = await feeConfig?.calculateFee?.({
+				fromChain,
+				toChain,
+				fromToken,
+				toToken,
+				fromAddress,
+				toAddress,
+				fromAmount,
+				toAmount,
+				slippage: formattedSlippage
+			});
+			if (mode === "custom" && contractCalls && toAmount) {
+				const contractCallQuote = await getContractCallsQuote(sdkClient, {
+					fromAddress,
+					fromChain: fromChainId,
+					fromToken: fromTokenAddress,
+					toAmount: toAmount.toString(),
+					toChain: toChainId,
+					toToken: toTokenAddress,
+					contractCalls,
+					denyBridges: disabledBridges.length ? disabledBridges : void 0,
+					denyExchanges: disabledExchanges.length ? disabledExchanges : void 0,
+					allowBridges,
+					allowExchanges,
+					toFallbackAddress: toAddress,
+					slippage: formattedSlippage,
+					fee: calculatedFee || configuredFee
+				}, { signal });
+				contractCallQuote.action.toToken = toToken;
+				const customStep = mode === "custom" ? contractCallQuote.includedSteps?.find((step) => step.type === "custom") : void 0;
+				if (customStep && contractTool) {
+					const toolDetails = {
+						key: contractTool.name,
+						name: contractTool.name,
+						logoURI: contractTool.logoURI
+					};
+					customStep.toolDetails = toolDetails;
+					contractCallQuote.toolDetails = toolDetails;
+				}
+				return [convertQuoteToRoute(contractCallQuote)];
+			}
+			if (fromChainId === toChainId && fromTokenAddress === toTokenAddress && !(mode === "custom" && modeOptions?.custom?.type === "deposit")) return;
+			const isObservableRelayerRoute = observableRoute?.steps?.some((step) => !!isGaslessStep?.(step, fromChain));
+			const shouldUseMainRoutes = !observableRoute || !isObservableRelayerRoute;
+			const shouldUseRelayerQuote = fromAddress && fromChain?.chainType === ChainType.EVM && fromChain.permit2 && fromChain.permit2Proxy && fromChain.relayerSupported && fromChain.nativeToken.address !== fromTokenAddress && useRelayerRoutes && !isBatchingSupported && (!observableRoute || isObservableRelayerRoute);
+			const mainRoutesPromise = shouldUseMainRoutes ? getRoutes(sdkClient, {
+				fromAddress,
+				fromAmount: fromAmount.toString(),
+				fromChainId,
+				fromTokenAddress,
+				toAddress,
+				toChainId,
+				toTokenAddress,
+				fromAmountForGas: enabledRefuel && gasRecommendationFromAmount ? gasRecommendationFromAmount : void 0,
+				options: {
+					allowSwitchChain: mode === "refuel" ? false : allowSwitchChain,
+					bridges: allowBridges?.length || disabledBridges.length ? {
+						allow: allowBridges,
+						deny: disabledBridges.length ? disabledBridges : void 0
+					} : void 0,
+					exchanges: allowExchanges?.length || disabledExchanges.length ? {
+						allow: allowExchanges,
+						deny: disabledExchanges.length ? disabledExchanges : void 0
+					} : void 0,
+					order: routePriority,
+					slippage: formattedSlippage,
+					fee: calculatedFee || configuredFee,
+					executionType: disableMessageSigning ? "transaction" : "all"
+				}
+			}, { signal }) : Promise.resolve(null);
+			const relayerQuotePromise = shouldUseRelayerQuote ? getRelayerQuote(sdkClient, {
+				fromAddress,
+				fromAmount: fromAmount.toString(),
+				fromChain: fromChainId,
+				fromToken: fromTokenAddress,
+				toAddress,
+				toChain: toChainId,
+				toToken: toTokenAddress,
+				fromAmountForGas: enabledRefuel && gasRecommendationFromAmount ? gasRecommendationFromAmount : void 0,
+				order: routePriority,
+				slippage: formattedSlippage,
+				fee: calculatedFee || configuredFee,
+				...allowBridges?.length || disabledBridges.length ? {
+					allowBridges,
+					denyBridges: disabledBridges.length ? disabledBridges : void 0
+				} : void 0,
+				...allowExchanges?.length || disabledExchanges.length ? {
+					allowExchanges,
+					denyExchanges: disabledExchanges.length ? disabledExchanges : void 0
+				} : void 0
+			}, { signal }).then(convertQuoteToRoute).catch(() => null) : Promise.resolve(null);
+			const routesResult = await mainRoutesPromise;
+			if (routesResult?.routes[0] && fromAddress) {
+				const { fromToken, toToken } = routesResult.routes[0];
+				[fromToken, toToken].forEach((token) => {
+					queryClient.setQueriesData({ queryKey: [getQueryKey("tokens", keyPrefix)] }, (data) => updateTokenInCache(data, token));
+					queryClient.setQueriesData({
+						queryKey: [getQueryKey("tokens-search", keyPrefix)],
+						exact: false
+					}, (data) => updateTokenInCache(data, token));
+					queryClient.setQueriesData({ queryKey: [
+						getQueryKey("token-balances", keyPrefix),
+						fromAddress,
+						token.chainId
+					] }, (data) => {
+						if (data) {
+							const clonedData = [...data];
+							const index = clonedData.findIndex((dataToken) => dataToken.address === token.address);
+							if (index >= 0) clonedData[index] = {
+								...clonedData[index],
+								...token
+							};
+							return clonedData;
+						}
+					});
+				});
+			}
+			const initialRoutes = routesResult?.routes ?? [];
+			if (shouldUseRelayerQuote && initialRoutes.length) {
+				setIntermediateRoutes(queryKey, initialRoutes);
+				emitter.emit("availableRoutes", initialRoutes);
+			} else if (shouldUseMainRoutes) {
+				emitter.emit("availableRoutes", initialRoutes);
+				return initialRoutes;
+			}
+			const relayerRouteResult = await relayerQuotePromise;
+			if (relayerRouteResult) {
+				initialRoutes.splice(1, 0, relayerRouteResult);
+				emitter.emit("availableRoutes", initialRoutes);
+			}
+			return initialRoutes;
+		},
+		enabled: isEnabled,
+		staleTime: refetchTime,
+		refetchInterval(query) {
+			return Math.min(Math.abs(refetchTime - (Date.now() - query.state.dataUpdatedAt)), refetchTime);
+		},
+		retry(failureCount, error) {
+			if (process.env.NODE_ENV === "development") console.warn("Route query failed:", {
+				failureCount,
+				error
+			});
+			if (failureCount >= 3) return false;
+			if (error?.code === LiFiErrorCode.NotFound) return false;
+			return true;
+		}
+	});
+	const setReviewableRoute = useCallback((route) => {
+		const queryDataKey = queryKey.toSpliced(queryKey.length - 1, 1, route.id);
+		queryClient.setQueryData(queryDataKey, [route], { updatedAt: dataUpdatedAt || Date.now() });
+		setExecutableRoute(route);
+	}, [
+		queryClient,
+		dataUpdatedAt,
+		setExecutableRoute,
+		queryKey
+	]);
+	return {
+		routes: data || getIntermediateRoutes(queryKey),
+		isLoading: isEnabled && isLoading,
+		isFetching,
+		isFetched,
+		dataUpdatedAt,
+		refetchTime,
+		refetch,
+		fromChain,
+		toChain,
+		queryKey,
+		setReviewableRoute
+	};
+};
+//#endregion
+export { useRoutes };
+
+//# sourceMappingURL=useRoutes.js.map