@lifi/widget 1.32.8 → 2.0.0-alpha.1

package/cjs/hooks/useGasRefuel.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGasRefuel = void 0;
+const big_js_1 = require("big.js");
+const react_1 = require("react");
+const react_hook_form_1 = require("react-hook-form");
+const _1 = require(".");
+const providers_1 = require("../providers");
+const useGasRecommendation_1 = require("./useGasRecommendation");
+const useTokenBalance_1 = require("./useTokenBalance");
+const useGasRefuel = () => {
+    const { getChainById } = (0, _1.useChains)();
+    const [fromChainId, fromTokenAddress, toChainId, toTokenAddress, toAddress] = (0, react_hook_form_1.useWatch)({
+        name: [
+            providers_1.SwapFormKey.FromChain,
+            providers_1.SwapFormKey.FromToken,
+            providers_1.SwapFormKey.ToChain,
+            providers_1.SwapFormKey.ToToken,
+            providers_1.SwapFormKey.ToAddress,
+        ],
+    });
+    const toChain = getChainById(toChainId);
+    const { token: nativeToken } = (0, useTokenBalance_1.useTokenBalance)(toChainId && toChain?.nativeToken, toAddress);
+    const { data: gasRecommendation, isLoading } = (0, useGasRecommendation_1.useGasRecommendation)(toChainId, fromChainId, fromTokenAddress);
+    const enabled = (0, react_1.useMemo)(() => {
+        if (
+        // We don't allow same chain refuel.
+        // If a user runs out of gas, he can't send a source chain transaction.
+        fromChainId === toChainId ||
+            // We don't want to apply auto refuel when swapping to native tokens
+            toChain?.nativeToken.address === toTokenAddress ||
+            !gasRecommendation?.available ||
+            !gasRecommendation.recommended ||
+            !nativeToken) {
+            return false;
+        }
+        const tokenBalance = (0, big_js_1.default)(nativeToken.amount ?? 0);
+        // check if the user balance < 50% of the recommended amount
+        const recommendedAmount = (0, big_js_1.default)(gasRecommendation.recommended.amount)
+            .div(10 ** gasRecommendation.recommended.token.decimals)
+            .div(2);
+        const insufficientGas = tokenBalance.lt(recommendedAmount);
+        return insufficientGas;
+    }, [
+        fromChainId,
+        gasRecommendation?.available,
+        gasRecommendation?.recommended,
+        nativeToken,
+        toChain?.nativeToken.address,
+        toChainId,
+        toTokenAddress,
+    ]);
+    return {
+        enabled: enabled,
+        availble: gasRecommendation?.available,
+        isLoading: isLoading,
+        chain: toChain,
+        gasRecommendation,
+    };
+};
+exports.useGasRefuel = useGasRefuel;

package/cjs/hooks/useGasSufficiency.d.ts

@@ -9,7 +9,6 @@ export interface GasSufficiency {
     chain?: EVMChain;
 }
 export declare const useGasSufficiency: (route?: Route) => {
-    insufficientGas: GasSufficiency[] | null | undefined;
-    insufficientFunds: boolean | null | undefined;
-    isLoading: boolean;
+    insufficientGas: GasSufficiency[] | undefined;
+    isInitialLoading: boolean;
 };

package/cjs/hooks/useGasSufficiency.js

@@ -5,16 +5,14 @@ const react_query_1 = require("@tanstack/react-query");
 const big_js_1 = require("big.js");
 const _1 = require(".");
 const providers_1 = require("../providers");
