@lifi/widget 1.13.2 → 1.13.5

package/cjs/hooks/useSwapRoutes.js

@@ -0,0 +1,109 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSwapRoutes = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const big_js_1 = __importDefault(require("big.js"));
+const react_hook_form_1 = require("react-hook-form");
+const _1 = require(".");
+const lifi_1 = require("../config/lifi");
+const SwapFormProvider_1 = require("../providers/SwapFormProvider");
+const WalletProvider_1 = require("../providers/WalletProvider");
+const stores_1 = require("../stores");
+const refetchTime = 60000;
+const useSwapRoutes = () => {
+    var _a;
+    const { account } = (0, WalletProvider_1.useWallet)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    const { slippage, enabledBridges, enabledExchanges, routePriority } = (0, stores_1.useSettings)([
+        'slippage',
+        'routePriority',
+        'enabledBridges',
+        'enabledExchanges',
+    ]);
+    const [fromChainId, fromTokenAddress, toChainId, toTokenAddress] = (0, react_hook_form_1.useWatch)({
+        name: [
+            SwapFormProvider_1.SwapFormKey.FromChain,
+            SwapFormProvider_1.SwapFormKey.FromToken,
+            SwapFormProvider_1.SwapFormKey.ToChain,
+            SwapFormProvider_1.SwapFormKey.ToToken,
+        ],
+    });
+    const [fromTokenAmount] = (0, _1.useDebouncedWatch)([SwapFormProvider_1.SwapFormKey.FromAmount], 250);
+    const { token } = (0, _1.useToken)(fromChainId, fromTokenAddress);
+    const isEnabled = 
+    // Boolean(account.address) &&
+    !isNaN(fromChainId) &&
+        !isNaN(toChainId) &&
+        Boolean(token === null || token === void 0 ? void 0 : token.address) &&
+        Boolean(toTokenAddress) &&
+        !isNaN(fromTokenAmount) &&
+        Number(fromTokenAmount) > 0 &&
+        !Number.isNaN(slippage);
+    const queryKey = [
+        'routes',
+        account.address,
+        fromChainId,
+        token === null || token === void 0 ? void 0 : token.address,
+        fromTokenAmount,
+        toChainId,
+        toTokenAddress,
+        slippage,
+        enabledBridges,
+        enabledExchanges,
+        routePriority,
+    ];
+    const previousDataUpdatedAt = (_a = queryClient.getQueryState(queryKey)) === null || _a === void 0 ? void 0 : _a.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, ({ queryKey: [_, address, fromChainId, fromTokenAddress, fromTokenAmount, toChainId, toTokenAddress, slippage, enabledBridges, enabledExchanges, routePriority,], signal, }) => __awaiter(void 0, void 0, void 0, function* () {
+        var _b;
+        return lifi_1.LiFi.getRoutes({
+            fromChainId,
+            fromAmount: (0, big_js_1.default)(Number(fromTokenAmount) * Math.pow(10, ((_b = token === null || token === void 0 ? void 0 : token.decimals) !== null && _b !== void 0 ? _b : 0))).toString(),
+            fromTokenAddress,
+            toChainId,
+            toTokenAddress,
+            fromAddress: address,
+            toAddress: address,
+            options: {
+                slippage: slippage / 100,
+                bridges: {
+                    allow: enabledBridges,
+                },
+                exchanges: {
+                    allow: enabledExchanges,
+                },
+                order: routePriority,
+            },
+        }, { signal });
+    }), {
+        enabled: isEnabled,
+        refetchIntervalInBackground: true,
+        refetchInterval,
+        staleTime: refetchTime,
+        cacheTime: refetchTime,
+    });
+    return {
+        routes: data === null || data === void 0 ? void 0 : data.routes,
+        isLoading: isEnabled && isLoading,
+        isFetching,
+        isFetched,
+        dataUpdatedAt,
+        refetchTime,
+        refetch,
+    };
+};
+exports.useSwapRoutes = useSwapRoutes;

package/cjs/hooks/useTelemetry.d.ts

@@ -0,0 +1 @@
+export declare const useTelemetry: (disabled?: boolean) => void;

package/cjs/hooks/useTelemetry.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTelemetry = void 0;
+/* eslint-disable consistent-return */
+const react_1 = require("react");
+const sentry_1 = require("../config/sentry");
+const useTelemetry = (disabled) => {
+    (0, react_1.useEffect)(() => {
+        if (disabled) {
+            if (process.env.NODE_ENV === 'production') {
+                console.warn('Enable crash reports and diagnostic data to be collected. This helps us to better understand how the widget is performing and where improvements need to be made.');
+            }
+        }
+        else {
+            (0, sentry_1.initSentry)(true);
+            return () => {
+                (0, sentry_1.initSentry)(false);
+            };
+        }
+    }, [disabled]);
+};
+exports.useTelemetry = useTelemetry;

