@0xsquid/react-hooks 8.4.1-beta-interactive-to-amount.0 → 8.4.1-beta-tempo.0

package/dist/{index-Bg7CS2Uo.js → index-CaI-xWCW.js}

@@ -27,9 +27,9 @@ var wagmi = require('wagmi');
 var SafeAppsSDK = require('@safe-global/safe-apps-sdk');
 var core$1 = require('@wallet-standard/core');
 var slushWallet = require('@mysten/slush-wallet');
-var connectors = require('wagmi/connectors');
 var stargate = require('@cosmjs/stargate');
 var client = require('@mysten/sui/client');
+var connectors = require('wagmi/connectors');
 var protoSigning = require('@cosmjs/proto-signing');
 var transactions = require('@mysten/sui/transactions');
 var cosmwasmStargate = require('@cosmjs/cosmwasm-stargate');
@@ -145,6 +145,9 @@ const CHAIN_IDS = {
     SONEIUM: "1868",
     PEAQ: "3338",
     HEDERA: "295",
+    MANTRA: "5888",
+    CITREA: "4114",
+    TEMPO: "4217",
     // others
     BITCOIN: "bitcoin",
     SOLANA: "solana-mainnet-beta",
@@ -22306,17 +22309,15 @@ const keys = () => ({
     // ============
     // Transactions
     // ============
-    transaction: (fromChainId, toChainId, toTokenAddress, fromTokenAddress, fromAmount, toAmount, slippage, getGasOnDestination, sourceUserAddress, degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChainType, preHook, postHook, overrideGasRefundAddress) => [
+    transaction: (fromChainId, toChainId, toTokenAddress, fromTokenAddress, price, slippage, sourceUserAddress, degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChainType, preHook, postHook, overrideGasRefundAddress) => [
         ...keys().transactions(),
         exports.QueryKeys.Transaction,
         fromChainId,
         toChainId,
         toTokenAddress,
         fromTokenAddress,
-        fromAmount,
-        toAmount,
+        price,
         slippage,
-        getGasOnDestination,
         sourceUserAddress,
         degenMode,
         destinationAddress,
@@ -22477,7 +22478,6 @@ 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),
@@ -22967,8 +22967,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;
@@ -23179,7 +23179,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-BXleHutG.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-Cld4gYfG.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -24870,7 +24870,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() ===
@@ -25036,7 +25036,10 @@ const useConfigStore = zustand.create(() => ({
     isInitialized: false,
 }));
 const useTransactionStore = zustand.create((set, get) => ({
+    fromPrice: undefined,
+    txLocalId: undefined,
     transactions: {},
+    currentTransaction: undefined,
     setTransactionState(txId, tx) {
         if (!txId)
             return;
@@ -26492,7 +26495,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 Promise.resolve().then(function () { return require('./stellarService.client-li6iEHAu.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-COeQeah_.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27391,8 +27394,7 @@ const useMultiChainWallet = (chain) => {
 
 const useSwap = () => {
     const { initialAssets, defaultTokensPerChain, disabledChains, availableChains, } = useConfigStore((state) => state.config);
-    const fromAmount = useTransactionStore((state) => state.fromAmount);
-    const toAmount = useTransactionStore((state) => state.toAmount);
+    const fromPrice = useTransactionStore((state) => state.fromPrice);
     const { swapRoute } = useSwapRoutePersistStore();
     const { tokens } = useSquidTokens();
     const queryClient = reactQuery.useQueryClient();
@@ -27450,17 +27452,8 @@ const useSwap = () => {
             }),
         };
     }, [destAddressData, destAddressEnsData.data, toChain?.chainType]);
-    const fromAmountChanged = React.useCallback((amount) => {
-        useTransactionStore.setState({
-            fromAmount: amount || undefined,
-            toAmount: undefined,
-        });
-    }, []);
-    const toAmountChanged = React.useCallback((amount) => {
-        useTransactionStore.setState({
-            toAmount: amount || undefined,
-            fromAmount: undefined,
-        });
+    const fromPriceChanged = React.useCallback((price) => {
+        useTransactionStore.setState({ fromPrice: price || undefined });
     }, []);
     /**
      * When user changes something from the SwapView
@@ -27601,10 +27594,8 @@ const useSwap = () => {
         tokenItems,
         onSwapChange,
         invertSwaps,
-        fromAmount,
-        toAmount,
-        fromAmountChanged,
-        toAmountChanged,
+        fromPrice,
+        fromPriceChanged,
         toToken,
         fromToken,
         fromChain,
@@ -27811,579 +27802,309 @@ function useTrackSearchEmpty({ searchQuery, resultsLength, context, debounceMs =
     }, [context, debounceMs, resultsLength, searchQuery]);
 }
 
-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;
+class StellarRpcClient {
+    server;
+    constructor(rpcUrl) {
+        this.server = new stellarSdk.rpc.Server(rpcUrl);
     }
-    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");
+    /**
+     * 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}`);
         }
-        if (typeof data.balance.balance !== "number") {
-            throw new Error("Invalid balance type, expected number");
+        const txBuilder = new stellarSdk.TransactionBuilder(account, {
+            fee: (BigInt(stellarSdk.BASE_FEE) * BigInt(2)).toString(),
+            networkPassphrase: network,
+        });
+        const contract = new stellarSdk.Contract(tokenAddress);
+        const tx = txBuilder
+            .addOperation(contract.call("balance", new stellarSdk.Address(userAddress).toScVal()))
+            .setTimeout(stellarSdk.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 (!Array.isArray(data.balance.tokens)) {
-            throw new Error("Invalid tokens type, expected array");
+        if ("result" in simulateTxResponse && simulateTxResponse.result != null) {
+            const native = stellarSdk.scValToNative(simulateTxResponse.result.retval);
+            return native.toString();
         }
-        return data;
+        throw new Error("Failed to fetch balance");
     }
-    async getAccountTokens(address) {
-        const data = await this.fetch(`accounts/${address}/tokens`);
-        if (!Array.isArray(data.tokens)) {
-            throw new Error("Invalid tokens type, expected array");
+    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 === stellarSdk.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 === stellarSdk.rpc.Api.GetTransactionStatus.SUCCESS) {
+                return result.status;
+            }
+            throw new Error(`Transaction failed with status: ${result.status}`);
         }
-        const firstToken = data.tokens[0];
-        if (typeof firstToken?.automatic_association !== "boolean") {
-            throw new Error("Invalid automatic_association type, expected boolean");
+    }
+    async isAccountActivated(address) {
+        try {
+            await this.getAccount(address);
+            return true;
         }
-        if (typeof firstToken?.token_id !== "string") {
-            throw new Error("Invalid token_id type, expected string");
+        catch (error) {
+            if (error?.message && error.message.includes("Account not found")) {
+                return false;
+            }
+            throw error;
         }
-        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}`);
+    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 response.json();
+        return transactionResponse;
+    }
+    async prepareTransaction(transaction) {
+        return this.server.prepareTransaction(transaction);
     }
 }
 
-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);
+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 };
             }
-        },
-        async connect(params = {}) {
+            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 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) => viem.getAddress(x));
-                const currentChainId = await this.getChainId();
-                if (displayUri) {
-                    provider.removeListener("display_uri", displayUri);
-                    displayUri = undefined;
-                }
-                if (connect) {
-                    provider.removeListener("connect", connect);
-                    connect = undefined;
+                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;
                 }
-                if (!disconnect) {
-                    disconnect = this.onDisconnect.bind(this);
-                    provider.on("disconnect", disconnect);
+                const status = response.meta?.TransactionResult;
+                if (status === XrplTxStatus.SUCCESS) {
+                    return status;
                 }
-                if (!sessionDelete) {
-                    sessionDelete = this.onSessionDelete.bind(this);
-                    provider.on("session_delete", sessionDelete);
+                else {
+                    throw new Error(`Transaction failed with status: ${status}`);
                 }
-                return { accounts, chainId: currentChainId };
             }
             catch (error) {
-                if (/(user rejected|connection request reset)/i.test(error?.message)) {
-                    throw new viem.UserRejectedRequestError(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 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) => viem.getAddress(x));
-        },
-        async getProvider() {
-            async function initProvider() {
-                const optionalChains = config.chains.map((x) => x.id);
-                if (!optionalChains.length)
-                    return;
-                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-BQGUcysL.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) => viem.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 === squidTypes.ChainType.EVM);
-    if (filteredEvmChains.length === 0) {
-        throw new Error("At least one chain is required");
+        }
     }
-    const wagmiChains = filteredEvmChains.map((chain) => {
-        return viem.defineChain({
-            id: Number(chain.chainId),
-            name: chain.networkName,
-            nativeCurrency: {
-                name: chain.nativeCurrency.name,
-                symbol: chain.nativeCurrency.symbol,
-                decimals: chain.nativeCurrency.decimals,
-            },
-            rpcUrls: {
-                public: {
-                    http: [chain.rpc],
-                },
-                default: {
-                    http: [chain.rpc],
-                },
+    async getServerState() {
+        return this.call("server_state", [{}]);
+    }
+    async getAccountInfo(address) {
+        return this.call("account_info", [
+            {
+                account: address,
+                ledger_index: "validated",
             },
-        });
-    });
-    const wcMetadata = {
-        url: SQUID_METADATA.url,
-        name: SQUID_METADATA.name,
-        icons: [SQUID_METADATA.icon],
-        description: SQUID_METADATA.description,
-    };
-    return wagmi.createConfig({
-        chains: wagmiChains,
-        transports: Object.fromEntries(wagmiChains.map((chain) => [
-            chain.id,
-            wagmi.http(chain.rpcUrls.public.http[0] ?? ""),
-        ])),
-        connectors: [
-            connectors.injected(),
-            connectors.safe({
-                allowedDomains: [/app.safe.global$/],
-            }),
-            connectors.metaMask({
-                dappMetadata: {
-                    name: SQUID_METADATA.name,
-                    url: SQUID_METADATA.url,
-                    iconUrl: SQUID_METADATA.icon,
-                },
-            }),
-            connectors.coinbaseWallet({
-                appName: SQUID_METADATA.name,
-                appLogoUrl: SQUID_METADATA.icon,
-            }),
-            connectors.walletConnect({
-                projectId: WALLETCONNECT_PROJECT_ID,
-                metadata: 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 ethers.BrowserProvider(transport, network);
-    const signer = new ethers.JsonRpcSigner(provider, account.address);
-    return signer;
-}
-
-function useEvmSigner({ chainId }) {
-    const { connector } = wagmi.useAccount();
-    const { data: client } = wagmi.useWalletClient({ chainId, connector });
-    const signer = React.useMemo(() => (client ? clientToSigner(client) : undefined), [client]);
-    return { signer };
-}
-const useSigner = ({ chain }) => {
-    const evmChainId = chain?.chainType === squidTypes.ChainType.EVM ? Number(chain.chainId) : undefined;
-    // EVM and Cosmos need a different signer for each chain
-    // This is not the case for Solana or Bitcoin as there's only one chain in those ecosystems
-    const { signer: evmSigner } = useEvmSigner({ chainId: evmChainId });
-    const { signer: cosmosSigner } = useCosmosSigner({ chain });
-    const { signer: solanaSigner } = useSolanaContext();
-    const { signer: bitcoinSigner } = useBitcoinContext();
-    const { signer: suiSigner } = useSuiContext();
-    const { signer: xrplSigner } = useXrplContext();
-    const { signer: stellarSigner } = useStellarContext();
-    const isEvmSignerReady = !!evmSigner;
-    const isSolanaSignerReady = !!solanaSigner;
-    const isCosmosSignerReady = !!cosmosSigner;
-    const isBitcoinSignerReady = !!bitcoinSigner;
-    const isSuiSignerReady = !!suiSigner;
-    const isXrplSignerReady = !!xrplSigner;
-    const isStellarSignerReady = !!stellarSigner;
-    const isSignerReady = React.useMemo(() => {
-        if (!chain?.chainType)
-            return false;
-        switch (chain.chainType) {
-            case squidTypes.ChainType.EVM:
-                return isEvmSignerReady;
-            case squidTypes.ChainType.COSMOS:
-                return isCosmosSignerReady;
-            case squidTypes.ChainType.BTC:
-                return isBitcoinSignerReady;
-            case squidTypes.ChainType.SOLANA:
-                return isSolanaSignerReady;
-            case squidTypes.ChainType.SUI:
-                return isSuiSignerReady;
-            case squidTypes.ChainType.XRPL:
-                return isXrplSignerReady;
-            case squidTypes.ChainType.STELLAR:
-                return isStellarSignerReady;
-        }
-    }, [
-        chain?.chainType,
-        isEvmSignerReady,
-        isCosmosSignerReady,
-        isBitcoinSignerReady,
-        isSolanaSignerReady,
-        isSuiSignerReady,
-        isXrplSignerReady,
-        isStellarSignerReady,
-    ]);
-    return {
-        isSignerReady,
-        evmSigner,
-        cosmosSigner,
-        bitcoinSigner,
-        solanaSigner,
-        suiSigner,
-        xrplSigner,
-        stellarSigner,
-    };
-};
-
-function useHederaTokenAssociations({ address, chain, token }) {
-    const publicClient = wagmi.usePublicClient({
-        chainId: Number(CHAIN_IDS.HEDERA),
-    });
-    const { evmSigner } = useSigner({ chain });
-    const queryClient = reactQuery.useQueryClient();
     /**
-     * Creates a token association transaction where the destination account authorizes to receive the given token
+     * Returns the balance of the user in the native XRP token
+     * formatted as a string
      */
-    const associateToken = reactQuery.useMutation({
-        mutationFn: async () => {
-            try {
-                if (!evmSigner) {
-                    throw new Error("EVM signer not found");
-                }
-                if (chain?.chainId !== CHAIN_IDS.HEDERA ||
-                    token?.chainId !== CHAIN_IDS.HEDERA) {
-                    throw new Error("Chain and token to associate must be on Hedera");
-                }
-                const tokenAddress = parseEvmAddress(token.address);
-                if (!tokenAddress) {
-                    throw new Error("Invalid token address");
-                }
-                const userAddress = parseEvmAddress(address);
-                if (!userAddress) {
-                    throw new Error("Invalid user address");
-                }
-                const encodedData = viem.encodeFunctionData({
-                    abi: 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(exports.QueryKeys.IsHederaTokenAssociated),
-            });
-        },
-    });
+    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);
+    }
     /**
-     * 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
+     * Returns the balance of the user in the given issued currency (e.g. RLUSD)
+     * formatted as a string
      */
-    const isTokenAssociated = reactQuery.useQuery({
-        queryKey: keys().isHederaTokenAssociated(address, token?.chainId, token?.type, token?.address),
-        queryFn: async () => {
-            if (token?.chainId !== CHAIN_IDS.HEDERA) {
-                return true;
-            }
-            // The native HBAR token doesn't need an association
-            if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase()) {
-                return true;
-            }
-            if (!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 = React.useCallback((event) => {
-        if (event.key === "Escape") {
-            onEscape?.();
-            return;
+    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})`);
         }
-    }, [onEscape]);
-    React.useEffect(() => {
-        document.addEventListener("keydown", onKeyDown, false);
-        return () => {
-            document.removeEventListener("keydown", onKeyDown, false);
-        };
-    }, [onKeyDown]);
-};
+        if ("error" in data.result) {
+            throw new Error(`Error from RPC (${method}): ${data.result.error}`);
+        }
+        return data.result;
+    }
+}
 
-const useSquidQueryClient = () => {
-    const queryClient = reactQuery.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,
-    };
-};
+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 squidTypes.ChainType.EVM:
+            return new ethers.JsonRpcProvider(chain.rpc);
+        case squidTypes.ChainType.COSMOS:
+            const rpcUrl = await getWorkingCosmosRpcUrl(chain);
+            return (await stargate.StargateClient.connect(rpcUrl));
+        case squidTypes.ChainType.SOLANA:
+            return new web3_js.Connection(SOLANA_RPC_URL);
+        case squidTypes.ChainType.BTC:
+            return null;
+        case squidTypes.ChainType.SUI:
+            return new client.SuiClient({
+                url: chain.rpc,
+            });
+        case squidTypes.ChainType.XRPL:
+            return new XrplRpcClient(chain.rpc);
+        case squidTypes.ChainType.STELLAR:
+            return new StellarRpcClient(chain.rpc);
+    }
+}
 
 /**
  * The default multicall3 address
@@ -29399,372 +29120,6 @@ function timeout(ms, promise) {
     return Promise.race([promise, timeoutPromise]);
 }
 
-class StellarRpcClient {
-    server;
-    constructor(rpcUrl) {
-        this.server = new stellarSdk.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 stellarSdk.TransactionBuilder(account, {
-            fee: (BigInt(stellarSdk.BASE_FEE) * BigInt(2)).toString(),
-            networkPassphrase: network,
-        });
-        const contract = new stellarSdk.Contract(tokenAddress);
-        const tx = txBuilder
-            .addOperation(contract.call("balance", new stellarSdk.Address(userAddress).toScVal()))
-            .setTimeout(stellarSdk.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 = stellarSdk.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 === stellarSdk.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 === stellarSdk.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 squidTypes.ChainType.EVM:
-            return new ethers.JsonRpcProvider(chain.rpc);
-        case squidTypes.ChainType.COSMOS:
-            const rpcUrl = await getWorkingCosmosRpcUrl(chain);
-            return (await stargate.StargateClient.connect(rpcUrl));
-        case squidTypes.ChainType.SOLANA:
-            return new web3_js.Connection(SOLANA_RPC_URL);
-        case squidTypes.ChainType.BTC:
-            return null;
-        case squidTypes.ChainType.SUI:
-            return new client.SuiClient({
-                url: chain.rpc,
-            });
-        case squidTypes.ChainType.XRPL:
-            return new XrplRpcClient(chain.rpc);
-        case squidTypes.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 = reactQuery.useQuery({
-        queryKey: keys().stellarAccountActivatedInfo(address, chain?.chainId, chain?.chainType),
-        queryFn: async () => {
-            if (chain?.chainType !== squidTypes.ChainType.STELLAR ||
-                token?.type !== squidTypes.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 === squidTypes.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();
@@ -29959,6 +29314,8 @@ function useNativeTokenForChain(chain) {
         }
     };
     const nativeTokenForChainType = React.useMemo(() => {
+        if (!chain)
+            return undefined;
         return findNativeToken(getTokensForChainType(), chain);
     }, [chain]);
     return { nativeToken: nativeTokenForChainType };
@@ -30116,136 +29473,772 @@ const useStellarNativeBalance = ({ address, chain, }) => {
         userAddress: address,
         enabled: chain?.chainType === squidTypes.ChainType.STELLAR,
     });
-    const balance = React.useMemo(() => {
-        if (nativeToken?.decimals && rawBalance) {
-            return {
-                decimals: nativeToken.decimals,
-                value: parseToBigInt(rawBalance, nativeToken.decimals),
-            };
-        }
-    }, [nativeToken?.decimals, rawBalance]);
-    return {
-        balance,
-        isLoading,
+    const balance = React.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[squidTypes.ChainType.EVM], chain });
+    const { balance: nativeBitcoinBalance, isLoading: isBitcoinLoading } = useBitcoinNativeBalance({
+        address: connectedAddresses[squidTypes.ChainType.BTC],
+        chain,
+    });
+    const { balance: nativeSolanaBalance, isLoading: isSolanaLoading } = useSolanaNativeBalance({
+        address: connectedAddresses[squidTypes.ChainType.SOLANA],
+        chain,
+    });
+    const { balance: nativeSuiBalance, isLoading: isSuiLoading } = useSuiNativeBalance({
+        address: connectedAddresses[squidTypes.ChainType.SUI],
+        chain,
+    });
+    const { balance: nativeXrplBalance, isLoading: isXrpLoading } = useXrplNativeBalance({
+        address: connectedAddresses[squidTypes.ChainType.XRPL],
+        chain,
+    });
+    const { balance: nativeStellarBalance, isLoading: isStellarLoading } = useStellarNativeBalance({
+        address: connectedAddresses[squidTypes.ChainType.STELLAR],
+        chain,
+    });
+    const { nativeBalance, nativeBalanceFormatted } = React.useMemo(() => {
+        let balance;
+        switch (chain?.chainType) {
+            case squidTypes.ChainType.EVM:
+                balance = nativeEvmBalance;
+                break;
+            case squidTypes.ChainType.COSMOS:
+                balance = nativeCosmosBalance;
+                break;
+            case squidTypes.ChainType.BTC:
+                balance = nativeBitcoinBalance;
+                break;
+            case squidTypes.ChainType.SOLANA:
+                balance = nativeSolanaBalance;
+                break;
+            case squidTypes.ChainType.SUI:
+                balance = nativeSuiBalance;
+                break;
+            case squidTypes.ChainType.XRPL:
+                balance = nativeXrplBalance;
+                break;
+            case squidTypes.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 = React.useMemo(() => {
+        if (!chain?.chainType)
+            return false;
+        switch (chain.chainType) {
+            case squidTypes.ChainType.EVM:
+                return isEvmLoading;
+            case squidTypes.ChainType.COSMOS:
+                return isCosmosLoading;
+            case squidTypes.ChainType.BTC:
+                return isBitcoinLoading;
+            case squidTypes.ChainType.SOLANA:
+                return isSolanaLoading;
+            case squidTypes.ChainType.SUI:
+                return isSuiLoading;
+            case squidTypes.ChainType.XRPL:
+                return isXrpLoading;
+            case squidTypes.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 = React.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) => viem.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 viem.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) => viem.getAddress(x));
+        },
+        async getProvider() {
+            async function initProvider() {
+                const optionalChains = config.chains.map((x) => x.id);
+                if (!optionalChains.length)
+                    return;
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-DAfqL2H0.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) => viem.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 === squidTypes.ChainType.EVM);
+    if (filteredEvmChains.length === 0) {
+        throw new Error("At least one chain is required");
+    }
+    const wagmiChains = filteredEvmChains.map((chain) => {
+        return viem.defineChain({
+            id: Number(chain.chainId),
+            name: chain.networkName,
+            nativeCurrency: {
+                name: chain.nativeCurrency.name,
+                symbol: chain.nativeCurrency.symbol,
+                decimals: chain.nativeCurrency.decimals,
+            },
+            rpcUrls: {
+                public: {
+                    http: [chain.rpc],
+                },
+                default: {
+                    http: [chain.rpc],
+                },
+            },
+        });
+    });
+    const wcMetadata = {
+        url: SQUID_METADATA.url,
+        name: SQUID_METADATA.name,
+        icons: [SQUID_METADATA.icon],
+        description: SQUID_METADATA.description,
     };
-};
-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[squidTypes.ChainType.EVM], chain });
-    const { balance: nativeBitcoinBalance, isLoading: isBitcoinLoading } = useBitcoinNativeBalance({
-        address: connectedAddresses[squidTypes.ChainType.BTC],
-        chain,
-    });
-    const { balance: nativeSolanaBalance, isLoading: isSolanaLoading } = useSolanaNativeBalance({
-        address: connectedAddresses[squidTypes.ChainType.SOLANA],
-        chain,
-    });
-    const { balance: nativeSuiBalance, isLoading: isSuiLoading } = useSuiNativeBalance({
-        address: connectedAddresses[squidTypes.ChainType.SUI],
-        chain,
-    });
-    const { balance: nativeXrplBalance, isLoading: isXrpLoading } = useXrplNativeBalance({
-        address: connectedAddresses[squidTypes.ChainType.XRPL],
-        chain,
-    });
-    const { balance: nativeStellarBalance, isLoading: isStellarLoading } = useStellarNativeBalance({
-        address: connectedAddresses[squidTypes.ChainType.STELLAR],
-        chain,
+    return wagmi.createConfig({
+        chains: wagmiChains,
+        transports: Object.fromEntries(wagmiChains.map((chain) => [
+            chain.id,
+            wagmi.http(chain.rpcUrls.public.http[0] ?? ""),
+        ])),
+        connectors: [
+            connectors.injected(),
+            connectors.safe({
+                allowedDomains: [/app.safe.global$/],
+            }),
+            connectors.metaMask({
+                dappMetadata: {
+                    name: SQUID_METADATA.name,
+                    url: SQUID_METADATA.url,
+                    iconUrl: SQUID_METADATA.icon,
+                },
+            }),
+            connectors.coinbaseWallet({
+                appName: SQUID_METADATA.name,
+                appLogoUrl: SQUID_METADATA.icon,
+            }),
+            connectors.walletConnect({
+                projectId: WALLETCONNECT_PROJECT_ID,
+                metadata: wcMetadata,
+            }),
+            ...hederaExtensions.map((extension) => hederaWalletConnect({
+                projectId: WALLETCONNECT_PROJECT_ID,
+                metadata: wcMetadata,
+                extension,
+            })),
+        ],
     });
-    const { nativeBalance, nativeBalanceFormatted } = React.useMemo(() => {
-        let balance;
-        switch (chain?.chainType) {
-            case squidTypes.ChainType.EVM:
-                balance = nativeEvmBalance;
-                break;
-            case squidTypes.ChainType.COSMOS:
-                balance = nativeCosmosBalance;
-                break;
-            case squidTypes.ChainType.BTC:
-                balance = nativeBitcoinBalance;
-                break;
-            case squidTypes.ChainType.SOLANA:
-                balance = nativeSolanaBalance;
-                break;
-            case squidTypes.ChainType.SUI:
-                balance = nativeSuiBalance;
-                break;
-            case squidTypes.ChainType.XRPL:
-                balance = nativeXrplBalance;
-                break;
-            case squidTypes.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 = React.useMemo(() => {
+};
+// Taken from wagmi docs
+// https://wagmi.sh/react/guides/ethers
+function clientToSigner(client) {
+    const { account, chain, transport } = client;
+    if (!account || !chain || !transport) {
+        return undefined;
+    }
+    const network = {
+        chainId: chain.id,
+        name: chain.name,
+        ensAddress: chain.contracts?.ensRegistry?.address,
+    };
+    const provider = new ethers.BrowserProvider(transport, network);
+    const signer = new ethers.JsonRpcSigner(provider, account.address);
+    return signer;
+}
+
+function useEvmSigner({ chainId }) {
+    const { connector } = wagmi.useAccount();
+    const { data: client } = wagmi.useWalletClient({ chainId, connector });
+    const signer = React.useMemo(() => (client ? clientToSigner(client) : undefined), [client]);
+    return { signer };
+}
+const useSigner = ({ chain }) => {
+    const evmChainId = chain?.chainType === squidTypes.ChainType.EVM ? Number(chain.chainId) : undefined;
+    // EVM and Cosmos need a different signer for each chain
+    // This is not the case for Solana or Bitcoin as there's only one chain in those ecosystems
+    const { signer: evmSigner } = useEvmSigner({ chainId: evmChainId });
+    const { signer: cosmosSigner } = useCosmosSigner({ chain });
+    const { signer: solanaSigner } = useSolanaContext();
+    const { signer: bitcoinSigner } = useBitcoinContext();
+    const { signer: suiSigner } = useSuiContext();
+    const { signer: xrplSigner } = useXrplContext();
+    const { signer: stellarSigner } = useStellarContext();
+    const isEvmSignerReady = !!evmSigner;
+    const isSolanaSignerReady = !!solanaSigner;
+    const isCosmosSignerReady = !!cosmosSigner;
+    const isBitcoinSignerReady = !!bitcoinSigner;
+    const isSuiSignerReady = !!suiSigner;
+    const isXrplSignerReady = !!xrplSigner;
+    const isStellarSignerReady = !!stellarSigner;
+    const isSignerReady = React.useMemo(() => {
         if (!chain?.chainType)
             return false;
         switch (chain.chainType) {
             case squidTypes.ChainType.EVM:
-                return isEvmLoading;
+                return isEvmSignerReady;
             case squidTypes.ChainType.COSMOS:
-                return isCosmosLoading;
+                return isCosmosSignerReady;
             case squidTypes.ChainType.BTC:
-                return isBitcoinLoading;
+                return isBitcoinSignerReady;
             case squidTypes.ChainType.SOLANA:
-                return isSolanaLoading;
+                return isSolanaSignerReady;
             case squidTypes.ChainType.SUI:
-                return isSuiLoading;
+                return isSuiSignerReady;
             case squidTypes.ChainType.XRPL:
-                return isXrpLoading;
+                return isXrplSignerReady;
             case squidTypes.ChainType.STELLAR:
-                return isStellarLoading;
+                return isStellarSignerReady;
         }
     }, [
         chain?.chainType,
-        isEvmLoading,
-        isCosmosLoading,
-        isBitcoinLoading,
-        isSolanaLoading,
-        isSuiLoading,
-        isXrpLoading,
-        isStellarLoading,
+        isEvmSignerReady,
+        isCosmosSignerReady,
+        isBitcoinSignerReady,
+        isSolanaSignerReady,
+        isSuiSignerReady,
+        isXrplSignerReady,
+        isStellarSignerReady,
     ]);
-    return { nativeBalance, nativeBalanceFormatted, isLoading };
+    return {
+        isSignerReady,
+        evmSigner,
+        cosmosSigner,
+        bitcoinSigner,
+        solanaSigner,
+        suiSigner,
+        xrplSigner,
+        stellarSigner,
+    };
 };
 
-function useHederaAccountActivation({ address, chain, token }) {
-    const { balance: destNativeEvmBalance } = useEvmNativeBalance({
-        chain,
-        address,
+function useHederaTokenAssociations({ address, chain, token }) {
+    const publicClient = wagmi.usePublicClient({
+        chainId: Number(CHAIN_IDS.HEDERA),
+    });
+    const { evmSigner } = useSigner({ chain });
+    const queryClient = reactQuery.useQueryClient();
+    /**
+     * Creates a token association transaction where the destination account authorizes to receive the given token
+     */
+    const associateToken = reactQuery.useMutation({
+        mutationFn: async () => {
+            try {
+                if (!evmSigner) {
+                    throw new Error("EVM signer not found");
+                }
+                if (chain?.chainId !== CHAIN_IDS.HEDERA ||
+                    token?.chainId !== CHAIN_IDS.HEDERA) {
+                    throw new Error("Chain and token to associate must be on Hedera");
+                }
+                const tokenAddress = parseEvmAddress(token.address);
+                if (!tokenAddress) {
+                    throw new Error("Invalid token address");
+                }
+                const userAddress = parseEvmAddress(address);
+                if (!userAddress) {
+                    throw new Error("Invalid user address");
+                }
+                const encodedData = viem.encodeFunctionData({
+                    abi: 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(exports.QueryKeys.IsHederaTokenAssociated),
+            });
+        },
+    });
+    /**
+     * Checks if the destination account has associated the given token.
+     *
+     * Hedera requires accounts to associate a token before being able to receive it.
+     *
+     * Accounts which have max. associations set to -1 can receive any token without previous association
+     */
+    const isTokenAssociated = reactQuery.useQuery({
+        queryKey: keys().isHederaTokenAssociated(address, token?.chainId, token?.type, token?.address),
+        queryFn: async () => {
+            if (token?.chainId !== CHAIN_IDS.HEDERA) {
+                return true;
+            }
+            // The native HBAR token doesn't need an association
+            if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase()) {
+                return true;
+            }
+            if (!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,
     });
-    const isHederaAccountActivated = React.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,
+        isTokenAssociated,
+        associateToken,
+    };
+}
+
+const useKeyboardNavigation = ({ onEscape }) => {
+    const onKeyDown = React.useCallback((event) => {
+        if (event.key === "Escape") {
+            onEscape?.();
+            return;
+        }
+    }, [onEscape]);
+    React.useEffect(() => {
+        document.addEventListener("keydown", onKeyDown, false);
+        return () => {
+            document.removeEventListener("keydown", onKeyDown, false);
+        };
+    }, [onKeyDown]);
+};
+
+const useSquidQueryClient = () => {
+    const queryClient = reactQuery.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,
+    };
+};
+
+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 = reactQuery.useQuery({
+        queryKey: keys().stellarAccountActivatedInfo(address, chain?.chainId, chain?.chainType),
+        queryFn: async () => {
+            if (chain?.chainType !== squidTypes.ChainType.STELLAR ||
+                token?.type !== squidTypes.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 === squidTypes.ChainType.STELLAR,
+        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
+        refetchOnWindowFocus: true,
+    });
+    return {
+        accountActivatedInfo,
     };
 }
 
@@ -30773,6 +30766,161 @@ 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[squidTypes.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 } = wagmi.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
+        viem.zeroAddress.toLowerCase() !== accountGasTokenAddress.toLowerCase();
+    // Fetch balance of the account-preferred gas token (if set)
+    const { data: accountGasTokenBalance } = wagmi.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 } = wagmi.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 = React.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);
@@ -30923,24 +31071,20 @@ const calculateTotalNativeFees = ({ expressFeeCost, firstFeeCost, firstGasCost,
     (sameTokenBetweenFees
         ? BigInt(firstFeeCost?.amount ?? "0") + BigInt(firstGasCost?.amount ?? "0")
         : BigInt(firstGasCost?.amount ?? "0"));
-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;
+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;
+};
 /**
  * Calculates the estimated duration of a route
  *
@@ -30979,12 +31123,10 @@ 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, }) => {
+const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, collectFees, nativeTokenBalanceFromChainWei, tempoFeeData, }) => {
     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";
@@ -31003,10 +31145,6 @@ 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,
@@ -31014,19 +31152,32 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         sameTokenBetweenFees,
     });
     const totalFeesInNativeTokenPlusRatio = (totalNativeFees * BigInt(110)) / BigInt(100);
-    const fromBalanceEnoughToSwap = isFromBalanceEnoughToSwap({
-        isFromTokenNative,
+    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,
         fromAmount,
-        fromTokenDecimals: fromToken?.decimals,
-        totalFeesInNativeTokenPlusRatio,
-        nativeTokenBalanceFromChainWei,
+        networkFeesWei,
     });
-    const minAmountValueWarnMsg = calculateMinAmountValueWarnMsg({
-        isFromTokenNative,
-        nativeTokenBalanceFromChainWei,
-        sourceChainNativeTokenDecimals: sourceChainNativeToken?.decimals,
-        totalFeesInNativeTokenPlusRatio,
+    const minAmount = calculateMinAmountValueWarnMsg({
+        chainFeeParams,
+        // gasTokenDecimals: chainFeeParams,
+        networkFeesWei,
     });
+    const minAmountValueWarnMsg = minAmount
+        ? formatBNToReadable(minAmount, chainFeeParams?.fromTokenPaysNetworkFee
+            ? fromToken?.decimals
+            : undefined)
+        : undefined;
     const isSingleChainRoute = fromChain?.chainId === toChain?.chainId;
     const estimatedRouteDuration = formatEstimatedRouteDuration({
         estimatedRouteDuration: squidRoute?.estimate?.estimatedRouteDuration,
@@ -31036,8 +31187,6 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         fromToken,
         fromAmount,
         fromAmountFormatted,
-        sourceChainNativeToken,
-        destChainNativeToken,
         toAmountUSD,
         exchangeRate,
         toAmountMinUSD,
@@ -31052,10 +31201,10 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         expectedGasRefundCost,
         expectedGasRefundCostUSD,
         sameTokenBetweenFees,
-        isFromTokenNative,
+        fromTokenPaysNetworkFee: chainFeeParams?.fromTokenPaysNetworkFee ?? false,
         totalNativeFees,
         totalFeesInNativeTokenPlusRatio,
-        fromBalanceEnoughToSwap,
+        gasBalanceEnough,
         minAmountValueWarnMsg,
         estimatedRouteDuration,
     };
@@ -31091,28 +31240,6 @@ 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 reactQuery.useQuery({
@@ -31134,7 +31261,11 @@ 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;
-                    if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase()) {
+                    // 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) {
                         const gas = await client.estimateGas({
                             from: sender,
                             to: dummyAddress,
@@ -31154,7 +31285,14 @@ function useSendTransactionGas({ chain, token, from, }) {
                         data,
                         chainId: chain.chainId,
                     });
-                    return gas * maxFeePerGas;
+                    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;
                 }
                 case squidTypes.ChainType.COSMOS: {
                     // TODO: get gas estimation from backend
@@ -31202,18 +31340,24 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
         from,
     });
     const { nativeBalance } = useNativeBalance(chain);
-    const isNativeBalanceEnoughToPayGasFees = React.useMemo(() => {
-        if (!nativeBalance?.value || !amount || !token?.decimals) {
+    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 = React.useMemo(() => {
+        if (!amount || !token?.decimals)
             return false;
-        }
-        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]);
+        return isGasBalanceEnough({
+            fromAmount: parseToBigInt(amount, token.decimals).toString(),
+            networkFeesWei: estimatedGas,
+            chainFeeParams,
+        });
+    }, [amount, estimatedGas, token, chainFeeParams]);
     const isBalanceEnough = React.useMemo(() => {
         if (token?.decimals == null || !balance || !amount)
             return false;
@@ -31221,28 +31365,30 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
             parseToBigInt(amount, token.decimals));
     }, [amount, balance, token?.decimals]);
     const minAmountValueWarnMsg = React.useMemo(() => {
-        if (!token?.address || !nativeBalance?.value || !estimatedGas)
+        if (!token?.address || !estimatedGas)
+            return undefined;
+        if (!chainFeeParams)
             return undefined;
-        const isFromTokenNative = token.address.toLowerCase() ===
-            chainTypeToNativeTokenAddressMap[token.type].toLowerCase();
-        return calculateMinAmountValueWarnMsg({
-            isFromTokenNative,
-            nativeTokenBalanceFromChainWei: nativeBalance.value,
-            sourceChainNativeTokenDecimals: nativeBalance.decimals,
-            totalFeesInNativeTokenPlusRatio: estimatedGas,
+        const minAmount = calculateMinAmountValueWarnMsg({
+            chainFeeParams,
+            // gasTokenDecimals: chainFeeParams.fromTokenPaysNetworkFee
+            //   ? token.decimals
+            //   : undefined,
+            networkFeesWei: estimatedGas,
         });
-    }, [
-        estimatedGas,
-        nativeBalance?.decimals,
-        nativeBalance?.value,
-        token?.address,
-        token?.type,
-    ]);
+        // return minAmount > BigInt(0)
+        //   ? formatBNToReadable(minAmount, gasTokenDecimals)
+        //   : "0";
+        if (!minAmount)
+            return undefined;
+        return formatBNToReadable(minAmount, chainFeeParams.fromTokenPaysNetworkFee ? token.decimals : undefined);
+    }, [estimatedGas, token, chainFeeParams]);
     return {
         estimatedGas,
         isBalanceEnough,
+        tokenPaysNetworkFee: chainFeeParams?.fromTokenPaysNetworkFee ?? false,
         isLoading,
-        isNativeBalanceEnoughToPayGasFees,
+        isGasBalanceEnough: gasBalanceEnough,
         minAmountValueWarnMsg,
     };
 }
@@ -32128,7 +32274,7 @@ const useApproval = ({ squidRoute, }) => {
     const publicClient = wagmi.usePublicClient();
     const queryClient = reactQuery.useQueryClient();
     const squid = useSquidStore((state) => state.squid);
-    const { fromChain, fromToken, fromAmount, toAmount, isSameChain } = useSwap();
+    const { fromChain, fromToken, fromPrice, isSameChain } = useSwap();
     const { evmSigner } = useSigner({ chain: fromChain });
     const { connector: activeConnector } = wagmi.useAccount();
     const { getChainType } = useSquidChains();
@@ -32301,7 +32447,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, fromAmount, toAmount, 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, 
+                    queryKey: keys().transaction(squidRoute.params.fromChain, squidRoute.params.toChain, squidRoute.params.toToken, squidRoute.params.fromToken, fromPrice, squidRoute.params.slippage, squidRoute.params.fromAddress, squidRoute.params.bypassGuardrails, squidRoute.params.toAddress, squidRoute.params.fallbackAddresses?.[0]?.address, squidRoute.params.quoteOnly, getChainType(squidRoute.params.fromChain), squidRoute.params.preHook, squidRoute.params.postHook, 
                     // TODO: update types
                     squidRoute.params?.overrideGasRefundAddress),
                 });
@@ -32320,8 +32466,10 @@ 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 } = useSwap();
+    const { fromChain, toChain, fromPrice } = useSwap();
     const { nativeBalance } = useNativeBalance(fromChain);
+    const fromToken = React.useMemo(() => findToken(tokens, squidRoute?.params.fromChain, squidRoute?.params.fromToken), [tokens, squidRoute?.params.fromChain, squidRoute?.params.fromToken]);
+    const tempoFeeData = useTempoFeeCheck({ fromChain, fromToken });
     const estimateResults = React.useMemo(() => calculateEstimateResults({
         squidRoute,
         tokens,
@@ -32329,8 +32477,17 @@ const useEstimate = (squidRoute) => {
         toChain,
         collectFees: !!collectFees && collectFees.fee > 0,
         nativeTokenBalanceFromChainWei: nativeBalance?.value ?? BigInt("0"),
-    }), [squidRoute, tokens, fromChain, toChain, collectFees, nativeBalance]);
-    const balanceFormatted = useMultiChainBalance({
+        tempoFeeData: tempoFeeData ?? undefined,
+    }), [
+        squidRoute,
+        tokens,
+        fromChain,
+        toChain,
+        collectFees,
+        nativeBalance,
+        tempoFeeData,
+    ]);
+    const fromBalanceFormatted = useMultiChainBalance({
         chain: fromChain,
         token: estimateResults.fromToken,
         userAddress: squidRoute?.params.fromAddress ?? "",
@@ -32342,7 +32499,6 @@ const useEstimate = (squidRoute) => {
         estimateResults.expectedGasRefundCost,
         getUSDValue,
     ]);
-    const proposedGasDestinationAmount = React.useMemo(() => getProposedGasDestinationAmount(estimateResults.destChainNativeToken?.symbol), [estimateResults.destChainNativeToken]);
     const { feeCostsFormatted, totalFeeCostsUsd } = React.useMemo(() => {
         const feeCosts = squidRoute?.estimate.feeCosts ?? [];
         const feeCostsRenamed = [];
@@ -32401,19 +32557,18 @@ const useEstimate = (squidRoute) => {
             totalFeeCostsUsd: totalFeeCostsUsdFormatted,
         };
     }, [squidRoute?.estimate.feeCosts]);
-    const slippageFormatted = 
-    // TODO: update types
-    Number(squidRoute?.estimate?.aggregateSlippage ?? 0).toFixed(2) +
-        "%";
-    const enoughBalanceToSwap = +balanceFormatted >= 0 &&
-        +balanceFormatted > +estimateResults.fromAmountFormatted;
+    const slippageFormatted = Number(squidRoute?.estimate?.aggregateSlippage ?? 0).toFixed(2) + "%";
+    const fromBalanceEnoughToSwap = React.useMemo(() => {
+        const fromBalanceNum = Number(fromBalanceFormatted ?? 0);
+        const fromPriceNum = Number(fromPrice ?? 0);
+        return fromBalanceNum >= fromPriceNum;
+    }, [fromBalanceFormatted, fromPrice]);
     return {
         ...estimateResults,
-        balanceFormatted,
+        fromBalanceFormatted,
         slippageFormatted,
         totalWithRefundEstimate,
-        proposedGasDestinationAmount,
-        enoughBalanceToSwap,
+        fromBalanceEnoughToSwap,
         feeCostsFormatted,
         totalFeeCostsUsd,
     };
@@ -36114,12 +36269,8 @@ const useGetRoute = () => {
      * These data will be used to trigger the transaction
      * @returns {Route} Route data
      */
-    return reactQuery.useMutation(async ({ fromChain, toChain, fromToken, toToken, sourceUserAddress, destinationAddress, fromPrice = "", toPrice = "", bypassGuardrails, quoteOnly, fromChainType, postHook, preHook, overrideGasRefundAddress, }) => {
-        if (!fromChain ||
-            !toChain ||
-            !fromToken ||
-            !toToken ||
-            (!fromPrice && !toPrice)) {
+    return reactQuery.useMutation(async ({ fromChain, toChain, fromToken, toToken, sourceUserAddress, destinationAddress, fromPrice, bypassGuardrails, quoteOnly, fromChainType, postHook, preHook, overrideGasRefundAddress, }) => {
+        if (!fromChain || !toChain || !fromToken || !toToken || !fromPrice) {
             return undefined;
         }
         // Dispatch requestQuote event
@@ -36129,7 +36280,6 @@ const useGetRoute = () => {
             fromToken: fromToken.address,
             toToken: toToken.address,
             fromAmount: fromPrice,
-            toAmount: toPrice,
             fromAddress: sourceUserAddress,
             toAddress: destinationAddress,
         });
@@ -36138,7 +36288,6 @@ const useGetRoute = () => {
         const fromTokenAddress = fromToken.address;
         const toTokenAddress = toToken.address;
         const fromAmount = parseToBigInt(fromPrice?.toString() ?? "0", fromToken?.decimals).toString();
-        const toAmount = parseToBigInt(toPrice?.toString() ?? "0", toToken?.decimals).toString();
         const fromAddress = sourceUserAddress ??
             chainTypeToZeroAddressMap[fromChainType ?? squidTypes.ChainType.EVM];
         const params = {
@@ -36146,7 +36295,6 @@ const useGetRoute = () => {
             fromToken: fromTokenAddress,
             fromAddress,
             fromAmount,
-            toAmount,
             toChain,
             toToken: toTokenAddress,
             toAddress: destinationAddress ?? "",
@@ -36168,7 +36316,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, toPrice, config.slippage, config.enableGetGasOnDestination, 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, sourceUserAddress, config.degenMode, destinationAddress, swapRoute?.fallbackAddress, quoteOnly, fromChainType, config.preHook, config.postHook, overrideGasRefundAddress), route);
         return route;
     });
 };
@@ -36182,7 +36330,7 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     const depositRefundAddress = useSwapRoutePersistStore((store) => store.swapRoute?.depositRefundAddress);
     const { isAvailableAsPaymentMethod, isEnabled: isDepositAddressEnabled } = useDepositAddress();
     const getRouteMutation = useGetRoute();
-    const { fromChain, toChain, fromAmount, toAmount, destinationAddress: { address: destinationAddress } = {}, fromToken, toToken, } = useSwap();
+    const { fromChain, toChain, fromPrice, destinationAddress: { address: destinationAddress } = {}, fromToken, toToken, } = useSwap();
     const { connectedAddress: { address: sourceConnectedAddress }, } = useMultiChainWallet(fromChain);
     // When the payment method is deposit address, users can specify a refund address on the source chain
     // Tokens will be sent to this address in case of swap failure
@@ -36191,15 +36339,13 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     const sourceUserAddress = isDepositAddressEnabled && isAvailableAsPaymentMethod
         ? depositRefundAddress ?? sourceConnectedAddress
         : sourceConnectedAddress;
-    const squidRouteQueryKeys = React.useMemo(() => keys().transaction(fromChain?.chainId, toChain?.chainId, toToken?.address, fromToken?.address, fromAmount, toAmount, config.slippage, config.enableGetGasOnDestination, sourceUserAddress, config.degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChain?.chainType, config.preHook, config.postHook, config.overrideGasRefundAddress), [
+    const squidRouteQueryKeys = React.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), [
         fromChain?.chainId,
         toChain?.chainId,
         toToken?.address,
         fromToken?.address,
-        fromAmount,
-        toAmount,
+        fromPrice,
         config.slippage,
-        config.enableGetGasOnDestination,
         sourceUserAddress,
         config.degenMode,
         destinationAddress,
@@ -36213,8 +36359,8 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     const queryEnabled = enabled != undefined
         ? enabled
         : squid !== undefined &&
-            ((fromAmount !== undefined && fromAmount !== "0") ||
-                (toAmount !== undefined && toAmount !== "0")) &&
+            fromPrice !== undefined &&
+            fromPrice !== "0" &&
             toChain?.chainId !== undefined &&
             toToken?.address !== undefined;
     const queryClient = reactQuery.useQueryClient();
@@ -36232,8 +36378,7 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
             toToken,
             sourceUserAddress,
             destinationAddress,
-            fromPrice: fromAmount,
-            toPrice: toAmount,
+            fromPrice,
             bypassGuardrails: config.degenMode,
             quoteOnly,
             fromChainType: fromChain?.chainType,
@@ -36472,35 +36617,6 @@ const useAvatar = (seed = zeroAddress) => {
     return avatar || "";
 };
 
-const useUserParams = () => {
-    const enableGetGasOnDestination = useConfigStore((state) => state.config.enableGetGasOnDestination);
-    const { fromToken, toToken, toChain, fromChain } = useSwap();
-    //   =============
-    //       GAS
-    //   =============
-    const getGasOnDestSupportedForThisRoute = React.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 !== squidTypes.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 } = wagmi.useAccount();
     const { connector } = wagmi.useAccount();
@@ -37153,6 +37269,7 @@ exports.useSendTransactionStore = useSendTransactionStore;
 exports.useSigner = useSigner;
 exports.useSingleTokenPrice = useSingleTokenPrice;
 exports.useSolanaNativeBalance = useSolanaNativeBalance;
+exports.useSourceChainGasToken = useSourceChainGasToken;
 exports.useSquid = useSquid;
 exports.useSquidChains = useSquidChains;
 exports.useSquidQueryClient = useSquidQueryClient;
@@ -37168,7 +37285,6 @@ exports.useSwapTransactionStatus = useSwapTransactionStatus;
 exports.useTokensData = useTokensData;
 exports.useTrackSearchEmpty = useTrackSearchEmpty;
 exports.useTransactionStore = useTransactionStore;
-exports.useUserParams = useUserParams;
 exports.useWallet = useWallet;
 exports.useWalletStore = useWalletStore;
 exports.useWallets = useWallets;
@@ -37177,4 +37293,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-Bg7CS2Uo.js.map
+//# sourceMappingURL=index-CaI-xWCW.js.map