@0xsquid/react-hooks 8.12.1-beta-arc.0 → 8.12.1-beta-arc.1

package/dist/{index-BBJD55XX.js → index-8RIq6GyB.js}

@@ -20965,24 +20965,6 @@ const isBitcoinAddressValid = (address) => {
     }
 };
 
-const arcUsdcTokenAddress = "0x3600000000000000000000000000000000000000";
-const isArcChain = (chainId) => chainId === CHAIN_IDS.ARC;
-const isArcUsdcToken = (token) => isArcChain(token?.chainId) &&
-    token?.address.toLowerCase() === arcUsdcTokenAddress;
-const isArcNativeToken = (token) => isArcChain(token?.chainId) &&
-    token?.address.toLowerCase() === nativeEvmTokenAddress;
-const normalizeArcTokenAddress = (chainId, address) => isArcChain(chainId) && address?.toLowerCase() === nativeEvmTokenAddress
-    ? arcUsdcTokenAddress
-    : address;
-const deduplicateArcBalances = (tokens) => {
-    const canonicalChains = new Set(tokens
-        .filter((token) => isArcChain(token.chainId) &&
-        token.address?.toLowerCase() === arcUsdcTokenAddress)
-        .map((token) => token.chainId));
-    return tokens.filter((token) => !(canonicalChains.has(token.chainId) &&
-        token.address?.toLowerCase() === nativeEvmTokenAddress));
-};
-
 function getCantonCommandId(memo) {
     return `canton-${memo}`;
 }