package/cjs/hooks/useToken.d.ts

@@ -0,0 +1,5 @@
+export declare const useToken: (chainId: number, tokenAddress: string) => {
+    token: import("..").Token | undefined;
+    isLoading: boolean;
+    isFetching: boolean;
+};

package/cjs/hooks/useToken.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useToken = void 0;
+const react_1 = require("react");
+const useTokens_1 = require("./useTokens");
+const useToken = (chainId, tokenAddress) => {
+    const { tokens, isLoading, isFetching } = (0, useTokens_1.useTokens)(chainId);
+    const token = (0, react_1.useMemo)(() => {
+        const token = tokens === null || tokens === void 0 ? void 0 : tokens.find((token) => token.address === tokenAddress && token.chainId === chainId);
+        return token;
+    }, [chainId, tokenAddress, tokens]);
+    return {
+        token,
+        isLoading,
+        isFetching,
+    };
+};
+exports.useToken = useToken;

package/cjs/hooks/useTokenBalance.d.ts

@@ -0,0 +1,5 @@
+export declare const useTokenBalance: (chainId: number, tokenAddress: string) => {
+    token: import("..").Token | undefined;
+    isLoading: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/query-core").RefetchOptions & import("@tanstack/query-core").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/query-core").QueryObserverResult<import("..").Token[] | undefined, unknown>>;
+};

package/cjs/hooks/useTokenBalance.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTokenBalance = void 0;
+const react_1 = require("react");
+const useTokenBalances_1 = require("./useTokenBalances");
+const useTokenBalance = (chainId, tokenAddress) => {
+    const { tokens, tokensWithBalance, isBalanceLoading, refetch } = (0, useTokenBalances_1.useTokenBalances)(chainId);
+    const token = (0, react_1.useMemo)(() => {
+        var _a;
+        const token = (_a = (tokensWithBalance !== null && tokensWithBalance !== void 0 ? tokensWithBalance : tokens)) === null || _a === void 0 ? void 0 : _a.find((token) => token.address === tokenAddress && token.chainId === chainId);
+        return token;
+    }, [chainId, tokenAddress, tokens, tokensWithBalance]);
+    return {
+        token,
+        isLoading: isBalanceLoading,
+        refetch,
+    };
+};
+exports.useTokenBalance = useTokenBalance;

package/cjs/hooks/useTokenBalances.d.ts

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

package/cjs/hooks/useTokenBalances.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTokenBalances = void 0;
+/* eslint-disable consistent-return */
+const react_query_1 = require("@tanstack/react-query");
+const react_1 = require("react");
+const lifi_1 = require("../config/lifi");
+const WalletProvider_1 = require("../providers/WalletProvider");
+const utils_1 = require("../utils");
+const useFeaturedTokens_1 = require("./useFeaturedTokens");
+const useTokens_1 = require("./useTokens");
+const defaultRefetchInterval = 60000;
+const minRefetchInterval = 1000;
+const useTokenBalances = (selectedChainId) => {
+    const { account } = (0, WalletProvider_1.useWallet)();
+    const featuredTokens = (0, useFeaturedTokens_1.useFeaturedTokens)(selectedChainId);
+    const { tokens, isLoading } = (0, useTokens_1.useTokens)(selectedChainId);
+    const [refetchInterval, setRefetchInterval] = (0, react_1.useState)(defaultRefetchInterval);
+    const isBalanceLoadingEnabled = Boolean(account.address) && Boolean(tokens === null || tokens === void 0 ? void 0 : tokens.length);
+    const { data: tokensWithBalance, isLoading: isBalanceLoading, isFetched: isBalanceFetched, refetch, } = (0, react_query_1.useQuery)(['token-balances', account.address, selectedChainId, tokens === null || tokens === void 0 ? void 0 : tokens.length], ({ queryKey: [, accountAddress] }) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!accountAddress || !tokens) {
+            return;
+        }
+        const tokenBalances = yield lifi_1.LiFi.getTokenBalances(accountAddress, tokens);
+        if (!(tokenBalances === null || tokenBalances === void 0 ? void 0 : tokenBalances.length)) {
+            // Sometimes RPCs (e.g. Arbitrum) don't return balances on first call
+            // TODO: fix and remove backplane
+            setRefetchInterval((interval) => interval === defaultRefetchInterval
+                ? minRefetchInterval
+                : interval * 2);
+            return;
+        }
+        const featuredTokenAddresses = new Set(featuredTokens === null || featuredTokens === void 0 ? void 0 : featuredTokens.map((token) => token.address));
+        const sortFn = (a, b) => {
+            var _a, _b, _c, _d;
+            return parseFloat((_a = b.amount) !== null && _a !== void 0 ? _a : '0') * parseFloat((_b = b.priceUSD) !== null && _b !== void 0 ? _b : '0') -
+                parseFloat((_c = a.amount) !== null && _c !== void 0 ? _c : '0') * parseFloat((_d = a.priceUSD) !== null && _d !== void 0 ? _d : '0');
+        };
+        const formattedTokens = (tokenBalances.length === 0 ? tokens : tokenBalances).map((token) => {
+            token.amount = (0, utils_1.formatTokenAmount)(token.amount);
+            return token;
+        });
+        const result = [
+            ...formattedTokens
+                .filter((token) => token.amount !== '0' && featuredTokenAddresses.has(token.address))
+                .sort(sortFn),
+            ...formattedTokens.filter((token) => token.amount === '0' && featuredTokenAddresses.has(token.address)),
+            ...formattedTokens
+                .filter((token) => token.amount !== '0' &&
+                !featuredTokenAddresses.has(token.address))
+                .sort(sortFn),
+            ...formattedTokens.filter((token) => token.amount === '0' && !featuredTokenAddresses.has(token.address)),
+        ];
+        return result;
+    }), {
+        enabled: isBalanceLoadingEnabled,
+        refetchIntervalInBackground: true,
+        refetchInterval,
+        staleTime: refetchInterval,
+    });
+    return {
+        tokens,
+        tokensWithBalance,
+        featuredTokens,
+        isLoading,
+        isBalanceLoading: isBalanceLoading && isBalanceLoadingEnabled,
+        isBalanceFetched,
+        refetch,
+    };
+};
+exports.useTokenBalances = useTokenBalances;