-const stores_1 = require("../stores");
-const useTokenBalance_1 = require("./useTokenBalance");
 const refetchInterval = 30000;
 const useGasSufficiency = (route) => {
-    const { account } = (0, providers_1.useWallet)();
+    const { account, provider } = (0, providers_1.useWallet)();
     const { getChainById } = (0, _1.useChains)();
-    const { token: fromToken, getTokenBalancesWithRetry } = (0, useTokenBalance_1.useTokenBalance)(route?.fromToken);
-    const { data: insufficientGas, isInitialLoading: insufficientGasLoading } = (0, react_query_1.useQuery)(['gas-sufficiency-check', account.address, route?.id], async () => {
+    const getTokenBalancesWithRetry = (0, _1.useGetTokenBalancesWithRetry)(provider);
+    const { data: insufficientGas, isInitialLoading } = (0, react_query_1.useQuery)(['gas-sufficiency-check', account.address, route?.id], async () => {
         if (!account.address || !route) {
-            return null;
+            return;
         }
         const gasCosts = route.steps
             .filter((step) => !step.execution || step.execution.status !== 'DONE')
@@ -42,7 +40,7 @@ const useGasSufficiency = (route) => {
         }
         const tokenBalances = await getTokenBalancesWithRetry(account.address, Object.values(gasCosts).map((item) => item.token));
         if (!tokenBalances?.length) {
-            return null;
+            return;
         }
         [route.fromChainId, route.toChainId].forEach((chainId) => {
             if (gasCosts[chainId]) {
@@ -71,38 +69,9 @@ const useGasSufficiency = (route) => {
         staleTime: refetchInterval,
         cacheTime: refetchInterval,
     });
-    const { data: insufficientFunds, isInitialLoading: insufficientFundsLoading, } = (0, react_query_1.useQuery)(['funds-sufficiency-check', account.address, route?.id], async () => {
-        if (!account.address || !fromToken || !route || (0, stores_1.isRouteDone)(route)) {
-            return null;
-        }
-        let currentTokenBalance = (0, big_js_1.default)(fromToken?.amount ?? 0);
-        const currentAction = route.steps.filter((step) => !step.execution || step.execution.status !== 'DONE')[0]?.action;
-        if (fromToken.chainId === currentAction.fromToken.chainId &&
-            fromToken.address === currentAction.fromToken.address &&
-            currentTokenBalance.gt(0)) {
-            const insufficientFunds = (0, big_js_1.default)(route.fromAmount)
-                .div(10 ** route.fromToken.decimals)
-                .gt(currentTokenBalance);
-            return insufficientFunds;
-        }
-        const tokenBalances = await getTokenBalancesWithRetry(account.address, [
-            currentAction.fromToken,
-        ]);
-        currentTokenBalance = (0, big_js_1.default)(tokenBalances?.[0]?.amount ?? 0);
-        const insufficientFunds = (0, big_js_1.default)(currentAction.fromAmount)
-            .div(10 ** currentAction.fromToken.decimals)
-            .gt(currentTokenBalance);
-        return insufficientFunds;
-    }, {
-        enabled: Boolean(account.address && route && fromToken),
-        refetchInterval,
-        staleTime: refetchInterval,
-        cacheTime: refetchInterval,
-    });
     return {
         insufficientGas,
-        insufficientFunds,
-        isLoading: insufficientGasLoading || insufficientFundsLoading,
+        isInitialLoading,
     };
 };
 exports.useGasSufficiency = useGasSufficiency;

package/cjs/hooks/useGetTokenBalancesWithRetry.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from '@ethersproject/providers';
+import type { Token, TokenAmount } from '@lifi/sdk';
+export declare const useGetTokenBalancesWithRetry: (provider?: Provider) => (accountAddress: string, tokens: Token[], depth?: number) => Promise<TokenAmount[] | undefined>;

package/cjs/hooks/useGetTokenBalancesWithRetry.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetTokenBalancesWithRetry = void 0;
+const address_1 = require("@ethersproject/address");
+const react_1 = require("react");
+const providers_1 = require("../providers");
+const useGetTokenBalancesWithRetry = (provider) => {
+    const lifi = (0, providers_1.useLiFi)();
+    const getTokenBalancesWithRetry = (0, react_1.useCallback)(async (accountAddress, tokens, depth = 0) => {
+        try {
+            const walletAddress = (0, address_1.isAddress)(accountAddress)
+                ? accountAddress
+                : await provider?.resolveName(accountAddress);
+            const tokenBalances = await lifi.getTokenBalances(walletAddress, tokens);
+            if (!tokenBalances.every((token) => token.blockNumber)) {
+                if (depth > 10) {
+                    console.warn('Token balance backoff depth exceeded.');
+                    return undefined;
+                }
+                await new Promise((resolve) => {
+                    setTimeout(resolve, 1.5 ** depth * 100);
+                });
+                return getTokenBalancesWithRetry(accountAddress, tokens, depth + 1);
+            }
+            return tokenBalances;
+        }
+        catch (error) {
+            //
+        }
+    }, [lifi, provider]);
+    return getTokenBalancesWithRetry;
+};
+exports.useGetTokenBalancesWithRetry = useGetTokenBalancesWithRetry;

package/cjs/hooks/useProcessMessage.d.ts

@@ -1,10 +1,10 @@
-import type { EVMChain, Process, Step } from '@lifi/sdk';
+import type { EVMChain, LifiStep, Process } from '@lifi/sdk';
 import type { TFunction } from 'i18next';
-export declare const useProcessMessage: (step?: Step, 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: Step, process: Process): {
+export declare function getProcessMessage(t: TFunction, getChainById: (chainId: number) => EVMChain | undefined, step: LifiStep, process: Process): {
     title?: string;
     message?: string;
 };

package/cjs/hooks/useSwapRoutes.d.ts

@@ -1,10 +1,15 @@
 import type { Route, RoutesResponse } from '@lifi/sdk';
-export declare const useSwapRoutes: () => {
+interface SwapRoutesProps {
+    onSettled?: (data?: RoutesResponse) => void;
+    insurableRoute?: Route;
+}
+export declare const useSwapRoutes: ({ onSettled, insurableRoute, }?: SwapRoutesProps) => {
     routes: Route[] | undefined;
     isLoading: boolean;
     isFetching: boolean;
     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, any>>;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<RoutesResponse, unknown>>;
 };
+export {};

package/cjs/hooks/useSwapRoutes.js

@@ -11,14 +11,15 @@ const _1 = require(".");
 const providers_1 = require("../providers");
 const stores_1 = require("../stores");
 const refetchTime = 60000;
-const useSwapRoutes = () => {
+const useSwapRoutes = ({ onSettled, insurableRoute, } = {}) => {
     const lifi = (0, providers_1.useLiFi)();
-    const { variant, sdkConfig } = (0, providers_1.useWidgetConfig)();
+    const { variant, sdkConfig, insurance } = (0, providers_1.useWidgetConfig)();
     const { account, provider } = (0, providers_1.useWallet)();
     const queryClient = (0, react_query_1.useQueryClient)();
-    const { slippage, enabledBridges, enabledExchanges, routePriority } = (0, stores_1.useSettings)([
+    const { slippage, enabledBridges, enabledAutoRefuel, enabledExchanges, routePriority, } = (0, stores_1.useSettings)([
         'slippage',
         'routePriority',
+        'enabledAutoRefuel',
         'enabledBridges',
         'enabledExchanges',
     ]);
@@ -38,6 +39,7 @@ const useSwapRoutes = () => {
     });
     const { token: fromToken } = (0, _1.useToken)(fromChainId, fromTokenAddress);
     const { token: toToken } = (0, _1.useToken)(toChainId, toTokenAddress);
+    const { enabled: enabledRefuel, gasRecommendation } = (0, _1.useGasRefuel)();
     const hasAmount = (!isNaN(fromTokenAmount) && Number(fromTokenAmount) > 0) ||
         (!isNaN(toTokenAmount) && Number(toTokenAmount) > 0);
     const contractCallQuoteEnabled = variant === 'nft'
@@ -69,12 +71,12 @@ const useSwapRoutes = () => {
         routePriority,
         variant,
         sdkConfig?.defaultRouteOptions?.allowSwitchChain,
+        enabledRefuel && enabledAutoRefuel,
+        gasRecommendation?.fromAmount,
+        insurance,
+        insurableRoute?.id,
     ];
-    const previousDataUpdatedAt = queryClient.getQueryState(queryKey)?.dataUpdatedAt;
-    const refetchInterval = previousDataUpdatedAt
-        ? Math.min(Math.abs(refetchTime - (Date.now() - previousDataUpdatedAt)), refetchTime)
-        : refetchTime;
-    const { data, isLoading, isFetching, isFetched, dataUpdatedAt, refetch } = (0, react_query_1.useQuery)(queryKey, async ({ queryKey: [_, fromAddress, fromChainId, fromTokenAddress, fromTokenAmount, toAddress, toChainId, toTokenAddress, toTokenAmount, toContractAddress, toContractCallData, toContractGasLimit, slippage, enabledBridges, enabledExchanges, routePriority, variant, allowSwitchChain,], signal, }) => {
+    const { data, isLoading, isFetching, isFetched, dataUpdatedAt, refetch } = (0, react_query_1.useQuery)(queryKey, async ({ queryKey: [_, fromAddress, fromChainId, fromTokenAddress, fromTokenAmount, toAddress, toChainId, toTokenAddress, toTokenAmount, toContractAddress, toContractCallData, toContractGasLimit, slippage, enabledBridges, enabledExchanges, routePriority, variant, allowSwitchChain, enabledRefuel, gasRecommendationFromAmount, insurance, insurableRouteId,], signal, }) => {
         let toWalletAddress;
         try {
             toWalletAddress =
@@ -120,9 +122,20 @@ const useSwapRoutes = () => {
                 toAddress: toAddress,
                 gasCostUSD: contractCallQuote.estimate.gasCosts?.[0].amountUSD,
                 steps: [contractCallQuote],
+                insurance: { state: 'NOT_INSURABLE', feeAmountUsd: '0' },
             };
             return { routes: [route] };
         }
+        const allowedBridges = insurableRoute
+            ? insurableRoute.steps.flatMap((step) => step.includedSteps
+                .filter((includedStep) => includedStep.type === 'cross')
+                .map((includedStep) => includedStep.toolDetails.key))
+            : enabledBridges;
+        const allowedExchanges = insurableRoute
+            ? insurableRoute.steps.flatMap((step) => step.includedSteps
+                .filter((includedStep) => includedStep.type === 'swap')
+                .map((includedStep) => includedStep.toolDetails.key))
+            : enabledExchanges;
         return lifi.getRoutes({
             fromChainId,
             fromAmount,
@@ -131,23 +144,29 @@ const useSwapRoutes = () => {
             toTokenAddress,
             fromAddress,
             toAddress: toWalletAddress,
+            fromAmountForGas: enabledRefuel && gasRecommendationFromAmount
+                ? gasRecommendationFromAmount
+                : undefined,
             options: {
                 slippage: formattedSlippage,
                 bridges: {
-                    allow: enabledBridges,
+                    allow: allowedBridges,
                 },
                 exchanges: {
-                    allow: enabledExchanges,
+                    allow: allowedExchanges,
                 },
                 order: routePriority,
                 allowSwitchChain: variant === 'refuel' ? false : allowSwitchChain,
+                insurance: insurance ? Boolean(insurableRoute) : undefined,
             },
         }, { signal });
     }, {
         enabled: isEnabled,
-        refetchInterval,
         staleTime: refetchTime,
         cacheTime: refetchTime,
+        refetchInterval(data, query) {
+            return Math.min(Math.abs(refetchTime - (Date.now() - query.state.dataUpdatedAt)), refetchTime);
+        },
         retry(failureCount, error) {
             if (error?.code === sdk_1.LifiErrorCode.NotFound) {
                 return false;
@@ -173,6 +192,7 @@ const useSwapRoutes = () => {
                 });
             }
         },
+        onSettled,
     });
     return {
         routes: data?.routes,

package/cjs/hooks/useTokenAddressBalance.js

@@ -6,8 +6,10 @@ const useTokenBalances_1 = require("./useTokenBalances");
 const useTokenAddressBalance = (chainId, tokenAddress) => {
     const { tokens, tokensWithBalance, isBalanceLoading, refetch } = (0, useTokenBalances_1.useTokenBalances)(chainId);
     const token = (0, react_1.useMemo)(() => {
-        const token = (tokensWithBalance ?? tokens)?.find((token) => token.address === tokenAddress && token.chainId === chainId);
-        return token;
+        if (tokenAddress && chainId) {
+            const token = (tokensWithBalance ?? tokens)?.find((token) => token.address === tokenAddress && token.chainId === chainId);
+            return token;
+        }
     }, [chainId, tokenAddress, tokens, tokensWithBalance]);
     return {
         token,

package/cjs/hooks/useTokenBalance.js

@@ -5,31 +5,13 @@ const react_query_1 = require("@tanstack/react-query");
 const react_1 = require("react");
 const providers_1 = require("../providers");
 const utils_1 = require("../utils");
+const useGetTokenBalancesWithRetry_1 = require("./useGetTokenBalancesWithRetry");
 const defaultRefetchInterval = 30000;
 const useTokenBalance = (token, accountAddress) => {
-    const lifi = (0, providers_1.useLiFi)();
-    const { account } = (0, providers_1.useWallet)();
+    const { account, provider } = (0, providers_1.useWallet)();
     const queryClient = (0, react_query_1.useQueryClient)();
-    const walletAddress = accountAddress ?? account.address;
-    const getTokenBalancesWithRetry = (0, react_1.useCallback)(async (accountAddress, tokens, depth = 0) => {
-        try {
-            const tokenBalances = await lifi.getTokenBalances(accountAddress, tokens);
-            if (!tokenBalances.every((token) => token.blockNumber)) {
-                if (depth > 10) {
-                    console.warn('Token balance backoff depth exceeded.');
-                    return undefined;
-                }
-                await new Promise((resolve) => {
-                    setTimeout(resolve, 1.5 ** depth * 100);
-                });
-                return getTokenBalancesWithRetry(accountAddress, tokens, depth + 1);
-            }
-            return tokenBalances;
-        }
-        catch (error) {
-            //
-        }
-    }, [lifi]);
+    const walletAddress = accountAddress || account.address;
+    const getTokenBalancesWithRetry = (0, useGetTokenBalancesWithRetry_1.useGetTokenBalancesWithRetry)(provider);
     const tokenBalanceQueryKey = (0, react_1.useMemo)(() => ['token-balance', walletAddress, token?.chainId, token?.address], [token?.address, token?.chainId, walletAddress]);
     const { data, isLoading, refetch } = (0, react_query_1.useQuery)(tokenBalanceQueryKey, async ({ queryKey: [, accountAddress] }) => {
         const cachedToken = queryClient

package/cjs/hooks/useTokenBalances.d.ts

@@ -2,7 +2,7 @@ import type { Token } from '../types';
 export declare const useTokenBalances: (selectedChainId?: number) => {
     tokens: Token[];
     tokensWithBalance: Token[] | undefined;
-    featuredTokens: import("@lifi/types").Token[];
+    featuredTokens: import("@lifi/types").Token[] | undefined;
     isLoading: boolean;
     isBalanceLoading: boolean;
     refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<Token[], unknown>>;

package/cjs/hooks/useTokenSearch.js

@@ -13,9 +13,9 @@ const useTokenSearch = (chainId, tokenQuery, enabled) => {
         if (token) {
             queryClient.setQueriesData(['tokens'], (data) => {
                 if (data &&
-                    !data.tokens[chainId].some((t) => t.address === token.address)) {
+                    !data.tokens[chainId]?.some((t) => t.address === token.address)) {
                     const clonedData = { ...data };
-                    clonedData.tokens[chainId].push(token);
+                    clonedData.tokens[chainId]?.push(token);
                     return clonedData;
                 }
             });

package/cjs/hooks/useTokens.js

@@ -11,14 +11,14 @@ const useTokens = (selectedChainId) => {
     const { data, isLoading, dataUpdatedAt } = (0, react_query_1.useQuery)(['tokens'], () => lifi.getTokens());
     const { getChainById, isLoading: isSupportedChainsLoading } = (0, useChains_1.useChains)();
     const featuredTokens = (0, useFeaturedTokens_1.useFeaturedTokens)(selectedChainId);
-    const { tokens: configTokens, chains: configChains, disabledChains, } = (0, providers_1.useWidgetConfig)();
+    const { tokens: configTokens, chains: configChains } = (0, providers_1.useWidgetConfig)();
     const tokens = (0, react_1.useMemo)(() => {
         if (isSupportedChainsLoading) {
             return [];
         }
         const chainAllowed = selectedChainId &&
             getChainById(selectedChainId) &&
-            (0, providers_1.isItemAllowed)(selectedChainId, configChains, disabledChains);
+            (0, providers_1.isItemAllowed)(selectedChainId, configChains);
         if (!chainAllowed) {
             return [];
         }
@@ -47,7 +47,6 @@ const useTokens = (selectedChainId) => {
         selectedChainId,
         getChainById,
         configChains,
-        disabledChains,
         configTokens?.allow,
         configTokens?.deny,
         featuredTokens,

package/cjs/i18n/en.json

@@ -106,12 +106,14 @@
     "inProgress": "in progress",
     "info": {
       "message": {
+        "autoRefuel": "You're low on {{chainName}} gas. By continuing, you'll get enough gas to complete the swap.",
         "emptyActiveSwaps": "Swaps in progress will appear here. Once completed, find them in swap history.",
         "emptySwapHistory": "Swap history is only stored locally and will be deleted if you clear your browser data.",
         "emptyTokenList": "We couldn't find tokens on {{chainName}} chain or you don't have any. Please try search again or choose another chain.",
         "routeNotFound": "Try another token combination."
       },
       "title": {
+        "autoRefuel": "Get gas",
         "emptyActiveSwaps": "No active swaps",
         "emptySwapHistory": "No recent swaps",
         "routeNotFound": "No routes available"
@@ -154,6 +156,7 @@
     "quotedAmount": "Quoted amount",
     "rateChange": "Rate change",
     "receiving": "Receiving",
+    "refuelStepDetails": "Get gas via {{tool}}",
     "routes": "You get",
     "selectChain": "Chain",
     "selectChainAndToken": "Select chain and token",
@@ -162,6 +165,7 @@
     "sendToWallet": "Send to a different wallet",
     "sentToAddress": "Sent to {{address}}",
     "stepBridge": "Bridge",
+    "stepDetails": "{{tool}} via LI.FI",
     "stepSwap": "Swap",
     "stepSwapAndBridge": "Swap and bridge",
     "success": {
@@ -180,11 +184,13 @@
     "swapStepDetails": "Swap on {{chain}} via {{tool}}",
     "swapping": "Swapping",
     "tags": {
-      "ALTERNATIVE": "ALTERNATIVE",
-      "CHEAPEST": "CHEAP",
-      "FASTEST": "FAST",
-      "RECOMMENDED": "RECOMMENDED",
-      "SAFEST": "SAFE"
+      "cheapest": "Cheap",
+      "fastest": "Fast",
+      "insurable": "Insurable",
+      "insurance": "Insurance",
+      "insured": "Insured",
+      "recommended": "Recommended",
+      "safest": "Safe"
     },
     "to": "To",
     "tokenOnChain": "{{tokenSymbol}} on {{chainName}}",
@@ -197,8 +203,8 @@
         "deleteActiveSwaps": "Active swaps are only stored locally and can't be recovered if you delete them.",
         "deleteSwapHistory": "Swap history is only stored locally and can't be recovered if you delete it.",
         "highValueLoss": "The value of the received tokens is significantly lower than the swapped tokens and transaction cost.",
-        "insufficientFunds": "You don't have enough funds to execute the swap.",
-        "insufficientGas": "You need to add at least:",
+        "insufficientFunds": "You don't have enough funds to complete the swap.",
+        "insufficientGas": "You don't have enough gas to complete the swap. You need to add at least:",
         "rateChanged": "The exchange rate has changed. By continuing the swap, you'll accept the new rate.",
         "resetSettings": "This will reset your route priority, slippage, gas price, enabled bridges and exchanges."
       },
@@ -214,6 +220,7 @@
     }
   },
   "tooltip": {
+    "additionalProviderFee": "Additional bridges, DEXs, and service fees.",
     "estimatedNetworkFee": "Estimated network fee.",
     "estimatedTime": "Estimated swap execution time in minutes.",
     "notFound": {

package/cjs/i18n/it.json

@@ -106,12 +106,14 @@
     "inProgress": "in corso",
     "info": {
       "message": {
+        "autoRefuel": "Livello basso di gas su {{chainName}}. Continuando avrai abbastanza gas per completare lo scambio.",
         "emptyActiveSwaps": "Gli scambi in corso verranno visualizzati qui. Una volta completati, saranno presenti nella cronologia di scambi.",
         "emptySwapHistory": "La cronologia di scambi viene memorizzata solo localmente e verrà cancellata se si cancellano i dati del browser.",
         "emptyTokenList": "Non siamo riusciti a trovare token sulla chain {{chainName}} o non ne hai. Riprova o scegli un'altra chain.",
         "routeNotFound": "Prova un'altra combinazione di token."
       },
       "title": {
+        "autoRefuel": "Ottieni gas",
         "emptyActiveSwaps": "Nessuno scambio attivo",
         "emptySwapHistory": "Nessuno scambio recente",
         "routeNotFound": "Nessuna rotta disponibile"
@@ -154,6 +156,7 @@
     "quotedAmount": "Totale quotato",
     "rateChange": "Tasso di scambio",
     "receiving": "In ricezione",
+    "refuelStepDetails": "Ottieni gas tramite {{tool}}",
     "routes": "Ottieni",
     "selectChain": "Chain",
     "selectChainAndToken": "Selezionare la chain ed il token",
@@ -162,6 +165,7 @@
     "sendToWallet": "Invia ad un altro portafoglio",
     "sentToAddress": "Inviati a {{address}}",
     "stepBridge": "Bridge",
+    "stepDetails": "{{tool}} tramite LI.FI",
     "stepSwap": "Scambio",
     "stepSwapAndBridge": "Scambia e bridge",
     "success": {
@@ -197,8 +201,8 @@
         "deleteActiveSwaps": "Gli scambi attivi vengono memorizzati solo localmente e non possono essere recuperati se vengono cancellati.",
         "deleteSwapHistory": "La cronologia degli scambi viene memorizzata solo localmente e, se cancellata, non può essere recuperata.",
         "highValueLoss": "Il valore dei token ricevuti è significativamente inferiore ai token scambiati più il costo della transazione.",
-        "insufficientFunds": "Non hai abbastanza fondi per eseguire lo scambio.",
-        "insufficientGas": "È necessario aggiungere almeno:",
+        "insufficientFunds": "Non hai abbastanza fondi per completare lo scambio.",
+        "insufficientGas": "Non hai abbastanza gas per completare lo scambio. Devi aggiungere almeno:",
         "rateChanged": "Il tasso di scambio è cambiato. Se procedi, confermi di accettare il nuovo tasso.",
         "resetSettings": "Questo porterà al ripristino della priorità di route, slittamento di prezzo, prezzo del gas, bridge abilitati ed exchanges."
       },