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

package/dist/core/constants.d.ts

@@ -64,8 +64,10 @@ export declare const CHAIN_IDS: {
     readonly GNOSIS: "100";
     readonly SONIC: "146";
     readonly HYPER_EVM: "999";
+    readonly DCHAIN: "2716446429837000";
     readonly SONEIUM: "1868";
     readonly PEAQ: "3338";
+    readonly HEDERA: "295";
     readonly BITCOIN: "bitcoin";
     readonly SOLANA: "solana-mainnet-beta";
     readonly SUI: "sui-mainnet";

package/dist/core/queries/queries-keys.d.ts

@@ -34,7 +34,9 @@ export declare enum QueryKeys {
     XrplAccountActivatedInfo = "xrplAccountActivatedInfo",
     FiatToCryptoPaymentMethods = "fiatToCryptoPaymentMethods",
     Stellar = "stellar",
-    StellarAccountActivatedInfo = "stellarAccountActivatedInfo"
+    StellarAccountActivatedInfo = "stellarAccountActivatedInfo",
+    Hedera = "hedera",
+    IsHederaTokenAssociated = "isHederaTokenAssociated"
 }
 export declare const keys: () => {
     all: QueryKeys;
@@ -45,6 +47,7 @@ export declare const keys: () => {
     transactions: () => QueryKeys[];
     xrpl: () => QueryKeys[];
     stellar: () => QueryKeys[];
+    hedera: () => QueryKeys[];
     coinGeckoPrices: (coingeckoIds?: string[]) => (string | undefined)[];
     historicalData: (coingeckoId?: string, timeFrame?: Timeframe) => (string | undefined)[];
     tokensData: (tokens?: TokenWithBalance[]) => (string | undefined)[];
@@ -69,5 +72,6 @@ export declare const keys: () => {
     isXrplTrustLineApproved: (address: string | undefined, chainId: string | undefined, chainType: ChainType | undefined, tokenAddress: string | undefined, trustLineLimit: string | undefined, amountToApprove: bigint | undefined) => (string | undefined)[];
     xrplAccountActivatedInfo: (destinationAddress: string | undefined, toChainId: string | undefined, toChainType: ChainType | undefined) => (string | undefined)[];
     stellarAccountActivatedInfo: (address: string | undefined, chainId: string | undefined, chainType: ChainType | undefined) => (string | undefined)[];
+    isHederaTokenAssociated: (address: string | undefined, chainId: string | undefined, chainType: ChainType | undefined, tokenAddress: string | undefined) => (string | undefined)[];
 };
 export declare const getPrefixKey: (key: QueryKeys) => QueryKeys[];

package/dist/hooks/hedera/useHederaTokenAssociations.d.ts

@@ -0,0 +1,11 @@
+import { ChainData, Token } from "@0xsquid/squid-types";
+interface Params {
+    address: string | undefined;
+    token: Token | undefined;
+    chain: ChainData | undefined;
+}
+export declare function useHederaTokenAssociations({ address, chain, token }: Params): {
+    isTokenAssociated: import("@tanstack/react-query").UseQueryResult<boolean, unknown>;
+    associateToken: import("@tanstack/react-query").UseMutationResult<boolean, unknown, void, unknown>;
+};
+export {};

package/dist/hooks/index.d.ts

@@ -2,6 +2,7 @@ export { useTrackSearchEmpty } from "./analytics/useTrackSearchEmpty";
 export { useSquidChains } from "./chains/useSquidChains";
 export { useClient } from "./client/useClient";
 export { useCosmosForChain } from "./cosmos/useCosmosForChain";
+export { useHederaTokenAssociations } from "./hedera/useHederaTokenAssociations";
 export { useKeyboardNavigation } from "./navigation/useKeyboardNavigation";
 export * from "./onramp/useFiatToCrypto";
 export { useSquidQueryClient } from "./query/useSquidQueryClient";

package/dist/{index-C23cJ6Ws.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
     // ============
@@ -22357,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) {
@@ -22374,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];
     }
@@ -23067,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) {
@@ -23084,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-M8SCtgDG.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-D7gPw0fs.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -24457,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...)
@@ -26260,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-CNTH5mSh.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();
@@ -27560,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") {
@@ -27608,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
@@ -29673,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();
@@ -30668,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);
@@ -36451,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;
@@ -36612,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;
@@ -36652,4 +36812,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-C23cJ6Ws.js.map
+//# sourceMappingURL=index-C0H64ktj.js.map