package/cjs/hooks/useTokenSearch.d.ts

@@ -0,0 +1,7 @@
+import type { Token } from '../types';
+export declare const useTokenSearch: (token: string, chainId: number, enabled?: boolean) => {
+    token: Token | undefined;
+    isLoading: boolean;
+    isFetching: boolean;
+    isFetched: boolean;
+};

package/cjs/hooks/useTokenSearch.js

@@ -0,0 +1,41 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTokenSearch = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const lifi_1 = require("../config/lifi");
+const useTokenSearch = (token, chainId, enabled) => {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    const { data, isLoading, isFetching, isFetched } = (0, react_query_1.useQuery)(['token-search', chainId, token], ({ queryKey: [, chainId, token], signal }) => __awaiter(void 0, void 0, void 0, function* () {
+        const data = yield lifi_1.LiFi.getToken(chainId, token, {
+            signal,
+        });
+        if (data) {
+            queryClient.setQueriesData(['tokens', chainId], (tokens) => {
+                if (!(tokens === null || tokens === void 0 ? void 0 : tokens.some((token) => token.address === data.address))) {
+                    tokens === null || tokens === void 0 ? void 0 : tokens.push(data);
+                }
+                return tokens;
+            });
+        }
+        return data;
+    }), {
+        enabled,
+        retry: false,
+    });
+    return {
+        token: data,
+        isLoading,
+        isFetching,
+        isFetched,
+    };
+};
+exports.useTokenSearch = useTokenSearch;

package/cjs/hooks/useTokens.d.ts

@@ -0,0 +1,6 @@
+import type { Token } from '../types';
+export declare const useTokens: (selectedChainId: number) => {
+    tokens: Token[] | undefined;
+    isLoading: boolean;
+    isFetching: boolean;
+};

package/cjs/hooks/useTokens.js

@@ -0,0 +1,36 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTokens = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const lifi_1 = require("../config/lifi");
+const useFeaturedTokens_1 = require("./useFeaturedTokens");
+const useTokens = (selectedChainId) => {
+    const featuredTokens = (0, useFeaturedTokens_1.useFeaturedTokens)(selectedChainId);
+    const { data: tokens, isLoading, isFetching, } = (0, react_query_1.useQuery)(['tokens', selectedChainId, featuredTokens === null || featuredTokens === void 0 ? void 0 : featuredTokens.length], () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const data = yield lifi_1.LiFi.getTokens({ chains: [selectedChainId] });
+        const featuredTokenAddresses = new Set(featuredTokens === null || featuredTokens === void 0 ? void 0 : featuredTokens.map((token) => token.address));
+        return [
+            ...((_a = featuredTokens === null || featuredTokens === void 0 ? void 0 : featuredTokens.map((token) => {
+                token.featured = true;
+                return token;
+            })) !== null && _a !== void 0 ? _a : []),
+            ...((_c = (_b = data.tokens) === null || _b === void 0 ? void 0 : _b[selectedChainId].filter((token) => !featuredTokenAddresses.has(token.address))) !== null && _c !== void 0 ? _c : []),
+        ];
+    }));
+    return {
+        tokens,
+        isLoading,
+        isFetching,
+    };
+};
+exports.useTokens = useTokens;

