@0xsquid/react-hooks 8.4.1-beta-tempo.0 → 8.5.0

package/dist/{index-B4aeecpP.js → index-BGVXRZI6.js}

@@ -1,5 +1,5 @@
 import { ChainType, ActionType, SquidDataType, BridgeType, BridgeProvider, FeeType } from '@0xsquid/squid-types';
-import { zeroAddress as zeroAddress$1, parseUnits, formatUnits, isAddress, SwitchChainError, UserRejectedRequestError, erc20Abi, getAddress, defineChain, encodeFunctionData } from 'viem';
+import { zeroAddress as zeroAddress$1, parseUnits, formatUnits, isAddress, SwitchChainError, UserRejectedRequestError, getAddress, defineChain, encodeFunctionData, erc20Abi } from 'viem';
 import React, { useMemo, useCallback, useState, useEffect, createContext, useContext, useRef } from 'react';
 import { useQuery, useMutation, useQueries, useQueryClient, QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { fromBech32 } from '@cosmjs/encoding';
@@ -15,20 +15,20 @@ import { StandardWalletAdapter } from '@solana/wallet-standard-wallet-adapter-ba
 import { PublicKey, VersionedTransaction, Transaction, SystemProgram, Connection } from '@solana/web3.js';
 import { Networks, StrKey, nativeToScVal, Address, rpc, TransactionBuilder, BASE_FEE, Contract, TimeoutInfinite, scValToNative, Operation, Transaction as Transaction$1, xdr } from '@stellar/stellar-sdk';
 import { SUI_TESTNET_CHAIN, SUI_MAINNET_CHAIN } from '@mysten/wallet-standard';
-import { CloudflareProvider, JsonRpcProvider, ethers, Interface, BrowserProvider, JsonRpcSigner, Contract as Contract$1, isError } from 'ethers';
+import { CloudflareProvider, BrowserProvider, JsonRpcSigner, JsonRpcProvider, ethers, Interface, Contract as Contract$1, isError } from 'ethers';
 import BigNumber$1, { BigNumber } from 'bignumber.js';
 import { countries } from 'countries-list';
 import getSymbolFromCurrency from 'currency-symbol-map';
 import Fuse from 'fuse.js';
 import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
-import { useAccount, useConnectors, useConnect, useDisconnect, useSwitchChain, useBalance, useReadContract, createConfig, http, useWalletClient, usePublicClient, WagmiProvider } from 'wagmi';
+import { useAccount, useConnectors, useConnect, useDisconnect, useSwitchChain, createConfig, http, useWalletClient, usePublicClient, useBalance, useReadContract, WagmiProvider } from 'wagmi';
 import SafeAppsSDK, { TransactionStatus as TransactionStatus$1 } from '@safe-global/safe-apps-sdk';
 import { getWallets } from '@wallet-standard/core';
 import { SlushWallet } from '@mysten/slush-wallet';
+import { injected, safe, metaMask, coinbaseWallet, walletConnect } from 'wagmi/connectors';
 import { StargateClient, SigningStargateClient } from '@cosmjs/stargate';
 import { SuiClient } from '@mysten/sui/client';
-import { injected, safe, metaMask, coinbaseWallet, walletConnect } from 'wagmi/connectors';
 import { coin as coin$1 } from '@cosmjs/proto-signing';
 import { Transaction as Transaction$2 } from '@mysten/sui/transactions';
 import { SigningCosmWasmClient } from '@cosmjs/cosmwasm-stargate';
@@ -124,9 +124,6 @@ const CHAIN_IDS = {
     SONEIUM: "1868",
     PEAQ: "3338",
     HEDERA: "295",
-    MANTRA: "5888",
-    CITREA: "4114",
-    TEMPO: "4217",
     // others
     BITCOIN: "bitcoin",
     SOLANA: "solana-mainnet-beta",
@@ -21119,17 +21116,9 @@ function isOnChainTxData(squidData) {
     return [
         SquidDataType.OnChainExecution,
         SquidDataType.DepositAddressWithSignature,
+        SquidDataType.OnChainExecutionWithSignature,
     ].includes(squidData.type);
 }
-/**
- * Checks if a route is of type deposit-with-signature
- *
- * deposit-with-signature routes are on-chain routes
- * that require a signature from the user to execute
- */
-function isDepositWithSignatureTxData(squidData) {
-    return squidData.type === SquidDataType.DepositAddressWithSignature;
-}
 function getHistoryTransactionId(tx) {
     switch (tx.txType) {
         case HistoryTxType.SWAP:
@@ -22288,7 +22277,7 @@ const keys = () => ({
     // ============
     // Transactions
     // ============
-    transaction: (fromChainId, toChainId, toTokenAddress, fromTokenAddress, price, slippage, sourceUserAddress, degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChainType, preHook, postHook, overrideGasRefundAddress) => [
+    transaction: (fromChainId, toChainId, toTokenAddress, fromTokenAddress, price, slippage, getGasOnDestination, sourceUserAddress, degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChainType, preHook, postHook, overrideGasRefundAddress) => [
         ...keys().transactions(),
         QueryKeys.Transaction,
         fromChainId,
@@ -22297,6 +22286,7 @@ const keys = () => ({
         fromTokenAddress,
         price,
         slippage,
+        getGasOnDestination,
         sourceUserAddress,
         degenMode,
         destinationAddress,
@@ -22457,6 +22447,7 @@ const getConfigWithDefaults = (config) => {
         integratorId: get$2(config, "integratorId", defaultConfigValues.integratorId),
         slippage: get$2(config, "slippage", defaultConfigValues.slippage),
         collectFees: get$2(config, "collectFees", defaultConfigValues.collectFees),
+        enableGetGasOnDestination: get$2(config, "enableGetGasOnDestination", defaultConfigValues.enableGetGasOnDestination),
         apiUrl: get$2(config, "apiUrl", defaultConfigValues.apiUrl),
         priceImpactWarnings: get$2(config, "priceImpactWarnings", defaultConfigValues.priceImpactWarnings),
         initialAssets: get$2(config, "initialAssets", defaultConfigValues.initialAssets),
@@ -22946,8 +22937,8 @@ const sortAllTokens = (tokenA, tokenB) => {
     return 0;
 };
 const findToken = (tokens, chainId, address) => tokens.find((t) => t.chainId === chainId && t.address === address);
-const findNativeToken = (tokens, chain) => tokens.find((t) => t.symbol.toUpperCase() === chain.nativeCurrency.symbol.toUpperCase() &&
-    t.chainId == chain.chainId);
+const findNativeToken = (tokens, chain) => tokens.find((t) => t.symbol.toUpperCase() === chain?.nativeCurrency.symbol.toUpperCase() &&
+    t.chainId == chain?.chainId);
 const normalizeIbcAddress = (address) => {
     if (!address.toLowerCase().startsWith("ibc/")) {
         return address;
@@ -23158,7 +23149,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 import('./secretService-CIYxEkTN.js');
+    const { fetchAllSecretBalances } = await import('./secretService-BMYOBXhv.js');
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -24849,7 +24840,7 @@ class OnrampService {
         });
         return data;
     }
-    async getConfiguration({ chains: _, tokens, }) {
+    async getConfiguration({ chains, tokens, }) {
         const { data } = await axios.get(`${this.baseUrl}/config`);
         // Filter supportedCryptos to only include tokens that match our provided tokens
         const filteredCryptos = data.supportedCryptos.filter((supportedCrypto) => tokens.some((token) => token.address.toLowerCase() ===
@@ -26474,7 +26465,7 @@ function useStellarWallets() {
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
                 const { LedgerModule } = await import('@creit.tech/stellar-wallets-kit/modules/ledger.module');
-                const { formatStellarWallet } = await import('./stellarService.client-ocLzRIB4.js');
+                const { formatStellarWallet } = await import('./stellarService.client-DOrCdvCd.js');
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27781,310 +27772,580 @@ function useTrackSearchEmpty({ searchQuery, resultsLength, context, debounceMs =
     }, [context, debounceMs, resultsLength, searchQuery]);
 }
 
-class StellarRpcClient {
-    server;
-    constructor(rpcUrl) {
-        this.server = new rpc.Server(rpcUrl);
+var hrc20 = [
+	{
+		inputs: [
+		],
+		name: "associate",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "responseCode",
+				type: "uint256"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	}
+];
+
+/**
+ * Client for interacting with the Hedera Mirrornode API.
+ *
+ * @docs https://mainnet.mirrornode.hedera.com/api/v1/docs
+ */
+class HederaApiClient {
+    apiUrl;
+    constructor(apiUrl) {
+        this.apiUrl = apiUrl;
     }
-    /**
-     * Returns the balance of a Stellar Contract Token. This is different from an Issued Token.
-     *
-     * With Contract Tokens, we need to call the .balance method on the token contract
-     * and simulate the transaction to get the balance.
-     */
-    async getBalance(userAddress, tokenAddress, chainId) {
-        const account = await this.server.getAccount(userAddress);
-        const network = getStellarNetwork(chainId);
-        if (network == null) {
-            throw new Error(`No Stellar network found for chainId ${chainId}`);
-        }
-        const txBuilder = new TransactionBuilder(account, {
-            fee: (BigInt(BASE_FEE) * BigInt(2)).toString(),
-            networkPassphrase: network,
-        });
-        const contract = new Contract(tokenAddress);
-        const tx = txBuilder
-            .addOperation(contract.call("balance", new Address(userAddress).toScVal()))
-            .setTimeout(TimeoutInfinite)
-            .build();
-        const simulateTxResponse = await this.server.simulateTransaction(tx);
-        if ("error" in simulateTxResponse) {
-            const isNoBalanceError = simulateTxResponse.error.includes("trying to get non-existing value for contract instance");
-            // If the error message indicates that the user has no balance just return 0
-            // We don't want to spam with this error as it's pretty common
-            if (isNoBalanceError) {
-                return "0";
-            }
-            throw new Error(`Failed to fetch balance. RPC response: ${simulateTxResponse.error}`);
+    async isTokenAssociated({ address, token, }) {
+        const accountInfo = await this.getAccountInfo(address);
+        // Unlimited auto associations
+        if (accountInfo.max_automatic_token_associations === -1) {
+            return true;
         }
-        if ("result" in simulateTxResponse && simulateTxResponse.result != null) {
-            const native = scValToNative(simulateTxResponse.result.retval);
-            return native.toString();
+        // If there's no unlimited auto-associations, we need to check if the token is already associated.
+        const { tokens: accountTokens } = await this.getAccountTokens(address);
+        const tokenId = convertEvmAddressToHederaAccountId(token.address);
+        if (accountTokens.some((t) => t.token_id === tokenId)) {
+            // Token is already associated
+            return true;
         }
-        throw new Error("Failed to fetch balance");
-    }
-    async getAllBalances(userAddress, tokens) {
-        const balancePromises = tokens.map((token) => {
-            return this.getBalance(userAddress, token.address, token.chainId);
-        });
-        const results = await Promise.allSettled(balancePromises);
-        const balances = results.map((result) => {
-            if (result.status === "fulfilled") {
-                return result.value;
-            }
-            return "0";
-        });
-        return balances.map((balance, index) => {
-            return {
-                ...tokens[index],
-                balance,
-            };
-        });
+        // Finally, if not auto-associated, check if there is an available auto-association slot
+        const autoAssociatedTokens = accountTokens.filter((t) => t.automatic_association);
+        const remainingAutoAssociations = accountInfo.max_automatic_token_associations -
+            autoAssociatedTokens.length;
+        return remainingAutoAssociations > 0;
     }
-    /**
-     * Resolves when the transaction is confirmed, or fails after a timeout.
-     */
-    async waitForTransaction(txHash, { interval = 2_000, timeout = 40_000 } = {}) {
-        const startTime = Date.now();
-        while (true) {
-            const result = await this.server.getTransaction(txHash);
-            if (result.status === rpc.Api.GetTransactionStatus.NOT_FOUND) {
-                if (Date.now() - startTime > timeout) {
-                    throw new Error(`Transaction ${txHash} not found within timeout`);
-                }
-                // eslint-disable-next-line @typescript-eslint/no-loop-func
-                await new Promise((res) => setTimeout(res, interval));
-                continue;
-            }
-            if (result.status === rpc.Api.GetTransactionStatus.SUCCESS) {
-                return result.status;
-            }
-            throw new Error(`Transaction failed with status: ${result.status}`);
+    async getAccountInfo(address) {
+        const data = await this.fetch(`accounts/${address}`);
+        if (typeof data.max_automatic_token_associations !== "number") {
+            throw new Error("Invalid max_automatic_token_associations type, expected number");
         }
-    }
-    async isAccountActivated(address) {
-        try {
-            await this.getAccount(address);
-            return true;
+        if (typeof data.balance.balance !== "number") {
+            throw new Error("Invalid balance type, expected number");
         }
-        catch (error) {
-            if (error?.message && error.message.includes("Account not found")) {
-                return false;
-            }
-            throw error;
+        if (!Array.isArray(data.balance.tokens)) {
+            throw new Error("Invalid tokens type, expected array");
         }
+        return data;
     }
-    async getAccount(address) {
-        return this.server.getAccount(address);
-    }
-    async sendTransaction(transaction) {
-        const transactionResponse = await this.server.sendTransaction(transaction);
-        if (transactionResponse.status === "ERROR") {
-            throw new Error("Error sending transaction");
+    async getAccountTokens(address) {
+        const data = await this.fetch(`accounts/${address}/tokens`);
+        if (!Array.isArray(data.tokens)) {
+            throw new Error("Invalid tokens type, expected array");
         }
-        return transactionResponse;
+        const firstToken = data.tokens[0];
+        if (typeof firstToken?.automatic_association !== "boolean") {
+            throw new Error("Invalid automatic_association type, expected boolean");
+        }
+        if (typeof firstToken?.token_id !== "string") {
+            throw new Error("Invalid token_id type, expected string");
+        }
+        return data;
     }
-    async prepareTransaction(transaction) {
-        return this.server.prepareTransaction(transaction);
+    async fetch(path) {
+        const url = new URL(path, this.apiUrl);
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Hedera API error: ${response.status}`);
+        }
+        return response.json();
     }
 }
 
-class XrplRpcClient {
-    rpcUrl;
-    constructor(rpcUrl) {
-        this.rpcUrl = rpcUrl;
-    }
-    async getBalance(address, tokenAddress) {
-        if (tokenAddress.toLowerCase() === nativeXrplTokenAddress.toLowerCase()) {
-            return this.getNativeBalance(address);
-        }
-        return this.getIssuedCurrencyBalance(address, tokenAddress);
-    }
-    async getAllBalances(address) {
-        const [nativeBalance, trustLineBalances] = await Promise.all([
-            this.getNativeBalance(address),
-            this.getTrustLines(address),
-        ]);
-        return [
-            {
-                balance: nativeBalance,
-                address: nativeXrplTokenAddress,
-            },
-            ...trustLineBalances.lines.map((line) => ({
-                balance: line.balance,
-                address: `${line.currency}.${line.account}`,
-            })),
-        ];
-    }
-    async getTrustLines(address, issuer) {
-        return this.call("account_lines", [
-            {
-                account: address,
-                ledger_index: "validated",
-                peer: issuer,
-            },
-        ]);
-    }
-    async getTrustLine(address, issuer, currency) {
-        const response = await this.getTrustLines(address, issuer);
-        const trustLine = response.lines.find((line) => line.currency === currency);
-        return trustLine ?? null;
-    }
-    async accountActivatedInfo(address) {
-        const serverState = await this.getServerState();
-        const reserveBaseBn = BigInt(serverState.state.validated_ledger.reserve_base);
-        try {
-            const accountInfo = await this.getAccountInfo(address);
-            const balanceBn = BigInt(accountInfo.account_data.Balance);
-            return {
-                isActivated: balanceBn >= reserveBaseBn,
-                reserveBaseBn,
-            };
-        }
-        catch (error) {
-            if (error.message?.includes("actNotFound")) {
-                return { isActivated: false, reserveBaseBn };
+hederaWalletConnect.type = "hederaWalletConnect";
+/**
+ * Wagmi connector to interact with the Hedera EVM network via the WalletConnect protocol.
+ *
+ * The connector removes the need for a WalletConnect modal, and instead
+ * communicates with the provided `extension` by opening the extension popup
+ * for user interaction upon request.
+ */
+function hederaWalletConnect(parameters) {
+    const { extension, ...restParameters } = parameters;
+    let provider_;
+    let providerPromise;
+    let connect;
+    let displayUri;
+    let sessionDelete;
+    let disconnect;
+    return createConnector((config) => ({
+        id: `hedera-wc-${extension.id}`,
+        name: extension.name,
+        icon: extension.icon,
+        type: hederaWalletConnect.type,
+        async setup() {
+            const provider = await this.getProvider().catch(() => null);
+            if (!provider)
+                return;
+            if (!connect) {
+                connect = this.onConnect.bind(this);
+                provider.on("connect", connect);
             }
-            throw error;
-        }
-    }
-    /**
-     * Waits for a transaction to be validated and returns its final status.
-     * Resolves to 'success' or throws an error with the failed status.
-     */
-    async waitForTransaction(txHash, { interval = 2_000, timeout = 20_000 } = {}) {
-        const startTime = Date.now();
-        while (true) {
+            if (!sessionDelete) {
+                sessionDelete = this.onSessionDelete.bind(this);
+                provider.on("session_delete", sessionDelete);
+            }
+        },
+        async connect(params = {}) {
             try {
-                const response = await this.call("tx", [
-                    {
-                        transaction: txHash,
-                        binary: false,
-                    },
-                ]);
-                if (!response.validated) {
-                    if (Date.now() - startTime > timeout) {
-                        throw new Error(`Transaction ${txHash} not validated within timeout`);
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-loop-func
-                    await new Promise((res) => setTimeout(res, interval));
-                    continue;
+                const provider = await this.getProvider();
+                if (!provider)
+                    throw new ProviderNotFoundError();
+                if (!displayUri) {
+                    displayUri = this.onDisplayUri;
+                    provider.on("display_uri", displayUri);
                 }
-                const status = response.meta?.TransactionResult;
-                if (status === XrplTxStatus.SUCCESS) {
-                    return status;
+                if (!provider.session) {
+                    await provider.connect({
+                        ...("pairingTopic" in params
+                            ? { pairingTopic: params.pairingTopic }
+                            : {}),
+                    });
                 }
-                else {
-                    throw new Error(`Transaction failed with status: ${status}`);
+                const accounts = (await provider.enable()).map((x) => getAddress(x));
+                const currentChainId = await this.getChainId();
+                if (displayUri) {
+                    provider.removeListener("display_uri", displayUri);
+                    displayUri = undefined;
+                }
+                if (connect) {
+                    provider.removeListener("connect", connect);
+                    connect = undefined;
+                }
+                if (!disconnect) {
+                    disconnect = this.onDisconnect.bind(this);
+                    provider.on("disconnect", disconnect);
+                }
+                if (!sessionDelete) {
+                    sessionDelete = this.onSessionDelete.bind(this);
+                    provider.on("session_delete", sessionDelete);
                 }
+                return { accounts, chainId: currentChainId };
             }
             catch (error) {
-                // txnNotFound = still pending or non-existent
-                if (error?.message?.includes("txnNotFound")) {
-                    if (Date.now() - startTime > timeout) {
-                        throw new Error(`Transaction ${txHash} not found within timeout`);
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-loop-func
-                    await new Promise((res) => setTimeout(res, interval));
-                    continue;
+                if (/(user rejected|connection request reset)/i.test(error?.message)) {
+                    throw new UserRejectedRequestError(error);
                 }
                 throw error;
             }
-        }
-    }
-    async getServerState() {
-        return this.call("server_state", [{}]);
+        },
+        async disconnect() {
+            const provider = await this.getProvider();
+            try {
+                await provider?.disconnect();
+            }
+            catch (error) {
+                if (!/No matching key/i.test(error.message))
+                    throw error;
+            }
+            finally {
+                if (disconnect) {
+                    provider?.removeListener("disconnect", disconnect);
+                    disconnect = undefined;
+                }
+                if (!connect) {
+                    connect = this.onConnect.bind(this);
+                    provider?.on("connect", connect);
+                }
+                if (sessionDelete) {
+                    provider?.removeListener("session_delete", sessionDelete);
+                    sessionDelete = undefined;
+                }
+            }
+        },
+        async getAccounts() {
+            const provider = await this.getProvider();
+            return provider.accounts.map((x) => getAddress(x));
+        },
+        async getProvider() {
+            async function initProvider() {
+                const optionalChains = config.chains.map((x) => x.id);
+                if (!optionalChains.length)
+                    return;
+                const { EthereumProvider } = await import('./index.es-BfdAGErV.js');
+                const rawProvider = await EthereumProvider.init({
+                    ...restParameters,
+                    disableProviderPing: true,
+                    optionalChains,
+                    projectId: restParameters.projectId,
+                    rpcMap: Object.fromEntries(config.chains.map((chain) => {
+                        const [url] = extractRpcUrls({
+                            chain,
+                            transports: config.transports,
+                        });
+                        return [chain.id, url];
+                    })),
+                    showQrModal: false,
+                    // We need to specify a custom storage prefix to avoid conflicts with Wagmi's walletConnect instance
+                    // https://docs.reown.com/walletkit/web/usage#core-instance-sharing
+                    customStoragePrefix: "squid-hedera",
+                });
+                const proxiedProvider = new Proxy(rawProvider, {
+                    get(target, prop, receiver) {
+                        if (prop === "request") {
+                            return async (args) => {
+                                const signingMethods = [
+                                    "eth_sendTransaction",
+                                    "eth_signTransaction",
+                                ];
+                                if (signingMethods.includes(args.method)) {
+                                    try {
+                                        HederaExtensionHelper.extensionOpen(extension.id);
+                                    }
+                                    catch { }
+                                }
+                                // forward request to original provider
+                                return target.request(args);
+                            };
+                        }
+                        // forward all other properties/methods
+                        return Reflect.get(target, prop, receiver);
+                    },
+                });
+                return proxiedProvider;
+            }
+            if (!provider_) {
+                if (!providerPromise)
+                    providerPromise = initProvider();
+                provider_ = await providerPromise;
+                provider_?.events.setMaxListeners(Number.POSITIVE_INFINITY);
+            }
+            return provider_;
+        },
+        async getChainId() {
+            const provider = await this.getProvider();
+            return provider.chainId;
+        },
+        async isAuthorized() {
+            try {
+                const accounts = await this.getAccounts();
+                return accounts.length > 0;
+            }
+            catch {
+                return false;
+            }
+        },
+        onAccountsChanged(accounts) {
+            if (accounts.length === 0)
+                this.onDisconnect();
+            else
+                config.emitter.emit("change", {
+                    accounts: accounts.map((x) => getAddress(x)),
+                });
+        },
+        onChainChanged(chain) {
+            const chainId = Number(chain);
+            config.emitter.emit("change", { chainId });
+        },
+        async onConnect(connectInfo) {
+            const chainId = Number(connectInfo.chainId);
+            const accounts = await this.getAccounts();
+            config.emitter.emit("connect", { accounts, chainId });
+        },
+        async onDisconnect() {
+            config.emitter.emit("disconnect");
+            const provider = await this.getProvider();
+            if (disconnect) {
+                provider.removeListener("disconnect", disconnect);
+                disconnect = undefined;
+            }
+            if (sessionDelete) {
+                provider.removeListener("session_delete", sessionDelete);
+                sessionDelete = undefined;
+            }
+            if (!connect) {
+                connect = this.onConnect.bind(this);
+                provider.on("connect", connect);
+            }
+        },
+        onDisplayUri(uri) {
+            config.emitter.emit("message", { type: "display_uri", data: uri });
+            HederaExtensionHelper.extensionConnect(extension.id, uri);
+        },
+        onSessionDelete() {
+            this.onDisconnect();
+        },
+    }));
+}
+
+const createWagmiConfig = (squidChains, hederaExtensions) => {
+    const filteredEvmChains = squidChains.filter((chain) => chain.chainType === ChainType.EVM);
+    if (filteredEvmChains.length === 0) {
+        throw new Error("At least one chain is required");
     }
-    async getAccountInfo(address) {
-        return this.call("account_info", [
-            {
-                account: address,
-                ledger_index: "validated",
+    const wagmiChains = filteredEvmChains.map((chain) => {
+        return defineChain({
+            id: Number(chain.chainId),
+            name: chain.networkName,
+            nativeCurrency: {
+                name: chain.nativeCurrency.name,
+                symbol: chain.nativeCurrency.symbol,
+                decimals: chain.nativeCurrency.decimals,
             },
-        ]);
-    }
-    /**
-     * Returns the balance of the user in the native XRP token
-     * formatted as a string
-     */
-    async getNativeBalance(address) {
-        const [accountInfo, serverState] = await Promise.all([
-            this.getAccountInfo(address),
-            this.getServerState(),
-        ]);
-        const balance = BigInt(accountInfo.account_data.Balance);
-        const ownerCount = BigInt(accountInfo.account_data.OwnerCount);
-        const reserveBase = BigInt(serverState.state.validated_ledger.reserve_base);
-        const reserveIncrement = BigInt(serverState.state.validated_ledger.reserve_inc);
-        const reserveBalance = reserveBase + ownerCount * reserveIncrement;
-        const spendableBalance = balance - reserveBalance;
-        return formatBNToReadable(spendableBalance, 6);
-    }
-    /**
-     * Returns the balance of the user in the given issued currency (e.g. RLUSD)
-     * formatted as a string
-     */
-    async getIssuedCurrencyBalance(address, tokenAddress) {
-        const response = await this.getTrustLines(address);
-        const tokenBalance = response.lines.find((line) => `${line.currency}.${line.account}` === tokenAddress);
-        return tokenBalance?.balance || "0";
-    }
-    async call(method, params) {
-        const response = await fetch(this.rpcUrl, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
+            rpcUrls: {
+                public: {
+                    http: [chain.rpc],
+                },
+                default: {
+                    http: [chain.rpc],
+                },
             },
-            body: JSON.stringify({
-                jsonrpc: "2.0",
-                id: 1,
-                method,
-                params,
-            }),
         });
-        const data = await response.json();
-        if (!data.result) {
-            throw new Error(`Invalid response from RPC (${method})`);
-        }
-        if ("error" in data.result) {
-            throw new Error(`Error from RPC (${method}): ${data.result.error}`);
-        }
-        return data.result;
+    });
+    const wcMetadata = {
+        url: SQUID_METADATA.url,
+        name: SQUID_METADATA.name,
+        icons: [SQUID_METADATA.icon],
+        description: SQUID_METADATA.description,
+    };
+    return createConfig({
+        chains: wagmiChains,
+        transports: Object.fromEntries(wagmiChains.map((chain) => [
+            chain.id,
+            http(chain.rpcUrls.public.http[0] ?? ""),
+        ])),
+        connectors: [
+            injected(),
+            safe({
+                allowedDomains: [/app.safe.global$/],
+            }),
+            metaMask({
+                dappMetadata: {
+                    name: SQUID_METADATA.name,
+                    url: SQUID_METADATA.url,
+                    iconUrl: SQUID_METADATA.icon,
+                },
+            }),
+            coinbaseWallet({
+                appName: SQUID_METADATA.name,
+                appLogoUrl: SQUID_METADATA.icon,
+            }),
+            walletConnect({
+                projectId: WALLETCONNECT_PROJECT_ID,
+                metadata: wcMetadata,
+            }),
+            ...hederaExtensions.map((extension) => hederaWalletConnect({
+                projectId: WALLETCONNECT_PROJECT_ID,
+                metadata: wcMetadata,
+                extension,
+            })),
+        ],
+    });
+};
+// 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 BrowserProvider(transport, network);
+    const signer = new JsonRpcSigner(provider, account.address);
+    return signer;
 }
 
-const clientCache = new Map();
-async function getClient(chain) {
-    const key = `${chain.chainType}:${chain.chainId}`;
-    if (clientCache.has(key)) {
-        return clientCache.get(key);
-    }
-    const client = await createClient(chain);
-    clientCache.set(key, client);
-    return client;
+function useEvmSigner({ chainId }) {
+    const { connector } = useAccount();
+    const { data: client } = useWalletClient({ chainId, connector });
+    const signer = useMemo(() => (client ? clientToSigner(client) : undefined), [client]);
+    return { signer };
 }
-async function createClient(chain) {
-    switch (chain.chainType) {
-        case ChainType.EVM:
-            return new JsonRpcProvider(chain.rpc);
-        case ChainType.COSMOS:
-            const rpcUrl = await getWorkingCosmosRpcUrl(chain);
-            return (await StargateClient.connect(rpcUrl));
-        case ChainType.SOLANA:
-            return new Connection(SOLANA_RPC_URL);
-        case ChainType.BTC:
-            return null;
-        case ChainType.SUI:
-            return new SuiClient({
-                url: chain.rpc,
+const useSigner = ({ chain }) => {
+    const evmChainId = chain?.chainType === 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 = useMemo(() => {
+        if (!chain?.chainType)
+            return false;
+        switch (chain.chainType) {
+            case ChainType.EVM:
+                return isEvmSignerReady;
+            case ChainType.COSMOS:
+                return isCosmosSignerReady;
+            case ChainType.BTC:
+                return isBitcoinSignerReady;
+            case ChainType.SOLANA:
+                return isSolanaSignerReady;
+            case ChainType.SUI:
+                return isSuiSignerReady;
+            case ChainType.XRPL:
+                return isXrplSignerReady;
+            case 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 = usePublicClient({
+        chainId: Number(CHAIN_IDS.HEDERA),
+    });
+    const { evmSigner } = useSigner({ chain });
+    const queryClient = useQueryClient();
+    /**
+     * Creates a token association transaction where the destination account authorizes to receive the given token
+     */
+    const associateToken = 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 = encodeFunctionData({
+                    abi: hrc20,
+                    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),
             });
-        case ChainType.XRPL:
-            return new XrplRpcClient(chain.rpc);
-        case ChainType.STELLAR:
-            return new StellarRpcClient(chain.rpc);
-    }
+        },
+    });
+    /**
+     * 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 = 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 (!chain || !address || !publicClient) {
+                throw new Error("Missing required parameters");
+            }
+            // TODO: update types
+            const apiUrl = chain?.chainConfig?.hedera?.mirrorNodeUrl;
+            if (!apiUrl) {
+                throw new Error("Missing Hedera mirror node URL in chain config");
+            }
+            const hederaApiClient = new HederaApiClient(apiUrl);
+            return hederaApiClient.isTokenAssociated({
+                address,
+                token,
+            });
+        },
+        enabled: !!address && !!publicClient && token?.chainId === CHAIN_IDS.HEDERA,
+    });
+    return {
+        isTokenAssociated,
+        associateToken,
+    };
 }
 
+const useKeyboardNavigation = ({ onEscape }) => {
+    const onKeyDown = useCallback((event) => {
+        if (event.key === "Escape") {
+            onEscape?.();
+            return;
+        }
+    }, [onEscape]);
+    useEffect(() => {
+        document.addEventListener("keydown", onKeyDown, false);
+        return () => {
+            document.removeEventListener("keydown", onKeyDown, false);
+        };
+    }, [onKeyDown]);
+};
+
+const useSquidQueryClient = () => {
+    const queryClient = useQueryClient();
+    const invalidateQueries = (key) => {
+        const prefixKey = getPrefixKey(key);
+        queryClient.invalidateQueries(prefixKey);
+    };
+    const refetchQueries = (key) => {
+        const prefixKey = getPrefixKey(key);
+        queryClient.refetchQueries(prefixKey);
+    };
+    const invalidateAndRefetchQueries = (key) => {
+        invalidateQueries(key);
+        refetchQueries(key);
+    };
+    return {
+        invalidateQueries,
+        refetchQueries,
+        invalidateAndRefetchQueries,
+    };
+};
+
 /**
  * The default multicall3 address
  * available on most EVM chains
@@ -29099,6 +29360,372 @@ function timeout(ms, promise) {
     return Promise.race([promise, timeoutPromise]);
 }
 
+class StellarRpcClient {
+    server;
+    constructor(rpcUrl) {
+        this.server = new rpc.Server(rpcUrl);
+    }
+    /**
+     * Returns the balance of a Stellar Contract Token. This is different from an Issued Token.
+     *
+     * With Contract Tokens, we need to call the .balance method on the token contract
+     * and simulate the transaction to get the balance.
+     */
+    async getBalance(userAddress, tokenAddress, chainId) {
+        const account = await this.server.getAccount(userAddress);
+        const network = getStellarNetwork(chainId);
+        if (network == null) {
+            throw new Error(`No Stellar network found for chainId ${chainId}`);
+        }
+        const txBuilder = new TransactionBuilder(account, {
+            fee: (BigInt(BASE_FEE) * BigInt(2)).toString(),
+            networkPassphrase: network,
+        });
+        const contract = new Contract(tokenAddress);
+        const tx = txBuilder
+            .addOperation(contract.call("balance", new Address(userAddress).toScVal()))
+            .setTimeout(TimeoutInfinite)
+            .build();
+        const simulateTxResponse = await this.server.simulateTransaction(tx);
+        if ("error" in simulateTxResponse) {
+            const isNoBalanceError = simulateTxResponse.error.includes("trying to get non-existing value for contract instance");
+            // If the error message indicates that the user has no balance just return 0
+            // We don't want to spam with this error as it's pretty common
+            if (isNoBalanceError) {
+                return "0";
+            }
+            throw new Error(`Failed to fetch balance. RPC response: ${simulateTxResponse.error}`);
+        }
+        if ("result" in simulateTxResponse && simulateTxResponse.result != null) {
+            const native = scValToNative(simulateTxResponse.result.retval);
+            return native.toString();
+        }
+        throw new Error("Failed to fetch balance");
+    }
+    async getAllBalances(userAddress, tokens) {
+        const balancePromises = tokens.map((token) => {
+            return this.getBalance(userAddress, token.address, token.chainId);
+        });
+        const results = await Promise.allSettled(balancePromises);
+        const balances = results.map((result) => {
+            if (result.status === "fulfilled") {
+                return result.value;
+            }
+            return "0";
+        });
+        return balances.map((balance, index) => {
+            return {
+                ...tokens[index],
+                balance,
+            };
+        });
+    }
+    /**
+     * Resolves when the transaction is confirmed, or fails after a timeout.
+     */
+    async waitForTransaction(txHash, { interval = 2_000, timeout = 40_000 } = {}) {
+        const startTime = Date.now();
+        while (true) {
+            const result = await this.server.getTransaction(txHash);
+            if (result.status === rpc.Api.GetTransactionStatus.NOT_FOUND) {
+                if (Date.now() - startTime > timeout) {
+                    throw new Error(`Transaction ${txHash} not found within timeout`);
+                }
+                // eslint-disable-next-line @typescript-eslint/no-loop-func
+                await new Promise((res) => setTimeout(res, interval));
+                continue;
+            }
+            if (result.status === rpc.Api.GetTransactionStatus.SUCCESS) {
+                return result.status;
+            }
+            throw new Error(`Transaction failed with status: ${result.status}`);
+        }
+    }
+    async isAccountActivated(address) {
+        try {
+            await this.getAccount(address);
+            return true;
+        }
+        catch (error) {
+            if (error?.message && error.message.includes("Account not found")) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    async getAccount(address) {
+        return this.server.getAccount(address);
+    }
+    async sendTransaction(transaction) {
+        const transactionResponse = await this.server.sendTransaction(transaction);
+        if (transactionResponse.status === "ERROR") {
+            throw new Error("Error sending transaction");
+        }
+        return transactionResponse;
+    }
+    async prepareTransaction(transaction) {
+        return this.server.prepareTransaction(transaction);
+    }
+}
+
+class XrplRpcClient {
+    rpcUrl;
+    constructor(rpcUrl) {
+        this.rpcUrl = rpcUrl;
+    }
+    async getBalance(address, tokenAddress) {
+        if (tokenAddress.toLowerCase() === nativeXrplTokenAddress.toLowerCase()) {
+            return this.getNativeBalance(address);
+        }
+        return this.getIssuedCurrencyBalance(address, tokenAddress);
+    }
+    async getAllBalances(address) {
+        const [nativeBalance, trustLineBalances] = await Promise.all([
+            this.getNativeBalance(address),
+            this.getTrustLines(address),
+        ]);
+        return [
+            {
+                balance: nativeBalance,
+                address: nativeXrplTokenAddress,
+            },
+            ...trustLineBalances.lines.map((line) => ({
+                balance: line.balance,
+                address: `${line.currency}.${line.account}`,
+            })),
+        ];
+    }
+    async getTrustLines(address, issuer) {
+        return this.call("account_lines", [
+            {
+                account: address,
+                ledger_index: "validated",
+                peer: issuer,
+            },
+        ]);
+    }
+    async getTrustLine(address, issuer, currency) {
+        const response = await this.getTrustLines(address, issuer);
+        const trustLine = response.lines.find((line) => line.currency === currency);
+        return trustLine ?? null;
+    }
+    async accountActivatedInfo(address) {
+        const serverState = await this.getServerState();
+        const reserveBaseBn = BigInt(serverState.state.validated_ledger.reserve_base);
+        try {
+            const accountInfo = await this.getAccountInfo(address);
+            const balanceBn = BigInt(accountInfo.account_data.Balance);
+            return {
+                isActivated: balanceBn >= reserveBaseBn,
+                reserveBaseBn,
+            };
+        }
+        catch (error) {
+            if (error.message?.includes("actNotFound")) {
+                return { isActivated: false, reserveBaseBn };
+            }
+            throw error;
+        }
+    }
+    /**
+     * Waits for a transaction to be validated and returns its final status.
+     * Resolves to 'success' or throws an error with the failed status.
+     */
+    async waitForTransaction(txHash, { interval = 2_000, timeout = 20_000 } = {}) {
+        const startTime = Date.now();
+        while (true) {
+            try {
+                const response = await this.call("tx", [
+                    {
+                        transaction: txHash,
+                        binary: false,
+                    },
+                ]);
+                if (!response.validated) {
+                    if (Date.now() - startTime > timeout) {
+                        throw new Error(`Transaction ${txHash} not validated within timeout`);
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-loop-func
+                    await new Promise((res) => setTimeout(res, interval));
+                    continue;
+                }
+                const status = response.meta?.TransactionResult;
+                if (status === XrplTxStatus.SUCCESS) {
+                    return status;
+                }
+                else {
+                    throw new Error(`Transaction failed with status: ${status}`);
+                }
+            }
+            catch (error) {
+                // txnNotFound = still pending or non-existent
+                if (error?.message?.includes("txnNotFound")) {
+                    if (Date.now() - startTime > timeout) {
+                        throw new Error(`Transaction ${txHash} not found within timeout`);
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-loop-func
+                    await new Promise((res) => setTimeout(res, interval));
+                    continue;
+                }
+                throw error;
+            }
+        }
+    }
+    async getServerState() {
+        return this.call("server_state", [{}]);
+    }
+    async getAccountInfo(address) {
+        return this.call("account_info", [
+            {
+                account: address,
+                ledger_index: "validated",
+            },
+        ]);
+    }
+    /**
+     * Returns the balance of the user in the native XRP token
+     * formatted as a string
+     */
+    async getNativeBalance(address) {
+        const [accountInfo, serverState] = await Promise.all([
+            this.getAccountInfo(address),
+            this.getServerState(),
+        ]);
+        const balance = BigInt(accountInfo.account_data.Balance);
+        const ownerCount = BigInt(accountInfo.account_data.OwnerCount);
+        const reserveBase = BigInt(serverState.state.validated_ledger.reserve_base);
+        const reserveIncrement = BigInt(serverState.state.validated_ledger.reserve_inc);
+        const reserveBalance = reserveBase + ownerCount * reserveIncrement;
+        const spendableBalance = balance - reserveBalance;
+        return formatBNToReadable(spendableBalance, 6);
+    }
+    /**
+     * Returns the balance of the user in the given issued currency (e.g. RLUSD)
+     * formatted as a string
+     */
+    async getIssuedCurrencyBalance(address, tokenAddress) {
+        const response = await this.getTrustLines(address);
+        const tokenBalance = response.lines.find((line) => `${line.currency}.${line.account}` === tokenAddress);
+        return tokenBalance?.balance || "0";
+    }
+    async call(method, params) {
+        const response = await fetch(this.rpcUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method,
+                params,
+            }),
+        });
+        const data = await response.json();
+        if (!data.result) {
+            throw new Error(`Invalid response from RPC (${method})`);
+        }
+        if ("error" in data.result) {
+            throw new Error(`Error from RPC (${method}): ${data.result.error}`);
+        }
+        return data.result;
+    }
+}
+
+const clientCache = new Map();
+async function getClient(chain) {
+    const key = `${chain.chainType}:${chain.chainId}`;
+    if (clientCache.has(key)) {
+        return clientCache.get(key);
+    }
+    const client = await createClient(chain);
+    clientCache.set(key, client);
+    return client;
+}
+async function createClient(chain) {
+    switch (chain.chainType) {
+        case ChainType.EVM:
+            return new JsonRpcProvider(chain.rpc);
+        case ChainType.COSMOS:
+            const rpcUrl = await getWorkingCosmosRpcUrl(chain);
+            return (await StargateClient.connect(rpcUrl));
+        case ChainType.SOLANA:
+            return new Connection(SOLANA_RPC_URL);
+        case ChainType.BTC:
+            return null;
+        case ChainType.SUI:
+            return new SuiClient({
+                url: chain.rpc,
+            });
+        case ChainType.XRPL:
+            return new XrplRpcClient(chain.rpc);
+        case ChainType.STELLAR:
+            return new StellarRpcClient(chain.rpc);
+    }
+}
+
+class StellarApiClient {
+    apiUrl;
+    constructor(apiUrl) {
+        this.apiUrl = apiUrl;
+    }
+    async getBaseReserve() {
+        const response = await fetch(`${this.apiUrl}/ledgers?order=desc&limit=1`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ledgers: ${response.status}`);
+        }
+        const ledgers = await response.json();
+        const latestLedger = ledgers?._embedded.records?.[0];
+        if (latestLedger?.base_reserve_in_stroops == null) {
+            throw new Error("Invalid ledger data");
+        }
+        const baseReserveBn = BigInt(latestLedger.base_reserve_in_stroops);
+        return baseReserveBn;
+    }
+}
+
+const DEFAULT_REFETCH_INTERVAL$1 = 20_000;
+function useStellarAccountActivation({ address, chain, token, }) {
+    /**
+     * Checks if the destination account exists on the Stellar network
+     * Stellar accounts need to have a minimum balance before they can receive payments
+     */
+    const accountActivatedInfo = useQuery({
+        queryKey: keys().stellarAccountActivatedInfo(address, chain?.chainId, chain?.chainType),
+        queryFn: async () => {
+            if (chain?.chainType !== ChainType.STELLAR ||
+                token?.type !== ChainType.STELLAR) {
+                return null;
+            }
+            if (!address) {
+                throw new Error("Destination address is required");
+            }
+            // TODO: update types
+            const [horizonApiUrl] = chain?.horizonRpcList;
+            if (typeof horizonApiUrl !== "string") {
+                throw new Error("Invalid Horizon API URL");
+            }
+            const stellarApiClient = new StellarApiClient(horizonApiUrl);
+            const reserveBase = await stellarApiClient.getBaseReserve();
+            // Stellar accounts require two base reserves to be activated
+            // https://developers.stellar.org/docs/learn/fundamentals/lumens#minimum-balance
+            const accountReserveBase = reserveBase * BigInt(2);
+            const stellarRpcClient = await getClient(chain);
+            const isActivated = await stellarRpcClient.isAccountActivated(address);
+            return {
+                isActivated,
+                reserveBaseBn: accountReserveBase,
+            };
+        },
+        enabled: !!address && chain?.chainType === ChainType.STELLAR,
+        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
+        refetchOnWindowFocus: true,
+    });
+    return {
+        accountActivatedInfo,
+    };
+}
+
 const DEFAULT_REFRESH_INTERVAL_MS = 15000;
 const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
     const { isChainTypeConnected } = useWallet();
@@ -29293,8 +29920,6 @@ function useNativeTokenForChain(chain) {
         }
     };
     const nativeTokenForChainType = useMemo(() => {
-        if (!chain)
-            return undefined;
         return findNativeToken(getTokensForChainType(), chain);
     }, [chain]);
     return { nativeToken: nativeTokenForChainType };
@@ -29410,814 +30035,178 @@ const useSuiNativeBalance = ({ address, chain, }) => {
         token: nativeToken,
         userAddress: address,
     });
-    const balance = useMemo(() => {
-        if (nativeToken?.decimals && rawBalance) {
-            return {
-                decimals: nativeToken.decimals,
-                value: parseToBigInt(rawBalance, nativeToken.decimals),
-            };
-        }
-    }, [nativeToken?.decimals, rawBalance]);
-    return {
-        balance,
-        isLoading,
-    };
-};
-const useXrplNativeBalance = ({ address, chain, }) => {
-    const { nativeToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isLoading } = useXrplBalance({
-        chain,
-        token: nativeToken,
-        userAddress: address,
-        enabled: chain?.chainType === ChainType.XRPL,
-    });
-    const balance = useMemo(() => {
-        if (nativeToken?.decimals && rawBalance) {
-            return {
-                decimals: nativeToken.decimals,
-                value: parseToBigInt(rawBalance, nativeToken.decimals),
-            };
-        }
-    }, [nativeToken?.decimals, rawBalance]);
-    return {
-        balance,
-        isLoading,
-    };
-};
-const useStellarNativeBalance = ({ address, chain, }) => {
-    const { nativeToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isLoading } = useStellarBalance({
-        chain,
-        token: nativeToken,
-        userAddress: address,
-        enabled: chain?.chainType === ChainType.STELLAR,
-    });
-    const balance = useMemo(() => {
-        if (nativeToken?.decimals && rawBalance) {
-            return {
-                decimals: nativeToken.decimals,
-                value: parseToBigInt(rawBalance, nativeToken.decimals),
-            };
-        }
-    }, [nativeToken?.decimals, rawBalance]);
-    return {
-        balance,
-        isLoading,
-    };
-};
-const useNativeBalance = (chain) => {
-    const { connectedAddresses } = useWallet();
-    const { data: cosmosAddressForChain } = useCosmosForChain(chain);
-    // Cosmos is a special case because the address changes on every chain
-    // so we can't use the default cosmos connected address
-    const { balance: nativeCosmosBalance, isLoading: isCosmosLoading } = useCosmosNativeBalance({
-        address: cosmosAddressForChain,
-        chain,
-    });
-    const { balance: nativeEvmBalance, isLoading: isEvmLoading } = useEvmNativeBalance({ address: connectedAddresses[ChainType.EVM], chain });
-    const { balance: nativeBitcoinBalance, isLoading: isBitcoinLoading } = useBitcoinNativeBalance({
-        address: connectedAddresses[ChainType.BTC],
-        chain,
-    });
-    const { balance: nativeSolanaBalance, isLoading: isSolanaLoading } = useSolanaNativeBalance({
-        address: connectedAddresses[ChainType.SOLANA],
-        chain,
-    });
-    const { balance: nativeSuiBalance, isLoading: isSuiLoading } = useSuiNativeBalance({
-        address: connectedAddresses[ChainType.SUI],
-        chain,
-    });
-    const { balance: nativeXrplBalance, isLoading: isXrpLoading } = useXrplNativeBalance({
-        address: connectedAddresses[ChainType.XRPL],
-        chain,
-    });
-    const { balance: nativeStellarBalance, isLoading: isStellarLoading } = useStellarNativeBalance({
-        address: connectedAddresses[ChainType.STELLAR],
-        chain,
-    });
-    const { nativeBalance, nativeBalanceFormatted } = useMemo(() => {
-        let balance;
-        switch (chain?.chainType) {
-            case ChainType.EVM:
-                balance = nativeEvmBalance;
-                break;
-            case ChainType.COSMOS:
-                balance = nativeCosmosBalance;
-                break;
-            case ChainType.BTC:
-                balance = nativeBitcoinBalance;
-                break;
-            case ChainType.SOLANA:
-                balance = nativeSolanaBalance;
-                break;
-            case ChainType.SUI:
-                balance = nativeSuiBalance;
-                break;
-            case ChainType.XRPL:
-                balance = nativeXrplBalance;
-                break;
-            case ChainType.STELLAR:
-                balance = nativeStellarBalance;
-        }
-        const balanceFormatted = !!balance
-            ? formatBNToReadable(balance.value, balance.decimals)
-            : undefined;
-        return {
-            nativeBalance: balance,
-            nativeBalanceFormatted: balanceFormatted,
-        };
-    }, [
-        chain?.chainType,
-        nativeEvmBalance,
-        nativeCosmosBalance,
-        nativeBitcoinBalance,
-        nativeSolanaBalance,
-        nativeSuiBalance,
-        nativeXrplBalance,
-        nativeStellarBalance,
-    ]);
-    const isLoading = useMemo(() => {
-        if (!chain?.chainType)
-            return false;
-        switch (chain.chainType) {
-            case ChainType.EVM:
-                return isEvmLoading;
-            case ChainType.COSMOS:
-                return isCosmosLoading;
-            case ChainType.BTC:
-                return isBitcoinLoading;
-            case ChainType.SOLANA:
-                return isSolanaLoading;
-            case ChainType.SUI:
-                return isSuiLoading;
-            case ChainType.XRPL:
-                return isXrpLoading;
-            case ChainType.STELLAR:
-                return isStellarLoading;
-        }
-    }, [
-        chain?.chainType,
-        isEvmLoading,
-        isCosmosLoading,
-        isBitcoinLoading,
-        isSolanaLoading,
-        isSuiLoading,
-        isXrpLoading,
-        isStellarLoading,
-    ]);
-    return { nativeBalance, nativeBalanceFormatted, isLoading };
-};
-
-function useHederaAccountActivation({ address, chain, token }) {
-    const { balance: destNativeEvmBalance } = useEvmNativeBalance({
-        chain,
-        address,
-    });
-    const isHederaAccountActivated = useMemo(() => {
-        if (token?.chainId !== CHAIN_IDS.HEDERA)
-            return true;
-        if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase())
-            return true;
-        return (!!destNativeEvmBalance?.value && destNativeEvmBalance.value > BigInt(0));
-    }, [token?.chainId, token?.address, destNativeEvmBalance?.value]);
-    return {
-        isHederaAccountActivated,
-    };
-}
-
-var hrc20 = [
-	{
-		inputs: [
-		],
-		name: "associate",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "responseCode",
-				type: "uint256"
-			}
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	}
-];
-
-/**
- * Client for interacting with the Hedera Mirrornode API.
- *
- * @docs https://mainnet.mirrornode.hedera.com/api/v1/docs
- */
-class HederaApiClient {
-    apiUrl;
-    constructor(apiUrl) {
-        this.apiUrl = apiUrl;
-    }
-    async isTokenAssociated({ address, token, }) {
-        const accountInfo = await this.getAccountInfo(address);
-        // Unlimited auto associations
-        if (accountInfo.max_automatic_token_associations === -1) {
-            return true;
-        }
-        // If there's no unlimited auto-associations, we need to check if the token is already associated.
-        const { tokens: accountTokens } = await this.getAccountTokens(address);
-        const tokenId = convertEvmAddressToHederaAccountId(token.address);
-        if (accountTokens.some((t) => t.token_id === tokenId)) {
-            // Token is already associated
-            return true;
-        }
-        // Finally, if not auto-associated, check if there is an available auto-association slot
-        const autoAssociatedTokens = accountTokens.filter((t) => t.automatic_association);
-        const remainingAutoAssociations = accountInfo.max_automatic_token_associations -
-            autoAssociatedTokens.length;
-        return remainingAutoAssociations > 0;
-    }
-    async getAccountInfo(address) {
-        const data = await this.fetch(`accounts/${address}`);
-        if (typeof data.max_automatic_token_associations !== "number") {
-            throw new Error("Invalid max_automatic_token_associations type, expected number");
-        }
-        if (typeof data.balance.balance !== "number") {
-            throw new Error("Invalid balance type, expected number");
-        }
-        if (!Array.isArray(data.balance.tokens)) {
-            throw new Error("Invalid tokens type, expected array");
-        }
-        return data;
-    }
-    async getAccountTokens(address) {
-        const data = await this.fetch(`accounts/${address}/tokens`);
-        if (!Array.isArray(data.tokens)) {
-            throw new Error("Invalid tokens type, expected array");
-        }
-        const firstToken = data.tokens[0];
-        if (typeof firstToken?.automatic_association !== "boolean") {
-            throw new Error("Invalid automatic_association type, expected boolean");
-        }
-        if (typeof firstToken?.token_id !== "string") {
-            throw new Error("Invalid token_id type, expected string");
-        }
-        return data;
-    }
-    async fetch(path) {
-        const url = new URL(path, this.apiUrl);
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Hedera API error: ${response.status}`);
-        }
-        return response.json();
-    }
-}
-
-hederaWalletConnect.type = "hederaWalletConnect";
-/**
- * Wagmi connector to interact with the Hedera EVM network via the WalletConnect protocol.
- *
- * The connector removes the need for a WalletConnect modal, and instead
- * communicates with the provided `extension` by opening the extension popup
- * for user interaction upon request.
- */
-function hederaWalletConnect(parameters) {
-    const { extension, ...restParameters } = parameters;
-    let provider_;
-    let providerPromise;
-    let connect;
-    let displayUri;
-    let sessionDelete;
-    let disconnect;
-    return createConnector((config) => ({
-        id: `hedera-wc-${extension.id}`,
-        name: extension.name,
-        icon: extension.icon,
-        type: hederaWalletConnect.type,
-        async setup() {
-            const provider = await this.getProvider().catch(() => null);
-            if (!provider)
-                return;
-            if (!connect) {
-                connect = this.onConnect.bind(this);
-                provider.on("connect", connect);
-            }
-            if (!sessionDelete) {
-                sessionDelete = this.onSessionDelete.bind(this);
-                provider.on("session_delete", sessionDelete);
-            }
-        },
-        async connect(params = {}) {
-            try {
-                const provider = await this.getProvider();
-                if (!provider)
-                    throw new ProviderNotFoundError();
-                if (!displayUri) {
-                    displayUri = this.onDisplayUri;
-                    provider.on("display_uri", displayUri);
-                }
-                if (!provider.session) {
-                    await provider.connect({
-                        ...("pairingTopic" in params
-                            ? { pairingTopic: params.pairingTopic }
-                            : {}),
-                    });
-                }
-                const accounts = (await provider.enable()).map((x) => getAddress(x));
-                const currentChainId = await this.getChainId();
-                if (displayUri) {
-                    provider.removeListener("display_uri", displayUri);
-                    displayUri = undefined;
-                }
-                if (connect) {
-                    provider.removeListener("connect", connect);
-                    connect = undefined;
-                }
-                if (!disconnect) {
-                    disconnect = this.onDisconnect.bind(this);
-                    provider.on("disconnect", disconnect);
-                }
-                if (!sessionDelete) {
-                    sessionDelete = this.onSessionDelete.bind(this);
-                    provider.on("session_delete", sessionDelete);
-                }
-                return { accounts, chainId: currentChainId };
-            }
-            catch (error) {
-                if (/(user rejected|connection request reset)/i.test(error?.message)) {
-                    throw new UserRejectedRequestError(error);
-                }
-                throw error;
-            }
-        },
-        async disconnect() {
-            const provider = await this.getProvider();
-            try {
-                await provider?.disconnect();
-            }
-            catch (error) {
-                if (!/No matching key/i.test(error.message))
-                    throw error;
-            }
-            finally {
-                if (disconnect) {
-                    provider?.removeListener("disconnect", disconnect);
-                    disconnect = undefined;
-                }
-                if (!connect) {
-                    connect = this.onConnect.bind(this);
-                    provider?.on("connect", connect);
-                }
-                if (sessionDelete) {
-                    provider?.removeListener("session_delete", sessionDelete);
-                    sessionDelete = undefined;
-                }
-            }
-        },
-        async getAccounts() {
-            const provider = await this.getProvider();
-            return provider.accounts.map((x) => getAddress(x));
-        },
-        async getProvider() {
-            async function initProvider() {
-                const optionalChains = config.chains.map((x) => x.id);
-                if (!optionalChains.length)
-                    return;
-                const { EthereumProvider } = await import('./index.es-BXf9jwuI.js');
-                const rawProvider = await EthereumProvider.init({
-                    ...restParameters,
-                    disableProviderPing: true,
-                    optionalChains,
-                    projectId: restParameters.projectId,
-                    rpcMap: Object.fromEntries(config.chains.map((chain) => {
-                        const [url] = extractRpcUrls({
-                            chain,
-                            transports: config.transports,
-                        });
-                        return [chain.id, url];
-                    })),
-                    showQrModal: false,
-                    // We need to specify a custom storage prefix to avoid conflicts with Wagmi's walletConnect instance
-                    // https://docs.reown.com/walletkit/web/usage#core-instance-sharing
-                    customStoragePrefix: "squid-hedera",
-                });
-                const proxiedProvider = new Proxy(rawProvider, {
-                    get(target, prop, receiver) {
-                        if (prop === "request") {
-                            return async (args) => {
-                                const signingMethods = [
-                                    "eth_sendTransaction",
-                                    "eth_signTransaction",
-                                ];
-                                if (signingMethods.includes(args.method)) {
-                                    try {
-                                        HederaExtensionHelper.extensionOpen(extension.id);
-                                    }
-                                    catch { }
-                                }
-                                // forward request to original provider
-                                return target.request(args);
-                            };
-                        }
-                        // forward all other properties/methods
-                        return Reflect.get(target, prop, receiver);
-                    },
-                });
-                return proxiedProvider;
-            }
-            if (!provider_) {
-                if (!providerPromise)
-                    providerPromise = initProvider();
-                provider_ = await providerPromise;
-                provider_?.events.setMaxListeners(Number.POSITIVE_INFINITY);
-            }
-            return provider_;
-        },
-        async getChainId() {
-            const provider = await this.getProvider();
-            return provider.chainId;
-        },
-        async isAuthorized() {
-            try {
-                const accounts = await this.getAccounts();
-                return accounts.length > 0;
-            }
-            catch {
-                return false;
-            }
-        },
-        onAccountsChanged(accounts) {
-            if (accounts.length === 0)
-                this.onDisconnect();
-            else
-                config.emitter.emit("change", {
-                    accounts: accounts.map((x) => getAddress(x)),
-                });
-        },
-        onChainChanged(chain) {
-            const chainId = Number(chain);
-            config.emitter.emit("change", { chainId });
-        },
-        async onConnect(connectInfo) {
-            const chainId = Number(connectInfo.chainId);
-            const accounts = await this.getAccounts();
-            config.emitter.emit("connect", { accounts, chainId });
-        },
-        async onDisconnect() {
-            config.emitter.emit("disconnect");
-            const provider = await this.getProvider();
-            if (disconnect) {
-                provider.removeListener("disconnect", disconnect);
-                disconnect = undefined;
-            }
-            if (sessionDelete) {
-                provider.removeListener("session_delete", sessionDelete);
-                sessionDelete = undefined;
-            }
-            if (!connect) {
-                connect = this.onConnect.bind(this);
-                provider.on("connect", connect);
-            }
-        },
-        onDisplayUri(uri) {
-            config.emitter.emit("message", { type: "display_uri", data: uri });
-            HederaExtensionHelper.extensionConnect(extension.id, uri);
-        },
-        onSessionDelete() {
-            this.onDisconnect();
-        },
-    }));
-}
-
-const createWagmiConfig = (squidChains, hederaExtensions) => {
-    const filteredEvmChains = squidChains.filter((chain) => chain.chainType === ChainType.EVM);
-    if (filteredEvmChains.length === 0) {
-        throw new Error("At least one chain is required");
-    }
-    const wagmiChains = filteredEvmChains.map((chain) => {
-        return 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],
-                },
-            },
-        });
-    });
-    const wcMetadata = {
-        url: SQUID_METADATA.url,
-        name: SQUID_METADATA.name,
-        icons: [SQUID_METADATA.icon],
-        description: SQUID_METADATA.description,
-    };
-    return createConfig({
-        chains: wagmiChains,
-        transports: Object.fromEntries(wagmiChains.map((chain) => [
-            chain.id,
-            http(chain.rpcUrls.public.http[0] ?? ""),
-        ])),
-        connectors: [
-            injected(),
-            safe({
-                allowedDomains: [/app.safe.global$/],
-            }),
-            metaMask({
-                dappMetadata: {
-                    name: SQUID_METADATA.name,
-                    url: SQUID_METADATA.url,
-                    iconUrl: SQUID_METADATA.icon,
-                },
-            }),
-            coinbaseWallet({
-                appName: SQUID_METADATA.name,
-                appLogoUrl: SQUID_METADATA.icon,
-            }),
-            walletConnect({
-                projectId: WALLETCONNECT_PROJECT_ID,
-                metadata: wcMetadata,
-            }),
-            ...hederaExtensions.map((extension) => hederaWalletConnect({
-                projectId: WALLETCONNECT_PROJECT_ID,
-                metadata: wcMetadata,
-                extension,
-            })),
-        ],
+    const balance = useMemo(() => {
+        if (nativeToken?.decimals && rawBalance) {
+            return {
+                decimals: nativeToken.decimals,
+                value: parseToBigInt(rawBalance, nativeToken.decimals),
+            };
+        }
+    }, [nativeToken?.decimals, rawBalance]);
+    return {
+        balance,
+        isLoading,
+    };
+};
+const useXrplNativeBalance = ({ address, chain, }) => {
+    const { nativeToken } = useNativeTokenForChain(chain);
+    const { balance: rawBalance, isLoading } = useXrplBalance({
+        chain,
+        token: nativeToken,
+        userAddress: address,
+        enabled: chain?.chainType === ChainType.XRPL,
     });
+    const balance = useMemo(() => {
+        if (nativeToken?.decimals && rawBalance) {
+            return {
+                decimals: nativeToken.decimals,
+                value: parseToBigInt(rawBalance, nativeToken.decimals),
+            };
+        }
+    }, [nativeToken?.decimals, rawBalance]);
+    return {
+        balance,
+        isLoading,
+    };
 };
-// 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 useStellarNativeBalance = ({ address, chain, }) => {
+    const { nativeToken } = useNativeTokenForChain(chain);
+    const { balance: rawBalance, isLoading } = useStellarBalance({
+        chain,
+        token: nativeToken,
+        userAddress: address,
+        enabled: chain?.chainType === ChainType.STELLAR,
+    });
+    const balance = useMemo(() => {
+        if (nativeToken?.decimals && rawBalance) {
+            return {
+                decimals: nativeToken.decimals,
+                value: parseToBigInt(rawBalance, nativeToken.decimals),
+            };
+        }
+    }, [nativeToken?.decimals, rawBalance]);
+    return {
+        balance,
+        isLoading,
     };
-    const provider = new BrowserProvider(transport, network);
-    const signer = new JsonRpcSigner(provider, account.address);
-    return signer;
-}
-
-function useEvmSigner({ chainId }) {
-    const { connector } = useAccount();
-    const { data: client } = useWalletClient({ chainId, connector });
-    const signer = useMemo(() => (client ? clientToSigner(client) : undefined), [client]);
-    return { signer };
-}
-const useSigner = ({ chain }) => {
-    const evmChainId = chain?.chainType === 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 = useMemo(() => {
+};
+const useNativeBalance = (chain) => {
+    const { connectedAddresses } = useWallet();
+    const { data: cosmosAddressForChain } = useCosmosForChain(chain);
+    // Cosmos is a special case because the address changes on every chain
+    // so we can't use the default cosmos connected address
+    const { balance: nativeCosmosBalance, isLoading: isCosmosLoading } = useCosmosNativeBalance({
+        address: cosmosAddressForChain,
+        chain,
+    });
+    const { balance: nativeEvmBalance, isLoading: isEvmLoading } = useEvmNativeBalance({ address: connectedAddresses[ChainType.EVM], chain });
+    const { balance: nativeBitcoinBalance, isLoading: isBitcoinLoading } = useBitcoinNativeBalance({
+        address: connectedAddresses[ChainType.BTC],
+        chain,
+    });
+    const { balance: nativeSolanaBalance, isLoading: isSolanaLoading } = useSolanaNativeBalance({
+        address: connectedAddresses[ChainType.SOLANA],
+        chain,
+    });
+    const { balance: nativeSuiBalance, isLoading: isSuiLoading } = useSuiNativeBalance({
+        address: connectedAddresses[ChainType.SUI],
+        chain,
+    });
+    const { balance: nativeXrplBalance, isLoading: isXrpLoading } = useXrplNativeBalance({
+        address: connectedAddresses[ChainType.XRPL],
+        chain,
+    });
+    const { balance: nativeStellarBalance, isLoading: isStellarLoading } = useStellarNativeBalance({
+        address: connectedAddresses[ChainType.STELLAR],
+        chain,
+    });
+    const { nativeBalance, nativeBalanceFormatted } = useMemo(() => {
+        let balance;
+        switch (chain?.chainType) {
+            case ChainType.EVM:
+                balance = nativeEvmBalance;
+                break;
+            case ChainType.COSMOS:
+                balance = nativeCosmosBalance;
+                break;
+            case ChainType.BTC:
+                balance = nativeBitcoinBalance;
+                break;
+            case ChainType.SOLANA:
+                balance = nativeSolanaBalance;
+                break;
+            case ChainType.SUI:
+                balance = nativeSuiBalance;
+                break;
+            case ChainType.XRPL:
+                balance = nativeXrplBalance;
+                break;
+            case ChainType.STELLAR:
+                balance = nativeStellarBalance;
+        }
+        const balanceFormatted = !!balance
+            ? formatBNToReadable(balance.value, balance.decimals)
+            : undefined;
+        return {
+            nativeBalance: balance,
+            nativeBalanceFormatted: balanceFormatted,
+        };
+    }, [
+        chain?.chainType,
+        nativeEvmBalance,
+        nativeCosmosBalance,
+        nativeBitcoinBalance,
+        nativeSolanaBalance,
+        nativeSuiBalance,
+        nativeXrplBalance,
+        nativeStellarBalance,
+    ]);
+    const isLoading = useMemo(() => {
         if (!chain?.chainType)
             return false;
         switch (chain.chainType) {
             case ChainType.EVM:
-                return isEvmSignerReady;
+                return isEvmLoading;
             case ChainType.COSMOS:
-                return isCosmosSignerReady;
+                return isCosmosLoading;
             case ChainType.BTC:
-                return isBitcoinSignerReady;
+                return isBitcoinLoading;
             case ChainType.SOLANA:
-                return isSolanaSignerReady;
+                return isSolanaLoading;
             case ChainType.SUI:
-                return isSuiSignerReady;
+                return isSuiLoading;
             case ChainType.XRPL:
-                return isXrplSignerReady;
+                return isXrpLoading;
             case ChainType.STELLAR:
-                return isStellarSignerReady;
+                return isStellarLoading;
         }
     }, [
         chain?.chainType,
-        isEvmSignerReady,
-        isCosmosSignerReady,
-        isBitcoinSignerReady,
-        isSolanaSignerReady,
-        isSuiSignerReady,
-        isXrplSignerReady,
-        isStellarSignerReady,
+        isEvmLoading,
+        isCosmosLoading,
+        isBitcoinLoading,
+        isSolanaLoading,
+        isSuiLoading,
+        isXrpLoading,
+        isStellarLoading,
     ]);
-    return {
-        isSignerReady,
-        evmSigner,
-        cosmosSigner,
-        bitcoinSigner,
-        solanaSigner,
-        suiSigner,
-        xrplSigner,
-        stellarSigner,
-    };
-};
-
-function useHederaTokenAssociations({ address, chain, token }) {
-    const publicClient = usePublicClient({
-        chainId: Number(CHAIN_IDS.HEDERA),
-    });
-    const { evmSigner } = useSigner({ chain });
-    const queryClient = useQueryClient();
-    /**
-     * Creates a token association transaction where the destination account authorizes to receive the given token
-     */
-    const associateToken = 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 = encodeFunctionData({
-                    abi: hrc20,
-                    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 = 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 (!chain || !address || !publicClient) {
-                throw new Error("Missing required parameters");
-            }
-            // TODO: update types
-            const apiUrl = chain?.chainConfig?.hedera?.mirrorNodeUrl;
-            if (!apiUrl) {
-                throw new Error("Missing Hedera mirror node URL in chain config");
-            }
-            const hederaApiClient = new HederaApiClient(apiUrl);
-            return hederaApiClient.isTokenAssociated({
-                address,
-                token,
-            });
-        },
-        enabled: !!address && !!publicClient && token?.chainId === CHAIN_IDS.HEDERA,
-    });
-    return {
-        isTokenAssociated,
-        associateToken,
-    };
-}
-
-const useKeyboardNavigation = ({ onEscape }) => {
-    const onKeyDown = useCallback((event) => {
-        if (event.key === "Escape") {
-            onEscape?.();
-            return;
-        }
-    }, [onEscape]);
-    useEffect(() => {
-        document.addEventListener("keydown", onKeyDown, false);
-        return () => {
-            document.removeEventListener("keydown", onKeyDown, false);
-        };
-    }, [onKeyDown]);
-};
-
-const useSquidQueryClient = () => {
-    const queryClient = useQueryClient();
-    const invalidateQueries = (key) => {
-        const prefixKey = getPrefixKey(key);
-        queryClient.invalidateQueries(prefixKey);
-    };
-    const refetchQueries = (key) => {
-        const prefixKey = getPrefixKey(key);
-        queryClient.refetchQueries(prefixKey);
-    };
-    const invalidateAndRefetchQueries = (key) => {
-        invalidateQueries(key);
-        refetchQueries(key);
-    };
-    return {
-        invalidateQueries,
-        refetchQueries,
-        invalidateAndRefetchQueries,
-    };
+    return { nativeBalance, nativeBalanceFormatted, isLoading };
 };
 
-class StellarApiClient {
-    apiUrl;
-    constructor(apiUrl) {
-        this.apiUrl = apiUrl;
-    }
-    async getBaseReserve() {
-        const response = await fetch(`${this.apiUrl}/ledgers?order=desc&limit=1`);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch ledgers: ${response.status}`);
-        }
-        const ledgers = await response.json();
-        const latestLedger = ledgers?._embedded.records?.[0];
-        if (latestLedger?.base_reserve_in_stroops == null) {
-            throw new Error("Invalid ledger data");
-        }
-        const baseReserveBn = BigInt(latestLedger.base_reserve_in_stroops);
-        return baseReserveBn;
-    }
-}
-
-const DEFAULT_REFETCH_INTERVAL$1 = 20_000;
-function useStellarAccountActivation({ address, chain, token, }) {
-    /**
-     * Checks if the destination account exists on the Stellar network
-     * Stellar accounts need to have a minimum balance before they can receive payments
-     */
-    const accountActivatedInfo = useQuery({
-        queryKey: keys().stellarAccountActivatedInfo(address, chain?.chainId, chain?.chainType),
-        queryFn: async () => {
-            if (chain?.chainType !== ChainType.STELLAR ||
-                token?.type !== ChainType.STELLAR) {
-                return null;
-            }
-            if (!address) {
-                throw new Error("Destination address is required");
-            }
-            // TODO: update types
-            const [horizonApiUrl] = chain?.horizonRpcList;
-            if (typeof horizonApiUrl !== "string") {
-                throw new Error("Invalid Horizon API URL");
-            }
-            const stellarApiClient = new StellarApiClient(horizonApiUrl);
-            const reserveBase = await stellarApiClient.getBaseReserve();
-            // Stellar accounts require two base reserves to be activated
-            // https://developers.stellar.org/docs/learn/fundamentals/lumens#minimum-balance
-            const accountReserveBase = reserveBase * BigInt(2);
-            const stellarRpcClient = await getClient(chain);
-            const isActivated = await stellarRpcClient.isAccountActivated(address);
-            return {
-                isActivated,
-                reserveBaseBn: accountReserveBase,
-            };
-        },
-        enabled: !!address && chain?.chainType === ChainType.STELLAR,
-        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
-        refetchOnWindowFocus: true,
+function useHederaAccountActivation({ address, chain, token }) {
+    const { balance: destNativeEvmBalance } = useEvmNativeBalance({
+        chain,
+        address,
     });
+    const isHederaAccountActivated = useMemo(() => {
+        if (token?.chainId !== CHAIN_IDS.HEDERA)
+            return true;
+        if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase())
+            return true;
+        return (!!destNativeEvmBalance?.value && destNativeEvmBalance.value > BigInt(0));
+    }, [token?.chainId, token?.address, destNativeEvmBalance?.value]);
     return {
-        accountActivatedInfo,
+        isHederaAccountActivated,
     };
 }
 
@@ -30745,161 +30734,6 @@ const useSingleTokenPrice = (tokenData) => {
     return { tokenPrice, getUSDValue };
 };
 
-const TEMPO_FEE_MANAGER_ADDRESS = "0xfeec000000000000000000000000000000000000";
-const feeManagerAbi = [
-    {
-        name: "userTokens",
-        type: "function",
-        stateMutability: "view",
-        inputs: [{ type: "address", name: "user" }],
-        outputs: [{ type: "address" }],
-    },
-];
-const isTempoChain = (chainId) => chainId === CHAIN_IDS.TEMPO;
-/**
- * Convert a fee amount from virtual USD (18 decimals, attodollars)
- * to 6-decimal TIP-20 stablecoin units (microdollars).
- * All TIP-20 tokens on Tempo have 6 decimals.
- */
-const convertTempoFeeToStablecoinUnits = (feeIn18Dec) => feeIn18Dec / BigInt(10 ** 12);
-/**
- * Pure function that derives TempoFeeData from on-chain query results.
- * Extracted from useTempoFeeCheck so the branching logic is unit-testable
- * without mocking React hooks.
- */
-function resolveTempoFeeData({ hasAccountFeePreference, accountGasTokenAddress, accountGasTokenBalance, fromTokenAddress, fromTokenBalance, }) {
-    if (hasAccountFeePreference && accountGasTokenAddress) {
-        const gasTokenIsFromToken = !!fromTokenAddress &&
-            accountGasTokenAddress.toLowerCase() === fromTokenAddress.toLowerCase();
-        return {
-            gasTokenBalance: accountGasTokenBalance ?? BigInt(0),
-            gasTokenIsFromToken,
-            gasTokenAddress: accountGasTokenAddress,
-        };
-    }
-    if (fromTokenAddress != null && fromTokenBalance != null) {
-        return {
-            gasTokenBalance: fromTokenBalance,
-            gasTokenIsFromToken: true,
-            gasTokenAddress: fromTokenAddress,
-        };
-    }
-    return null;
-}
-/**
- * Resolves the token that pays network gas fees for a given chain and transaction context.
- * For Tempo chains, this is the dynamically resolved gas token (from tempoFeeData).
- * For all other chains, this is the static native gas token.
- */
-function resolveGasToken({ nativeToken, chain, tempoFeeData, evmTokens, }) {
-    if (!chain)
-        return undefined;
-    if (isTempoChain(chain.chainId)) {
-        if (!tempoFeeData)
-            return undefined;
-        return evmTokens.find((t) => t.chainId === chain.chainId &&
-            t.address.toLowerCase() === tempoFeeData.gasTokenAddress.toLowerCase());
-    }
-    return nativeToken;
-}
-/**
- * Resolves chain-agnostic fee parameters from chain-specific inputs.
- * This is the single place that knows about Tempo vs. native-token fee semantics.
- *
- * Safe defaults when tempoFeeData is missing on a Tempo chain: balance=0 and
- * fromTokenPaysNetworkFee=false, so the UI blocks rather than misleads.
- */
-function resolveChainFeeParams({ fromChainId, tempoFeeData, isFromTokenNative, nativeBalanceWei, }) {
-    if (isTempoChain(fromChainId)) {
-        if (!tempoFeeData) {
-            return null;
-        }
-        return {
-            fromTokenPaysNetworkFee: tempoFeeData?.gasTokenIsFromToken ?? false,
-            gasTokenBalanceWei: tempoFeeData?.gasTokenBalance ?? BigInt(0),
-            normalizeFee: convertTempoFeeToStablecoinUnits,
-        };
-    }
-    return {
-        fromTokenPaysNetworkFee: isFromTokenNative,
-        gasTokenBalanceWei: nativeBalanceWei,
-        normalizeFee: (fee) => fee,
-    };
-}
-
-const BALANCE_QUERY_STALE_TIME = 10_000;
-/**
- * Returns raw on-chain gas token data for Tempo chains, or null when the source
- * chain is not Tempo.
- */
-const useTempoFeeCheck = ({ fromChain, fromToken, }) => {
-    const { connectedAddresses } = useWallet();
-    const evmAddress = parseEvmAddress(connectedAddresses[ChainType.EVM]);
-    const isTempo = isTempoChain(fromChain?.chainId);
-    const chainId = Number(fromChain?.chainId);
-    // Read account-level gas token preference from FeeManager precompile
-    // See docs: https://docs.tempo.xyz/protocol/fees/spec-fee#account-level
-    const { data: accountGasTokenAddress } = useReadContract({
-        address: TEMPO_FEE_MANAGER_ADDRESS,
-        abi: feeManagerAbi,
-        functionName: "userTokens",
-        args: evmAddress ? [evmAddress] : undefined,
-        chainId,
-        query: {
-            enabled: isTempo && !!evmAddress,
-            staleTime: 30_000,
-        },
-    });
-    const hasAccountFeePreference = !!accountGasTokenAddress &&
-        // By default, the zero address is returned when the user has no preference set
-        zeroAddress$1.toLowerCase() !== accountGasTokenAddress.toLowerCase();
-    // Fetch balance of the account-preferred gas token (if set)
-    const { data: accountGasTokenBalance } = useBalance({
-        address: evmAddress,
-        token: hasAccountFeePreference ? accountGasTokenAddress : undefined,
-        chainId,
-        query: {
-            enabled: isTempo && hasAccountFeePreference && !!evmAddress,
-            staleTime: BALANCE_QUERY_STALE_TIME,
-        },
-    });
-    const fromTokenAddress = parseEvmAddress(fromToken?.address);
-    const { data: fromTokenBalance } = useBalance({
-        address: evmAddress,
-        token: fromTokenAddress,
-        chainId,
-        query: {
-            enabled: isTempo && !!evmAddress,
-            staleTime: BALANCE_QUERY_STALE_TIME,
-        },
-    });
-    if (!isTempo)
-        return null;
-    return resolveTempoFeeData({
-        hasAccountFeePreference,
-        accountGasTokenAddress,
-        accountGasTokenBalance: accountGasTokenBalance?.value,
-        fromTokenAddress,
-        fromTokenBalance: fromTokenBalance?.value,
-    });
-};
-
-/**
- * Resolves the token that pays network gas fees for a given chain
- */
-function useSourceChainGasToken({ fromChain, fromToken, }) {
-    const { nativeToken } = useNativeTokenForChain(fromChain);
-    const { evmTokens } = useSquidTokens();
-    const tempoFeeData = useTempoFeeCheck({ fromChain, fromToken });
-    const gasToken = useMemo(() => resolveGasToken({
-        nativeToken,
-        chain: fromChain,
-        tempoFeeData,
-        evmTokens,
-    }), [nativeToken, fromChain, tempoFeeData, evmTokens]);
-    return { gasToken };
-}
-
 const MAX_COINGECKO_QUERY_TOKENS = 100;
 const fetchHistoricalData = async (coingeckoId, timeFrame) => {
     const now = Math.floor(Date.now() / 1000);
@@ -31050,20 +30884,24 @@ const calculateTotalNativeFees = ({ expressFeeCost, firstFeeCost, firstGasCost,
     (sameTokenBetweenFees
         ? BigInt(firstFeeCost?.amount ?? "0") + BigInt(firstGasCost?.amount ?? "0")
         : BigInt(firstGasCost?.amount ?? "0"));
-const isGasBalanceEnough = ({ fromAmount, networkFeesWei, chainFeeParams, }) => {
-    if (!chainFeeParams)
-        return false;
-    if (chainFeeParams.fromTokenPaysNetworkFee) {
-        return (BigInt(fromAmount ?? "0") + networkFeesWei <=
-            chainFeeParams.gasTokenBalanceWei);
-    }
-    return networkFeesWei <= chainFeeParams.gasTokenBalanceWei;
-};
-const calculateMinAmountValueWarnMsg = ({ networkFeesWei, chainFeeParams, }) => {
-    if (!chainFeeParams?.fromTokenPaysNetworkFee)
-        return undefined;
-    return chainFeeParams.gasTokenBalanceWei - networkFeesWei;
-};
+const isFromBalanceEnoughToSwap = ({ isFromTokenNative, fromAmount, totalFeesInNativeTokenPlusRatio, nativeTokenBalanceFromChainWei, }) => {
+    const fromAmountBigInt = BigInt(fromAmount ?? "0");
+    const totalFeesInNativeTokenPlusRatioBigInt = totalFeesInNativeTokenPlusRatio;
+    const nativeTokenBalanceFromChainWeiBigInt = nativeTokenBalanceFromChainWei;
+    return isFromTokenNative
+        ? fromAmountBigInt + totalFeesInNativeTokenPlusRatioBigInt <=
+            nativeTokenBalanceFromChainWeiBigInt
+        : totalFeesInNativeTokenPlusRatioBigInt <=
+            nativeTokenBalanceFromChainWeiBigInt;
+};
+const calculateMinAmountValueWarnMsg = ({ isFromTokenNative, nativeTokenBalanceFromChainWei, sourceChainNativeTokenDecimals, totalFeesInNativeTokenPlusRatio, }) => isFromTokenNative
+    ? (() => {
+        const minAmount = nativeTokenBalanceFromChainWei - totalFeesInNativeTokenPlusRatio;
+        return minAmount > BigInt(0)
+            ? formatBNToReadable(minAmount, sourceChainNativeTokenDecimals)
+            : "0";
+    })()
+    : undefined;
 /**
  * Calculates the estimated duration of a route
  *
@@ -31102,10 +30940,12 @@ const formatEstimatedRouteDuration = ({ estimatedRouteDuration, isSingleChainRou
  * @returns {Object} An object containing various estimate results and calculations, including token information,
  *                   amounts, fees, gas costs, and other relevant data for the transaction.
  */
-const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, collectFees, nativeTokenBalanceFromChainWei, tempoFeeData, }) => {
+const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, collectFees, nativeTokenBalanceFromChainWei, }) => {
     const fromToken = findToken(tokens, squidRoute?.params.fromChain, squidRoute?.params.fromToken);
     const fromAmount = squidRoute?.estimate?.fromAmount;
     const fromAmountFormatted = formatAmount(fromAmount, fromToken?.decimals);
+    const sourceChainNativeToken = findNativeToken(tokens, fromChain);
+    const destChainNativeToken = findNativeToken(tokens, toChain);
     const toAmountUSD = squidRoute?.estimate?.toAmountUSD;
     const exchangeRate = squidRoute?.estimate.exchangeRate ?? "0";
     const toAmountMinUSD = squidRoute?.estimate.toAmountMinUSD ?? "0";
@@ -31124,6 +30964,10 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
     const expectedGasRefundCostUSD = convertTokenAmountToUSD(formatBNToReadable(expectedGasRefundCost, firstFeeCost?.token.decimals ?? 18), firstFeeCost?.token.usdPrice ?? "0");
     const sameTokenBetweenFees = firstFeeCost?.token.address === firstGasCost?.token.address &&
         firstFeeCost?.token.chainId === firstGasCost?.token.chainId;
+    const isFromTokenNative = 
+    // TODO: temporary fix, currently nativeCurrency.symbol is not always in uppercase
+    fromToken?.symbol.toUpperCase() ===
+        fromChain?.nativeCurrency.symbol.toUpperCase();
     const totalNativeFees = calculateTotalNativeFees({
         expressFeeCost,
         firstFeeCost,
@@ -31131,32 +30975,19 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         sameTokenBetweenFees,
     });
     const totalFeesInNativeTokenPlusRatio = (totalNativeFees * BigInt(110)) / BigInt(100);
-    const isNativeTokenFromChain = 
-    // TODO: nativeCurrency.symbol is not always uppercase
-    fromToken?.symbol.toUpperCase() ===
-        fromChain?.nativeCurrency.symbol.toUpperCase();
-    const chainFeeParams = resolveChainFeeParams({
-        tempoFeeData,
-        isFromTokenNative: isNativeTokenFromChain,
-        nativeBalanceWei: nativeTokenBalanceFromChainWei,
-        fromChainId: fromChain?.chainId,
-    });
-    const networkFeesWei = chainFeeParams?.normalizeFee(totalFeesInNativeTokenPlusRatio) ?? BigInt(0);
-    const gasBalanceEnough = isGasBalanceEnough({
-        chainFeeParams,
+    const fromBalanceEnoughToSwap = isFromBalanceEnoughToSwap({
+        isFromTokenNative,
         fromAmount,
-        networkFeesWei,
+        fromTokenDecimals: fromToken?.decimals,
+        totalFeesInNativeTokenPlusRatio,
+        nativeTokenBalanceFromChainWei,
     });
-    const minAmount = calculateMinAmountValueWarnMsg({
-        chainFeeParams,
-        // gasTokenDecimals: chainFeeParams,
-        networkFeesWei,
+    const minAmountValueWarnMsg = calculateMinAmountValueWarnMsg({
+        isFromTokenNative,
+        nativeTokenBalanceFromChainWei,
+        sourceChainNativeTokenDecimals: sourceChainNativeToken?.decimals,
+        totalFeesInNativeTokenPlusRatio,
     });
-    const minAmountValueWarnMsg = minAmount
-        ? formatBNToReadable(minAmount, chainFeeParams?.fromTokenPaysNetworkFee
-            ? fromToken?.decimals
-            : undefined)
-        : undefined;
     const isSingleChainRoute = fromChain?.chainId === toChain?.chainId;
     const estimatedRouteDuration = formatEstimatedRouteDuration({
         estimatedRouteDuration: squidRoute?.estimate?.estimatedRouteDuration,
@@ -31166,6 +30997,8 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         fromToken,
         fromAmount,
         fromAmountFormatted,
+        sourceChainNativeToken,
+        destChainNativeToken,
         toAmountUSD,
         exchangeRate,
         toAmountMinUSD,
@@ -31180,10 +31013,10 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         expectedGasRefundCost,
         expectedGasRefundCostUSD,
         sameTokenBetweenFees,
-        fromTokenPaysNetworkFee: chainFeeParams?.fromTokenPaysNetworkFee ?? false,
+        isFromTokenNative,
         totalNativeFees,
         totalFeesInNativeTokenPlusRatio,
-        gasBalanceEnough,
+        fromBalanceEnoughToSwap,
         minAmountValueWarnMsg,
         estimatedRouteDuration,
     };
@@ -31219,6 +31052,28 @@ const calculateTotalWithRefundEstimate = (allFeeCosts, expectedGasRefundCost, ge
         feeToken: firstFeeCost?.token,
     };
 };
+/**
+ * Calculates the proposed gas amount for the destination chain.
+ *
+ * @param destChainNativeToken - The symbol of the native token for the destination chain.
+ * @returns An object containing the proposed gas amount value and the currency symbol.
+ */
+const getProposedGasDestinationAmount = (destChainNativeToken) => {
+    const gasAmounts = {
+        GLMR: 5.289,
+        ETH: 0.0009,
+        AVAX: 0.115,
+        BNB: 0.00425,
+        FTM: 4.45,
+        CELO: 3.052,
+        KAVA: 2.339,
+        MATIC: 1.795,
+    };
+    return {
+        value: gasAmounts[destChainNativeToken ?? ""] ?? 0,
+        currency: destChainNativeToken,
+    };
+};
 
 function useSendTransactionGas({ chain, token, from, }) {
     return useQuery({
@@ -31240,11 +31095,7 @@ function useSendTransactionGas({ chain, token, from, }) {
                     // Some RPC providers require the sender to have enough balance, otherwise estimation reverts
                     // so we'll try to use the user provided address when possible
                     const sender = from || dummyAddress;
-                    // Tempo has no native token, so `value` transfers are rejected by the EVM.
-                    // We can simulate an ERC20 transfer instead
-                    const supportsNativeTransfers = chain.chainId !== CHAIN_IDS.TEMPO;
-                    const isNativeToken = token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase();
-                    if (isNativeToken && supportsNativeTransfers) {
+                    if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase()) {
                         const gas = await client.estimateGas({
                             from: sender,
                             to: dummyAddress,
@@ -31264,14 +31115,7 @@ function useSendTransactionGas({ chain, token, from, }) {
                         data,
                         chainId: chain.chainId,
                     });
-                    const feeWei = gas * maxFeePerGas;
-                    // Tempo fees are denominated in virtual USD (18 dec, 1e-18 USD units).
-                    // Convert to 6-dec stablecoin units so all callers receive a
-                    // consistent unit without needing to know about the chain.
-                    if (chain.chainId === CHAIN_IDS.TEMPO) {
-                        return convertTempoFeeToStablecoinUnits(feeWei);
-                    }
-                    return feeWei;
+                    return gas * maxFeePerGas;
                 }
                 case ChainType.COSMOS: {
                     // TODO: get gas estimation from backend
@@ -31319,24 +31163,18 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
         from,
     });
     const { nativeBalance } = useNativeBalance(chain);
-    const tempoFeeData = useTempoFeeCheck({ fromChain: chain, fromToken: token });
-    const chainFeeParams = resolveChainFeeParams({
-        fromChainId: chain?.chainId,
-        tempoFeeData,
-        isFromTokenNative: token != null &&
-            token.address.toLowerCase() ===
-                chainTypeToNativeTokenAddressMap[token.type]?.toLowerCase(),
-        nativeBalanceWei: nativeBalance?.value ?? BigInt(0),
-    });
-    const gasBalanceEnough = useMemo(() => {
-        if (!amount || !token?.decimals)
+    const isNativeBalanceEnoughToPayGasFees = useMemo(() => {
+        if (!nativeBalance?.value || !amount || !token?.decimals) {
             return false;
-        return isGasBalanceEnough({
-            fromAmount: parseToBigInt(amount, token.decimals).toString(),
-            networkFeesWei: estimatedGas,
-            chainFeeParams,
-        });
-    }, [amount, estimatedGas, token, chainFeeParams]);
+        }
+        const isTokenNative = token.address.toLowerCase() ===
+            chainTypeToNativeTokenAddressMap[token.type].toLowerCase();
+        if (isTokenNative) {
+            return (parseToBigInt(amount, token.decimals) + estimatedGas <=
+                nativeBalance.value);
+        }
+        return estimatedGas <= nativeBalance.value;
+    }, [amount, estimatedGas, nativeBalance?.value, token]);
     const isBalanceEnough = useMemo(() => {
         if (token?.decimals == null || !balance || !amount)
             return false;
@@ -31344,30 +31182,28 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
             parseToBigInt(amount, token.decimals));
     }, [amount, balance, token?.decimals]);
     const minAmountValueWarnMsg = useMemo(() => {
-        if (!token?.address || !estimatedGas)
-            return undefined;
-        if (!chainFeeParams)
+        if (!token?.address || !nativeBalance?.value || !estimatedGas)
             return undefined;
-        const minAmount = calculateMinAmountValueWarnMsg({
-            chainFeeParams,
-            // gasTokenDecimals: chainFeeParams.fromTokenPaysNetworkFee
-            //   ? token.decimals
-            //   : undefined,
-            networkFeesWei: estimatedGas,
+        const isFromTokenNative = token.address.toLowerCase() ===
+            chainTypeToNativeTokenAddressMap[token.type].toLowerCase();
+        return calculateMinAmountValueWarnMsg({
+            isFromTokenNative,
+            nativeTokenBalanceFromChainWei: nativeBalance.value,
+            sourceChainNativeTokenDecimals: nativeBalance.decimals,
+            totalFeesInNativeTokenPlusRatio: estimatedGas,
         });
-        // return minAmount > BigInt(0)
-        //   ? formatBNToReadable(minAmount, gasTokenDecimals)
-        //   : "0";
-        if (!minAmount)
-            return undefined;
-        return formatBNToReadable(minAmount, chainFeeParams.fromTokenPaysNetworkFee ? token.decimals : undefined);
-    }, [estimatedGas, token, chainFeeParams]);
+    }, [
+        estimatedGas,
+        nativeBalance?.decimals,
+        nativeBalance?.value,
+        token?.address,
+        token?.type,
+    ]);
     return {
         estimatedGas,
         isBalanceEnough,
-        tokenPaysNetworkFee: chainFeeParams?.fromTokenPaysNetworkFee ?? false,
         isLoading,
-        isGasBalanceEnough: gasBalanceEnough,
+        isNativeBalanceEnoughToPayGasFees,
         minAmountValueWarnMsg,
     };
 }
@@ -32426,7 +32262,7 @@ const useApproval = ({ squidRoute, }) => {
             // This is to ensure we're using the latest expiry timestamp
             if (squidRoute) {
                 queryClient.refetchQueries({
-                    queryKey: keys().transaction(squidRoute.params.fromChain, squidRoute.params.toChain, squidRoute.params.toToken, squidRoute.params.fromToken, fromPrice, squidRoute.params.slippage, squidRoute.params.fromAddress, squidRoute.params.bypassGuardrails, squidRoute.params.toAddress, squidRoute.params.fallbackAddresses?.[0]?.address, squidRoute.params.quoteOnly, getChainType(squidRoute.params.fromChain), squidRoute.params.preHook, squidRoute.params.postHook, 
+                    queryKey: keys().transaction(squidRoute.params.fromChain, squidRoute.params.toChain, squidRoute.params.toToken, squidRoute.params.fromToken, fromPrice, squidRoute.params.slippage, squidRoute.params.receiveGasOnDestination, squidRoute.params.fromAddress, squidRoute.params.bypassGuardrails, squidRoute.params.toAddress, squidRoute.params.fallbackAddresses?.[0]?.address, squidRoute.params.quoteOnly, getChainType(squidRoute.params.fromChain), squidRoute.params.preHook, squidRoute.params.postHook, 
                     // TODO: update types
                     squidRoute.params?.overrideGasRefundAddress),
                 });
@@ -32445,10 +32281,8 @@ const AXELAR_PROVIDER_IMAGE_URL = "https://raw.githubusercontent.com/0xsquid/ass
 const useEstimate = (squidRoute) => {
     const collectFees = useConfigStore((state) => state.config.collectFees);
     const { tokens } = useSquidTokens();
-    const { fromChain, toChain, fromPrice } = useSwap();
+    const { fromChain, toChain } = useSwap();
     const { nativeBalance } = useNativeBalance(fromChain);
-    const fromToken = useMemo(() => findToken(tokens, squidRoute?.params.fromChain, squidRoute?.params.fromToken), [tokens, squidRoute?.params.fromChain, squidRoute?.params.fromToken]);
-    const tempoFeeData = useTempoFeeCheck({ fromChain, fromToken });
     const estimateResults = useMemo(() => calculateEstimateResults({
         squidRoute,
         tokens,
@@ -32456,17 +32290,8 @@ const useEstimate = (squidRoute) => {
         toChain,
         collectFees: !!collectFees && collectFees.fee > 0,
         nativeTokenBalanceFromChainWei: nativeBalance?.value ?? BigInt("0"),
-        tempoFeeData: tempoFeeData ?? undefined,
-    }), [
-        squidRoute,
-        tokens,
-        fromChain,
-        toChain,
-        collectFees,
-        nativeBalance,
-        tempoFeeData,
-    ]);
-    const fromBalanceFormatted = useMultiChainBalance({
+    }), [squidRoute, tokens, fromChain, toChain, collectFees, nativeBalance]);
+    const balanceFormatted = useMultiChainBalance({
         chain: fromChain,
         token: estimateResults.fromToken,
         userAddress: squidRoute?.params.fromAddress ?? "",
@@ -32478,6 +32303,7 @@ const useEstimate = (squidRoute) => {
         estimateResults.expectedGasRefundCost,
         getUSDValue,
     ]);
+    const proposedGasDestinationAmount = useMemo(() => getProposedGasDestinationAmount(estimateResults.destChainNativeToken?.symbol), [estimateResults.destChainNativeToken]);
     const { feeCostsFormatted, totalFeeCostsUsd } = useMemo(() => {
         const feeCosts = squidRoute?.estimate.feeCosts ?? [];
         const feeCostsRenamed = [];
@@ -32536,18 +32362,19 @@ const useEstimate = (squidRoute) => {
             totalFeeCostsUsd: totalFeeCostsUsdFormatted,
         };
     }, [squidRoute?.estimate.feeCosts]);
-    const slippageFormatted = Number(squidRoute?.estimate?.aggregateSlippage ?? 0).toFixed(2) + "%";
-    const fromBalanceEnoughToSwap = useMemo(() => {
-        const fromBalanceNum = Number(fromBalanceFormatted ?? 0);
-        const fromPriceNum = Number(fromPrice ?? 0);
-        return fromBalanceNum >= fromPriceNum;
-    }, [fromBalanceFormatted, fromPrice]);
+    const slippageFormatted = 
+    // TODO: update types
+    Number(squidRoute?.estimate?.aggregateSlippage ?? 0).toFixed(2) +
+        "%";
+    const enoughBalanceToSwap = +balanceFormatted >= 0 &&
+        +balanceFormatted > +estimateResults.fromAmountFormatted;
     return {
         ...estimateResults,
-        fromBalanceFormatted,
+        balanceFormatted,
         slippageFormatted,
         totalWithRefundEstimate,
-        fromBalanceEnoughToSwap,
+        proposedGasDestinationAmount,
+        enoughBalanceToSwap,
         feeCostsFormatted,
         totalFeeCostsUsd,
     };
@@ -36295,7 +36122,7 @@ const useGetRoute = () => {
         });
         // Cache the route data
         // Useful when the getRoute mutation is called from another hook
-        queryClient.setQueryData(keys().transaction(fromChain, toChain, toToken.address, fromToken.address, fromPrice, config.slippage, sourceUserAddress, config.degenMode, destinationAddress, swapRoute?.fallbackAddress, quoteOnly, fromChainType, config.preHook, config.postHook, overrideGasRefundAddress), route);
+        queryClient.setQueryData(keys().transaction(fromChain, toChain, toToken.address, fromToken.address, fromPrice, config.slippage, config.enableGetGasOnDestination, sourceUserAddress, config.degenMode, destinationAddress, swapRoute?.fallbackAddress, quoteOnly, fromChainType, config.preHook, config.postHook, overrideGasRefundAddress), route);
         return route;
     });
 };
@@ -36318,13 +36145,14 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     const sourceUserAddress = isDepositAddressEnabled && isAvailableAsPaymentMethod
         ? depositRefundAddress ?? sourceConnectedAddress
         : sourceConnectedAddress;
-    const squidRouteQueryKeys = useMemo(() => keys().transaction(fromChain?.chainId, toChain?.chainId, toToken?.address, fromToken?.address, fromPrice, config.slippage, sourceUserAddress, config.degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChain?.chainType, config.preHook, config.postHook, config.overrideGasRefundAddress), [
+    const squidRouteQueryKeys = useMemo(() => keys().transaction(fromChain?.chainId, toChain?.chainId, toToken?.address, fromToken?.address, fromPrice, config.slippage, config.enableGetGasOnDestination, sourceUserAddress, config.degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChain?.chainType, config.preHook, config.postHook, config.overrideGasRefundAddress), [
         fromChain?.chainId,
         toChain?.chainId,
         toToken?.address,
         fromToken?.address,
         fromPrice,
         config.slippage,
+        config.enableGetGasOnDestination,
         sourceUserAddress,
         config.degenMode,
         destinationAddress,
@@ -36596,6 +36424,35 @@ const useAvatar = (seed = zeroAddress) => {
     return avatar || "";
 };
 
+const useUserParams = () => {
+    const enableGetGasOnDestination = useConfigStore((state) => state.config.enableGetGasOnDestination);
+    const { fromToken, toToken, toChain, fromChain } = useSwap();
+    //   =============
+    //       GAS
+    //   =============
+    const getGasOnDestSupportedForThisRoute = useMemo(() => 
+    // Not supporting get gas on dest for same chains
+    fromChain?.chainId !== toChain?.chainId &&
+        // If the destination chain is cosmos, we don't support getting gas there
+        toChain?.chainType !== ChainType.COSMOS &&
+        // Not supporting get gas on dest for same tokens (bridge)
+        ((fromToken?.subGraphIds?.some((sgi) => !!toToken?.subGraphIds?.includes(sgi)) &&
+            toToken?.subGraphIds?.some((sgi) => !!fromToken?.subGraphIds?.includes(sgi))) ||
+            // Except for uusdc -> uusdc
+            (fromToken?.subGraphIds?.includes("uusdc") &&
+                toToken?.subGraphIds?.includes("uusdc"))), [
+        fromChain?.chainId,
+        fromToken?.subGraphIds,
+        toChain?.chainId,
+        toToken?.subGraphIds,
+        toChain?.chainType,
+    ]);
+    return {
+        gasEnabled: enableGetGasOnDestination && getGasOnDestSupportedForThisRoute,
+        getGasOnDestSupportedForThisRoute,
+    };
+};
+
 const useAddToken = (chainToCompare, tokenToCompare) => {
     const { chain: currentEvmChain } = useAccount();
     const { connector } = useAccount();
@@ -37023,5 +36880,5 @@ const SquidProvider = ({ children, config, placeholder, }) => {
                                     React.createElement(CosmosProvider, null, children)))))))))) : (placeholder);
 };
 
-export { useSwap as $, AxelarStatusResponseType as A, useHederaTokenAssociations as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useKeyboardNavigation as E, useSquidQueryClient as F, useSquid as G, HistoryTxType as H, useStellarAccountActivation as I, useAddressBookStore as J, useAssetsColorsStore as K, useFavoriteTokensStore as L, useHistoryStore as M, Nr as N, useSendTransactionStore as O, useConfigStore as P, QueryKeys as Q, useSquidStore as R, SquidStatusErrorType as S, TransactionErrorType as T, useSwapRoutePersistStore as U, useTransactionStore as V, Wo as W, XamanXrplNetwork as X, ConnectingWalletStatus as Y, useWalletStore as Z, useDepositAddress as _, WindowWalletFlag as a, getXummClient as a$, useAllConnectedWalletBalances as a0, useAllTokensWithBalanceForChainType as a1, useCosmosBalance as a2, useEvmBalance as a3, useMultiChainBalance as a4, useMultipleTokenPrices as a5, useBitcoinNativeBalance as a6, useCosmosNativeBalance as a7, useEvmNativeBalance as a8, useNativeBalance as a9, useAddToken as aA, useAutoConnect as aB, useEnsDataForAddress as aC, useEnsSearch as aD, useGnosisContext as aE, useIsSameAddressAndGnosisContext as aF, useIntegratorContext as aG, useMultiChainWallet as aH, useSigner as aI, useWallet as aJ, useWallets as aK, useXrplTrustLine as aL, TX_STATUS_CONSTANTS as aM, FINAL_TRANSACTION_STATUSES as aN, useGetFiatQuote as aO, useGetOnRampConfig as aP, useExecuteFiatQuote as aQ, useFiatOnRampTxStatus as aR, useFiatTransactions as aS, useCurrencyDetails as aT, useCountryDetails as aU, useAvailableQuotes as aV, useRecommendedQuote as aW, useGetOnrampPaymentTypes as aX, useSuggestedFiatAmounts as aY, SquidProvider as aZ, EnsService as a_, useSolanaNativeBalance as aa, useStellarNativeBalance as ab, useSuiNativeBalance as ac, useXrplNativeBalance as ad, useNativeTokenForChain as ae, useSingleTokenPrice as af, useSourceChainGasToken as ag, useSquidTokens as ah, useHistoricalData as ai, useTokensData as aj, useEstimateSendTransaction as ak, useSendTransaction as al, useSendTransactionGas as am, useAllTransactionsStatus as an, useApproval as ao, useEstimate as ap, useEstimatePriceImpact as aq, useExecuteTransaction as ar, useGetRoute as as, useGetRouteWrapper as at, useRouteWarnings as au, useSendTransactionStatus as av, useSwapTransactionStatus as aw, useAvatar as ax, useHistory as ay, useDebouncedValue as az, chainTypeToZeroAddressMap as b, adaptiveRound as b$, isXamanXAppContext as b0, getQueryHeaders as b1, getStatusCode as b2, is404Error as b3, assetsBaseUrl as b4, shareSubgraphId as b5, sortTokensBySharedSubgraphIds as b6, getSupportedChainIdsForDirection as b7, filterChains as b8, filterTokens as b9, getCosmosKey as bA, getKeysSettled as bB, getAllKeysForSupportedCosmosChains as bC, isCosmosAddressValid as bD, getCosmosSigningClient as bE, getCosmosChainInfosObject as bF, connectCosmosWallet as bG, isFallbackAddressNeeded as bH, suggestChainOrThrow as bI, normalizeError as bJ, transactionErrorCode as bK, isUserRejectionError as bL, getTransactionError as bM, handleTransactionErrorEvents as bN, isSwapRouteError as bO, isStatusError as bP, createQuoteRequestParamsHash as bQ, WidgetEvents as bR, EvmNetworkNotSupportedErrorCode as bS, addEthereumChain as bT, parseEvmAddress as bU, formatEvmWallet as bV, filterWagmiConnector as bW, waitForReceiptWithRetry as bX, getUserCountry as bY, getCountryData as bZ, getCurrencyData as b_, getTokenImage as ba, getNewSwapParamsFromInput as bb, sortAllTokens as bc, findToken as bd, findNativeToken as be, normalizeIbcAddress as bf, groupTokensBySymbol as bg, groupTokensByChainId as bh, filterViewableTokens as bi, getSecretNetworkBalances as bj, getTokenAssetsKey as bk, fetchAssetsColors as bl, initializeSquidWithAssetsColors as bm, isEmptyObject as bn, normalizeTokenSymbol as bo, areTokenSymbolsCompatible as bp, isEvmosChain as bq, getConfigWithDefaults as br, randomIntFromInterval as bs, getTokensForChain as bt, getFirstAvailableChainId as bu, fetchHighestBalanceToken as bv, getInitialOrDefaultTokenAddressForChain as bw, getInitialTokenAddressForChain as bx, filterTokensForDestination as by, getInitialChainIdFromConfig as bz, chainTypeToNativeTokenAddressMap as c, addTokenToWallet as c$, getSuggestedAmountsForCurrency as c0, HederaExtensionHelper as c1, convertHederaAccountIdToEvmAddress as c2, convertEvmAddressToHederaAccountId as c3, scaleHbarToWei as c4, scaleWeiToHbar as c5, parseToBigInt as c6, roundNumericValue as c7, formatUnitsRounded as c8, formatTokenAmount as c9, isChainflipBridgeTransaction as cA, isOnChainTxData as cB, isDepositWithSignatureTxData as cC, getHistoryTransactionId as cD, getStepStatuses as cE, getHalfSuccessState as cF, getStepsInfos as cG, getSwapTxStatusRefetchInterval as cH, getSendTxStatusRefetchInterval as cI, chainflipMultihopBridgeType as cJ, getBridgeType as cK, getTransactionStatus as cL, getTransactionEndStatus as cM, isHistoryTransactionPending as cN, isHistoryTransactionFailed as cO, isHistoryTransactionWarning as cP, isHistoryTransactionEnded as cQ, formatHash as cR, isWalletAddressValid as cS, redirectToExtensionsStore as cT, accessProperty as cU, populateWallets as cV, getDefaultChain as cW, sortWallets as cX, areSameAddress as cY, sortAddressBook as cZ, calculateTotalUsdBalanceUSD as c_, formatUsdAmount as ca, trimExtraDecimals as cb, getNumericValue as cc, cleanAmount as cd, convertTokenAmountToUSD as ce, convertUSDToTokenAmount as cf, calculateTotal24hChange as cg, getRouteExpiry as ch, searchTokens as ci, filterSolanaWallets as cj, isSolanaAddressValid as ck, executeSolanaSwap as cl, executeSolanaTransfer as cm, formatTransactionHistoryDate as cn, getAxelarExplorerTxUrl as co, getSourceExplorerTxUrl as cp, getMainExplorerUrl as cq, formatDistance as cr, formatSeconds as cs, formatSwapTxStatusResponseForStorage as ct, simplifyRouteAction as cu, fetchSwapTransactionStatus as cv, compareTransactionIds as cw, isCoralBridgeAction as cx, sleep as cy, isDepositRoute as cz, definedInWindow as d, isEvmChainNotSupportedError as d0, getWalletSupportedChainTypes as d1, getConnectorForChainType as d2, walletSupportsChainType as d3, connectWallet as d4, cancelConnectWallet as d5, isProblematicConnector as d6, mergeWallets as d7, isXionSmartContractAddress as d8, isXrplAddressValid as d9, buildXrplTrustSetTx as da, getXrplNetwork as db, parseXrplPaymentTx as dc, er as e, formatBNToReadable as f, DEFAULT_ROUTE_REFETCH_INTERVAL as g, destinationAddressResetValue as h, fallbackAddressResetValue as i, nativeCosmosTokenAddress as j, nativeEvmTokenAddress as k, nativeSolanaTokenAddress as l, nativeStellarTokenAddress as m, nativeBitcoinTokenAddress as n, nativeSuiTokenAddress as o, nativeXrplTokenAddress as p, CosmosProvider as q, SendTransactionStatus as r, TransactionStatus as s, useTrackSearchEmpty as t, useCosmosContext as u, useSquidChains as v, walletIconBaseUrl as w, useClient as x, useCosmosForChain as y, useHederaAccountActivation as z };
-//# sourceMappingURL=index-B4aeecpP.js.map
+export { useSwap as $, AxelarStatusResponseType as A, useKeyboardNavigation as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useSquidQueryClient as E, useSquid as F, useStellarAccountActivation as G, HistoryTxType as H, useHederaAccountActivation as I, useAddressBookStore as J, useAssetsColorsStore as K, useFavoriteTokensStore as L, useHistoryStore as M, Nr as N, useSendTransactionStore as O, useConfigStore as P, QueryKeys as Q, useSquidStore as R, SquidStatusErrorType as S, TransactionErrorType as T, useSwapRoutePersistStore as U, useTransactionStore as V, Wo as W, XamanXrplNetwork as X, ConnectingWalletStatus as Y, useWalletStore as Z, useDepositAddress as _, WindowWalletFlag as a, getXummClient as a$, useAllConnectedWalletBalances as a0, useAllTokensWithBalanceForChainType as a1, useCosmosBalance as a2, useEvmBalance as a3, useMultiChainBalance as a4, useMultipleTokenPrices as a5, useBitcoinNativeBalance as a6, useCosmosNativeBalance as a7, useEvmNativeBalance as a8, useNativeBalance as a9, useAddToken as aA, useAutoConnect as aB, useEnsDataForAddress as aC, useEnsSearch as aD, useGnosisContext as aE, useIsSameAddressAndGnosisContext as aF, useIntegratorContext as aG, useMultiChainWallet as aH, useSigner as aI, useWallet as aJ, useWallets as aK, useXrplTrustLine as aL, TX_STATUS_CONSTANTS as aM, FINAL_TRANSACTION_STATUSES as aN, useGetFiatQuote as aO, useGetOnRampConfig as aP, useExecuteFiatQuote as aQ, useFiatOnRampTxStatus as aR, useFiatTransactions as aS, useCurrencyDetails as aT, useCountryDetails as aU, useAvailableQuotes as aV, useRecommendedQuote as aW, useGetOnrampPaymentTypes as aX, useSuggestedFiatAmounts as aY, SquidProvider as aZ, EnsService as a_, useSolanaNativeBalance as aa, useStellarNativeBalance as ab, useSuiNativeBalance as ac, useXrplNativeBalance as ad, useNativeTokenForChain as ae, useSingleTokenPrice as af, useSquidTokens as ag, useHistoricalData as ah, useTokensData as ai, useEstimateSendTransaction as aj, useSendTransaction as ak, useSendTransactionGas as al, useAllTransactionsStatus as am, useApproval as an, useEstimate as ao, useEstimatePriceImpact as ap, useExecuteTransaction as aq, useGetRoute as ar, useGetRouteWrapper as as, useRouteWarnings as at, useSendTransactionStatus as au, useSwapTransactionStatus as av, useAvatar as aw, useHistory as ax, useUserParams as ay, useDebouncedValue as az, chainTypeToZeroAddressMap as b, adaptiveRound as b$, isXamanXAppContext as b0, getQueryHeaders as b1, getStatusCode as b2, is404Error as b3, assetsBaseUrl as b4, shareSubgraphId as b5, sortTokensBySharedSubgraphIds as b6, getSupportedChainIdsForDirection as b7, filterChains as b8, filterTokens as b9, getCosmosKey as bA, getKeysSettled as bB, getAllKeysForSupportedCosmosChains as bC, isCosmosAddressValid as bD, getCosmosSigningClient as bE, getCosmosChainInfosObject as bF, connectCosmosWallet as bG, isFallbackAddressNeeded as bH, suggestChainOrThrow as bI, normalizeError as bJ, transactionErrorCode as bK, isUserRejectionError as bL, getTransactionError as bM, handleTransactionErrorEvents as bN, isSwapRouteError as bO, isStatusError as bP, createQuoteRequestParamsHash as bQ, WidgetEvents as bR, EvmNetworkNotSupportedErrorCode as bS, addEthereumChain as bT, parseEvmAddress as bU, formatEvmWallet as bV, filterWagmiConnector as bW, waitForReceiptWithRetry as bX, getUserCountry as bY, getCountryData as bZ, getCurrencyData as b_, getTokenImage as ba, getNewSwapParamsFromInput as bb, sortAllTokens as bc, findToken as bd, findNativeToken as be, normalizeIbcAddress as bf, groupTokensBySymbol as bg, groupTokensByChainId as bh, filterViewableTokens as bi, getSecretNetworkBalances as bj, getTokenAssetsKey as bk, fetchAssetsColors as bl, initializeSquidWithAssetsColors as bm, isEmptyObject as bn, normalizeTokenSymbol as bo, areTokenSymbolsCompatible as bp, isEvmosChain as bq, getConfigWithDefaults as br, randomIntFromInterval as bs, getTokensForChain as bt, getFirstAvailableChainId as bu, fetchHighestBalanceToken as bv, getInitialOrDefaultTokenAddressForChain as bw, getInitialTokenAddressForChain as bx, filterTokensForDestination as by, getInitialChainIdFromConfig as bz, chainTypeToNativeTokenAddressMap as c, isEvmChainNotSupportedError as c$, getSuggestedAmountsForCurrency as c0, HederaExtensionHelper as c1, convertHederaAccountIdToEvmAddress as c2, convertEvmAddressToHederaAccountId as c3, scaleHbarToWei as c4, scaleWeiToHbar as c5, parseToBigInt as c6, roundNumericValue as c7, formatUnitsRounded as c8, formatTokenAmount as c9, isChainflipBridgeTransaction as cA, isOnChainTxData as cB, getHistoryTransactionId as cC, getStepStatuses as cD, getHalfSuccessState as cE, getStepsInfos as cF, getSwapTxStatusRefetchInterval as cG, getSendTxStatusRefetchInterval as cH, chainflipMultihopBridgeType as cI, getBridgeType as cJ, getTransactionStatus as cK, getTransactionEndStatus as cL, isHistoryTransactionPending as cM, isHistoryTransactionFailed as cN, isHistoryTransactionWarning as cO, isHistoryTransactionEnded as cP, formatHash as cQ, isWalletAddressValid as cR, redirectToExtensionsStore as cS, accessProperty as cT, populateWallets as cU, getDefaultChain as cV, sortWallets as cW, areSameAddress as cX, sortAddressBook as cY, calculateTotalUsdBalanceUSD as cZ, addTokenToWallet as c_, formatUsdAmount as ca, trimExtraDecimals as cb, getNumericValue as cc, cleanAmount as cd, convertTokenAmountToUSD as ce, convertUSDToTokenAmount as cf, calculateTotal24hChange as cg, getRouteExpiry as ch, searchTokens as ci, filterSolanaWallets as cj, isSolanaAddressValid as ck, executeSolanaSwap as cl, executeSolanaTransfer as cm, formatTransactionHistoryDate as cn, getAxelarExplorerTxUrl as co, getSourceExplorerTxUrl as cp, getMainExplorerUrl as cq, formatDistance as cr, formatSeconds as cs, formatSwapTxStatusResponseForStorage as ct, simplifyRouteAction as cu, fetchSwapTransactionStatus as cv, compareTransactionIds as cw, isCoralBridgeAction as cx, sleep as cy, isDepositRoute as cz, definedInWindow as d, getWalletSupportedChainTypes as d0, getConnectorForChainType as d1, walletSupportsChainType as d2, connectWallet as d3, cancelConnectWallet as d4, isProblematicConnector as d5, mergeWallets as d6, isXionSmartContractAddress as d7, isXrplAddressValid as d8, buildXrplTrustSetTx as d9, getXrplNetwork as da, parseXrplPaymentTx as db, er as e, formatBNToReadable as f, DEFAULT_ROUTE_REFETCH_INTERVAL as g, destinationAddressResetValue as h, fallbackAddressResetValue as i, nativeCosmosTokenAddress as j, nativeEvmTokenAddress as k, nativeSolanaTokenAddress as l, nativeStellarTokenAddress as m, nativeBitcoinTokenAddress as n, nativeSuiTokenAddress as o, nativeXrplTokenAddress as p, CosmosProvider as q, SendTransactionStatus as r, TransactionStatus as s, useTrackSearchEmpty as t, useCosmosContext as u, useSquidChains as v, walletIconBaseUrl as w, useClient as x, useCosmosForChain as y, useHederaTokenAssociations as z };
+//# sourceMappingURL=index-BGVXRZI6.js.map