@0xsquid/react-hooks 8.0.5 → 8.0.7-hedera-beta.0

package/dist/{index-fCnKL8wD.js → index-C0H64ktj.js}

@@ -27,11 +27,11 @@ var wagmi = require('wagmi');
 var SafeAppsSDK = require('@safe-global/safe-apps-sdk');
 var core$1 = require('@wallet-standard/core');
 var slushWallet = require('@mysten/slush-wallet');
+var connectors = require('wagmi/connectors');
 var stargate = require('@cosmjs/stargate');
 var client = require('@mysten/sui/client');
 var protoSigning = require('@cosmjs/proto-signing');
 var transactions = require('@mysten/sui/transactions');
-var connectors = require('wagmi/connectors');
 var cosmwasmStargate = require('@cosmjs/cosmwasm-stargate');
 var index_js = require('@injectivelabs/sdk-ts/dist/cjs/core/stargate/index.js');
 var sdk = require('@0xsquid/sdk');
@@ -140,8 +140,10 @@ const CHAIN_IDS = {
     GNOSIS: "100",
     SONIC: "146",
     HYPER_EVM: "999",
+    DCHAIN: "2716446429837000",
     SONEIUM: "1868",
     PEAQ: "3338",
+    HEDERA: "295",
     // others
     BITCOIN: "bitcoin",
     SOLANA: "solana-mainnet-beta",
@@ -22168,6 +22170,8 @@ var QueryKeys;
     QueryKeys["FiatToCryptoPaymentMethods"] = "fiatToCryptoPaymentMethods";
     QueryKeys["Stellar"] = "stellar";
     QueryKeys["StellarAccountActivatedInfo"] = "stellarAccountActivatedInfo";
+    QueryKeys["Hedera"] = "hedera";
+    QueryKeys["IsHederaTokenAssociated"] = "isHederaTokenAssociated";
 })(QueryKeys || (QueryKeys = {}));
 const keys = () => ({
     // ============
@@ -22181,6 +22185,7 @@ const keys = () => ({
     transactions: () => [QueryKeys.All, QueryKeys.Transactions],
     xrpl: () => [QueryKeys.All, QueryKeys.Xrpl],
     stellar: () => [QueryKeys.All, QueryKeys.Stellar],
+    hedera: () => [QueryKeys.All, QueryKeys.Hedera],
     // ============
     // Tokens
     // ============
@@ -22270,7 +22275,7 @@ const keys = () => ({
     // ============
     // Approval
     // ============
-    routeApproved: (routeData, allowanceInWei, approvalType) => [
+    routeApproved: (routeData, allowanceInWei) => [
         ...keys().transactions(),
         QueryKeys.RouteApproved,
         routeData?.params.fromAddress,
@@ -22278,7 +22283,6 @@ const keys = () => ({
         routeData?.params.fromToken,
         routeData?.params.fromAmount,
         allowanceInWei?.toString(),
-        approvalType,
     ],
     sendTransactionGas: (chainId, tokenAddress, from) => [
         QueryKeys.All,
@@ -22358,6 +22362,17 @@ const keys = () => ({
         chainId,
         chainType,
     ],
+    // ============
+    // Hedera
+    // ============
+    isHederaTokenAssociated: (address, chainId, chainType, tokenAddress) => [
+        ...keys().hedera(),
+        QueryKeys.IsHederaTokenAssociated,
+        address,
+        chainId,
+        chainType,
+        tokenAddress,
+    ],
 });
 const getPrefixKey = (key) => {
     switch (key) {
@@ -22375,6 +22390,8 @@ const getPrefixKey = (key) => {
             return [...keys().transactions(), key];
         case QueryKeys.XrplTrustLine:
             return [...keys().xrpl(), key];
+        case QueryKeys.IsHederaTokenAssociated:
+            return [...keys().hedera(), key];
         default:
             return [QueryKeys.All, key];
     }
@@ -23068,6 +23085,7 @@ const filterViewableTokens = (tokens, config, direction) => {
         { chainId: CHAIN_IDS.CELO, 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 (direction) {
@@ -23085,7 +23103,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-CIyWIixx.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-D7gPw0fs.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -24458,6 +24476,13 @@ function getSuggestedAmountsForCurrency(currencyCode) {
     return amounts.map(adaptiveRound);
 }
 
+function convertHederaAccountIdToEvmAddress(accId) {
+    return "0x" + Number(accId.split(".").at(-1)).toString(16).padStart(40, "0");
+}
+function convertEvmAddressToHederaAccountId(address) {
+    return "0.0." + Number(address);
+}
+
 /**
  * Minimum length of a search query to search by address
  * Some tokens can have very short addresses (e.g. "uosmo", "uixo", "satoshi", etc...)
@@ -26261,7 +26286,7 @@ function useStellarWallets() {
                 return;
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
-                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-K2_2eYYZ.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-peMOjG49.js'); });
                 const modules = initializeAllModules();
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27561,6 +27586,268 @@ function useTrackSearchEmpty({ searchQuery, resultsLength, context, debounceMs =
     }, [context, debounceMs, resultsLength, searchQuery]);
 }
 
+const createWagmiConfig = (squidChains) => {
+    const filteredEvmChains = squidChains.filter((chain) => chain.chainType === squidTypes.ChainType.EVM);
+    if (filteredEvmChains.length === 0) {
+        throw new Error("At least one chain is required");
+    }
+    const wagmiChains = filteredEvmChains.map((chain) => {
+        return viem.defineChain({
+            id: Number(chain.chainId),
+            name: chain.networkName,
+            nativeCurrency: {
+                name: chain.nativeCurrency.name,
+                symbol: chain.nativeCurrency.symbol,
+                decimals: chain.nativeCurrency.decimals,
+            },
+            rpcUrls: {
+                public: {
+                    http: [chain.rpc],
+                },
+                default: {
+                    http: [chain.rpc],
+                },
+            },
+        });
+    });
+    return wagmi.createConfig({
+        chains: wagmiChains,
+        transports: Object.fromEntries(wagmiChains.map((chain) => [
+            chain.id,
+            wagmi.http(chain.rpcUrls.public.http[0] ?? ""),
+        ])),
+        connectors: [
+            connectors.injected(),
+            connectors.safe({
+                allowedDomains: [/app.safe.global$/],
+            }),
+            connectors.metaMask({
+                dappMetadata: {
+                    name: SQUID_METADATA.name,
+                    url: SQUID_METADATA.url,
+                    iconUrl: SQUID_METADATA.icon,
+                },
+            }),
+            connectors.coinbaseWallet({
+                appName: SQUID_METADATA.name,
+                appLogoUrl: SQUID_METADATA.icon,
+            }),
+            connectors.walletConnect({
+                projectId: WALLETCONNECT_PROJECT_ID,
+                metadata: {
+                    url: SQUID_METADATA.url,
+                    name: SQUID_METADATA.name,
+                    icons: [SQUID_METADATA.icon],
+                    description: SQUID_METADATA.description,
+                },
+            }),
+        ],
+    });
+};
+// Taken from wagmi docs
+// https://wagmi.sh/react/guides/ethers
+function clientToSigner(client) {
+    const { account, chain, transport } = client;
+    if (!account || !chain || !transport) {
+        return undefined;
+    }
+    const network = {
+        chainId: chain.id,
+        name: chain.name,
+        ensAddress: chain.contracts?.ensRegistry?.address,
+    };
+    const provider = new ethers.BrowserProvider(transport, network);
+    const signer = new ethers.JsonRpcSigner(provider, account.address);
+    return signer;
+}
+
+function useEvmSigner({ chainId }) {
+    const { connector } = wagmi.useAccount();
+    const { data: client } = wagmi.useWalletClient({ chainId, connector });
+    const signer = React.useMemo(() => (client ? clientToSigner(client) : undefined), [client]);
+    return { signer };
+}
+const useSigner = ({ chain }) => {
+    const evmChainId = chain?.chainType === squidTypes.ChainType.EVM ? Number(chain.chainId) : undefined;
+    // EVM and Cosmos need a different signer for each chain
+    // This is not the case for Solana or Bitcoin as there's only one chain in those ecosystems
+    const { signer: evmSigner } = useEvmSigner({ chainId: evmChainId });
+    const { signer: cosmosSigner } = useCosmosSigner({ chain });
+    const { signer: solanaSigner } = useSolanaContext();
+    const { signer: bitcoinSigner } = useBitcoinContext();
+    const { signer: suiSigner } = useSuiContext();
+    const { signer: xrplSigner } = useXrplContext();
+    const { signer: stellarSigner } = useStellarContext();
+    const isEvmSignerReady = !!evmSigner;
+    const isSolanaSignerReady = !!solanaSigner;
+    const isCosmosSignerReady = !!cosmosSigner;
+    const isBitcoinSignerReady = !!bitcoinSigner;
+    const isSuiSignerReady = !!suiSigner;
+    const isXrplSignerReady = !!xrplSigner;
+    const isStellarSignerReady = !!stellarSigner;
+    const isSignerReady = React.useMemo(() => {
+        if (!chain?.chainType)
+            return false;
+        switch (chain.chainType) {
+            case squidTypes.ChainType.EVM:
+                return isEvmSignerReady;
+            case squidTypes.ChainType.COSMOS:
+                return isCosmosSignerReady;
+            case squidTypes.ChainType.BTC:
+                return isBitcoinSignerReady;
+            case squidTypes.ChainType.SOLANA:
+                return isSolanaSignerReady;
+            case squidTypes.ChainType.SUI:
+                return isSuiSignerReady;
+            case squidTypes.ChainType.XRPL:
+                return isXrplSignerReady;
+            case squidTypes.ChainType.STELLAR:
+                return isStellarSignerReady;
+        }
+    }, [
+        chain?.chainType,
+        isEvmSignerReady,
+        isCosmosSignerReady,
+        isBitcoinSignerReady,
+        isSolanaSignerReady,
+        isSuiSignerReady,
+        isXrplSignerReady,
+        isStellarSignerReady,
+    ]);
+    return {
+        isSignerReady,
+        evmSigner,
+        cosmosSigner,
+        bitcoinSigner,
+        solanaSigner,
+        suiSigner,
+        xrplSigner,
+        stellarSigner,
+    };
+};
+
+function useHederaTokenAssociations({ address, chain, token }) {
+    const publicClient = wagmi.usePublicClient({
+        chainId: Number(CHAIN_IDS.HEDERA),
+    });
+    const { evmSigner } = useSigner({ chain });
+    const queryClient = reactQuery.useQueryClient();
+    /**
+     * Creates a token association transaction where the destination account authorizes to receive the given token
+     */
+    const associateToken = reactQuery.useMutation({
+        mutationFn: async () => {
+            try {
+                if (!evmSigner) {
+                    throw new Error("EVM signer not found");
+                }
+                if (chain?.chainId !== CHAIN_IDS.HEDERA ||
+                    token?.chainId !== CHAIN_IDS.HEDERA) {
+                    throw new Error("Chain and token to associate must be on Hedera");
+                }
+                const tokenAddress = parseEvmAddress(token.address);
+                if (!tokenAddress) {
+                    throw new Error("Invalid token address");
+                }
+                const userAddress = parseEvmAddress(address);
+                if (!userAddress) {
+                    throw new Error("Invalid user address");
+                }
+                const encodedData = viem.encodeFunctionData({
+                    abi: [
+                        {
+                            inputs: [],
+                            name: "associate",
+                            outputs: [
+                                {
+                                    internalType: "uint256",
+                                    name: "responseCode",
+                                    type: "uint256",
+                                },
+                            ],
+                            stateMutability: "nonpayable",
+                            type: "function",
+                        },
+                    ],
+                    functionName: "associate",
+                    args: [],
+                });
+                const txRes = await evmSigner.sendTransaction({
+                    data: encodedData,
+                    to: tokenAddress,
+                    chainId: chain.chainId,
+                });
+                const receipt = await txRes.wait();
+                if (receipt?.status !== 1) {
+                    throw new Error(`Transaction failed with status: ${receipt?.status}`);
+                }
+                return true;
+            }
+            catch (error) {
+                console.error("Error associating Hedera token:", error);
+                return false;
+            }
+        },
+        async onSuccess() {
+            queryClient.refetchQueries({
+                queryKey: getPrefixKey(QueryKeys.IsHederaTokenAssociated),
+            });
+        },
+    });
+    /**
+     * Checks if the destination account has associated the given token.
+     *
+     * Hedera requires accounts to associate a token before being able to receive it.
+     *
+     * Accounts which have max. associations set to -1 can receive any token without previous association
+     */
+    const isTokenAssociated = reactQuery.useQuery({
+        queryKey: keys().isHederaTokenAssociated(address, token?.chainId, token?.type, token?.address),
+        queryFn: async () => {
+            if (token?.chainId !== CHAIN_IDS.HEDERA) {
+                return true;
+            }
+            // The native HBAR token doesn't need an association
+            if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase()) {
+                return true;
+            }
+            if (!publicClient) {
+                throw new Error("Public client not found");
+            }
+            const url = `https://mainnet-public.mirrornode.hedera.com/api/v1/accounts/${address}`;
+            const response = await fetch(url);
+            const data = await response.json();
+            switch (data.max_automatic_token_associations) {
+                case -1: {
+                    // Unlimited auto associations
+                    return true;
+                }
+                case 0: {
+                    // No auto associations, token needs to be associated beforehand
+                    const tokenId = convertEvmAddressToHederaAccountId(token.address);
+                    return data.balance.tokens.some((t) => t.token_id === tokenId);
+                }
+                default: {
+                    // Limited auto associations, check if there is an available slot
+                    const url2 = `https://mainnet-public.mirrornode.hedera.com/api/v1/accounts/${address}/tokens`;
+                    const response2 = await fetch(url2);
+                    const data2 = await response2.json();
+                    if (!data2.tokens)
+                        return false;
+                    const autoAssociatedTokens = data2.tokens.filter((t) => t.automatic_association);
+                    const remainingAutoAssociations = data.max_automatic_token_associations - autoAssociatedTokens.length;
+                    return remainingAutoAssociations > 0;
+                }
+            }
+        },
+        enabled: !!address && !!publicClient && token?.chainId === CHAIN_IDS.HEDERA,
+    });
+    return {
+        isTokenAssociated,
+        associateToken,
+    };
+}
+
 const useKeyboardNavigation = ({ onEscape }) => {
     const onKeyDown = React.useCallback((event) => {
         if (event.key === "Escape") {
@@ -27609,6 +27896,7 @@ const chainIdToMulticall3AddressMap = {
     [CHAIN_IDS.SAGA_EVM]: "0x864DDc9B50B9A0dF676d826c9B9EDe9F8913a160",
     [CHAIN_IDS.XRPL_EVM]: "0xaB3a12b26e72F4D6D9B579aCb5027a0918eF1114",
     [CHAIN_IDS.XRPL_EVM_TESTNET]: "0x82Cc144D7d0AD4B1c27cb41420e82b82Ad6e9B31",
+    [CHAIN_IDS.HEDERA]: "0xf21405c87d8538d22607eb9987cd3386121dd5dd",
 };
 /**
  * Returns the multicall3 address for a given chain ID
@@ -29674,12 +29962,20 @@ const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshInter
             retry: 2,
         },
     });
-    const balance = isNativeToken ? nativeBalance?.value : erc20Balance;
-    const isLoading = isNativeToken ? isNativeTokenLoading : isErc20Loading;
-    const formattedBalance = balance != null && token?.decimals != null
-        ? formatBNToReadable(balance, token.decimals)
-        : "0";
-    return { balance: formattedBalance, isLoading };
+    if (isNativeToken) {
+        return {
+            isLoading: isNativeTokenLoading,
+            balance: nativeBalance
+                ? formatBNToReadable(nativeBalance.value, nativeBalance.decimals)
+                : "0",
+        };
+    }
+    return {
+        balance: erc20Balance && token
+            ? formatBNToReadable(erc20Balance, token.decimals)
+            : "0",
+        isLoading: isErc20Loading,
+    };
 };
 const useCosmosBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
     const { isConnected } = useCosmosContext();
@@ -30669,146 +30965,6 @@ async function sendTransactionStellar({ amount, signer, to, token, chain, }) {
     };
 }
 
-const createWagmiConfig = (squidChains) => {
-    const filteredEvmChains = squidChains.filter((chain) => chain.chainType === squidTypes.ChainType.EVM);
-    if (filteredEvmChains.length === 0) {
-        throw new Error("At least one chain is required");
-    }
-    const wagmiChains = filteredEvmChains.map((chain) => {
-        return viem.defineChain({
-            id: Number(chain.chainId),
-            name: chain.networkName,
-            nativeCurrency: {
-                name: chain.nativeCurrency.name,
-                symbol: chain.nativeCurrency.symbol,
-                decimals: chain.nativeCurrency.decimals,
-            },
-            rpcUrls: {
-                public: {
-                    http: [chain.rpc],
-                },
-                default: {
-                    http: [chain.rpc],
-                },
-            },
-        });
-    });
-    return wagmi.createConfig({
-        chains: wagmiChains,
-        transports: Object.fromEntries(wagmiChains.map((chain) => [
-            chain.id,
-            wagmi.http(chain.rpcUrls.public.http[0] ?? ""),
-        ])),
-        connectors: [
-            connectors.injected(),
-            connectors.safe({
-                allowedDomains: [/app.safe.global$/],
-            }),
-            connectors.metaMask({
-                dappMetadata: {
-                    name: SQUID_METADATA.name,
-                    url: SQUID_METADATA.url,
-                    iconUrl: SQUID_METADATA.icon,
-                },
-            }),
-            connectors.coinbaseWallet({
-                appName: SQUID_METADATA.name,
-                appLogoUrl: SQUID_METADATA.icon,
-            }),
-            connectors.walletConnect({
-                projectId: WALLETCONNECT_PROJECT_ID,
-                metadata: {
-                    url: SQUID_METADATA.url,
-                    name: SQUID_METADATA.name,
-                    icons: [SQUID_METADATA.icon],
-                    description: SQUID_METADATA.description,
-                },
-            }),
-        ],
-    });
-};
-// Taken from wagmi docs
-// https://wagmi.sh/react/guides/ethers
-function clientToSigner(client) {
-    const { account, chain, transport } = client;
-    if (!account || !chain || !transport) {
-        return undefined;
-    }
-    const network = {
-        chainId: chain.id,
-        name: chain.name,
-        ensAddress: chain.contracts?.ensRegistry?.address,
-    };
-    const provider = new ethers.BrowserProvider(transport, network);
-    const signer = new ethers.JsonRpcSigner(provider, account.address);
-    return signer;
-}
-
-function useEvmSigner({ chainId }) {
-    const { connector } = wagmi.useAccount();
-    const { data: client } = wagmi.useWalletClient({ chainId, connector });
-    const signer = React.useMemo(() => (client ? clientToSigner(client) : undefined), [client]);
-    return { signer };
-}
-const useSigner = ({ chain }) => {
-    const evmChainId = chain?.chainType === squidTypes.ChainType.EVM ? Number(chain.chainId) : undefined;
-    // EVM and Cosmos need a different signer for each chain
-    // This is not the case for Solana or Bitcoin as there's only one chain in those ecosystems
-    const { signer: evmSigner } = useEvmSigner({ chainId: evmChainId });
-    const { signer: cosmosSigner } = useCosmosSigner({ chain });
-    const { signer: solanaSigner } = useSolanaContext();
-    const { signer: bitcoinSigner } = useBitcoinContext();
-    const { signer: suiSigner } = useSuiContext();
-    const { signer: xrplSigner } = useXrplContext();
-    const { signer: stellarSigner } = useStellarContext();
-    const isEvmSignerReady = !!evmSigner;
-    const isSolanaSignerReady = !!solanaSigner;
-    const isCosmosSignerReady = !!cosmosSigner;
-    const isBitcoinSignerReady = !!bitcoinSigner;
-    const isSuiSignerReady = !!suiSigner;
-    const isXrplSignerReady = !!xrplSigner;
-    const isStellarSignerReady = !!stellarSigner;
-    const isSignerReady = React.useMemo(() => {
-        if (!chain?.chainType)
-            return false;
-        switch (chain.chainType) {
-            case squidTypes.ChainType.EVM:
-                return isEvmSignerReady;
-            case squidTypes.ChainType.COSMOS:
-                return isCosmosSignerReady;
-            case squidTypes.ChainType.BTC:
-                return isBitcoinSignerReady;
-            case squidTypes.ChainType.SOLANA:
-                return isSolanaSignerReady;
-            case squidTypes.ChainType.SUI:
-                return isSuiSignerReady;
-            case squidTypes.ChainType.XRPL:
-                return isXrplSignerReady;
-            case squidTypes.ChainType.STELLAR:
-                return isStellarSignerReady;
-        }
-    }, [
-        chain?.chainType,
-        isEvmSignerReady,
-        isCosmosSignerReady,
-        isBitcoinSignerReady,
-        isSolanaSignerReady,
-        isSuiSignerReady,
-        isXrplSignerReady,
-        isStellarSignerReady,
-    ]);
-    return {
-        isSignerReady,
-        evmSigner,
-        cosmosSigner,
-        bitcoinSigner,
-        solanaSigner,
-        suiSigner,
-        xrplSigner,
-        stellarSigner,
-    };
-};
-
 function useSendTransaction({ to, amount, token, chain, }) {
     const { connectedWalletsByChainType } = useWallet();
     const { connectedAddress } = useMultiChainWallet(chain);
@@ -31526,11 +31682,12 @@ var ics20Abi = [
 	}
 ];
 
-const useErc20Allowance = ({ tokenAddress, ownerAddress, spenderAddress, amount = BigInt(0), chainId, enabled = true, }) => {
+const useErc20Allowance = ({ tokenAddress, ownerAddress, spenderAddress, amount = BigInt(0), chainId, transactionType, enabled = true, }) => {
     const parsedTokenAddress = parseEvmAddress(tokenAddress);
     const parsedOwnerAddress = parseEvmAddress(ownerAddress);
     const parsedSpenderAddress = parseEvmAddress(spenderAddress);
     const isNativeToken = parsedTokenAddress?.toLowerCase() === nativeEvmTokenAddress.toLowerCase();
+    const isDepositAddressTx = transactionType === squidTypes.SquidDataType.DepositAddressCalldata;
     const result = wagmi.useReadContract({
         abi: viem.erc20Abi,
         address: parsedTokenAddress ?? undefined,
@@ -31544,17 +31701,16 @@ const useErc20Allowance = ({ tokenAddress, ownerAddress, spenderAddress, amount
                 Boolean(parsedTokenAddress &&
                     parsedOwnerAddress &&
                     parsedSpenderAddress &&
-                    !isNativeToken),
+                    !isNativeToken &&
+                    !isDepositAddressTx),
         },
     });
     if (!parsedTokenAddress || !parsedOwnerAddress || !parsedSpenderAddress) {
-        return {
-            hasAllowance: false,
-            error: new Error("Invalid or missing address"),
-        };
+        return { hasAllowance: false };
     }
-    if (isNativeToken) {
-        return { hasAllowance: true, isNativeToken: true };
+    // Native tokens and deposit address transactions don't need approval
+    if (isNativeToken || isDepositAddressTx) {
+        return { hasAllowance: true };
     }
     const allowanceInWei = result.data ?? BigInt(0);
     const hasAllowance = allowanceInWei >= amount;
@@ -31622,26 +31778,8 @@ const useApproval = ({ squidRoute, }) => {
     const isSrcChainEvmos = isEvmosChain(fromChain);
     const isSagaSameChainSwap = isSameChain &&
         fromChain?.chainId.toString() === CHAIN_IDS.SAGA_EVM.toString();
-    const approvalType = React.useMemo(() => {
-        if (squidRoute?.transactionRequest?.type ===
-            squidTypes.SquidDataType.DepositAddressCalldata) {
-            // No approvals needed for deposit address calls
-            return null;
-        }
-        if (isSrcChainEvmos && !isSagaSameChainSwap) {
-            // Use ICS20 for Evmos chains, except for SagaEVM same-chain swaps
-            return "ics20";
-        }
-        else {
-            return "erc20";
-        }
-    }, [
-        isSagaSameChainSwap,
-        isSrcChainEvmos,
-        squidRoute?.transactionRequest?.type,
-    ]);
-    const useIcs20 = approvalType === "ics20";
-    const useErc20 = approvalType === "erc20";
+    // Use ICS20 for Evmos chains, except for SagaEVM same-chain swaps
+    const useIcs20 = isSrcChainEvmos && !isSagaSameChainSwap;
     const { hasAllowance: hasErc20Allowance, query: erc20AllowanceQuery, allowanceInWei: erc20AllowanceInWei, } = useErc20Allowance({
         tokenAddress: fromToken?.address,
         ownerAddress: sourceUserAddress,
@@ -31649,7 +31787,8 @@ const useApproval = ({ squidRoute, }) => {
             ?.target,
         amount: BigInt(squidRoute?.params.fromAmount ?? "0"),
         chainId: Number(fromChain?.chainId),
-        enabled: useErc20,
+        transactionType: squidRoute?.transactionRequest?.type,
+        enabled: !useIcs20,
     });
     const { hasAllowance: hasIcs20Allowance, query: ics20AllowanceQuery, allowanceInWei: ics20AllowanceInWei, } = useIcs20Allowance({
         ownerAddress: sourceUserAddress,
@@ -31668,10 +31807,7 @@ const useApproval = ({ squidRoute, }) => {
      * On Error: Showing the error message if any
      * @returns {boolean} approved
      */
-    const routeApproved = reactQuery.useQuery(keys().routeApproved(squidRoute, allowanceInWei, approvalType), async () => {
-        if (approvalType === null) {
-            return true;
-        }
+    const routeApproved = reactQuery.useQuery(keys().routeApproved(squidRoute, allowanceInWei), async () => {
         // Approval is only needed for EVM chains
         if (getChainType(squidRoute?.params.fromChain) === squidTypes.ChainType.EVM) {
             return hasAllowance;
@@ -31680,8 +31816,8 @@ const useApproval = ({ squidRoute, }) => {
     }, {
         enabled: !!squidRoute &&
             !!sourceUserAddress &&
-            ((!allowanceQuery?.isLoading && allowanceQuery?.isFetched) ||
-                approvalType === null),
+            !allowanceQuery?.isLoading &&
+            allowanceQuery?.isFetched,
     });
     // USDT has a very specific way of handling approvals
     // ```
@@ -31771,9 +31907,6 @@ const useApproval = ({ squidRoute, }) => {
      */
     const approveRoute = reactQuery.useMutation(async () => {
         try {
-            if (approvalType === null) {
-                return true;
-            }
             if (fromToken?.address === nativeEvmTokenAddress) {
                 return true;
             }
@@ -36475,6 +36608,8 @@ exports.cleanAmount = cleanAmount;
 exports.compareTransactionIds = compareTransactionIds;
 exports.connectCosmosWallet = connectCosmosWallet;
 exports.connectWallet = connectWallet;
+exports.convertEvmAddressToHederaAccountId = convertEvmAddressToHederaAccountId;
+exports.convertHederaAccountIdToEvmAddress = convertHederaAccountIdToEvmAddress;
 exports.convertTokenAmountToUSD = convertTokenAmountToUSD;
 exports.convertUSDToTokenAmount = convertUSDToTokenAmount;
 exports.createQuoteRequestParamsHash = createQuoteRequestParamsHash;
@@ -36636,6 +36771,7 @@ exports.useGetOnrampPaymentTypes = useGetOnrampPaymentTypes;
 exports.useGetRoute = useGetRoute;
 exports.useGetRouteWrapper = useGetRouteWrapper;
 exports.useGnosisContext = useGnosisContext;
+exports.useHederaTokenAssociations = useHederaTokenAssociations;
 exports.useHistoricalData = useHistoricalData;
 exports.useHistory = useHistory;
 exports.useHistoryStore = useHistoryStore;
@@ -36676,4 +36812,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-fCnKL8wD.js.map
+//# sourceMappingURL=index-C0H64ktj.js.map