package/cjs/hooks/useTools.d.ts

@@ -0,0 +1,10 @@
+import type { Bridge, Exchange } from '@lifi/sdk';
+declare type FormattedTool<T, K extends keyof T> = Record<string, Pick<T, K>>;
+export declare const useTools: () => {
+    tools: import("@lifi/sdk").ToolsResponse | undefined;
+    formattedTools: {
+        bridges: FormattedTool<Bridge, "key" | "name" | "logoURI"> | undefined;
+        exchanges: FormattedTool<Exchange, "key" | "name" | "logoURI"> | undefined;
+    };
+};
+export {};

package/cjs/hooks/useTools.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTools = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const react_1 = require("react");
+const lifi_1 = require("../config/lifi");
+const stores_1 = require("../stores");
+const useTools = () => {
+    const initializeTools = (0, stores_1.useSettingsStore)((state) => state.initializeTools);
+    const { data } = (0, react_query_1.useQuery)(['tools'], ({ signal }) => lifi_1.LiFi.getTools(undefined, { signal }), {
+        onSuccess(data) {
+            initializeTools('Bridges', data.bridges.map((bridge) => bridge.key));
+            initializeTools('Exchanges', data.exchanges.map((exchange) => exchange.key));
+        },
+    });
+    const formattedTools = (0, react_1.useMemo)(() => ({
+        bridges: data === null || data === void 0 ? void 0 : data.bridges.reduce((bridges, bridge) => {
+            bridges[bridge.key] = bridge;
+            return bridges;
+        }, {}),
+        exchanges: data === null || data === void 0 ? void 0 : data.exchanges.reduce((exchanges, exchange) => {
+            exchanges[exchange.key] = exchange;
+            return exchanges;
+        }, {}),
+    }), [data === null || data === void 0 ? void 0 : data.bridges, data === null || data === void 0 ? void 0 : data.exchanges]);
+    return { tools: data, formattedTools };
+};
+exports.useTools = useTools;

package/cjs/i18n/en/translation.json

