@0xsquid/react-hooks 8.5.1-beta-stellar-tempo.0 → 8.6.0

package/dist/{index-BSX11dad.js → index-BvAot66c.js}

@@ -57,7 +57,7 @@ function _interopNamespaceDefault(e) {
 var bitcoin__namespace = /*#__PURE__*/_interopNamespaceDefault(bitcoin);
 var ecc__namespace = /*#__PURE__*/_interopNamespaceDefault(ecc);
 
-const squidApiBaseUrl = "https://api.uatsquidrouter.com";
+const squidApiBaseUrl = "https://v2.api.squidrouter.com";
 
 const WALLETCONNECT_PROJECT_ID = "db6a4f6ff58e4172b2fd52f01360bc49";
 const WALLETCONNECT_WALLET_IDS = {
@@ -145,9 +145,6 @@ const CHAIN_IDS = {
     SONEIUM: "1868",
     PEAQ: "3338",
     HEDERA: "295",
-    MANTRA: "5888",
-    CITREA: "4114",
-    TEMPO: "4217",
     // others
     BITCOIN: "bitcoin",
     SOLANA: "solana-mainnet-beta",
@@ -22412,7 +22409,7 @@ const keys = () => ({
     // ============
     // Transactions
     // ============
-    transaction: (fromChainId, toChainId, toTokenAddress, fromTokenAddress, price, slippage, sourceUserAddress, degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChainType, preHook, postHook, overrideGasRefundAddress) => [
+    transaction: (fromChainId, toChainId, toTokenAddress, fromTokenAddress, price, slippage, getGasOnDestination, sourceUserAddress, degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChainType, preHook, postHook, overrideGasRefundAddress) => [
         ...keys().transactions(),
         exports.QueryKeys.Transaction,
         fromChainId,
@@ -22421,6 +22418,7 @@ const keys = () => ({
         fromTokenAddress,
         price,
         slippage,
+        getGasOnDestination,
         sourceUserAddress,
         degenMode,
         destinationAddress,
@@ -22597,11 +22595,19 @@ const getPrefixKey = (key) => {
     }
 };
 
+const isNamedTokenConfig = (t) => "networkName" in t;
+const resolveChainIdFromAsset = (asset, chains) => {
+    const chainId = isNamedTokenConfig(asset)
+        ? chains.find((c) => c.networkName.toLowerCase() === asset.networkName.toLowerCase())?.chainId
+        : asset.chainId;
+    return chains.some((c) => c.chainId === chainId) ? chainId : undefined;
+};
 const getConfigWithDefaults = (config) => {
     return {
         integratorId: get$2(config, "integratorId", defaultConfigValues.integratorId),
         slippage: get$2(config, "slippage", defaultConfigValues.slippage),
         collectFees: get$2(config, "collectFees", defaultConfigValues.collectFees),
+        enableGetGasOnDestination: get$2(config, "enableGetGasOnDestination", defaultConfigValues.enableGetGasOnDestination),
         apiUrl: get$2(config, "apiUrl", defaultConfigValues.apiUrl),
         priceImpactWarnings: get$2(config, "priceImpactWarnings", defaultConfigValues.priceImpactWarnings),
         initialAssets: get$2(config, "initialAssets", defaultConfigValues.initialAssets),
@@ -22724,15 +22730,20 @@ const getInitialOrDefaultTokenAddressForChain = ({ tokens, config, chainId, dire
  * @returns The initial token address if found; otherwise, the default token address.
  */
 const getInitialTokenAddressForChain = ({ chainId, config, direction, tokens, unavailableTokenAddress, }) => {
-    if (config.initialAssets &&
-        config.initialAssets?.[direction] &&
-        config.initialAssets?.[direction]?.chainId === chainId &&
-        config.initialAssets?.[direction]?.address !== unavailableTokenAddress &&
-        // check if initial asset exists in tokens
-        tokens.some((t) => t.chainId === config.initialAssets?.[direction]?.chainId &&
-            t.address.toLowerCase() ===
-                config.initialAssets?.[direction]?.address?.toLowerCase())) {
-        return config.initialAssets?.[direction]?.address;
+    const initialAsset = config.initialAssets?.[direction];
+    if (!initialAsset)
+        return undefined;
+    if (isNamedTokenConfig(initialAsset)) {
+        if (!initialAsset.symbol)
+            return undefined;
+        return tokens.find((t) => t.chainId === chainId &&
+            t.symbol.toLowerCase() === initialAsset.symbol.toLowerCase())?.address;
+    }
+    if (initialAsset.chainId === chainId &&
+        initialAsset.address !== unavailableTokenAddress &&
+        tokens.some((t) => t.chainId === initialAsset.chainId &&
+            t.address.toLowerCase() === initialAsset.address.toLowerCase())) {
+        return initialAsset.address;
     }
 };
 /**
@@ -22777,15 +22788,14 @@ const getInitialChainIdFromConfig = ({ config, direction, chains = [], }) => {
         return undefined;
     const supportedChainIds = getSupportedChainIdsForDirection(chains.map((c) => c.chainId), config, direction);
     const availableChains = chains.filter((c) => supportedChainIds.includes(c.chainId));
-    if (direction === "from" &&
-        config.initialAssets?.from &&
-        availableChains.some((c) => c.chainId === String(config.initialAssets?.from?.chainId))) {
-        return String(config.initialAssets.from.chainId);
+    const initialAsset = config.initialAssets?.[direction];
+    if (!initialAsset)
+        return undefined;
+    if (isNamedTokenConfig(initialAsset)) {
+        return availableChains.find((c) => c.networkName.toLowerCase() === initialAsset.networkName.toLowerCase())?.chainId;
     }
-    if (direction === "to" &&
-        config.initialAssets?.to &&
-        availableChains.some((c) => c.chainId === String(config.initialAssets?.to?.chainId))) {
-        return String(config.initialAssets.to.chainId);
+    if (availableChains.some((c) => c.chainId === initialAsset.chainId)) {
+        return initialAsset.chainId;
     }
     return undefined;
 };
@@ -23091,8 +23101,8 @@ const sortAllTokens = (tokenA, tokenB) => {
     return 0;
 };
 const findToken = (tokens, chainId, address) => tokens.find((t) => t.chainId === chainId && t.address === address);
-const findNativeToken = (tokens, chain) => tokens.find((t) => t.symbol.toUpperCase() === chain.nativeCurrency.symbol.toUpperCase() &&
-    t.chainId == chain.chainId);
+const findNativeToken = (tokens, chain) => tokens.find((t) => t.symbol.toUpperCase() === chain?.nativeCurrency.symbol.toUpperCase() &&
+    t.chainId == chain?.chainId);
 const normalizeIbcAddress = (address) => {
     if (!address.toLowerCase().startsWith("ibc/")) {
         return address;
@@ -23303,7 +23313,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-ChCrHmS3.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-Cj_HK_on.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -24994,7 +25004,7 @@ class OnrampService {
         });
         return data;
     }
-    async getConfiguration({ chains: _, tokens, }) {
+    async getConfiguration({ chains, tokens, }) {
         const { data } = await axios.get(`${this.baseUrl}/config`);
         // Filter supportedCryptos to only include tokens that match our provided tokens
         const filteredCryptos = data.supportedCryptos.filter((supportedCrypto) => tokens.some((token) => token.address.toLowerCase() ===
@@ -25999,6 +26009,88 @@ function isHistoryTransactionEnded({ txType, data, }) {
     }
 }
 
+/**
+ * Parses URL search params into an initialAssets config object.
+ *
+ * Supports two formats:
+ * - Legacy:  ?chains=fromId,toId&tokens=fromAddr,toAddr
+ * - Pretty:  ?fromChain=ethereum&fromToken=eth&toChain=polygon&toToken=usdc
+ *   - Collapsed chain/token: when both from/to chains or tokens are the same,
+ *     they are collapsed into a single param:
+ *       - ?chain=ethereum -> from and to chains are both ethereum
+ *       - ?token=eth -> from and to tokens are both eth
+ */
+const parseInitialAssetsFromUrl = (searchParams) => {
+    // Legacy format
+    if (searchParams.has("chains") || searchParams.has("tokens")) {
+        const [fromTokenAddress, toTokenAddress] = searchParams.get("tokens")?.split(",") ?? [];
+        const [fromChainId, toChainId] = searchParams.get("chains")?.split(",") ?? [];
+        const from = fromChainId && fromTokenAddress
+            ? { chainId: fromChainId, address: fromTokenAddress }
+            : undefined;
+        const to = toChainId && toTokenAddress
+            ? { chainId: toChainId, address: toTokenAddress }
+            : undefined;
+        return { from, to };
+    }
+    // Pretty format
+    const chainParam = searchParams.get("chain")?.toLowerCase();
+    const tokenParam = searchParams.get("token")?.toLowerCase();
+    const fromChainParam = searchParams.get("fromChain")?.toLowerCase() ?? chainParam;
+    const toTokenExplicit = searchParams.get("toToken")?.toLowerCase();
+    // ?chain=X falls back for toChain when toToken is explicit (same-chain bridge shorthand)
+    const toChainParam = searchParams.get("toChain")?.toLowerCase() ??
+        (toTokenExplicit ? chainParam : undefined);
+    const fromTokenParam = searchParams.get("fromToken")?.toLowerCase() ?? tokenParam;
+    const toTokenParam = toTokenExplicit ?? (toChainParam ? tokenParam : undefined);
+    const from = fromChainParam
+        ? { networkName: fromChainParam, symbol: fromTokenParam }
+        : undefined;
+    const to = toChainParam
+        ? { networkName: toChainParam, symbol: toTokenParam }
+        : undefined;
+    return { from, to };
+};
+/**
+ * Builds URL search params from a `swapParamsChanged` event detail.
+ * Uses the pretty format, collapsing chain/token params when both sides match.
+ */
+const buildUrlSearchParamsFromSwapEvent = (swapParams) => {
+    const fromNetworkName = swapParams.fromNetworkName?.toLowerCase();
+    const toNetworkName = swapParams.toNetworkName?.toLowerCase();
+    const fromTokenSymbol = swapParams.fromTokenSymbol?.toLowerCase();
+    const toTokenSymbol = swapParams.toTokenSymbol?.toLowerCase();
+    const params = new URLSearchParams();
+    const bothResolved = fromNetworkName && fromTokenSymbol && toNetworkName && toTokenSymbol;
+    if (bothResolved) {
+        if (fromNetworkName === toNetworkName) {
+            params.set("chain", fromNetworkName);
+        }
+        else {
+            params.set("fromChain", fromNetworkName);
+            params.set("toChain", toNetworkName);
+        }
+        if (fromTokenSymbol === toTokenSymbol) {
+            params.set("token", fromTokenSymbol);
+        }
+        else {
+            params.set("fromToken", fromTokenSymbol);
+            params.set("toToken", toTokenSymbol);
+        }
+    }
+    else {
+        if (fromNetworkName && fromTokenSymbol) {
+            params.set("fromChain", fromNetworkName);
+            params.set("fromToken", fromTokenSymbol);
+        }
+        if (toNetworkName && toTokenSymbol) {
+            params.set("toChain", toNetworkName);
+            params.set("toToken", toTokenSymbol);
+        }
+    }
+    return params;
+};
+
 // Memoized map to store chain data, calculated only once
 let memoizedChainsByIdMap = null;
 // Optimize calculation to prevent unnecessary re-renders
@@ -26619,7 +26711,7 @@ function useStellarWallets() {
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
                 const { LedgerModule } = await import('@creit.tech/stellar-wallets-kit/modules/ledger.module');
-                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-D65n-wCV.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-CBzr6pLs.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27523,20 +27615,14 @@ const useSwap = () => {
     const { tokens } = useSquidTokens();
     const queryClient = reactQuery.useQueryClient();
     const { chains, supportedDestinationChains, supportedSourceChains } = useSquidChains();
-    const sourceChainId = React.useMemo(() => swapRoute?.fromChainId ||
-        (supportedSourceChains.find((c) => c.chainId === initialAssets?.from?.chainId) &&
-            initialAssets?.from?.chainId), [
-        swapRoute?.fromChainId,
-        supportedSourceChains,
-        initialAssets?.from?.chainId,
-    ]);
-    const destChainId = React.useMemo(() => swapRoute?.toChainId ||
-        (supportedDestinationChains.find((c) => c.chainId === initialAssets?.to?.chainId) &&
-            initialAssets?.to?.chainId), [
-        swapRoute?.toChainId,
-        supportedDestinationChains,
-        initialAssets?.to?.chainId,
-    ]);
+    const sourceChainId = React.useMemo(() => swapRoute?.fromChainId ??
+        (initialAssets?.from
+            ? resolveChainIdFromAsset(initialAssets.from, supportedSourceChains)
+            : undefined), [swapRoute?.fromChainId, supportedSourceChains, initialAssets?.from]);
+    const destChainId = React.useMemo(() => swapRoute?.toChainId ??
+        (initialAssets?.to
+            ? resolveChainIdFromAsset(initialAssets.to, supportedDestinationChains)
+            : undefined), [swapRoute?.toChainId, supportedDestinationChains, initialAssets?.to]);
     const fromChain = React.useMemo(() => supportedSourceChains.find((c) => c.chainId === swapRoute?.fromChainId), [swapRoute?.fromChainId, supportedSourceChains]);
     const toChain = React.useMemo(() => supportedDestinationChains.find((c) => c.chainId === swapRoute?.toChainId), [swapRoute?.toChainId, supportedDestinationChains]);
     const fromTokens = React.useMemo(() => getTokensForChain(tokens, sourceChainId), [tokens, sourceChainId]);
@@ -27597,11 +27683,30 @@ const useSwap = () => {
             queryClient,
             connectedSourceAddress: connectedSourceAddress.address,
         });
+        const { fromChainId, toChainId, fromTokenAddress, toTokenAddress } = newSwapParams;
+        const fromChainData = fromChainId
+            ? chains.find((c) => c.chainId === fromChainId)
+            : undefined;
+        const toChainData = toChainId
+            ? chains.find((c) => c.chainId === toChainId)
+            : undefined;
+        const fromTokenData = fromChainId && fromTokenAddress
+            ? tokens.find((t) => t.chainId === fromChainId &&
+                t.address.toLowerCase() === fromTokenAddress.toLowerCase())
+            : undefined;
+        const toTokenData = toChainId && toTokenAddress
+            ? tokens.find((t) => t.chainId === toChainId &&
+                t.address.toLowerCase() === toTokenAddress.toLowerCase())
+            : undefined;
         WidgetEvents.getInstance().dispatchSwapParamsChanged({
-            fromChainId: String(newSwapParams.fromChainId),
-            toChainId: String(newSwapParams.toChainId),
-            fromTokenAddress: newSwapParams.fromTokenAddress,
-            toTokenAddress: newSwapParams.toTokenAddress,
+            fromChainId,
+            toChainId,
+            fromTokenAddress,
+            toTokenAddress,
+            fromNetworkName: fromChainData?.networkName,
+            toNetworkName: toChainData?.networkName,
+            fromTokenSymbol: fromTokenData?.symbol,
+            toTokenSymbol: toTokenData?.symbol,
         });
         useSwapRoutePersistStore.setState({
             swapRoute: newSwapParams,
@@ -29441,8 +29546,6 @@ function useNativeTokenForChain(chain) {
         }
     };
     const nativeTokenForChainType = React.useMemo(() => {
-        if (!chain)
-            return undefined;
         return findNativeToken(getTokensForChainType(), chain);
     }, [chain]);
     return { nativeToken: nativeTokenForChainType };
@@ -29926,7 +30029,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-CkrP1GZJ.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-C_BgGjLx.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -30668,6 +30771,28 @@ function useDepositAddress(squidRoute) {
     };
 }
 
+/**
+ * Reads initial swap assets from URL params on mount, and keeps the URL in
+ * sync with swap param changes emitted by the widget.
+ */
+const useUrlSwapParams = () => {
+    const initialAssets = React.useMemo(() => typeof window !== "undefined"
+        ? parseInitialAssetsFromUrl(new URLSearchParams(window.location.search))
+        : undefined, []);
+    React.useEffect(() => {
+        const onSwapParamsChanged = (event) => {
+            const params = buildUrlSearchParamsFromSwapEvent(event?.detail);
+            const qs = params.toString();
+            history.pushState({}, "", qs ? "?" + qs : location.pathname);
+        };
+        WidgetEvents.getInstance().listenToWidget("swapParamsChanged", onSwapParamsChanged);
+        return () => {
+            WidgetEvents.getInstance().removeWidgetListener("swapParamsChanged", onSwapParamsChanged);
+        };
+    }, []);
+    return { initialAssets };
+};
+
 const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, queryOptions, }) => {
     const { evmChains, cosmosChains, suiChains, xrplChains, stellarChains } = useSquidChains(direction);
     const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = useSquidTokens(direction);
@@ -31052,143 +31177,6 @@ const useSingleTokenPrice = (tokenData) => {
     return { tokenPrice, getUSDValue };
 };
 
-const TEMPO_FEE_MANAGER_ADDRESS = "0xfeec000000000000000000000000000000000000";
-const feeManagerAbi = [
-    {
-        name: "userTokens",
-        type: "function",
-        stateMutability: "view",
-        inputs: [{ type: "address", name: "user" }],
-        outputs: [{ type: "address" }],
-    },
-];
-const isTempoChain = (chainId) => chainId === CHAIN_IDS.TEMPO;
-/**
- * Convert a fee amount from virtual USD (18 decimals, attodollars)
- * to 6-decimal TIP-20 stablecoin units (microdollars).
- * All TIP-20 tokens on Tempo have 6 decimals.
- */
-const convertTempoFeeToStablecoinUnits = (feeIn18Dec) => feeIn18Dec / BigInt(10 ** 12);
-
-const BALANCE_QUERY_STALE_TIME = 10_000;
-/**
- * Returns raw on-chain gas token data for Tempo chains, or null when the source
- * chain is not Tempo.
- */
-const useTempoFeeCheck = ({ fromChain, fromToken, }) => {
-    const { connectedAddresses } = useWallet();
-    const evmAddress = parseEvmAddress(connectedAddresses[squidTypes.ChainType.EVM]);
-    const isTempo = isTempoChain(fromChain?.chainId);
-    const chainId = Number(fromChain?.chainId);
-    // Read account-level gas token preference from FeeManager precompile
-    // See docs: https://docs.tempo.xyz/protocol/fees/spec-fee#account-level
-    const { data: accountGasTokenAddress } = wagmi.useReadContract({
-        address: TEMPO_FEE_MANAGER_ADDRESS,
-        abi: feeManagerAbi,
-        functionName: "userTokens",
-        args: evmAddress ? [evmAddress] : undefined,
-        chainId,
-        query: {
-            enabled: isTempo && !!evmAddress,
-            staleTime: 30_000,
-        },
-    });
-    const hasAccountFeePreference = !!accountGasTokenAddress &&
-        // By default, the zero address is returned when the user has no preference set
-        viem.zeroAddress.toLowerCase() !== accountGasTokenAddress.toLowerCase();
-    // Fetch balance of the account-preferred gas token (if set)
-    const { data: accountGasTokenBalance } = wagmi.useBalance({
-        address: evmAddress,
-        token: hasAccountFeePreference ? accountGasTokenAddress : undefined,
-        chainId,
-        query: {
-            enabled: isTempo && hasAccountFeePreference && !!evmAddress,
-            staleTime: BALANCE_QUERY_STALE_TIME,
-        },
-    });
-    const fromTokenAddress = parseEvmAddress(fromToken?.address);
-    const { data: fromTokenBalance } = wagmi.useBalance({
-        address: evmAddress,
-        token: fromTokenAddress,
-        chainId,
-        query: {
-            enabled: isTempo && !!evmAddress,
-            staleTime: BALANCE_QUERY_STALE_TIME,
-        },
-    });
-    if (!isTempo)
-        return null;
-    if (hasAccountFeePreference) {
-        if (!accountGasTokenAddress || !accountGasTokenBalance)
-            return null;
-        return {
-            gasTokenAddress: accountGasTokenAddress,
-            gasBalance: accountGasTokenBalance.value,
-        };
-    }
-    if (!fromTokenAddress || !fromTokenBalance)
-        return null;
-    return {
-        gasTokenAddress: fromTokenAddress,
-        gasBalance: fromTokenBalance.value,
-    };
-};
-
-function useSourceChainGasToken({ fromChain, fromToken, }) {
-    const { nativeToken } = useNativeTokenForChain(fromChain);
-    const { evmTokens } = useSquidTokens();
-    const { nativeBalance } = useNativeBalance(fromChain);
-    const tempoFeeData = useTempoFeeCheck({ fromChain, fromToken });
-    const chainFeeParams = React.useMemo(() => {
-        if (fromToken?.address == null ||
-            fromChain?.chainId == null ||
-            nativeBalance?.value == null) {
-            return null;
-        }
-        if (isTempoChain(fromChain.chainId)) {
-            if (!tempoFeeData)
-                return null;
-            const fromTokenPaysNetworkFee = tempoFeeData.gasTokenAddress.toLowerCase() ===
-                fromToken.address.toLowerCase();
-            return {
-                fromTokenPaysNetworkFee,
-                gasTokenBalanceWei: tempoFeeData.gasBalance,
-                normalizeFee: convertTempoFeeToStablecoinUnits,
-            };
-        }
-        return {
-            fromTokenPaysNetworkFee: fromToken.address.toLowerCase() ===
-                chainTypeToNativeTokenAddressMap[fromToken.type].toLowerCase(),
-            gasTokenBalanceWei: nativeBalance.value,
-            normalizeFee: (fee) => fee,
-        };
-    }, [
-        fromToken?.address,
-        fromToken?.type,
-        fromChain?.chainId,
-        nativeBalance?.value,
-        tempoFeeData,
-    ]);
-    const gasToken = React.useMemo(() => {
-        if (fromChain?.chainId == null || fromToken?.address == null)
-            return undefined;
-        if (isTempoChain(fromChain.chainId)) {
-            if (!tempoFeeData)
-                return undefined;
-            return evmTokens.find((t) => t.chainId === fromChain.chainId &&
-                t.address.toLowerCase() === tempoFeeData.gasTokenAddress.toLowerCase());
-        }
-        return nativeToken;
-    }, [
-        fromChain?.chainId,
-        fromToken?.address,
-        nativeToken,
-        tempoFeeData,
-        evmTokens,
-    ]);
-    return { gasToken, chainFeeParams };
-}
-
 const MAX_COINGECKO_QUERY_TOKENS = 100;
 const fetchHistoricalData = async (coingeckoId, timeFrame) => {
     const now = Math.floor(Date.now() / 1000);
@@ -31339,23 +31327,24 @@ const calculateTotalNativeFees = ({ expressFeeCost, firstFeeCost, firstGasCost,
     (sameTokenBetweenFees
         ? BigInt(firstFeeCost?.amount ?? "0") + BigInt(firstGasCost?.amount ?? "0")
         : BigInt(firstGasCost?.amount ?? "0"));
-const isGasBalanceEnough = ({ fromAmount, networkFeesWei, chainFeeParams, }) => {
-    if (!chainFeeParams)
-        return false;
-    if (chainFeeParams.fromTokenPaysNetworkFee) {
-        return (BigInt(fromAmount ?? "0") + networkFeesWei <=
-            chainFeeParams.gasTokenBalanceWei);
-    }
-    return networkFeesWei <= chainFeeParams.gasTokenBalanceWei;
-};
-const calculateMinAmountValueWarnMsg = ({ networkFeesWei, chainFeeParams, fromTokenDecimals, }) => {
-    if (!chainFeeParams?.fromTokenPaysNetworkFee)
-        return undefined;
-    const minAmount = chainFeeParams.gasTokenBalanceWei - networkFeesWei;
-    if (minAmount <= BigInt(0))
-        return undefined;
-    return formatBNToReadable(minAmount, fromTokenDecimals);
-};
+const isFromBalanceEnoughToSwap = ({ isFromTokenNative, fromAmount, totalFeesInNativeTokenPlusRatio, nativeTokenBalanceFromChainWei, }) => {
+    const fromAmountBigInt = BigInt(fromAmount ?? "0");
+    const totalFeesInNativeTokenPlusRatioBigInt = totalFeesInNativeTokenPlusRatio;
+    const nativeTokenBalanceFromChainWeiBigInt = nativeTokenBalanceFromChainWei;
+    return isFromTokenNative
+        ? fromAmountBigInt + totalFeesInNativeTokenPlusRatioBigInt <=
+            nativeTokenBalanceFromChainWeiBigInt
+        : totalFeesInNativeTokenPlusRatioBigInt <=
+            nativeTokenBalanceFromChainWeiBigInt;
+};
+const calculateMinAmountValueWarnMsg = ({ isFromTokenNative, nativeTokenBalanceFromChainWei, sourceChainNativeTokenDecimals, totalFeesInNativeTokenPlusRatio, }) => isFromTokenNative
+    ? (() => {
+        const minAmount = nativeTokenBalanceFromChainWei - totalFeesInNativeTokenPlusRatio;
+        return minAmount > BigInt(0)
+            ? formatBNToReadable(minAmount, sourceChainNativeTokenDecimals)
+            : "0";
+    })()
+    : undefined;
 /**
  * Calculates the estimated duration of a route
  *
@@ -31394,10 +31383,12 @@ const formatEstimatedRouteDuration = ({ estimatedRouteDuration, isSingleChainRou
  * @returns {Object} An object containing various estimate results and calculations, including token information,
  *                   amounts, fees, gas costs, and other relevant data for the transaction.
  */
-const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, collectFees, chainFeeParams, gasToken, }) => {
+const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, collectFees, nativeTokenBalanceFromChainWei, }) => {
     const fromToken = findToken(tokens, squidRoute?.params.fromChain, squidRoute?.params.fromToken);
     const fromAmount = squidRoute?.estimate?.fromAmount;
     const fromAmountFormatted = formatAmount(fromAmount, fromToken?.decimals);
+    const sourceChainNativeToken = findNativeToken(tokens, fromChain);
+    const destChainNativeToken = findNativeToken(tokens, toChain);
     const toAmountUSD = squidRoute?.estimate?.toAmountUSD;
     const exchangeRate = squidRoute?.estimate.exchangeRate ?? "0";
     const toAmountMinUSD = squidRoute?.estimate.toAmountMinUSD ?? "0";
@@ -31416,6 +31407,10 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
     const expectedGasRefundCostUSD = convertTokenAmountToUSD(formatBNToReadable(expectedGasRefundCost, firstFeeCost?.token.decimals ?? 18), firstFeeCost?.token.usdPrice ?? "0");
     const sameTokenBetweenFees = firstFeeCost?.token.address === firstGasCost?.token.address &&
         firstFeeCost?.token.chainId === firstGasCost?.token.chainId;
+    const isFromTokenNative = 
+    // TODO: temporary fix, currently nativeCurrency.symbol is not always in uppercase
+    fromToken?.symbol.toUpperCase() ===
+        fromChain?.nativeCurrency.symbol.toUpperCase();
     const totalNativeFees = calculateTotalNativeFees({
         expressFeeCost,
         firstFeeCost,
@@ -31423,32 +31418,30 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         sameTokenBetweenFees,
     });
     const totalFeesInNativeTokenPlusRatio = (totalNativeFees * BigInt(110)) / BigInt(100);
-    const networkFeesWei = chainFeeParams?.normalizeFee(totalFeesInNativeTokenPlusRatio) ?? BigInt(0);
-    const gasBalanceEnough = isGasBalanceEnough({
-        chainFeeParams,
+    const fromBalanceEnoughToSwap = isFromBalanceEnoughToSwap({
+        isFromTokenNative,
         fromAmount,
-        networkFeesWei,
+        fromTokenDecimals: fromToken?.decimals,
+        totalFeesInNativeTokenPlusRatio,
+        nativeTokenBalanceFromChainWei,
     });
     const minAmountValueWarnMsg = calculateMinAmountValueWarnMsg({
-        chainFeeParams,
-        networkFeesWei,
-        fromTokenDecimals: fromToken?.decimals,
+        isFromTokenNative,
+        nativeTokenBalanceFromChainWei,
+        sourceChainNativeTokenDecimals: sourceChainNativeToken?.decimals,
+        totalFeesInNativeTokenPlusRatio,
     });
     const isSingleChainRoute = fromChain?.chainId === toChain?.chainId;
     const estimatedRouteDuration = formatEstimatedRouteDuration({
         estimatedRouteDuration: squidRoute?.estimate?.estimatedRouteDuration,
         isSingleChainRoute,
     });
-    // native fees + fromAmount (if native)
-    const totalGasBalanceNeeded = networkFeesWei +
-        BigInt(chainFeeParams?.fromTokenPaysNetworkFee ? fromAmount ?? 0 : 0);
-    const gasBalanceNeeded = gasToken
-        ? formatBNToReadable(totalGasBalanceNeeded, gasToken.decimals)
-        : undefined;
     return {
         fromToken,
         fromAmount,
         fromAmountFormatted,
+        sourceChainNativeToken,
+        destChainNativeToken,
         toAmountUSD,
         exchangeRate,
         toAmountMinUSD,
@@ -31463,12 +31456,12 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         expectedGasRefundCost,
         expectedGasRefundCostUSD,
         sameTokenBetweenFees,
-        fromTokenPaysNetworkFee: chainFeeParams?.fromTokenPaysNetworkFee ?? false,
+        isFromTokenNative,
         totalNativeFees,
-        gasBalanceEnough,
+        totalFeesInNativeTokenPlusRatio,
+        fromBalanceEnoughToSwap,
         minAmountValueWarnMsg,
         estimatedRouteDuration,
-        gasBalanceNeeded,
     };
 };
 /**
@@ -31502,6 +31495,28 @@ const calculateTotalWithRefundEstimate = (allFeeCosts, expectedGasRefundCost, ge
         feeToken: firstFeeCost?.token,
     };
 };
+/**
+ * Calculates the proposed gas amount for the destination chain.
+ *
+ * @param destChainNativeToken - The symbol of the native token for the destination chain.
+ * @returns An object containing the proposed gas amount value and the currency symbol.
+ */
+const getProposedGasDestinationAmount = (destChainNativeToken) => {
+    const gasAmounts = {
+        GLMR: 5.289,
+        ETH: 0.0009,
+        AVAX: 0.115,
+        BNB: 0.00425,
+        FTM: 4.45,
+        CELO: 3.052,
+        KAVA: 2.339,
+        MATIC: 1.795,
+    };
+    return {
+        value: gasAmounts[destChainNativeToken ?? ""] ?? 0,
+        currency: destChainNativeToken,
+    };
+};
 
 function useSendTransactionGas({ chain, token, from, }) {
     return reactQuery.useQuery({
@@ -31523,11 +31538,7 @@ function useSendTransactionGas({ chain, token, from, }) {
                     // Some RPC providers require the sender to have enough balance, otherwise estimation reverts
                     // so we'll try to use the user provided address when possible
                     const sender = from || dummyAddress;
-                    // Tempo has no native token, so `value` transfers are rejected by the EVM.
-                    // We can simulate an ERC20 transfer instead
-                    const supportsNativeTransfers = chain.chainId !== CHAIN_IDS.TEMPO;
-                    const isNativeToken = token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase();
-                    if (isNativeToken && supportsNativeTransfers) {
+                    if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase()) {
                         const gas = await client.estimateGas({
                             from: sender,
                             to: dummyAddress,
@@ -31547,14 +31558,7 @@ function useSendTransactionGas({ chain, token, from, }) {
                         data,
                         chainId: chain.chainId,
                     });
-                    const feeWei = gas * maxFeePerGas;
-                    // Tempo fees are denominated in virtual USD (18 dec, 1e-18 USD units).
-                    // Convert to 6-dec stablecoin units so all callers receive a
-                    // consistent unit without needing to know about the chain.
-                    if (chain.chainId === CHAIN_IDS.TEMPO) {
-                        return convertTempoFeeToStablecoinUnits(feeWei);
-                    }
-                    return feeWei;
+                    return gas * maxFeePerGas;
                 }
                 case squidTypes.ChainType.COSMOS: {
                     // TODO: get gas estimation from backend
@@ -31601,33 +31605,19 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
         token,
         from,
     });
-    const { chainFeeParams, gasToken } = useSourceChainGasToken({
-        fromChain: chain,
-        fromToken: token,
-    });
-    const gasBalanceEnough = React.useMemo(() => {
-        if (!amount || !token?.decimals)
+    const { nativeBalance } = useNativeBalance(chain);
+    const isNativeBalanceEnoughToPayGasFees = React.useMemo(() => {
+        if (!nativeBalance?.value || !amount || !token?.decimals) {
             return false;
-        return isGasBalanceEnough({
-            fromAmount: parseToBigInt(amount, token.decimals).toString(),
-            networkFeesWei: estimatedGas,
-            chainFeeParams,
-        });
-    }, [amount, estimatedGas, token, chainFeeParams]);
-    const gasBalanceNeeded = React.useMemo(() => {
-        if (!amount || !token?.decimals || !gasToken?.decimals)
-            return undefined;
-        // native fees + fromAmount (if native)
-        const totalGasBalanceNeeded = estimatedGas +
-            parseToBigInt(chainFeeParams?.fromTokenPaysNetworkFee ? amount ?? "0" : "0", token.decimals);
-        return formatBNToReadable(totalGasBalanceNeeded, gasToken.decimals);
-    }, [
-        amount,
-        chainFeeParams?.fromTokenPaysNetworkFee,
-        estimatedGas,
-        gasToken?.decimals,
-        token?.decimals,
-    ]);
+        }
+        const isTokenNative = token.address.toLowerCase() ===
+            chainTypeToNativeTokenAddressMap[token.type].toLowerCase();
+        if (isTokenNative) {
+            return (parseToBigInt(amount, token.decimals) + estimatedGas <=
+                nativeBalance.value);
+        }
+        return estimatedGas <= nativeBalance.value;
+    }, [amount, estimatedGas, nativeBalance?.value, token]);
     const isBalanceEnough = React.useMemo(() => {
         if (token?.decimals == null || !balance || !amount)
             return false;
@@ -31635,21 +31625,28 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
             parseToBigInt(amount, token.decimals));
     }, [amount, balance, token?.decimals]);
     const minAmountValueWarnMsg = React.useMemo(() => {
-        if (!token?.address || !estimatedGas || !chainFeeParams)
+        if (!token?.address || !nativeBalance?.value || !estimatedGas)
             return undefined;
+        const isFromTokenNative = token.address.toLowerCase() ===
+            chainTypeToNativeTokenAddressMap[token.type].toLowerCase();
         return calculateMinAmountValueWarnMsg({
-            chainFeeParams,
-            networkFeesWei: estimatedGas,
-            fromTokenDecimals: token.decimals,
+            isFromTokenNative,
+            nativeTokenBalanceFromChainWei: nativeBalance.value,
+            sourceChainNativeTokenDecimals: nativeBalance.decimals,
+            totalFeesInNativeTokenPlusRatio: estimatedGas,
         });
-    }, [estimatedGas, token, chainFeeParams]);
+    }, [
+        estimatedGas,
+        nativeBalance?.decimals,
+        nativeBalance?.value,
+        token?.address,
+        token?.type,
+    ]);
     return {
         estimatedGas,
-        gasBalanceNeeded,
         isBalanceEnough,
-        tokenPaysNetworkFee: chainFeeParams?.fromTokenPaysNetworkFee ?? false,
         isLoading,
-        isGasBalanceEnough: gasBalanceEnough,
+        isNativeBalanceEnoughToPayGasFees,
         minAmountValueWarnMsg,
     };
 }
@@ -32711,7 +32708,7 @@ const useApproval = ({ squidRoute, }) => {
             // This is to ensure we're using the latest expiry timestamp
             if (squidRoute) {
                 queryClient.refetchQueries({
-                    queryKey: keys().transaction(squidRoute.params.fromChain, squidRoute.params.toChain, squidRoute.params.toToken, squidRoute.params.fromToken, fromPrice, squidRoute.params.slippage, squidRoute.params.fromAddress, squidRoute.params.bypassGuardrails, squidRoute.params.toAddress, squidRoute.params.fallbackAddresses?.[0]?.address, squidRoute.params.quoteOnly, getChainType(squidRoute.params.fromChain), squidRoute.params.preHook, squidRoute.params.postHook, 
+                    queryKey: keys().transaction(squidRoute.params.fromChain, squidRoute.params.toChain, squidRoute.params.toToken, squidRoute.params.fromToken, fromPrice, squidRoute.params.slippage, squidRoute.params.receiveGasOnDestination, squidRoute.params.fromAddress, squidRoute.params.bypassGuardrails, squidRoute.params.toAddress, squidRoute.params.fallbackAddresses?.[0]?.address, squidRoute.params.quoteOnly, getChainType(squidRoute.params.fromChain), squidRoute.params.preHook, squidRoute.params.postHook, 
                     // TODO: update types
                     squidRoute.params?.overrideGasRefundAddress),
                 });
@@ -32730,30 +32727,17 @@ const AXELAR_PROVIDER_IMAGE_URL = "https://raw.githubusercontent.com/0xsquid/ass
 const useEstimate = (squidRoute) => {
     const collectFees = useConfigStore((state) => state.config.collectFees);
     const { tokens } = useSquidTokens();
-    const { fromChain, toChain, fromPrice } = useSwap();
-    const fromToken = React.useMemo(() => findToken(tokens, squidRoute?.params.fromChain, squidRoute?.params.fromToken), [tokens, squidRoute?.params.fromChain, squidRoute?.params.fromToken]);
-    const { chainFeeParams, gasToken } = useSourceChainGasToken({
-        fromChain,
-        fromToken,
-    });
+    const { fromChain, toChain } = useSwap();
+    const { nativeBalance } = useNativeBalance(fromChain);
     const estimateResults = React.useMemo(() => calculateEstimateResults({
         squidRoute,
         tokens,
         fromChain,
         toChain,
         collectFees: !!collectFees && collectFees.fee > 0,
-        chainFeeParams,
-        gasToken,
-    }), [
-        squidRoute,
-        tokens,
-        fromChain,
-        toChain,
-        collectFees,
-        chainFeeParams,
-        gasToken,
-    ]);
-    const fromBalanceFormatted = useMultiChainBalance({
+        nativeTokenBalanceFromChainWei: nativeBalance?.value ?? BigInt("0"),
+    }), [squidRoute, tokens, fromChain, toChain, collectFees, nativeBalance]);
+    const balanceFormatted = useMultiChainBalance({
         chain: fromChain,
         token: estimateResults.fromToken,
         userAddress: squidRoute?.params.fromAddress ?? "",
@@ -32765,6 +32749,7 @@ const useEstimate = (squidRoute) => {
         estimateResults.expectedGasRefundCost,
         getUSDValue,
     ]);
+    const proposedGasDestinationAmount = React.useMemo(() => getProposedGasDestinationAmount(estimateResults.destChainNativeToken?.symbol), [estimateResults.destChainNativeToken]);
     const { feeCostsFormatted, totalFeeCostsUsd } = React.useMemo(() => {
         const feeCosts = squidRoute?.estimate.feeCosts ?? [];
         const feeCostsRenamed = [];
@@ -32823,21 +32808,21 @@ const useEstimate = (squidRoute) => {
             totalFeeCostsUsd: totalFeeCostsUsdFormatted,
         };
     }, [squidRoute?.estimate.feeCosts]);
-    const slippageFormatted = Number(squidRoute?.estimate?.aggregateSlippage ?? 0).toFixed(2) + "%";
-    const fromBalanceEnoughToSwap = React.useMemo(() => {
-        const fromBalanceNum = Number(fromBalanceFormatted ?? 0);
-        const fromPriceNum = Number(fromPrice ?? 0);
-        return fromBalanceNum >= fromPriceNum;
-    }, [fromBalanceFormatted, fromPrice]);
+    const slippageFormatted = 
+    // TODO: update types
+    Number(squidRoute?.estimate?.aggregateSlippage ?? 0).toFixed(2) +
+        "%";
+    const enoughBalanceToSwap = +balanceFormatted >= 0 &&
+        +balanceFormatted > +estimateResults.fromAmountFormatted;
     return {
         ...estimateResults,
-        fromBalanceFormatted,
+        balanceFormatted,
         slippageFormatted,
         totalWithRefundEstimate,
-        fromBalanceEnoughToSwap,
+        proposedGasDestinationAmount,
+        enoughBalanceToSwap,
         feeCostsFormatted,
         totalFeeCostsUsd,
-        gasToken,
     };
 };
 
@@ -36605,7 +36590,7 @@ const useGetRoute = () => {
         });
         // Cache the route data
         // Useful when the getRoute mutation is called from another hook
-        queryClient.setQueryData(keys().transaction(fromChain, toChain, toToken.address, fromToken.address, fromPrice, config.slippage, sourceUserAddress, config.degenMode, destinationAddress, swapRoute?.fallbackAddress, quoteOnly, fromChainType, config.preHook, config.postHook, overrideGasRefundAddress), route);
+        queryClient.setQueryData(keys().transaction(fromChain, toChain, toToken.address, fromToken.address, fromPrice, config.slippage, config.enableGetGasOnDestination, sourceUserAddress, config.degenMode, destinationAddress, swapRoute?.fallbackAddress, quoteOnly, fromChainType, config.preHook, config.postHook, overrideGasRefundAddress), route);
         return route;
     });
 };
@@ -36628,13 +36613,14 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     const sourceUserAddress = isDepositAddressEnabled && isAvailableAsPaymentMethod
         ? depositRefundAddress ?? sourceConnectedAddress
         : sourceConnectedAddress;
-    const squidRouteQueryKeys = React.useMemo(() => keys().transaction(fromChain?.chainId, toChain?.chainId, toToken?.address, fromToken?.address, fromPrice, config.slippage, sourceUserAddress, config.degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChain?.chainType, config.preHook, config.postHook, config.overrideGasRefundAddress), [
+    const squidRouteQueryKeys = React.useMemo(() => keys().transaction(fromChain?.chainId, toChain?.chainId, toToken?.address, fromToken?.address, fromPrice, config.slippage, config.enableGetGasOnDestination, sourceUserAddress, config.degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChain?.chainType, config.preHook, config.postHook, config.overrideGasRefundAddress), [
         fromChain?.chainId,
         toChain?.chainId,
         toToken?.address,
         fromToken?.address,
         fromPrice,
         config.slippage,
+        config.enableGetGasOnDestination,
         sourceUserAddress,
         config.degenMode,
         destinationAddress,
@@ -36906,6 +36892,35 @@ const useAvatar = (seed = zeroAddress) => {
     return avatar || "";
 };
 
+const useUserParams = () => {
+    const enableGetGasOnDestination = useConfigStore((state) => state.config.enableGetGasOnDestination);
+    const { fromToken, toToken, toChain, fromChain } = useSwap();
+    //   =============
+    //       GAS
+    //   =============
+    const getGasOnDestSupportedForThisRoute = React.useMemo(() => 
+    // Not supporting get gas on dest for same chains
+    fromChain?.chainId !== toChain?.chainId &&
+        // If the destination chain is cosmos, we don't support getting gas there
+        toChain?.chainType !== squidTypes.ChainType.COSMOS &&
+        // Not supporting get gas on dest for same tokens (bridge)
+        ((fromToken?.subGraphIds?.some((sgi) => !!toToken?.subGraphIds?.includes(sgi)) &&
+            toToken?.subGraphIds?.some((sgi) => !!fromToken?.subGraphIds?.includes(sgi))) ||
+            // Except for uusdc -> uusdc
+            (fromToken?.subGraphIds?.includes("uusdc") &&
+                toToken?.subGraphIds?.includes("uusdc"))), [
+        fromChain?.chainId,
+        fromToken?.subGraphIds,
+        toChain?.chainId,
+        toToken?.subGraphIds,
+        toChain?.chainType,
+    ]);
+    return {
+        gasEnabled: enableGetGasOnDestination && getGasOnDestSupportedForThisRoute,
+        getGasOnDestSupportedForThisRoute,
+    };
+};
+
 const useAddToken = (chainToCompare, tokenToCompare) => {
     const { chain: currentEvmChain } = wagmi.useAccount();
     const { connector } = wagmi.useAccount();
@@ -37353,6 +37368,7 @@ exports.addTokenToWallet = addTokenToWallet;
 exports.areSameAddress = areSameAddress;
 exports.areTokenSymbolsCompatible = areTokenSymbolsCompatible;
 exports.assetsBaseUrl = assetsBaseUrl;
+exports.buildUrlSearchParamsFromSwapEvent = buildUrlSearchParamsFromSwapEvent;
 exports.buildXrplTrustSetTx = buildXrplTrustSetTx;
 exports.calculateTotal24hChange = calculateTotal24hChange;
 exports.calculateTotalUsdBalanceUSD = calculateTotalUsdBalanceUSD;
@@ -37485,12 +37501,14 @@ exports.normalizeError = normalizeError;
 exports.normalizeIbcAddress = normalizeIbcAddress;
 exports.normalizeTokenSymbol = normalizeTokenSymbol;
 exports.parseEvmAddress = parseEvmAddress;
+exports.parseInitialAssetsFromUrl = parseInitialAssetsFromUrl;
 exports.parseToBigInt = parseToBigInt;
 exports.parseXrplPaymentTx = parseXrplPaymentTx;
 exports.parseXrplTokenAddress = parseXrplTokenAddress;
 exports.populateWallets = populateWallets;
 exports.randomIntFromInterval = randomIntFromInterval;
 exports.redirectToExtensionsStore = redirectToExtensionsStore;
+exports.resolveChainIdFromAsset = resolveChainIdFromAsset;
 exports.roundNumericValue = roundNumericValue;
 exports.scaleHbarToWei = scaleHbarToWei;
 exports.scaleWeiToHbar = scaleWeiToHbar;
@@ -37567,7 +37585,6 @@ exports.useSendTransactionStore = useSendTransactionStore;
 exports.useSigner = useSigner;
 exports.useSingleTokenPrice = useSingleTokenPrice;
 exports.useSolanaNativeBalance = useSolanaNativeBalance;
-exports.useSourceChainGasToken = useSourceChainGasToken;
 exports.useSquid = useSquid;
 exports.useSquidChains = useSquidChains;
 exports.useSquidQueryClient = useSquidQueryClient;
@@ -37584,6 +37601,8 @@ exports.useSwapTransactionStatus = useSwapTransactionStatus;
 exports.useTokensData = useTokensData;
 exports.useTrackSearchEmpty = useTrackSearchEmpty;
 exports.useTransactionStore = useTransactionStore;
+exports.useUrlSwapParams = useUrlSwapParams;
+exports.useUserParams = useUserParams;
 exports.useWallet = useWallet;
 exports.useWalletStore = useWalletStore;
 exports.useWallets = useWallets;
@@ -37592,4 +37611,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-BSX11dad.js.map
+//# sourceMappingURL=index-BvAot66c.js.map