@@ -22219,7 +22201,7 @@ function sortAddressBook(a, b, selectedAddress) {
     return 0;
 }
 const calculateTotalUsdBalanceUSD = (tokens) => {
-    const totalUsd = deduplicateArcBalances(tokens).reduce((total, token) => {
+    const totalUsd = tokens.reduce((total, token) => {
         const balance = parseFloat(token.balance);
         const usdPrice = token.usdPrice ?? 0;
         const balanceUsd = balance * usdPrice;
@@ -23031,36 +23013,22 @@ const getFirstAvailableChainId = (config, direction, chains = []) => {
     // if no initial chain ID is found in config, return the first available chain ID
     return availableChains.length > 0 ? availableChains[0].chainId : undefined;
 };
-const fetchHighestBalanceToken = (fetchCachedBalance, chainId, selectableTokens, direction) => {
+const fetchHighestBalanceToken = (fetchCachedBalance, chainId) => {
     let address = undefined;
     if (fetchCachedBalance) {
         const queryCache = fetchCachedBalance?.queryClient?.getQueryCache();
-        const directionCache = isArcChain(chainId) && direction
-            ? queryCache?.find(keys().allTokensBalance(fetchCachedBalance.address, squidTypes.ChainType.EVM, direction))
-            : undefined;
         // get cached balance from key
-        const cache = directionCache?.state.data !== undefined
-            ? directionCache
-            : queryCache?.find(keys().allTokensBalance(fetchCachedBalance?.address, !isNaN(Number(chainId)) ? squidTypes.ChainType.EVM : squidTypes.ChainType.COSMOS));
-        const cacheData = cache?.state.data;
-        const cacheResult = Array.isArray(cacheData)
-            ? cacheData
-            : isArcChain(chainId)
-                ? (cacheData?.tokens ?? [])
-                : [];
+        const cache = queryCache?.find(keys().allTokensBalance(fetchCachedBalance?.address, !isNaN(Number(chainId)) ? squidTypes.ChainType.EVM : squidTypes.ChainType.COSMOS));
+        // Parse result to TokenWithBalance[]
+        const cacheResult = cache?.state.data ?? [];
         if (cacheResult.length > 0) {
-            const tokensWithBalance = deduplicateArcBalances(cacheResult).filter((t) => t.chainId === chainId &&
-                Number(t.balance) > 0 &&
-                (!selectableTokens ||
-                    selectableTokens.some((token) => token.chainId === t.chainId &&
-                        token.address.toLowerCase() ===
-                            normalizeArcTokenAddress(t.chainId, t.address)?.toLowerCase())));
+            const tokensWithBalance = cacheResult.filter((t) => t.chainId === chainId && Number(t.balance) > 0);
             if (tokensWithBalance.length > 0) {
                 // Return the token with the highest balance
                 // TODO: At the moment we're not taking into account usd price
                 const tokenWithHighestBalance = tokensWithBalance.reduce((prev, current) => Number(prev.balance) > Number(current.balance) ? prev : current);
                 if (tokenWithHighestBalance) {
-                    address = normalizeArcTokenAddress(tokenWithHighestBalance.chainId, tokenWithHighestBalance.address);
+                    address = tokenWithHighestBalance.address;
                 }
             }
         }
@@ -23071,21 +23039,6 @@ const findNativeTokenForChainType = (tokens) => {
     return tokens.find((t) => t.address.toLowerCase() ===
         chainTypeToNativeTokenAddressMap[t.type].toLowerCase());
 };
-const getTokenAddressForSelection = ({ tokens, config, chainId, address, direction, excludeToken, }) => {
-    if (!isArcChain(chainId))
-        return address;
-    const normalizedAddress = normalizeArcTokenAddress(chainId, address);
-    const excludedAddress = normalizeArcTokenAddress(excludeToken?.chainId, excludeToken?.address);
-    if (!chainId ||
-        !normalizedAddress ||
-        (excludeToken?.chainId === chainId &&
-            normalizedAddress.toLowerCase() === excludedAddress?.toLowerCase()) ||
-        !getSupportedChainIdsForDirection([chainId], config, direction).includes(chainId)) {
-        return undefined;
-    }
-    return filterViewableTokens(tokens, config, direction).find((token) => token.chainId === chainId &&
-        token.address.toLowerCase() === normalizedAddress.toLowerCase())?.address;
-};
 /**
  * Returns the default token address for a specific chain and direction based on config.
  * If no default tokens are set in config, returns the native token for the specified chain
@@ -23103,25 +23056,6 @@ const getInitialOrDefaultTokenAddressForChain = ({ tokens, config, chainId, dire
     const supportedChainIds = getSupportedChainIdsForDirection([chainId], config, direction);
     if (!supportedChainIds.includes(chainId))
         return;
-    if (isArcChain(chainId)) {
-        const selectAddress = (address) => getTokenAddressForSelection({
-            tokens,
-            config,
-            chainId,
-            address,
-            direction,
-            excludeToken,
-        });
-        const selectableTokens = tokens.filter((token) => token.chainId === chainId &&
-            !isArcNativeToken(token) &&
-            selectAddress(token.address) !== undefined);
-        return (selectAddress(config.defaultTokensPerChain?.find((token) => token.chainId === chainId)
-            ?.address) ??
-            selectAddress(getInitialTokenAddressForChain({ tokens, config, chainId, direction })) ??
-            selectAddress(fetchHighestBalanceToken(fetchCachedBalance, chainId, selectableTokens, direction)) ??
-            selectAddress(arcUsdcTokenAddress) ??
-            selectableTokens[0]?.address);
-    }
     const configDefaultTokenForChain = config.defaultTokensPerChain?.find((token) => token.chainId == chainId);
     // get default token from config
     if (configDefaultTokenForChain &&
@@ -23165,23 +23099,6 @@ const getInitialTokenAddressForChain = ({ chainId, config, direction, tokens, un
     const initialAsset = config.initialAssets?.[direction];
     if (!initialAsset)
         return undefined;
-    if (isArcChain(chainId)) {
-        const address = isNamedTokenConfig(initialAsset)
-            ? tokens.find((token) => token.chainId === chainId &&
-                !isArcNativeToken(token) &&
-                token.symbol.toLowerCase() === initialAsset.symbol?.toLowerCase())?.address
-            : initialAsset.chainId === chainId
-                ? initialAsset.address
-                : undefined;
-        return getTokenAddressForSelection({
-            tokens,
-            config,
-            chainId,
-            address,
-            direction,
-            excludeToken: { chainId, address: unavailableTokenAddress },
-        });
-    }
     if (isNamedTokenConfig(initialAsset)) {
         if (!initialAsset.symbol)
             return undefined;
@@ -23396,39 +23313,7 @@ const handleDestinationAddressOnSwapChange = ({ fromChainId, fromTokenAddress, t
     if (destinationTokensFiltered.find((t) => t.address === lowerCaseDestinationTokenAddress) === undefined) {
         destinationTokenAddress = defaultToAddress;
     }
-    return isArcChain(toChainId ?? swapRoute?.toChainId)
-        ? destinationTokenAddress?.toLowerCase()
-        : lowerCaseDestinationTokenAddress;
-};
-const normalizeSwapParamsForSelection = ({ swapParams, tokens, chains, config, }) => {
-    const fromTokenAddress = getTokenAddressForSelection({
-        tokens,
-        config,
-        chainId: swapParams.fromChainId,
-        address: swapParams.fromTokenAddress,
-        direction: "from",
-    });
-    const fromToken = tokens.find((token) => token.chainId === swapParams.fromChainId &&
-        token.address.toLowerCase() === fromTokenAddress?.toLowerCase());
-    const toTokenAddress = getTokenAddressForSelection({
-        tokens: isArcChain(swapParams.toChainId)
-            ? filterTokensForDestination({
-                tokens,
-                selectedDestinationChain: chains.find((chain) => chain.chainId === swapParams.toChainId),
-                selectedSourceToken: fromToken,
-                removeSourceToken: true,
-            })
-            : tokens,
-        config,
-        chainId: swapParams.toChainId,
-        address: swapParams.toTokenAddress,
-        direction: "to",
-        excludeToken: {
-            chainId: swapParams.fromChainId,
-            address: fromTokenAddress,
-        },
-    });
-    return { ...swapParams, fromTokenAddress, toTokenAddress };
+    return lowerCaseDestinationTokenAddress;
 };
 /**
  * When user changes something from the SwapView
@@ -23440,19 +23325,10 @@ const normalizeSwapParamsForSelection = ({ swapParams, tokens, chains, config, }
  * If only destination token is changed but source is not, and they were the same, then source token updates to something else
  *
  */
-const getNewSwapParamsFromInput = ({ inputParams, initialSwapRoute: storedSwapRoute, tokens, chains, config, queryClient, connectedSourceAddress, }) => {
-    const initialSwapRoute = storedSwapRoute
-        ? {
-            ...storedSwapRoute,
-            fromTokenAddress: normalizeArcTokenAddress(storedSwapRoute.fromChainId, storedSwapRoute.fromTokenAddress),
-            toTokenAddress: normalizeArcTokenAddress(storedSwapRoute.toChainId, storedSwapRoute.toTokenAddress),
-        }
-        : undefined;
-    const { fromChainId, toChainId, destinationAddress, fallbackAddress, depositRefundAddress, } = inputParams;
+const getNewSwapParamsFromInput = ({ inputParams, initialSwapRoute, tokens, chains, config, queryClient, connectedSourceAddress, }) => {
+    const { fromChainId, fromTokenAddress, toChainId, toTokenAddress, destinationAddress, fallbackAddress, depositRefundAddress, } = inputParams;
     const srcChainId = fromChainId ?? initialSwapRoute?.fromChainId;
     const destinationChainId = toChainId ?? initialSwapRoute?.toChainId;
-    const fromTokenAddress = normalizeArcTokenAddress(srcChainId, inputParams.fromTokenAddress);
-    const toTokenAddress = normalizeArcTokenAddress(destinationChainId, inputParams.toTokenAddress);
     const defaultFromAddress = getInitialOrDefaultTokenAddressForChain({
         tokens,
         config,
@@ -23528,20 +23404,15 @@ const getNewSwapParamsFromInput = ({ inputParams, initialSwapRoute: storedSwapRo
     const newDepositRefundAddress = sourceChainChanged
         ? undefined
         : depositRefundAddress || initialSwapRoute?.depositRefundAddress;
-    return normalizeSwapParamsForSelection({
-        swapParams: {
-            fromChainId: srcChainId,
-            fromTokenAddress: sourceTokenAddress,
-            toChainId: destinationChainId,
-            toTokenAddress: destinationTokenAddress,
-            destinationAddress: newDestinationAddress,
-            fallbackAddress: newFallbackAddress,
-            depositRefundAddress: newDepositRefundAddress,
-        },
-        tokens,
-        chains,
-        config,
-    });
+    return {
+        fromChainId: srcChainId,
+        fromTokenAddress: sourceTokenAddress,
+        toChainId: destinationChainId,
+        toTokenAddress: destinationTokenAddress,
+        destinationAddress: newDestinationAddress,
+        fallbackAddress: newFallbackAddress,
+        depositRefundAddress: newDepositRefundAddress,
+    };
 };
 /* Sorts tokens based on the following order:
  * 1. Native token on chain ID "1" (Ethereum) comes first.
@@ -23599,10 +23470,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.chainId === chain.chainId &&
-    (isArcChain(chain.chainId)
-        ? isArcNativeToken(t)
-        : t.symbol.toUpperCase() === chain.nativeCurrency.symbol.toUpperCase()));
+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;
@@ -23672,7 +23541,9 @@ function selectGroupDefaultInfo(tokens) {
 const groupTokensBySymbol = (tokens, chainType) => {
     const groups = {};
     // Filter tokens by chain type if specified
-    const filteredTokens = deduplicateArcBalances(chainType ? tokens.filter((token) => token.type === chainType) : tokens);
+    const filteredTokens = chainType
+        ? tokens.filter((token) => token.type === chainType)
+        : tokens;
     // First pass: group by coingeckoId or symbol
     filteredTokens.forEach((token) => {
         const groupKey = token.coingeckoId || token.symbol.split(".")[0];
@@ -23748,7 +23619,7 @@ const groupTokensBySymbol = (tokens, chainType) => {
  */
 const groupTokensByChainId = (tokens, chains) => {
     const groups = {};
-    deduplicateArcBalances(tokens).forEach((token) => {
+    tokens.forEach((token) => {
         const chainData = chains.find((chain) => chain.chainId === token.chainId);
         const groupKey = token.chainId;
         if (!groups[groupKey]) {
@@ -23788,16 +23659,14 @@ const groupTokensByChainId = (tokens, chains) => {
  */
 const filterViewableTokens = (tokens, config, direction) => {
     const disabledTokens = [
-        // On Celo, native token & custom address tokens are returned
-        // so we should hide the native one but keep receiving it to use gas balance
+        // Both interfaces share one balance; show only the ERC20 token.
         { chainId: CHAIN_IDS.CELO, address: nativeEvmTokenAddress },
+        { chainId: CHAIN_IDS.ARC, address: nativeEvmTokenAddress },
         // SagaEVM is gasless, so the native token is not used
         { chainId: CHAIN_IDS.SAGA_EVM, address: nativeEvmTokenAddress },
         { chainId: CHAIN_IDS.DCHAIN, address: nativeEvmTokenAddress },
     ];
     return (tokens.filter((token) => {
-        if (isArcNativeToken(token))
-            return false;
         if (direction) {
             const parsedDirection = getParsedDirection(direction);
             const availableTokensForDirection = config.availableTokens?.[parsedDirection];
@@ -23813,7 +23682,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-BZ06HTOJ.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-C6GiPeC8.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -28240,7 +28109,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.mjs');
-                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-fnyXRadt.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-DkBWS3eX.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -29168,27 +29037,12 @@ const useMultiChainWallet = (chain) => {
 };
 
 const useSwap = () => {
-    const { initialAssets, defaultTokensPerChain, disabledChains, availableChains, availableTokens, } = useConfigStore((state) => state.config);
+    const { initialAssets, defaultTokensPerChain, disabledChains, availableChains, } = useConfigStore((state) => state.config);
     const fromPrice = useTransactionStore((state) => state.fromPrice);
-    const { swapRoute: storedSwapRoute } = useSwapRoutePersistStore();
+    const { swapRoute } = useSwapRoutePersistStore();
     const { tokens } = useSquidTokens();
     const queryClient = reactQuery.useQueryClient();
     const { chains, supportedDestinationChains, supportedSourceChains } = useSquidChains();
-    const swapRoute = React.useMemo(() => storedSwapRoute
-        ? normalizeSwapParamsForSelection({
-            swapParams: storedSwapRoute,
-            tokens,
-            chains,
-            config: { disabledChains, availableChains, availableTokens },
-        })
-        : undefined, [
-        storedSwapRoute,
-        tokens,
-        chains,
-        disabledChains,
-        availableChains,
-        availableTokens,
-    ]);
     const sourceChainId = React.useMemo(() => swapRoute?.fromChainId ??
         (initialAssets?.from
             ? resolveChainIdFromAsset(initialAssets.from, supportedSourceChains)
@@ -29199,23 +29053,13 @@ const useSwap = () => {
             : 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(() => {
-        const chainTokens = getTokensForChain(tokens, sourceChainId);
-        return isArcChain(sourceChainId)
-            ? filterViewableTokens(chainTokens, { availableTokens }, "from")
-            : chainTokens;
-    }, [tokens, sourceChainId, availableTokens]);
+    const fromTokens = React.useMemo(() => getTokensForChain(tokens, sourceChainId), [tokens, sourceChainId]);
     const fromToken = React.useMemo(() => fromTokens.find((t) => t.address.toLowerCase() === swapRoute?.fromTokenAddress?.toLowerCase()), [fromTokens, swapRoute?.fromTokenAddress]);
-    const toTokens = React.useMemo(() => {
-        const destinationTokens = filterTokensForDestination({
-            tokens: getTokensForChain(tokens, destChainId),
-            selectedDestinationChain: toChain,
-            selectedSourceToken: fromToken,
-        });
-        return isArcChain(destChainId)
-            ? filterViewableTokens(destinationTokens, { availableTokens }, "to")
-            : destinationTokens;
-    }, [destChainId, toChain, fromToken, tokens, availableTokens]);
+    const toTokens = React.useMemo(() => filterTokensForDestination({
+        tokens: getTokensForChain(tokens, destChainId),
+        selectedDestinationChain: toChain,
+        selectedSourceToken: fromToken,
+    }), [destChainId, toChain, fromToken, tokens]);
     const toToken = React.useMemo(() => toTokens.find((t) => t.address.toLowerCase() === swapRoute?.toTokenAddress?.toLowerCase()), [toTokens, swapRoute?.toTokenAddress]);
     const isSameChain = sourceChainId === destChainId;
     const tokenItems = React.useMemo(() => ({ from: fromTokens, to: toTokens }), [fromTokens, toTokens]);
@@ -29263,7 +29107,6 @@ const useSwap = () => {
                 defaultTokensPerChain,
                 disabledChains,
                 availableChains,
-                availableTokens,
             },
             queryClient,
             connectedSourceAddress: connectedSourceAddress.address,
@@ -29303,7 +29146,6 @@ const useSwap = () => {
         defaultTokensPerChain,
         disabledChains,
         availableChains,
-        availableTokens,
         initialAssets,
         queryClient,
         swapRoute,
@@ -29359,10 +29201,6 @@ const useSwap = () => {
                 },
                 direction: "to",
             });
-            if ([defaultFromChainId, defaultToChainId].some((chainId) => isArcChain(chainId) &&
-                !tokens.some((token) => token.chainId === chainId && !isArcNativeToken(token)))) {
-                return;
-            }
             const fromTokenAddress = getInitialOrDefaultTokenAddressForChain({
                 tokens,
                 config: {
@@ -29370,7 +29208,6 @@ const useSwap = () => {
                     defaultTokensPerChain,
                     disabledChains,
                     availableChains,
-                    availableTokens,
                 },
                 chainId: defaultFromChainId,
                 direction: "from",
@@ -29382,7 +29219,6 @@ const useSwap = () => {
                     defaultTokensPerChain,
                     disabledChains,
                     availableChains,
-                    availableTokens,
                 },
                 chainId: defaultToChainId,
                 direction: "to",
@@ -29407,7 +29243,6 @@ const useSwap = () => {
         initialAssets,
         disabledChains,
         availableChains,
-        availableTokens,
         defaultTokensPerChain,
         tokens,
     ]);
@@ -31199,18 +31034,17 @@ function useNativeTokenForChain(chain) {
                 return cantonTokens;
         }
     };
-    const tokens = getTokensForChainType();
     const nativeTokenForChainType = React.useMemo(() => {
         if (!chain)
             return undefined;
-        return findNativeToken(tokens, chain);
-    }, [chain, tokens]);
+        return findNativeToken(getTokensForChainType(), chain);
+    }, [chain]);
     return { nativeToken: nativeTokenForChainType };
 }
 
 const useEvmNativeBalance = ({ address, chain, }) => {
     const { isChainTypeConnected } = useWallet();
-    const { data: nativeEvmBalance, isLoading, isError, } = wagmi.useBalance({
+    const { data: nativeEvmBalance, isLoading } = wagmi.useBalance({
         address: address,
         chainId: Number(chain?.chainId),
         query: {
@@ -31222,8 +31056,6 @@ const useEvmNativeBalance = ({ address, chain, }) => {
         },
     });
     const balance = React.useMemo(() => {
-        if (isArcChain(chain?.chainId) && isError)
-            return undefined;
         if (nativeEvmBalance?.decimals != null && nativeEvmBalance?.value != null) {
             if (chain?.chainId === CHAIN_IDS.HEDERA) {
                 return {
@@ -31237,12 +31069,7 @@ const useEvmNativeBalance = ({ address, chain, }) => {
             };
         }
         return;
-    }, [
-        nativeEvmBalance?.decimals,
-        nativeEvmBalance?.value,
-        chain?.chainId,
-        isError,
-    ]);
+    }, [nativeEvmBalance?.decimals, nativeEvmBalance?.value, chain?.chainId]);
     return {
         balance,
         isLoading,
@@ -31729,7 +31556,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-BVCh4tlV.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-CnV3EYrQ.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -32953,6 +32780,12 @@ const isTempoChain = (chainId) => chainId === CHAIN_IDS.TEMPO;
  */
 const convertTempoFeeToStablecoinUnits = (feeIn18Dec) => feeIn18Dec / BigInt(10 ** 12);
 
+const arcUsdcTokenAddress = "0x3600000000000000000000000000000000000000";
+const isArcChain = (chainId) => chainId === CHAIN_IDS.ARC;
+const isArcUsdcToken = (token) => isArcChain(token?.chainId) &&
+    token?.address.toLowerCase() === arcUsdcTokenAddress;
+const convertArcGasToUsdcUnits = (fee) => (fee + 10n ** 12n - 1n) / 10n ** 12n;
+
 const DEFAULT_REFRESH_INTERVAL_MS = 15000;
 /**
  * Returns raw on-chain gas token data for Tempo chains, or null when the source
@@ -33019,6 +32852,30 @@ const useTempoFeeCheck = ({ fromChain, fromToken, }) => {
     };
 };
 
+const useArcFeeCheck = ({ fromChain, }) => {
+    const { connectedAddresses } = useWallet();
+    const { evmTokens } = useSquidTokens();
+    const isArc = isArcChain(fromChain?.chainId);
+    const gasToken = React.useMemo(() => {
+        if (!isArc)
+            return undefined;
+        return evmTokens.find(isArcUsdcToken);
+    }, [isArc, evmTokens]);
+    const userAddress = connectedAddresses[squidTypes.ChainType.EVM];
+    const { balance, isLoading } = useEvmBalance({
+        chain: fromChain,
+        token: gasToken,
+        userAddress,
+        enabled: isArc && !!gasToken,
+    });
+    if (!isArc || !gasToken || !userAddress || isLoading)
+        return null;
+    return {
+        gasTokenAddress: gasToken.address,
+        gasBalance: parseToBigInt(balance, gasToken.decimals),
+    };
+};
+
 /**
  * Hook that returns the gas token and chain fee params for a given source chain and token.
  */
@@ -33027,6 +32884,7 @@ function useSourceChainGasToken({ fromChain, fromToken, }) {
     const { evmTokens } = useSquidTokens();
     const { nativeBalance } = useNativeBalance(fromChain);
     const tempoFeeData = useTempoFeeCheck({ fromChain, fromToken });
+    const arcFeeData = useArcFeeCheck({ fromChain });
     const chainFeeParams = React.useMemo(() => {
         if (fromToken?.address == null ||
             fromChain?.chainId == null ||
@@ -33045,24 +32903,14 @@ function useSourceChainGasToken({ fromChain, fromToken, }) {
             };
         }
         if (isArcChain(fromChain.chainId)) {
-            const isUsdc = isArcUsdcToken(fromToken);
-            const isNative = isArcNativeToken(fromToken);
-            if (fromToken.chainId !== fromChain.chainId ||
-                nativeBalance.decimals !== 18 ||
-                (isUsdc && fromToken.decimals !== 6) ||
-                (isNative && fromToken.decimals !== 18)) {
+            if (!arcFeeData)
                 return null;
-            }
+            const fromTokenPaysGasFees = arcFeeData.gasTokenAddress.toLowerCase() ===
+                fromToken.address.toLowerCase();
             return {
-                fromTokenPaysGasFees: isUsdc || isNative,
-                gasTokenBalanceWei: nativeBalance.value,
+                fromTokenPaysGasFees,
+                gasTokenBalanceWei: arcFeeData.gasBalance,
                 normalizeFee: (fee) => fee,
-                fromAmountToGasUnits: isUsdc
-                    ? (amount) => amount * 10n ** 12n
-                    : undefined,
-                gasUnitsToFromAmount: isUsdc
-                    ? (amount) => amount / 10n ** 12n
-                    : undefined,
             };
         }
         return {
@@ -33072,11 +32920,12 @@ function useSourceChainGasToken({ fromChain, fromToken, }) {
             normalizeFee: (fee) => fee,
         };
     }, [
-        fromToken,
+        fromToken?.address,
+        fromToken?.type,
         fromChain?.chainId,
         nativeBalance?.value,
-        nativeBalance?.decimals,
         tempoFeeData,
+        arcFeeData,
     ]);
     /**
      * The token to pay for gas on the source chain.
@@ -33091,22 +32940,18 @@ function useSourceChainGasToken({ fromChain, fromToken, }) {
                 t.address.toLowerCase() === tempoFeeData.gasTokenAddress.toLowerCase());
         }
         if (isArcChain(fromChain.chainId)) {
-            return nativeToken?.decimals === 18
-                ? {
-                    ...nativeToken,
-                    symbol: fromChain.nativeCurrency.symbol,
-                    name: fromChain.nativeCurrency.name,
-                }
-                : undefined;
+            if (!arcFeeData)
+                return undefined;
+            return evmTokens.find((t) => t.chainId === fromChain.chainId &&
+                t.address.toLowerCase() === arcFeeData.gasTokenAddress.toLowerCase());
         }
         return nativeToken;
     }, [
         fromChain?.chainId,
-        fromChain?.nativeCurrency.symbol,
-        fromChain?.nativeCurrency.name,
         fromToken?.address,
         nativeToken,
         tempoFeeData,
+        arcFeeData,
         evmTokens,
     ]);
     return { gasToken, chainFeeParams };
@@ -33262,57 +33107,22 @@ const calculateTotalNativeFees = ({ expressFeeCost, firstFeeCost, firstGasCost,
     (sameTokenBetweenFees
         ? BigInt(firstFeeCost?.amount ?? "0") + BigInt(firstGasCost?.amount ?? "0")
         : BigInt(firstGasCost?.amount ?? "0"));
-const addGasReserve = (fee) => (fee * 110n + 99n) / 100n;
-const calculateArcGasCosts = (gasCosts) => {
-    const sourceGasCosts = gasCosts.filter((cost) => isArcChain(cost.token.chainId));
-    if (sourceGasCosts.length === 0)
-        return undefined;
-    let total = 0n;
-    for (const { amount, token } of sourceGasCosts) {
-        const fee = BigInt(amount);
-        if (fee <= 0n)
-            return undefined;
-        if (isArcUsdcToken(token) && token.decimals === 6) {
-            total += fee * 10n ** 12n;
-        }
-        else if (isArcNativeToken(token) && token.decimals === 18) {
-            total += fee;
-        }
-        else {
-            return undefined;
-        }
-    }
-    return total;
-};
-const calculateTotalGasBalanceNeeded = ({ fromAmount, networkFeesWei, chainFeeParams, }) => {
-    if (!chainFeeParams || networkFeesWei == null)
-        return undefined;
-    if (!chainFeeParams.fromTokenPaysGasFees)
-        return networkFeesWei;
-    const amount = BigInt(fromAmount ?? "0");
-    const amountInGasUnits = chainFeeParams.fromAmountToGasUnits?.(amount) ?? amount;
-    return amountInGasUnits + networkFeesWei;
-};
 const checkIsGasBalanceEnough = ({ fromAmount, networkFeesWei, chainFeeParams, }) => {
     if (!chainFeeParams)
         return false;
-    const total = calculateTotalGasBalanceNeeded({
-        fromAmount,
-        networkFeesWei,
-        chainFeeParams,
-    });
-    return total != null && total <= chainFeeParams.gasTokenBalanceWei;
+    if (chainFeeParams.fromTokenPaysGasFees) {
+        return (BigInt(fromAmount ?? "0") + networkFeesWei <=
+            chainFeeParams.gasTokenBalanceWei);
+    }
+    return networkFeesWei <= chainFeeParams.gasTokenBalanceWei;
 };
 const calculateMinAmountValueWarnMsg = ({ networkFeesWei, chainFeeParams, fromTokenDecimals, }) => {
-    if (!chainFeeParams?.fromTokenPaysGasFees || networkFeesWei == null)
+    if (!chainFeeParams?.fromTokenPaysGasFees)
         return undefined;
     const minAmount = chainFeeParams.gasTokenBalanceWei - networkFeesWei;
     if (minAmount <= BigInt(0))
         return undefined;
-    const amountInTokenUnits = chainFeeParams.gasUnitsToFromAmount?.(minAmount) ?? minAmount;
-    if (amountInTokenUnits <= 0n)
-        return undefined;
-    return formatBNToReadable(amountInTokenUnits, fromTokenDecimals);
+    return formatBNToReadable(minAmount, fromTokenDecimals);
 };
 /**
  * Calculates the estimated duration of a route
@@ -33361,22 +33171,14 @@ 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 totalNativeFees = isArcChain(fromChain?.chainId)
-        ? calculateArcGasCosts(allGasCosts)
-        : calculateTotalNativeFees({
-            expressFeeCost,
-            firstFeeCost,
-            firstGasCost,
-            sameTokenBetweenFees,
-        });
-    const totalFeesInNativeTokenPlusRatio = totalNativeFees == null
-        ? undefined
-        : isArcChain(fromChain?.chainId)
-            ? addGasReserve(totalNativeFees)
-            : (totalNativeFees * BigInt(110)) / BigInt(100);
-    const networkFeesWei = totalFeesInNativeTokenPlusRatio == null
-        ? undefined
-        : chainFeeParams?.normalizeFee(totalFeesInNativeTokenPlusRatio);
+    const totalNativeFees = calculateTotalNativeFees({
+        expressFeeCost,
+        firstFeeCost,
+        firstGasCost,
+        sameTokenBetweenFees,
+    });
+    const totalFeesInNativeTokenPlusRatio = (totalNativeFees * BigInt(110)) / BigInt(100);
+    const networkFeesWei = chainFeeParams?.normalizeFee(totalFeesInNativeTokenPlusRatio) ?? BigInt(0);
     const isGasBalanceEnough = checkIsGasBalanceEnough({
         chainFeeParams,
         fromAmount,
@@ -33392,12 +33194,10 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         estimatedRouteDuration: squidRoute?.estimate?.estimatedRouteDuration,
         isSingleChainRoute,
     });
-    const totalGasBalanceNeeded = calculateTotalGasBalanceNeeded({
-        fromAmount,
-        networkFeesWei,
-        chainFeeParams,
-    });
-    const gasBalanceNeeded = gasToken && totalGasBalanceNeeded != null
+    // gas fees + fromAmount (if fromToken is gas token)
+    const totalGasBalanceNeeded = networkFeesWei +
+        BigInt(chainFeeParams?.fromTokenPaysGasFees ? (fromAmount ?? 0) : 0);
+    const gasBalanceNeeded = gasToken
         ? formatBNToReadable(totalGasBalanceNeeded, gasToken.decimals)
         : undefined;
     return {
@@ -33419,7 +33219,7 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         expectedGasRefundCostUSD,
         sameTokenBetweenFees,
         fromTokenPaysGasFees: chainFeeParams?.fromTokenPaysGasFees ?? false,
-        totalNativeFees: totalNativeFees ?? 0n,
+        totalNativeFees,
         isGasBalanceEnough,
         minAmountValueWarnMsg,
         estimatedRouteDuration,
@@ -33468,12 +33268,8 @@ function useSendTransactionGas({ chain, token, from, }) {
                 case squidTypes.ChainType.EVM: {
                     const client = await getClient(chain);
                     const feeData = await client.getFeeData();
-                    if (!feeData.maxFeePerGas) {
-                        if (isArcChain(chain.chainId)) {
-                            throw new Error("Gas price is unavailable");
-                        }
+                    if (!feeData.maxFeePerGas)
                         return BigInt(0);
-                    }
                     let maxFeePerGas = feeData.maxFeePerGas;
                     if (token.chainId === CHAIN_IDS.HEDERA) {
                         maxFeePerGas = scaleWeiToHbar(BigInt(feeData.maxFeePerGas));
@@ -33493,9 +33289,6 @@ function useSendTransactionGas({ chain, token, from, }) {
                             value: 1,
                             chainId: chain.chainId,
                         });
-                        if (isArcChain(chain.chainId) && gas <= 0n) {
-                            throw new Error("Gas estimate is unavailable");
-                        }
                         return gas * maxFeePerGas;
                     }
                     const erc20Interface = new ethers.Interface(viem.erc20Abi);
@@ -33510,14 +33303,14 @@ function useSendTransactionGas({ chain, token, from, }) {
                         chainId: chain.chainId,
                     });
                     const feeWei = gas * maxFeePerGas;
-                    if (isArcChain(chain.chainId) && feeWei <= 0n) {
-                        throw new Error("Gas estimate is unavailable");
-                    }
                     // Tempo gas fees are denominated 18 units,
                     // this value needs to be scaled to 6 decimals
                     if (chain.chainId === CHAIN_IDS.TEMPO) {
                         return convertTempoFeeToStablecoinUnits(feeWei);
                     }
+                    if (isArcChain(chain.chainId)) {
+                        return convertArcGasToUsdcUnits(feeWei);
+                    }
                     return feeWei;
                 }
                 case squidTypes.ChainType.COSMOS: {
@@ -33560,45 +33353,35 @@ function useSendTransactionGas({ chain, token, from, }) {
 }
 
 function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
-    const { data, isLoading, isFetching, isError, refetch } = useSendTransactionGas({
+    const { data: estimatedGas = BigInt(0), isLoading } = useSendTransactionGas({
         chain,
         token,
         from,
     });
-    const estimatedGas = isError || isFetching ? undefined : data;
-    const networkFeesWei = estimatedGas == null
-        ? undefined
-        : isArcChain(chain?.chainId)
-            ? addGasReserve(estimatedGas)
-            : estimatedGas;
     const { chainFeeParams, gasToken } = useSourceChainGasToken({
         fromChain: chain,
         fromToken: token,
     });
     const isGasBalanceEnough = React.useMemo(() => {
-        if (!amount || token?.decimals == null || !gasToken)
+        if (!amount || !token?.decimals)
             return false;
         return checkIsGasBalanceEnough({
             fromAmount: parseToBigInt(amount, token.decimals).toString(),
-            networkFeesWei,
+            networkFeesWei: estimatedGas,
             chainFeeParams,
         });
-    }, [amount, networkFeesWei, token, chainFeeParams, gasToken]);
+    }, [amount, estimatedGas, token, chainFeeParams]);
     const gasBalanceNeeded = React.useMemo(() => {
-        if (!amount || token?.decimals == null || gasToken?.decimals == null)
-            return undefined;
-        const totalGasBalanceNeeded = calculateTotalGasBalanceNeeded({
-            fromAmount: parseToBigInt(amount, token.decimals).toString(),
-            networkFeesWei,
-            chainFeeParams,
-        });
-        if (totalGasBalanceNeeded == null)
+        if (!amount || !token?.decimals || !gasToken?.decimals)
             return undefined;
+        // gas fees + fromAmount (if fromToken is gas token)
+        const totalGasBalanceNeeded = estimatedGas +
+            parseToBigInt(chainFeeParams?.fromTokenPaysGasFees ? (amount ?? "0") : "0", token.decimals);
         return formatBNToReadable(totalGasBalanceNeeded, gasToken.decimals);
     }, [
         amount,
-        chainFeeParams,
-        networkFeesWei,
+        chainFeeParams?.fromTokenPaysGasFees,
+        estimatedGas,
         gasToken?.decimals,
         token?.decimals,
     ]);
@@ -33609,22 +33392,20 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
             parseToBigInt(amount, token.decimals));
     }, [amount, balance, token?.decimals]);
     const minAmountValueWarnMsg = React.useMemo(() => {
-        if (!token?.address || !gasToken || !chainFeeParams)
+        if (!token?.address || !estimatedGas || !chainFeeParams)
             return undefined;
         return calculateMinAmountValueWarnMsg({
             chainFeeParams,
-            networkFeesWei,
+            networkFeesWei: estimatedGas,
             fromTokenDecimals: token.decimals,
         });
-    }, [networkFeesWei, token, chainFeeParams, gasToken]);
+    }, [estimatedGas, token, chainFeeParams]);
     return {
         estimatedGas,
         gasBalanceNeeded,
         isBalanceEnough,
         tokenPaysGasFees: chainFeeParams?.fromTokenPaysGasFees ?? false,
-        isLoading: isLoading || isFetching,
-        isError,
-        refetchGasEstimate: refetch,
+        isLoading,
         isGasBalanceEnough,
         minAmountValueWarnMsg,
     };
@@ -34525,19 +34306,6 @@ const useApproval = ({ squidRoute, }) => {
     const { getChainType } = useSquidChains();
     const { switchChainAsync } = wagmi.useSwitchChain();
     const { connectedAddress: { address: sourceUserAddress }, } = useMultiChainWallet(fromChain);
-    const arcNativeBalanceQuery = wagmi.useBalance({
-        address: sourceUserAddress,
-        chainId: Number(fromChain?.chainId),
-        query: { enabled: false },
-    });
-    const arcTokenBalanceQuery = wagmi.useReadContract({
-        address: fromToken?.address,
-        abi: viem.erc20Abi,
-        functionName: "balanceOf",
-        args: [sourceUserAddress],
-        chainId: Number(fromChain?.chainId),
-        query: { enabled: false },
-    });
     const isSagaEvmSameChainSwap = isSameChain &&
         fromChain?.chainId.toString() === CHAIN_IDS.SAGA_EVM.toString();
     // Swaps on SagaEVM are regular EVM transactions, following the standard ERC20 approve/allowance mechanism.
@@ -34698,20 +34466,13 @@ const useApproval = ({ squidRoute, }) => {
             return false;
         }
     }, {
-        onSuccess: async (approved) => {
-            if (approved && isArcChain(fromChain?.chainId)) {
-                await Promise.all([
-                    arcNativeBalanceQuery.refetch({ throwOnError: true }),
-                    arcTokenBalanceQuery.refetch({ throwOnError: true }),
-                ]);
-                queryClient.invalidateQueries(getPrefixKey(exports.QueryKeys.AllTokensBalance));
-            }
+        onSuccess: async () => {
             await allowanceQuery?.refetch();
             queryClient.invalidateQueries(getPrefixKey(exports.QueryKeys.RouteApproved));
             // After an approval, we refetch the transaction query with all required parameters
             // This is to ensure we're using the latest expiry timestamp
             if (squidRoute) {
-                await queryClient.refetchQueries({
+                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, 
                     // TODO: update types
                     squidRoute.params?.overrideGasRefundAddress),
@@ -39586,7 +39347,6 @@ exports.getStepsInfos = getStepsInfos;
 exports.getSuggestedAmountsForCurrency = getSuggestedAmountsForCurrency;
 exports.getSupportedChainIdsForDirection = getSupportedChainIdsForDirection;
 exports.getSwapTxStatusRefetchInterval = getSwapTxStatusRefetchInterval;
-exports.getTokenAddressForSelection = getTokenAddressForSelection;
 exports.getTokenAssetsKey = getTokenAssetsKey;
 exports.getTokenImage = getTokenImage;
 exports.getTokensForChain = getTokensForChain;
@@ -39643,7 +39403,6 @@ exports.nativeSuiTokenAddress = nativeSuiTokenAddress;
 exports.nativeXrplTokenAddress = nativeXrplTokenAddress;
 exports.normalizeError = normalizeError;
 exports.normalizeIbcAddress = normalizeIbcAddress;
-exports.normalizeSwapParamsForSelection = normalizeSwapParamsForSelection;
 exports.normalizeTokenSymbol = normalizeTokenSymbol;
 exports.parseEvmAddress = parseEvmAddress;
 exports.parseInitialAssetsFromUrl = parseInitialAssetsFromUrl;
@@ -39757,4 +39516,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-BBJD55XX.js.map
+//# sourceMappingURL=index-8RIq6GyB.js.map