@@ -0,0 +1,175 @@
+{
+    "header": {
+        "walletConnected": "Wallet connected",
+        "connectWallet": "Connect wallet",
+        "selectWallet": "Select your wallet",
+        "swap": "Swap",
+        "from": "Swap from",
+        "to": "Swap to",
+        "settings": "Settings",
+        "routes": "You get",
+        "swapHistory": "Swap history",
+        "swapDetails": "Swap details"
+    },
+    "button": {
+        "connectWallet": "Connect wallet",
+        "switchChain": "Switch chain",
+        "swap": "Swap",
+        "reviewSwap": "Review swap",
+        "startSwap": "Start swap",
+        "restartSwap": "Restart swap",
+        "removeSwap": "Remove swap",
+        "done": "Done",
+        "okay": "Okay",
+        "seeDetails": "See details",
+        "tryAgain": "Try again",
+        "light": "Light",
+        "dark": "Dark",
+        "auto": "Auto",
+        "ok": "Ok",
+        "cancel": "Cancel",
+        "delete": "Delete",
+        "hide": "Hide",
+        "max": "max",
+        "contactSupport": "Contact support",
+        "lifiSwap": "LI.FI Swap"
+    },
+    "swap": {
+        "from": "From",
+        "to": "To",
+        "amount": "You pay",
+        "maxAmount": "/ {{amount}}",
+        "routes": "You get",
+        "approximateCurrency": "\u2248 {{value, currency(currency: USD)}}",
+        "currency": "{{value, currency(currency: USD)}}",
+        "sendToRecipient": "Send to recipient",
+        "addressConfirmation": "I confirm that the address above is correct",
+        "gas": "gas fee",
+        "minutes": "minutes",
+        "tokenSearch": "Search your token",
+        "selectChain": "Chain",
+        "selectToken": "Token",
+        "selectChainAndToken": "Select chain and token",
+        "featuredTokens": "Featured tokens",
+        "otherTokens": "Other tokens",
+        "inProgress": "In progress",
+        "couldntFindTokens": "We couldn't find tokens on this chain or you don't have any.",
+        "stepSwap": "Swap",
+        "stepBridge": "Bridge",
+        "stepSwapAndBridge": "Swap and bridge",
+        "estimatedTime": "~{{value}} min.",
+        "networkIsBusy": "Network is busy...",
+        "crossStepDetails": "Bridge from {{from}} to {{to}} via {{tool}}",
+        "swapStepDetails": "Swap on {{chain}} via {{tool}}",
+        "tokenOnChain": "{{tokenSymbol}} on {{chainName}}",
+        "tokenOnChainAmount": "{{amount}} {{tokenSymbol}} on {{chainName}}",
+        "routeId": "Route ID",
+        "tags": {
+            "recommended": "Recommended",
+            "fastest": "Fast",
+            "cheapest": "Cheap",
+            "safest": "Safe",
+            "general": "General"
+        },
+        "success": {
+            "title": {
+                "fundsReceived": "Funds received"
+            },
+            "message": {
+                "fundsReceived": "You now have {{amount}} {{tokenSymbol}} in your wallet on {{chainName}} chain."
+            }
+        },
+        "info": {
+            "title": {
+                "routeNotFound": "No routes available",
+                "emptySwapHistory": "No recent swaps"
+            },
+            "message": {
+                "routeNotFound": "Try another token combination.",
+                "emptySwapHistory": "Swap history is only stored locally and will be deleted if you clear your browser data."
+            }
+        },
+        "warning": {
+            "title": {
+                "insufficientGas": "Insufficient gas",
+                "deleteSwap": "Delete this swap?",
+                "deleteSwapHistory": "Delete swap history?"
+            },
+            "message": {
+                "insufficientFunds": "You don't have enough funds to execute the swap.",
+                "insufficientGas": "You need to add at least:",
+                "deleteSwap": "Swap history is only stored locally and can't be recovered if you delete it."
+            }
+        },
+        "error": {
+            "title": {
+                "chainSwitch": "Chain switch required.",
+                "transactionFailed": "Transaction has failed.",
+                "transactionUnderpriced": "Transaction is underpriced.",
+                "transactionUnprepared": "Unable to prepare transaction.",
+                "unknown": "Something went wrong.",
+                "userRejectedSignatureRequest": "Signature required.",
+                "slippageTooLarge": "Slippage too large."
+            },
+            "message": {
+                "signatureRequired": "Your signature is required to complete the transaction. {{amount}} {{tokenSymbol}} on {{chainName}} remain in your wallet.",
+                "transactionFailed": "Please check the block explorer for more information.",
+                "transactionNotSent": "Transaction was not sent, your funds are still in your wallet ({{amount}} {{tokenSymbol}} on {{chainName}}).",
+                "slippageTooLarge": "The slippage is larger than the defined threshold. Please request a new route to get a fresh quote."
+            }
+        },
+        "process": {
+            "tokenAllowance": {
+                "started": "Setting token allowance.",
+                "pending": "Waiting for token allowance.",
+                "done": "Token allowance approved."
+            },
+            "switchChain": {
+                "pending": "Chain switch required.",
+                "done": "Chain switched successfully."
+            },
+            "swap": {
+                "started": "Preparing swap.",
+                "actionRequired": "Please sign the transaction.",
+                "pending": "Swapping.",
+                "done": "Swap completed."
+            },
+            "crossChain": {
+                "started": "Preparing transaction.",
+                "actionRequired": "Please sign the transaction.",
+                "pending": "Waiting for transaction.",
+                "done": "Transaction approved."
+            },
+            "receivingChain": {
+                "pending": "Waiting for receiving chain.",
+                "done": "Funds received."
+            }
+        }
+    },
+    "settings": {
+        "routePriority": "Route priority",
+        "slippage": "Slippage",
+        "gasPrice": {
+            "title": "Gas price",
+            "slow": "Slow",
+            "normal": "Normal",
+            "fast": "Fast"
+        },
+        "advancedPreferences": "Advanced preferences",
+        "enabledBridges": "Enabled bridges",
+        "selectEnabledBridges": "Select enabled bridges",
+        "enabledExchanges": "Enabled exchanges",
+        "selectEnabledExchanges": "Select enabled exchanges",
+        "resetToDefault": "Reset to default"
+    },
+    "wallet": {
+        "extensionNotFound": "Please make sure that only the {{name}} browser extension is active before choosing this wallet."
+    },
+    "tooltip": {
+        "notFound": {
+            "title": "404",
+            "text": "We couldn't find this page."
+        },
+        "progressToNextUpdate": "Displayed data will auto-refresh after {{value}} seconds. Click this circle to update manually."
+    }
+}