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

package/dist/{index-CJVX-7hj.js → index-BBJD55XX.js}

@@ -153,6 +153,7 @@ const CHAIN_IDS = {
     MANTRA: "5888",
     CITREA: "4114",
     TEMPO: "4217",
+    ARC: "5042",
     // others
     BITCOIN: "bitcoin",
     SOLANA: "solana-mainnet-beta",
@@ -20964,6 +20965,24 @@ 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}`;
 }
@@ -22200,7 +22219,7 @@ function sortAddressBook(a, b, selectedAddress) {
     return 0;
 }
 const calculateTotalUsdBalanceUSD = (tokens) => {
-    const totalUsd = tokens.reduce((total, token) => {
+    const totalUsd = deduplicateArcBalances(tokens).reduce((total, token) => {
         const balance = parseFloat(token.balance);
         const usdPrice = token.usdPrice ?? 0;
         const balanceUsd = balance * usdPrice;
@@ -23012,22 +23031,36 @@ 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) => {
+const fetchHighestBalanceToken = (fetchCachedBalance, chainId, selectableTokens, direction) => {
     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 = queryCache?.find(keys().allTokensBalance(fetchCachedBalance?.address, !isNaN(Number(chainId)) ? squidTypes.ChainType.EVM : squidTypes.ChainType.COSMOS));
-        // Parse result to TokenWithBalance[]
-        const cacheResult = cache?.state.data ?? [];
+        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 ?? [])
+                : [];
         if (cacheResult.length > 0) {
-            const tokensWithBalance = cacheResult.filter((t) => t.chainId === chainId && Number(t.balance) > 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())));
             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 = tokenWithHighestBalance.address;
+                    address = normalizeArcTokenAddress(tokenWithHighestBalance.chainId, tokenWithHighestBalance.address);
                 }
             }
         }
@@ -23038,6 +23071,21 @@ 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
@@ -23055,6 +23103,25 @@ 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 &&
@@ -23098,6 +23165,23 @@ 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;
@@ -23312,7 +23396,39 @@ const handleDestinationAddressOnSwapChange = ({ fromChainId, fromTokenAddress, t
     if (destinationTokensFiltered.find((t) => t.address === lowerCaseDestinationTokenAddress) === undefined) {
         destinationTokenAddress = defaultToAddress;
     }
-    return lowerCaseDestinationTokenAddress;
+    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 };
 };
 /**
  * When user changes something from the SwapView
@@ -23324,10 +23440,19 @@ const handleDestinationAddressOnSwapChange = ({ fromChainId, fromTokenAddress, t
  * 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, tokens, chains, config, queryClient, connectedSourceAddress, }) => {
-    const { fromChainId, fromTokenAddress, toChainId, toTokenAddress, destinationAddress, fallbackAddress, depositRefundAddress, } = inputParams;
+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 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,
@@ -23403,15 +23528,20 @@ const getNewSwapParamsFromInput = ({ inputParams, initialSwapRoute, tokens, chai
     const newDepositRefundAddress = sourceChainChanged
         ? undefined
         : depositRefundAddress || initialSwapRoute?.depositRefundAddress;
-    return {
-        fromChainId: srcChainId,
-        fromTokenAddress: sourceTokenAddress,
-        toChainId: destinationChainId,
-        toTokenAddress: destinationTokenAddress,
-        destinationAddress: newDestinationAddress,
-        fallbackAddress: newFallbackAddress,
-        depositRefundAddress: newDepositRefundAddress,
-    };
+    return normalizeSwapParamsForSelection({
+        swapParams: {
+            fromChainId: srcChainId,
+            fromTokenAddress: sourceTokenAddress,
+            toChainId: destinationChainId,
+            toTokenAddress: destinationTokenAddress,
+            destinationAddress: newDestinationAddress,
+            fallbackAddress: newFallbackAddress,
+            depositRefundAddress: newDepositRefundAddress,
+        },
+        tokens,
+        chains,
+        config,
+    });
 };
 /* Sorts tokens based on the following order:
  * 1. Native token on chain ID "1" (Ethereum) comes first.
@@ -23469,8 +23599,10 @@ 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.chainId === chain.chainId &&
+    (isArcChain(chain.chainId)
+        ? isArcNativeToken(t)
+        : t.symbol.toUpperCase() === chain.nativeCurrency.symbol.toUpperCase()));
 const normalizeIbcAddress = (address) => {
     if (!address.toLowerCase().startsWith("ibc/")) {
         return address;
@@ -23540,9 +23672,7 @@ function selectGroupDefaultInfo(tokens) {
 const groupTokensBySymbol = (tokens, chainType) => {
     const groups = {};
     // Filter tokens by chain type if specified
-    const filteredTokens = chainType
-        ? tokens.filter((token) => token.type === chainType)
-        : tokens;
+    const filteredTokens = deduplicateArcBalances(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];
@@ -23618,7 +23748,7 @@ const groupTokensBySymbol = (tokens, chainType) => {
  */
 const groupTokensByChainId = (tokens, chains) => {
     const groups = {};
-    tokens.forEach((token) => {
+    deduplicateArcBalances(tokens).forEach((token) => {
         const chainData = chains.find((chain) => chain.chainId === token.chainId);
         const groupKey = token.chainId;
         if (!groups[groupKey]) {
@@ -23666,6 +23796,8 @@ const filterViewableTokens = (tokens, config, direction) => {
         { 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];
@@ -23681,7 +23813,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-GHdReJBs.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-BZ06HTOJ.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -28108,7 +28240,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-DvA-2pXq.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-fnyXRadt.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -29036,12 +29168,27 @@ const useMultiChainWallet = (chain) => {
 };
 
 const useSwap = () => {
-    const { initialAssets, defaultTokensPerChain, disabledChains, availableChains, } = useConfigStore((state) => state.config);
+    const { initialAssets, defaultTokensPerChain, disabledChains, availableChains, availableTokens, } = useConfigStore((state) => state.config);
     const fromPrice = useTransactionStore((state) => state.fromPrice);
-    const { swapRoute } = useSwapRoutePersistStore();
+    const { swapRoute: storedSwapRoute } = 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)
@@ -29052,13 +29199,23 @@ 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(() => getTokensForChain(tokens, sourceChainId), [tokens, sourceChainId]);
+    const fromTokens = React.useMemo(() => {
+        const chainTokens = getTokensForChain(tokens, sourceChainId);
+        return isArcChain(sourceChainId)
+            ? filterViewableTokens(chainTokens, { availableTokens }, "from")
+            : chainTokens;
+    }, [tokens, sourceChainId, availableTokens]);
     const fromToken = React.useMemo(() => fromTokens.find((t) => t.address.toLowerCase() === swapRoute?.fromTokenAddress?.toLowerCase()), [fromTokens, swapRoute?.fromTokenAddress]);
-    const toTokens = React.useMemo(() => filterTokensForDestination({
-        tokens: getTokensForChain(tokens, destChainId),
-        selectedDestinationChain: toChain,
-        selectedSourceToken: fromToken,
-    }), [destChainId, toChain, fromToken, tokens]);
+    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 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]);
@@ -29106,6 +29263,7 @@ const useSwap = () => {
                 defaultTokensPerChain,
                 disabledChains,
                 availableChains,
+                availableTokens,
             },
             queryClient,
             connectedSourceAddress: connectedSourceAddress.address,
@@ -29145,6 +29303,7 @@ const useSwap = () => {
         defaultTokensPerChain,
         disabledChains,
         availableChains,
+        availableTokens,
         initialAssets,
         queryClient,
         swapRoute,
@@ -29200,6 +29359,10 @@ 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: {
@@ -29207,6 +29370,7 @@ const useSwap = () => {
                     defaultTokensPerChain,
                     disabledChains,
                     availableChains,
+                    availableTokens,
                 },
                 chainId: defaultFromChainId,
                 direction: "from",
@@ -29218,6 +29382,7 @@ const useSwap = () => {
                     defaultTokensPerChain,
                     disabledChains,
                     availableChains,
+                    availableTokens,
                 },
                 chainId: defaultToChainId,
                 direction: "to",
@@ -29242,6 +29407,7 @@ const useSwap = () => {
         initialAssets,
         disabledChains,
         availableChains,
+        availableTokens,
         defaultTokensPerChain,
         tokens,
     ]);
@@ -31033,17 +31199,18 @@ function useNativeTokenForChain(chain) {
                 return cantonTokens;
         }
     };
+    const tokens = getTokensForChainType();
     const nativeTokenForChainType = React.useMemo(() => {
         if (!chain)
             return undefined;
-        return findNativeToken(getTokensForChainType(), chain);
-    }, [chain]);
+        return findNativeToken(tokens, chain);
+    }, [chain, tokens]);
     return { nativeToken: nativeTokenForChainType };
 }
 
 const useEvmNativeBalance = ({ address, chain, }) => {
     const { isChainTypeConnected } = useWallet();
-    const { data: nativeEvmBalance, isLoading } = wagmi.useBalance({
+    const { data: nativeEvmBalance, isLoading, isError, } = wagmi.useBalance({
         address: address,
         chainId: Number(chain?.chainId),
         query: {
@@ -31055,6 +31222,8 @@ 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 {
@@ -31068,7 +31237,12 @@ const useEvmNativeBalance = ({ address, chain, }) => {
             };
         }
         return;
-    }, [nativeEvmBalance?.decimals, nativeEvmBalance?.value, chain?.chainId]);
+    }, [
+        nativeEvmBalance?.decimals,
+        nativeEvmBalance?.value,
+        chain?.chainId,
+        isError,
+    ]);
     return {
         balance,
         isLoading,
@@ -31555,7 +31729,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-CTKuR0LC.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-BVCh4tlV.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -32870,6 +33044,27 @@ function useSourceChainGasToken({ fromChain, fromToken, }) {
                 normalizeFee: convertTempoFeeToStablecoinUnits,
             };
         }
+        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)) {
+                return null;
+            }
+            return {
+                fromTokenPaysGasFees: isUsdc || isNative,
+                gasTokenBalanceWei: nativeBalance.value,
+                normalizeFee: (fee) => fee,
+                fromAmountToGasUnits: isUsdc
+                    ? (amount) => amount * 10n ** 12n
+                    : undefined,
+                gasUnitsToFromAmount: isUsdc
+                    ? (amount) => amount / 10n ** 12n
+                    : undefined,
+            };
+        }
         return {
             fromTokenPaysGasFees: fromToken.address.toLowerCase() ===
                 chainTypeToNativeTokenAddressMap[fromToken.type].toLowerCase(),
@@ -32877,10 +33072,10 @@ function useSourceChainGasToken({ fromChain, fromToken, }) {
             normalizeFee: (fee) => fee,
         };
     }, [
-        fromToken?.address,
-        fromToken?.type,
+        fromToken,
         fromChain?.chainId,
         nativeBalance?.value,
+        nativeBalance?.decimals,
         tempoFeeData,
     ]);
     /**
@@ -32895,9 +33090,20 @@ function useSourceChainGasToken({ fromChain, fromToken, }) {
             return evmTokens.find((t) => t.chainId === fromChain.chainId &&
                 t.address.toLowerCase() === tempoFeeData.gasTokenAddress.toLowerCase());
         }
+        if (isArcChain(fromChain.chainId)) {
+            return nativeToken?.decimals === 18
+                ? {
+                    ...nativeToken,
+                    symbol: fromChain.nativeCurrency.symbol,
+                    name: fromChain.nativeCurrency.name,
+                }
+                : undefined;
+        }
         return nativeToken;
     }, [
         fromChain?.chainId,
+        fromChain?.nativeCurrency.symbol,
+        fromChain?.nativeCurrency.name,
         fromToken?.address,
         nativeToken,
         tempoFeeData,
@@ -33056,22 +33262,57 @@ 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;
-    if (chainFeeParams.fromTokenPaysGasFees) {
-        return (BigInt(fromAmount ?? "0") + networkFeesWei <=
-            chainFeeParams.gasTokenBalanceWei);
-    }
-    return networkFeesWei <= chainFeeParams.gasTokenBalanceWei;
+    const total = calculateTotalGasBalanceNeeded({
+        fromAmount,
+        networkFeesWei,
+        chainFeeParams,
+    });
+    return total != null && total <= chainFeeParams.gasTokenBalanceWei;
 };
 const calculateMinAmountValueWarnMsg = ({ networkFeesWei, chainFeeParams, fromTokenDecimals, }) => {
-    if (!chainFeeParams?.fromTokenPaysGasFees)
+    if (!chainFeeParams?.fromTokenPaysGasFees || networkFeesWei == null)
         return undefined;
     const minAmount = chainFeeParams.gasTokenBalanceWei - networkFeesWei;
     if (minAmount <= BigInt(0))
         return undefined;
-    return formatBNToReadable(minAmount, fromTokenDecimals);
+    const amountInTokenUnits = chainFeeParams.gasUnitsToFromAmount?.(minAmount) ?? minAmount;
+    if (amountInTokenUnits <= 0n)
+        return undefined;
+    return formatBNToReadable(amountInTokenUnits, fromTokenDecimals);
 };
 /**
  * Calculates the estimated duration of a route
@@ -33120,14 +33361,22 @@ 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 = calculateTotalNativeFees({
-        expressFeeCost,
-        firstFeeCost,
-        firstGasCost,
-        sameTokenBetweenFees,
-    });
-    const totalFeesInNativeTokenPlusRatio = (totalNativeFees * BigInt(110)) / BigInt(100);
-    const networkFeesWei = chainFeeParams?.normalizeFee(totalFeesInNativeTokenPlusRatio) ?? BigInt(0);
+    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 isGasBalanceEnough = checkIsGasBalanceEnough({
         chainFeeParams,
         fromAmount,
@@ -33143,10 +33392,12 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         estimatedRouteDuration: squidRoute?.estimate?.estimatedRouteDuration,
         isSingleChainRoute,
     });
-    // gas fees + fromAmount (if fromToken is gas token)
-    const totalGasBalanceNeeded = networkFeesWei +
-        BigInt(chainFeeParams?.fromTokenPaysGasFees ? (fromAmount ?? 0) : 0);
-    const gasBalanceNeeded = gasToken
+    const totalGasBalanceNeeded = calculateTotalGasBalanceNeeded({
+        fromAmount,
+        networkFeesWei,
+        chainFeeParams,
+    });
+    const gasBalanceNeeded = gasToken && totalGasBalanceNeeded != null
         ? formatBNToReadable(totalGasBalanceNeeded, gasToken.decimals)
         : undefined;
     return {
@@ -33168,7 +33419,7 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         expectedGasRefundCostUSD,
         sameTokenBetweenFees,
         fromTokenPaysGasFees: chainFeeParams?.fromTokenPaysGasFees ?? false,
-        totalNativeFees,
+        totalNativeFees: totalNativeFees ?? 0n,
         isGasBalanceEnough,
         minAmountValueWarnMsg,
         estimatedRouteDuration,
@@ -33217,8 +33468,12 @@ function useSendTransactionGas({ chain, token, from, }) {
                 case squidTypes.ChainType.EVM: {
                     const client = await getClient(chain);
                     const feeData = await client.getFeeData();
-                    if (!feeData.maxFeePerGas)
+                    if (!feeData.maxFeePerGas) {
+                        if (isArcChain(chain.chainId)) {
+                            throw new Error("Gas price is unavailable");
+                        }
                         return BigInt(0);
+                    }
                     let maxFeePerGas = feeData.maxFeePerGas;
                     if (token.chainId === CHAIN_IDS.HEDERA) {
                         maxFeePerGas = scaleWeiToHbar(BigInt(feeData.maxFeePerGas));
@@ -33238,6 +33493,9 @@ 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);
@@ -33252,6 +33510,9 @@ 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) {
@@ -33299,35 +33560,45 @@ function useSendTransactionGas({ chain, token, from, }) {
 }
 
 function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
-    const { data: estimatedGas = BigInt(0), isLoading } = useSendTransactionGas({
+    const { data, isLoading, isFetching, isError, refetch } = 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)
+        if (!amount || token?.decimals == null || !gasToken)
             return false;
         return checkIsGasBalanceEnough({
             fromAmount: parseToBigInt(amount, token.decimals).toString(),
-            networkFeesWei: estimatedGas,
+            networkFeesWei,
             chainFeeParams,
         });
-    }, [amount, estimatedGas, token, chainFeeParams]);
+    }, [amount, networkFeesWei, token, chainFeeParams, gasToken]);
     const gasBalanceNeeded = React.useMemo(() => {
-        if (!amount || !token?.decimals || !gasToken?.decimals)
+        if (!amount || token?.decimals == null || gasToken?.decimals == null)
+            return undefined;
+        const totalGasBalanceNeeded = calculateTotalGasBalanceNeeded({
+            fromAmount: parseToBigInt(amount, token.decimals).toString(),
+            networkFeesWei,
+            chainFeeParams,
+        });
+        if (totalGasBalanceNeeded == null)
             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?.fromTokenPaysGasFees,
-        estimatedGas,
+        chainFeeParams,
+        networkFeesWei,
         gasToken?.decimals,
         token?.decimals,
     ]);
@@ -33338,20 +33609,22 @@ 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 || !gasToken || !chainFeeParams)
             return undefined;
         return calculateMinAmountValueWarnMsg({
             chainFeeParams,
-            networkFeesWei: estimatedGas,
+            networkFeesWei,
             fromTokenDecimals: token.decimals,
         });
-    }, [estimatedGas, token, chainFeeParams]);
+    }, [networkFeesWei, token, chainFeeParams, gasToken]);
     return {
         estimatedGas,
         gasBalanceNeeded,
         isBalanceEnough,
         tokenPaysGasFees: chainFeeParams?.fromTokenPaysGasFees ?? false,
-        isLoading,
+        isLoading: isLoading || isFetching,
+        isError,
+        refetchGasEstimate: refetch,
         isGasBalanceEnough,
         minAmountValueWarnMsg,
     };
@@ -34252,6 +34525,19 @@ 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.
@@ -34412,13 +34698,20 @@ const useApproval = ({ squidRoute, }) => {
             return false;
         }
     }, {
-        onSuccess: async () => {
+        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));
+            }
             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) {
-                queryClient.refetchQueries({
+                await 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),
@@ -39293,6 +39586,7 @@ exports.getStepsInfos = getStepsInfos;
 exports.getSuggestedAmountsForCurrency = getSuggestedAmountsForCurrency;
 exports.getSupportedChainIdsForDirection = getSupportedChainIdsForDirection;
 exports.getSwapTxStatusRefetchInterval = getSwapTxStatusRefetchInterval;
+exports.getTokenAddressForSelection = getTokenAddressForSelection;
 exports.getTokenAssetsKey = getTokenAssetsKey;
 exports.getTokenImage = getTokenImage;
 exports.getTokensForChain = getTokensForChain;
@@ -39349,6 +39643,7 @@ exports.nativeSuiTokenAddress = nativeSuiTokenAddress;
 exports.nativeXrplTokenAddress = nativeXrplTokenAddress;
 exports.normalizeError = normalizeError;
 exports.normalizeIbcAddress = normalizeIbcAddress;
+exports.normalizeSwapParamsForSelection = normalizeSwapParamsForSelection;
 exports.normalizeTokenSymbol = normalizeTokenSymbol;
 exports.parseEvmAddress = parseEvmAddress;
 exports.parseInitialAssetsFromUrl = parseInitialAssetsFromUrl;
@@ -39462,4 +39757,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-CJVX-7hj.js.map
+//# sourceMappingURL=index-BBJD55XX.js.map