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

package/dist/{index-CaI-xWCW.js → index-5cyMUZhY.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,9 +145,6 @@ const CHAIN_IDS = {
     SONEIUM: "1868",
     PEAQ: "3338",
     HEDERA: "295",
-    MANTRA: "5888",
-    CITREA: "4114",
-    TEMPO: "4217",
     // others
     BITCOIN: "bitcoin",
     SOLANA: "solana-mainnet-beta",
@@ -21140,17 +21137,9 @@ function isOnChainTxData(squidData) {
     return [
         squidTypes.SquidDataType.OnChainExecution,
         squidTypes.SquidDataType.DepositAddressWithSignature,
+        squidTypes.SquidDataType.OnChainExecutionWithSignature,
     ].includes(squidData.type);
 }
-/**
- * Checks if a route is of type deposit-with-signature
- *
- * deposit-with-signature routes are on-chain routes
- * that require a signature from the user to execute
- */
-function isDepositWithSignatureTxData(squidData) {
-    return squidData.type === squidTypes.SquidDataType.DepositAddressWithSignature;
-}
 function getHistoryTransactionId(tx) {
     switch (tx.txType) {
         case exports.HistoryTxType.SWAP:
@@ -22309,7 +22298,7 @@ const keys = () => ({
     // ============
     // Transactions
     // ============
-    transaction: (fromChainId, toChainId, toTokenAddress, fromTokenAddress, price, slippage, sourceUserAddress, degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChainType, preHook, postHook, overrideGasRefundAddress) => [
+    transaction: (fromChainId, toChainId, toTokenAddress, fromTokenAddress, price, slippage, getGasOnDestination, sourceUserAddress, degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChainType, preHook, postHook, overrideGasRefundAddress) => [
         ...keys().transactions(),
         exports.QueryKeys.Transaction,
         fromChainId,
@@ -22318,6 +22307,7 @@ const keys = () => ({
         fromTokenAddress,
         price,
         slippage,
+        getGasOnDestination,
         sourceUserAddress,
         degenMode,
         destinationAddress,
@@ -22478,6 +22468,7 @@ const getConfigWithDefaults = (config) => {
         integratorId: get$2(config, "integratorId", defaultConfigValues.integratorId),
         slippage: get$2(config, "slippage", defaultConfigValues.slippage),
         collectFees: get$2(config, "collectFees", defaultConfigValues.collectFees),
+        enableGetGasOnDestination: get$2(config, "enableGetGasOnDestination", defaultConfigValues.enableGetGasOnDestination),
         apiUrl: get$2(config, "apiUrl", defaultConfigValues.apiUrl),
         priceImpactWarnings: get$2(config, "priceImpactWarnings", defaultConfigValues.priceImpactWarnings),
         initialAssets: get$2(config, "initialAssets", defaultConfigValues.initialAssets),
@@ -22967,8 +22958,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 +23170,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-Cld4gYfG.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-D_d3CFdp.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -24870,7 +24861,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() ===
@@ -26495,7 +26486,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-COeQeah_.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-CIkvwxPo.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27802,310 +27793,580 @@ function useTrackSearchEmpty({ searchQuery, resultsLength, context, debounceMs =
     }, [context, debounceMs, resultsLength, searchQuery]);
 }
 
-class StellarRpcClient {
-    server;
-    constructor(rpcUrl) {
-        this.server = new stellarSdk.rpc.Server(rpcUrl);
+var hrc20 = [
+	{
+		inputs: [
+		],
+		name: "associate",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "responseCode",
+				type: "uint256"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	}
+];
+
+/**
+ * Client for interacting with the Hedera Mirrornode API.
+ *
+ * @docs https://mainnet.mirrornode.hedera.com/api/v1/docs
+ */
+class HederaApiClient {
+    apiUrl;
+    constructor(apiUrl) {
+        this.apiUrl = apiUrl;
     }
-    /**
-     * Returns the balance of a Stellar Contract Token. This is different from an Issued Token.
-     *
-     * With Contract Tokens, we need to call the .balance method on the token contract
-     * and simulate the transaction to get the balance.
-     */
-    async getBalance(userAddress, tokenAddress, chainId) {
-        const account = await this.server.getAccount(userAddress);
-        const network = getStellarNetwork(chainId);
-        if (network == null) {
-            throw new Error(`No Stellar network found for chainId ${chainId}`);
-        }
-        const txBuilder = new 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}`);
+    async isTokenAssociated({ address, token, }) {
+        const accountInfo = await this.getAccountInfo(address);
+        // Unlimited auto associations
+        if (accountInfo.max_automatic_token_associations === -1) {
+            return true;
         }
-        if ("result" in simulateTxResponse && simulateTxResponse.result != null) {
-            const native = stellarSdk.scValToNative(simulateTxResponse.result.retval);
-            return native.toString();
+        // If there's no unlimited auto-associations, we need to check if the token is already associated.
+        const { tokens: accountTokens } = await this.getAccountTokens(address);
+        const tokenId = convertEvmAddressToHederaAccountId(token.address);
+        if (accountTokens.some((t) => t.token_id === tokenId)) {
+            // Token is already associated
+            return true;
         }
-        throw new Error("Failed to fetch balance");
-    }
-    async getAllBalances(userAddress, tokens) {
-        const balancePromises = tokens.map((token) => {
-            return this.getBalance(userAddress, token.address, token.chainId);
-        });
-        const results = await Promise.allSettled(balancePromises);
-        const balances = results.map((result) => {
-            if (result.status === "fulfilled") {
-                return result.value;
-            }
-            return "0";
-        });
-        return balances.map((balance, index) => {
-            return {
-                ...tokens[index],
-                balance,
-            };
-        });
+        // Finally, if not auto-associated, check if there is an available auto-association slot
+        const autoAssociatedTokens = accountTokens.filter((t) => t.automatic_association);
+        const remainingAutoAssociations = accountInfo.max_automatic_token_associations -
+            autoAssociatedTokens.length;
+        return remainingAutoAssociations > 0;
     }
-    /**
-     * Resolves when the transaction is confirmed, or fails after a timeout.
-     */
-    async waitForTransaction(txHash, { interval = 2_000, timeout = 40_000 } = {}) {
-        const startTime = Date.now();
-        while (true) {
-            const result = await this.server.getTransaction(txHash);
-            if (result.status === 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 getAccountInfo(address) {
+        const data = await this.fetch(`accounts/${address}`);
+        if (typeof data.max_automatic_token_associations !== "number") {
+            throw new Error("Invalid max_automatic_token_associations type, expected number");
         }
-    }
-    async isAccountActivated(address) {
-        try {
-            await this.getAccount(address);
-            return true;
+        if (typeof data.balance.balance !== "number") {
+            throw new Error("Invalid balance type, expected number");
         }
-        catch (error) {
-            if (error?.message && error.message.includes("Account not found")) {
-                return false;
-            }
-            throw error;
+        if (!Array.isArray(data.balance.tokens)) {
+            throw new Error("Invalid tokens type, expected array");
         }
+        return data;
     }
-    async getAccount(address) {
-        return this.server.getAccount(address);
-    }
-    async sendTransaction(transaction) {
-        const transactionResponse = await this.server.sendTransaction(transaction);
-        if (transactionResponse.status === "ERROR") {
-            throw new Error("Error sending transaction");
+    async getAccountTokens(address) {
+        const data = await this.fetch(`accounts/${address}/tokens`);
+        if (!Array.isArray(data.tokens)) {
+            throw new Error("Invalid tokens type, expected array");
         }
-        return transactionResponse;
+        const firstToken = data.tokens[0];
+        if (typeof firstToken?.automatic_association !== "boolean") {
+            throw new Error("Invalid automatic_association type, expected boolean");
+        }
+        if (typeof firstToken?.token_id !== "string") {
+            throw new Error("Invalid token_id type, expected string");
+        }
+        return data;
     }
-    async prepareTransaction(transaction) {
-        return this.server.prepareTransaction(transaction);
+    async fetch(path) {
+        const url = new URL(path, this.apiUrl);
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Hedera API error: ${response.status}`);
+        }
+        return response.json();
     }
 }
 
-class XrplRpcClient {
-    rpcUrl;
-    constructor(rpcUrl) {
-        this.rpcUrl = rpcUrl;
-    }
-    async getBalance(address, tokenAddress) {
-        if (tokenAddress.toLowerCase() === nativeXrplTokenAddress.toLowerCase()) {
-            return this.getNativeBalance(address);
-        }
-        return this.getIssuedCurrencyBalance(address, tokenAddress);
-    }
-    async getAllBalances(address) {
-        const [nativeBalance, trustLineBalances] = await Promise.all([
-            this.getNativeBalance(address),
-            this.getTrustLines(address),
-        ]);
-        return [
-            {
-                balance: nativeBalance,
-                address: nativeXrplTokenAddress,
-            },
-            ...trustLineBalances.lines.map((line) => ({
-                balance: line.balance,
-                address: `${line.currency}.${line.account}`,
-            })),
-        ];
-    }
-    async getTrustLines(address, issuer) {
-        return this.call("account_lines", [
-            {
-                account: address,
-                ledger_index: "validated",
-                peer: issuer,
-            },
-        ]);
-    }
-    async getTrustLine(address, issuer, currency) {
-        const response = await this.getTrustLines(address, issuer);
-        const trustLine = response.lines.find((line) => line.currency === currency);
-        return trustLine ?? null;
-    }
-    async accountActivatedInfo(address) {
-        const serverState = await this.getServerState();
-        const reserveBaseBn = BigInt(serverState.state.validated_ledger.reserve_base);
-        try {
-            const accountInfo = await this.getAccountInfo(address);
-            const balanceBn = BigInt(accountInfo.account_data.Balance);
-            return {
-                isActivated: balanceBn >= reserveBaseBn,
-                reserveBaseBn,
-            };
-        }
-        catch (error) {
-            if (error.message?.includes("actNotFound")) {
-                return { isActivated: false, reserveBaseBn };
+hederaWalletConnect.type = "hederaWalletConnect";
+/**
+ * Wagmi connector to interact with the Hedera EVM network via the WalletConnect protocol.
+ *
+ * The connector removes the need for a WalletConnect modal, and instead
+ * communicates with the provided `extension` by opening the extension popup
+ * for user interaction upon request.
+ */
+function hederaWalletConnect(parameters) {
+    const { extension, ...restParameters } = parameters;
+    let provider_;
+    let providerPromise;
+    let connect;
+    let displayUri;
+    let sessionDelete;
+    let disconnect;
+    return createConnector((config) => ({
+        id: `hedera-wc-${extension.id}`,
+        name: extension.name,
+        icon: extension.icon,
+        type: hederaWalletConnect.type,
+        async setup() {
+            const provider = await this.getProvider().catch(() => null);
+            if (!provider)
+                return;
+            if (!connect) {
+                connect = this.onConnect.bind(this);
+                provider.on("connect", connect);
             }
-            throw error;
-        }
-    }
-    /**
-     * Waits for a transaction to be validated and returns its final status.
-     * Resolves to 'success' or throws an error with the failed status.
-     */
-    async waitForTransaction(txHash, { interval = 2_000, timeout = 20_000 } = {}) {
-        const startTime = Date.now();
-        while (true) {
+            if (!sessionDelete) {
+                sessionDelete = this.onSessionDelete.bind(this);
+                provider.on("session_delete", sessionDelete);
+            }
+        },
+        async connect(params = {}) {
             try {
-                const response = await this.call("tx", [
-                    {
-                        transaction: txHash,
-                        binary: false,
-                    },
-                ]);
-                if (!response.validated) {
-                    if (Date.now() - startTime > timeout) {
-                        throw new Error(`Transaction ${txHash} not validated within timeout`);
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-loop-func
-                    await new Promise((res) => setTimeout(res, interval));
-                    continue;
+                const provider = await this.getProvider();
+                if (!provider)
+                    throw new ProviderNotFoundError();
+                if (!displayUri) {
+                    displayUri = this.onDisplayUri;
+                    provider.on("display_uri", displayUri);
                 }
-                const status = response.meta?.TransactionResult;
-                if (status === XrplTxStatus.SUCCESS) {
-                    return status;
+                if (!provider.session) {
+                    await provider.connect({
+                        ...("pairingTopic" in params
+                            ? { pairingTopic: params.pairingTopic }
+                            : {}),
+                    });
                 }
-                else {
-                    throw new Error(`Transaction failed with status: ${status}`);
+                const accounts = (await provider.enable()).map((x) => 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) {
-                // txnNotFound = still pending or non-existent
-                if (error?.message?.includes("txnNotFound")) {
-                    if (Date.now() - startTime > timeout) {
-                        throw new Error(`Transaction ${txHash} not found within timeout`);
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-loop-func
-                    await new Promise((res) => setTimeout(res, interval));
-                    continue;
+                if (/(user rejected|connection request reset)/i.test(error?.message)) {
+                    throw new viem.UserRejectedRequestError(error);
                 }
                 throw error;
             }
-        }
-    }
-    async getServerState() {
-        return this.call("server_state", [{}]);
+        },
+        async disconnect() {
+            const provider = await this.getProvider();
+            try {
+                await provider?.disconnect();
+            }
+            catch (error) {
+                if (!/No matching key/i.test(error.message))
+                    throw error;
+            }
+            finally {
+                if (disconnect) {
+                    provider?.removeListener("disconnect", disconnect);
+                    disconnect = undefined;
+                }
+                if (!connect) {
+                    connect = this.onConnect.bind(this);
+                    provider?.on("connect", connect);
+                }
+                if (sessionDelete) {
+                    provider?.removeListener("session_delete", sessionDelete);
+                    sessionDelete = undefined;
+                }
+            }
+        },
+        async getAccounts() {
+            const provider = await this.getProvider();
+            return provider.accounts.map((x) => 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-CeHwkxPw.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");
     }
-    async getAccountInfo(address) {
-        return this.call("account_info", [
-            {
-                account: address,
-                ledger_index: "validated",
+    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,
             },
-        ]);
-    }
-    /**
-     * Returns the balance of the user in the native XRP token
-     * formatted as a string
-     */
-    async getNativeBalance(address) {
-        const [accountInfo, serverState] = await Promise.all([
-            this.getAccountInfo(address),
-            this.getServerState(),
-        ]);
-        const balance = BigInt(accountInfo.account_data.Balance);
-        const ownerCount = BigInt(accountInfo.account_data.OwnerCount);
-        const reserveBase = BigInt(serverState.state.validated_ledger.reserve_base);
-        const reserveIncrement = BigInt(serverState.state.validated_ledger.reserve_inc);
-        const reserveBalance = reserveBase + ownerCount * reserveIncrement;
-        const spendableBalance = balance - reserveBalance;
-        return formatBNToReadable(spendableBalance, 6);
-    }
-    /**
-     * Returns the balance of the user in the given issued currency (e.g. RLUSD)
-     * formatted as a string
-     */
-    async getIssuedCurrencyBalance(address, tokenAddress) {
-        const response = await this.getTrustLines(address);
-        const tokenBalance = response.lines.find((line) => `${line.currency}.${line.account}` === tokenAddress);
-        return tokenBalance?.balance || "0";
-    }
-    async call(method, params) {
-        const response = await fetch(this.rpcUrl, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
+            rpcUrls: {
+                public: {
+                    http: [chain.rpc],
+                },
+                default: {
+                    http: [chain.rpc],
+                },
             },
-            body: JSON.stringify({
-                jsonrpc: "2.0",
-                id: 1,
-                method,
-                params,
-            }),
         });
-        const data = await response.json();
-        if (!data.result) {
-            throw new Error(`Invalid response from RPC (${method})`);
-        }
-        if ("error" in data.result) {
-            throw new Error(`Error from RPC (${method}): ${data.result.error}`);
-        }
-        return data.result;
+    });
+    const wcMetadata = {
+        url: SQUID_METADATA.url,
+        name: SQUID_METADATA.name,
+        icons: [SQUID_METADATA.icon],
+        description: SQUID_METADATA.description,
+    };
+    return 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;
 }
 
-const clientCache = new Map();
-async function getClient(chain) {
-    const key = `${chain.chainType}:${chain.chainId}`;
-    if (clientCache.has(key)) {
-        return clientCache.get(key);
-    }
-    const client = await createClient(chain);
-    clientCache.set(key, client);
-    return client;
+function useEvmSigner({ chainId }) {
+    const { connector } = wagmi.useAccount();
+    const { data: client } = wagmi.useWalletClient({ chainId, connector });
+    const signer = React.useMemo(() => (client ? clientToSigner(client) : undefined), [client]);
+    return { signer };
 }
-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,
+const useSigner = ({ chain }) => {
+    const evmChainId = chain?.chainType === squidTypes.ChainType.EVM ? Number(chain.chainId) : undefined;
+    // EVM and Cosmos need a different signer for each chain
+    // This is not the case for Solana or Bitcoin as there's only one chain in those ecosystems
+    const { signer: evmSigner } = useEvmSigner({ chainId: evmChainId });
+    const { signer: cosmosSigner } = useCosmosSigner({ chain });
+    const { signer: solanaSigner } = useSolanaContext();
+    const { signer: bitcoinSigner } = useBitcoinContext();
+    const { signer: suiSigner } = useSuiContext();
+    const { signer: xrplSigner } = useXrplContext();
+    const { signer: stellarSigner } = useStellarContext();
+    const isEvmSignerReady = !!evmSigner;
+    const isSolanaSignerReady = !!solanaSigner;
+    const isCosmosSignerReady = !!cosmosSigner;
+    const isBitcoinSignerReady = !!bitcoinSigner;
+    const isSuiSignerReady = !!suiSigner;
+    const isXrplSignerReady = !!xrplSigner;
+    const isStellarSignerReady = !!stellarSigner;
+    const isSignerReady = React.useMemo(() => {
+        if (!chain?.chainType)
+            return false;
+        switch (chain.chainType) {
+            case squidTypes.ChainType.EVM:
+                return isEvmSignerReady;
+            case squidTypes.ChainType.COSMOS:
+                return isCosmosSignerReady;
+            case squidTypes.ChainType.BTC:
+                return isBitcoinSignerReady;
+            case squidTypes.ChainType.SOLANA:
+                return isSolanaSignerReady;
+            case squidTypes.ChainType.SUI:
+                return isSuiSignerReady;
+            case squidTypes.ChainType.XRPL:
+                return isXrplSignerReady;
+            case squidTypes.ChainType.STELLAR:
+                return isStellarSignerReady;
+        }
+    }, [
+        chain?.chainType,
+        isEvmSignerReady,
+        isCosmosSignerReady,
+        isBitcoinSignerReady,
+        isSolanaSignerReady,
+        isSuiSignerReady,
+        isXrplSignerReady,
+        isStellarSignerReady,
+    ]);
+    return {
+        isSignerReady,
+        evmSigner,
+        cosmosSigner,
+        bitcoinSigner,
+        solanaSigner,
+        suiSigner,
+        xrplSigner,
+        stellarSigner,
+    };
+};
+
+function useHederaTokenAssociations({ address, chain, token }) {
+    const publicClient = wagmi.usePublicClient({
+        chainId: Number(CHAIN_IDS.HEDERA),
+    });
+    const { evmSigner } = useSigner({ chain });
+    const queryClient = reactQuery.useQueryClient();
+    /**
+     * Creates a token association transaction where the destination account authorizes to receive the given token
+     */
+    const associateToken = reactQuery.useMutation({
+        mutationFn: async () => {
+            try {
+                if (!evmSigner) {
+                    throw new Error("EVM signer not found");
+                }
+                if (chain?.chainId !== CHAIN_IDS.HEDERA ||
+                    token?.chainId !== CHAIN_IDS.HEDERA) {
+                    throw new Error("Chain and token to associate must be on Hedera");
+                }
+                const tokenAddress = parseEvmAddress(token.address);
+                if (!tokenAddress) {
+                    throw new Error("Invalid token address");
+                }
+                const userAddress = parseEvmAddress(address);
+                if (!userAddress) {
+                    throw new Error("Invalid user address");
+                }
+                const encodedData = viem.encodeFunctionData({
+                    abi: 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),
             });
-        case squidTypes.ChainType.XRPL:
-            return new XrplRpcClient(chain.rpc);
-        case squidTypes.ChainType.STELLAR:
-            return new StellarRpcClient(chain.rpc);
-    }
+        },
+    });
+    /**
+     * Checks if the destination account has associated the given token.
+     *
+     * Hedera requires accounts to associate a token before being able to receive it.
+     *
+     * Accounts which have max. associations set to -1 can receive any token without previous association
+     */
+    const isTokenAssociated = 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;
+        }
+    }, [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,
+    };
+};
+
 /**
  * The default multicall3 address
  * available on most EVM chains
@@ -29120,6 +29381,372 @@ 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();
@@ -29314,8 +29941,6 @@ function useNativeTokenForChain(chain) {
         }
     };
     const nativeTokenForChainType = React.useMemo(() => {
-        if (!chain)
-            return undefined;
         return findNativeToken(getTokensForChainType(), chain);
     }, [chain]);
     return { nativeToken: nativeTokenForChainType };
@@ -29431,814 +30056,178 @@ const useSuiNativeBalance = ({ address, chain, }) => {
         token: nativeToken,
         userAddress: address,
     });
-    const balance = React.useMemo(() => {
-        if (nativeToken?.decimals && rawBalance) {
-            return {
-                decimals: nativeToken.decimals,
-                value: parseToBigInt(rawBalance, nativeToken.decimals),
-            };
-        }
-    }, [nativeToken?.decimals, rawBalance]);
-    return {
-        balance,
-        isLoading,
-    };
-};
-const useXrplNativeBalance = ({ address, chain, }) => {
-    const { nativeToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isLoading } = useXrplBalance({
-        chain,
-        token: nativeToken,
-        userAddress: address,
-        enabled: chain?.chainType === squidTypes.ChainType.XRPL,
-    });
-    const balance = React.useMemo(() => {
-        if (nativeToken?.decimals && rawBalance) {
-            return {
-                decimals: nativeToken.decimals,
-                value: parseToBigInt(rawBalance, nativeToken.decimals),
-            };
-        }
-    }, [nativeToken?.decimals, rawBalance]);
-    return {
-        balance,
-        isLoading,
-    };
-};
-const useStellarNativeBalance = ({ address, chain, }) => {
-    const { nativeToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isLoading } = useStellarBalance({
-        chain,
-        token: nativeToken,
-        userAddress: address,
-        enabled: chain?.chainType === 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 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,
-    };
-    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 balance = React.useMemo(() => {
+        if (nativeToken?.decimals && rawBalance) {
+            return {
+                decimals: nativeToken.decimals,
+                value: parseToBigInt(rawBalance, nativeToken.decimals),
+            };
+        }
+    }, [nativeToken?.decimals, rawBalance]);
+    return {
+        balance,
+        isLoading,
+    };
+};
+const useXrplNativeBalance = ({ address, chain, }) => {
+    const { nativeToken } = useNativeTokenForChain(chain);
+    const { balance: rawBalance, isLoading } = useXrplBalance({
+        chain,
+        token: nativeToken,
+        userAddress: address,
+        enabled: chain?.chainType === squidTypes.ChainType.XRPL,
     });
+    const balance = React.useMemo(() => {
+        if (nativeToken?.decimals && rawBalance) {
+            return {
+                decimals: nativeToken.decimals,
+                value: parseToBigInt(rawBalance, nativeToken.decimals),
+            };
+        }
+    }, [nativeToken?.decimals, rawBalance]);
+    return {
+        balance,
+        isLoading,
+    };
 };
-// Taken from wagmi docs
-// https://wagmi.sh/react/guides/ethers
-function clientToSigner(client) {
-    const { account, chain, transport } = client;
-    if (!account || !chain || !transport) {
-        return undefined;
-    }
-    const network = {
-        chainId: chain.id,
-        name: chain.name,
-        ensAddress: chain.contracts?.ensRegistry?.address,
+const useStellarNativeBalance = ({ address, chain, }) => {
+    const { nativeToken } = useNativeTokenForChain(chain);
+    const { balance: rawBalance, isLoading } = useStellarBalance({
+        chain,
+        token: nativeToken,
+        userAddress: address,
+        enabled: chain?.chainType === 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 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(() => {
+};
+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 isEvmSignerReady;
+                return isEvmLoading;
             case squidTypes.ChainType.COSMOS:
-                return isCosmosSignerReady;
+                return isCosmosLoading;
             case squidTypes.ChainType.BTC:
-                return isBitcoinSignerReady;
+                return isBitcoinLoading;
             case squidTypes.ChainType.SOLANA:
-                return isSolanaSignerReady;
+                return isSolanaLoading;
             case squidTypes.ChainType.SUI:
-                return isSuiSignerReady;
+                return isSuiLoading;
             case squidTypes.ChainType.XRPL:
-                return isXrplSignerReady;
+                return isXrpLoading;
             case squidTypes.ChainType.STELLAR:
-                return isStellarSignerReady;
+                return isStellarLoading;
         }
     }, [
         chain?.chainType,
-        isEvmSignerReady,
-        isCosmosSignerReady,
-        isBitcoinSignerReady,
-        isSolanaSignerReady,
-        isSuiSignerReady,
-        isXrplSignerReady,
-        isStellarSignerReady,
+        isEvmLoading,
+        isCosmosLoading,
+        isBitcoinLoading,
+        isSolanaLoading,
+        isSuiLoading,
+        isXrpLoading,
+        isStellarLoading,
     ]);
-    return {
-        isSignerReady,
-        evmSigner,
-        cosmosSigner,
-        bitcoinSigner,
-        solanaSigner,
-        suiSigner,
-        xrplSigner,
-        stellarSigner,
-    };
-};
-
-function useHederaTokenAssociations({ address, chain, token }) {
-    const publicClient = 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,
-    });
-    return {
-        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,
-    };
+    return { nativeBalance, nativeBalanceFormatted, isLoading };
 };
 
-class StellarApiClient {
-    apiUrl;
-    constructor(apiUrl) {
-        this.apiUrl = apiUrl;
-    }
-    async getBaseReserve() {
-        const response = await fetch(`${this.apiUrl}/ledgers?order=desc&limit=1`);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch ledgers: ${response.status}`);
-        }
-        const ledgers = await response.json();
-        const latestLedger = ledgers?._embedded.records?.[0];
-        if (latestLedger?.base_reserve_in_stroops == null) {
-            throw new Error("Invalid ledger data");
-        }
-        const baseReserveBn = BigInt(latestLedger.base_reserve_in_stroops);
-        return baseReserveBn;
-    }
-}
-
-const DEFAULT_REFETCH_INTERVAL$1 = 20_000;
-function useStellarAccountActivation({ address, chain, token, }) {
-    /**
-     * Checks if the destination account exists on the Stellar network
-     * Stellar accounts need to have a minimum balance before they can receive payments
-     */
-    const accountActivatedInfo = 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,
+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 {
-        accountActivatedInfo,
+        isHederaAccountActivated,
     };
 }
 
@@ -30766,161 +30755,6 @@ const useSingleTokenPrice = (tokenData) => {
     return { tokenPrice, getUSDValue };
 };
 
-const TEMPO_FEE_MANAGER_ADDRESS = "0xfeec000000000000000000000000000000000000";
-const feeManagerAbi = [
-    {
-        name: "userTokens",
-        type: "function",
-        stateMutability: "view",
-        inputs: [{ type: "address", name: "user" }],
-        outputs: [{ type: "address" }],
-    },
-];
-const isTempoChain = (chainId) => chainId === CHAIN_IDS.TEMPO;
-/**
- * Convert a fee amount from virtual USD (18 decimals, attodollars)
- * to 6-decimal TIP-20 stablecoin units (microdollars).
- * All TIP-20 tokens on Tempo have 6 decimals.
- */
-const convertTempoFeeToStablecoinUnits = (feeIn18Dec) => feeIn18Dec / BigInt(10 ** 12);
-/**
- * Pure function that derives TempoFeeData from on-chain query results.
- * Extracted from useTempoFeeCheck so the branching logic is unit-testable
- * without mocking React hooks.
- */
-function resolveTempoFeeData({ hasAccountFeePreference, accountGasTokenAddress, accountGasTokenBalance, fromTokenAddress, fromTokenBalance, }) {
-    if (hasAccountFeePreference && accountGasTokenAddress) {
-        const gasTokenIsFromToken = !!fromTokenAddress &&
-            accountGasTokenAddress.toLowerCase() === fromTokenAddress.toLowerCase();
-        return {
-            gasTokenBalance: accountGasTokenBalance ?? BigInt(0),
-            gasTokenIsFromToken,
-            gasTokenAddress: accountGasTokenAddress,
-        };
-    }
-    if (fromTokenAddress != null && fromTokenBalance != null) {
-        return {
-            gasTokenBalance: fromTokenBalance,
-            gasTokenIsFromToken: true,
-            gasTokenAddress: fromTokenAddress,
-        };
-    }
-    return null;
-}
-/**
- * Resolves the token that pays network gas fees for a given chain and transaction context.
- * For Tempo chains, this is the dynamically resolved gas token (from tempoFeeData).
- * For all other chains, this is the static native gas token.
- */
-function resolveGasToken({ nativeToken, chain, tempoFeeData, evmTokens, }) {
-    if (!chain)
-        return undefined;
-    if (isTempoChain(chain.chainId)) {
-        if (!tempoFeeData)
-            return undefined;
-        return evmTokens.find((t) => t.chainId === chain.chainId &&
-            t.address.toLowerCase() === tempoFeeData.gasTokenAddress.toLowerCase());
-    }
-    return nativeToken;
-}
-/**
- * Resolves chain-agnostic fee parameters from chain-specific inputs.
- * This is the single place that knows about Tempo vs. native-token fee semantics.
- *
- * Safe defaults when tempoFeeData is missing on a Tempo chain: balance=0 and
- * fromTokenPaysNetworkFee=false, so the UI blocks rather than misleads.
- */
-function resolveChainFeeParams({ fromChainId, tempoFeeData, isFromTokenNative, nativeBalanceWei, }) {
-    if (isTempoChain(fromChainId)) {
-        if (!tempoFeeData) {
-            return null;
-        }
-        return {
-            fromTokenPaysNetworkFee: tempoFeeData?.gasTokenIsFromToken ?? false,
-            gasTokenBalanceWei: tempoFeeData?.gasTokenBalance ?? BigInt(0),
-            normalizeFee: convertTempoFeeToStablecoinUnits,
-        };
-    }
-    return {
-        fromTokenPaysNetworkFee: isFromTokenNative,
-        gasTokenBalanceWei: nativeBalanceWei,
-        normalizeFee: (fee) => fee,
-    };
-}
-
-const BALANCE_QUERY_STALE_TIME = 10_000;
-/**
- * Returns raw on-chain gas token data for Tempo chains, or null when the source
- * chain is not Tempo.
- */
-const useTempoFeeCheck = ({ fromChain, fromToken, }) => {
-    const { connectedAddresses } = useWallet();
-    const evmAddress = parseEvmAddress(connectedAddresses[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);
@@ -31071,20 +30905,24 @@ const calculateTotalNativeFees = ({ expressFeeCost, firstFeeCost, firstGasCost,
     (sameTokenBetweenFees
         ? BigInt(firstFeeCost?.amount ?? "0") + BigInt(firstGasCost?.amount ?? "0")
         : BigInt(firstGasCost?.amount ?? "0"));
-const isGasBalanceEnough = ({ fromAmount, networkFeesWei, chainFeeParams, }) => {
-    if (!chainFeeParams)
-        return false;
-    if (chainFeeParams.fromTokenPaysNetworkFee) {
-        return (BigInt(fromAmount ?? "0") + networkFeesWei <=
-            chainFeeParams.gasTokenBalanceWei);
-    }
-    return networkFeesWei <= chainFeeParams.gasTokenBalanceWei;
-};
-const calculateMinAmountValueWarnMsg = ({ networkFeesWei, chainFeeParams, }) => {
-    if (!chainFeeParams?.fromTokenPaysNetworkFee)
-        return undefined;
-    return chainFeeParams.gasTokenBalanceWei - networkFeesWei;
-};
+const isFromBalanceEnoughToSwap = ({ isFromTokenNative, fromAmount, totalFeesInNativeTokenPlusRatio, nativeTokenBalanceFromChainWei, }) => {
+    const fromAmountBigInt = BigInt(fromAmount ?? "0");
+    const totalFeesInNativeTokenPlusRatioBigInt = totalFeesInNativeTokenPlusRatio;
+    const nativeTokenBalanceFromChainWeiBigInt = nativeTokenBalanceFromChainWei;
+    return isFromTokenNative
+        ? fromAmountBigInt + totalFeesInNativeTokenPlusRatioBigInt <=
+            nativeTokenBalanceFromChainWeiBigInt
+        : totalFeesInNativeTokenPlusRatioBigInt <=
+            nativeTokenBalanceFromChainWeiBigInt;
+};
+const calculateMinAmountValueWarnMsg = ({ isFromTokenNative, nativeTokenBalanceFromChainWei, sourceChainNativeTokenDecimals, totalFeesInNativeTokenPlusRatio, }) => isFromTokenNative
+    ? (() => {
+        const minAmount = nativeTokenBalanceFromChainWei - totalFeesInNativeTokenPlusRatio;
+        return minAmount > BigInt(0)
+            ? formatBNToReadable(minAmount, sourceChainNativeTokenDecimals)
+            : "0";
+    })()
+    : undefined;
 /**
  * Calculates the estimated duration of a route
  *
@@ -31123,10 +30961,12 @@ const formatEstimatedRouteDuration = ({ estimatedRouteDuration, isSingleChainRou
  * @returns {Object} An object containing various estimate results and calculations, including token information,
  *                   amounts, fees, gas costs, and other relevant data for the transaction.
  */
-const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, collectFees, nativeTokenBalanceFromChainWei, tempoFeeData, }) => {
+const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, collectFees, nativeTokenBalanceFromChainWei, }) => {
     const fromToken = findToken(tokens, squidRoute?.params.fromChain, squidRoute?.params.fromToken);
     const fromAmount = squidRoute?.estimate?.fromAmount;
     const fromAmountFormatted = formatAmount(fromAmount, fromToken?.decimals);
+    const sourceChainNativeToken = findNativeToken(tokens, fromChain);
+    const destChainNativeToken = findNativeToken(tokens, toChain);
     const toAmountUSD = squidRoute?.estimate?.toAmountUSD;
     const exchangeRate = squidRoute?.estimate.exchangeRate ?? "0";
     const toAmountMinUSD = squidRoute?.estimate.toAmountMinUSD ?? "0";
@@ -31145,6 +30985,10 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
     const expectedGasRefundCostUSD = convertTokenAmountToUSD(formatBNToReadable(expectedGasRefundCost, firstFeeCost?.token.decimals ?? 18), firstFeeCost?.token.usdPrice ?? "0");
     const sameTokenBetweenFees = firstFeeCost?.token.address === firstGasCost?.token.address &&
         firstFeeCost?.token.chainId === firstGasCost?.token.chainId;
+    const isFromTokenNative = 
+    // TODO: temporary fix, currently nativeCurrency.symbol is not always in uppercase
+    fromToken?.symbol.toUpperCase() ===
+        fromChain?.nativeCurrency.symbol.toUpperCase();
     const totalNativeFees = calculateTotalNativeFees({
         expressFeeCost,
         firstFeeCost,
@@ -31152,32 +30996,19 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         sameTokenBetweenFees,
     });
     const totalFeesInNativeTokenPlusRatio = (totalNativeFees * BigInt(110)) / BigInt(100);
-    const isNativeTokenFromChain = 
-    // TODO: nativeCurrency.symbol is not always uppercase
-    fromToken?.symbol.toUpperCase() ===
-        fromChain?.nativeCurrency.symbol.toUpperCase();
-    const chainFeeParams = resolveChainFeeParams({
-        tempoFeeData,
-        isFromTokenNative: isNativeTokenFromChain,
-        nativeBalanceWei: nativeTokenBalanceFromChainWei,
-        fromChainId: fromChain?.chainId,
-    });
-    const networkFeesWei = chainFeeParams?.normalizeFee(totalFeesInNativeTokenPlusRatio) ?? BigInt(0);
-    const gasBalanceEnough = isGasBalanceEnough({
-        chainFeeParams,
+    const fromBalanceEnoughToSwap = isFromBalanceEnoughToSwap({
+        isFromTokenNative,
         fromAmount,
-        networkFeesWei,
+        fromTokenDecimals: fromToken?.decimals,
+        totalFeesInNativeTokenPlusRatio,
+        nativeTokenBalanceFromChainWei,
     });
-    const minAmount = calculateMinAmountValueWarnMsg({
-        chainFeeParams,
-        // gasTokenDecimals: chainFeeParams,
-        networkFeesWei,
+    const minAmountValueWarnMsg = calculateMinAmountValueWarnMsg({
+        isFromTokenNative,
+        nativeTokenBalanceFromChainWei,
+        sourceChainNativeTokenDecimals: sourceChainNativeToken?.decimals,
+        totalFeesInNativeTokenPlusRatio,
     });
-    const minAmountValueWarnMsg = minAmount
-        ? formatBNToReadable(minAmount, chainFeeParams?.fromTokenPaysNetworkFee
-            ? fromToken?.decimals
-            : undefined)
-        : undefined;
     const isSingleChainRoute = fromChain?.chainId === toChain?.chainId;
     const estimatedRouteDuration = formatEstimatedRouteDuration({
         estimatedRouteDuration: squidRoute?.estimate?.estimatedRouteDuration,
@@ -31187,6 +31018,8 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         fromToken,
         fromAmount,
         fromAmountFormatted,
+        sourceChainNativeToken,
+        destChainNativeToken,
         toAmountUSD,
         exchangeRate,
         toAmountMinUSD,
@@ -31201,10 +31034,10 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         expectedGasRefundCost,
         expectedGasRefundCostUSD,
         sameTokenBetweenFees,
-        fromTokenPaysNetworkFee: chainFeeParams?.fromTokenPaysNetworkFee ?? false,
+        isFromTokenNative,
         totalNativeFees,
         totalFeesInNativeTokenPlusRatio,
-        gasBalanceEnough,
+        fromBalanceEnoughToSwap,
         minAmountValueWarnMsg,
         estimatedRouteDuration,
     };
@@ -31240,6 +31073,28 @@ const calculateTotalWithRefundEstimate = (allFeeCosts, expectedGasRefundCost, ge
         feeToken: firstFeeCost?.token,
     };
 };
+/**
+ * Calculates the proposed gas amount for the destination chain.
+ *
+ * @param destChainNativeToken - The symbol of the native token for the destination chain.
+ * @returns An object containing the proposed gas amount value and the currency symbol.
+ */
+const getProposedGasDestinationAmount = (destChainNativeToken) => {
+    const gasAmounts = {
+        GLMR: 5.289,
+        ETH: 0.0009,
+        AVAX: 0.115,
+        BNB: 0.00425,
+        FTM: 4.45,
+        CELO: 3.052,
+        KAVA: 2.339,
+        MATIC: 1.795,
+    };
+    return {
+        value: gasAmounts[destChainNativeToken ?? ""] ?? 0,
+        currency: destChainNativeToken,
+    };
+};
 
 function useSendTransactionGas({ chain, token, from, }) {
     return reactQuery.useQuery({
@@ -31261,11 +31116,7 @@ function useSendTransactionGas({ chain, token, from, }) {
                     // Some RPC providers require the sender to have enough balance, otherwise estimation reverts
                     // so we'll try to use the user provided address when possible
                     const sender = from || dummyAddress;
-                    // Tempo has no native token, so `value` transfers are rejected by the EVM.
-                    // We can simulate an ERC20 transfer instead
-                    const supportsNativeTransfers = chain.chainId !== CHAIN_IDS.TEMPO;
-                    const isNativeToken = token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase();
-                    if (isNativeToken && supportsNativeTransfers) {
+                    if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase()) {
                         const gas = await client.estimateGas({
                             from: sender,
                             to: dummyAddress,
@@ -31285,14 +31136,7 @@ function useSendTransactionGas({ chain, token, from, }) {
                         data,
                         chainId: chain.chainId,
                     });
-                    const feeWei = gas * maxFeePerGas;
-                    // Tempo fees are denominated in virtual USD (18 dec, 1e-18 USD units).
-                    // Convert to 6-dec stablecoin units so all callers receive a
-                    // consistent unit without needing to know about the chain.
-                    if (chain.chainId === CHAIN_IDS.TEMPO) {
-                        return convertTempoFeeToStablecoinUnits(feeWei);
-                    }
-                    return feeWei;
+                    return gas * maxFeePerGas;
                 }
                 case squidTypes.ChainType.COSMOS: {
                     // TODO: get gas estimation from backend
@@ -31340,24 +31184,18 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
         from,
     });
     const { nativeBalance } = useNativeBalance(chain);
-    const tempoFeeData = useTempoFeeCheck({ fromChain: chain, fromToken: token });
-    const chainFeeParams = resolveChainFeeParams({
-        fromChainId: chain?.chainId,
-        tempoFeeData,
-        isFromTokenNative: token != null &&
-            token.address.toLowerCase() ===
-                chainTypeToNativeTokenAddressMap[token.type]?.toLowerCase(),
-        nativeBalanceWei: nativeBalance?.value ?? BigInt(0),
-    });
-    const gasBalanceEnough = React.useMemo(() => {
-        if (!amount || !token?.decimals)
+    const isNativeBalanceEnoughToPayGasFees = React.useMemo(() => {
+        if (!nativeBalance?.value || !amount || !token?.decimals) {
             return false;
-        return isGasBalanceEnough({
-            fromAmount: parseToBigInt(amount, token.decimals).toString(),
-            networkFeesWei: estimatedGas,
-            chainFeeParams,
-        });
-    }, [amount, estimatedGas, token, chainFeeParams]);
+        }
+        const isTokenNative = token.address.toLowerCase() ===
+            chainTypeToNativeTokenAddressMap[token.type].toLowerCase();
+        if (isTokenNative) {
+            return (parseToBigInt(amount, token.decimals) + estimatedGas <=
+                nativeBalance.value);
+        }
+        return estimatedGas <= nativeBalance.value;
+    }, [amount, estimatedGas, nativeBalance?.value, token]);
     const isBalanceEnough = React.useMemo(() => {
         if (token?.decimals == null || !balance || !amount)
             return false;
@@ -31365,30 +31203,28 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
             parseToBigInt(amount, token.decimals));
     }, [amount, balance, token?.decimals]);
     const minAmountValueWarnMsg = React.useMemo(() => {
-        if (!token?.address || !estimatedGas)
-            return undefined;
-        if (!chainFeeParams)
+        if (!token?.address || !nativeBalance?.value || !estimatedGas)
             return undefined;
-        const minAmount = calculateMinAmountValueWarnMsg({
-            chainFeeParams,
-            // gasTokenDecimals: chainFeeParams.fromTokenPaysNetworkFee
-            //   ? token.decimals
-            //   : undefined,
-            networkFeesWei: estimatedGas,
+        const isFromTokenNative = token.address.toLowerCase() ===
+            chainTypeToNativeTokenAddressMap[token.type].toLowerCase();
+        return calculateMinAmountValueWarnMsg({
+            isFromTokenNative,
+            nativeTokenBalanceFromChainWei: nativeBalance.value,
+            sourceChainNativeTokenDecimals: nativeBalance.decimals,
+            totalFeesInNativeTokenPlusRatio: estimatedGas,
         });
-        // return minAmount > BigInt(0)
-        //   ? formatBNToReadable(minAmount, gasTokenDecimals)
-        //   : "0";
-        if (!minAmount)
-            return undefined;
-        return formatBNToReadable(minAmount, chainFeeParams.fromTokenPaysNetworkFee ? token.decimals : undefined);
-    }, [estimatedGas, token, chainFeeParams]);
+    }, [
+        estimatedGas,
+        nativeBalance?.decimals,
+        nativeBalance?.value,
+        token?.address,
+        token?.type,
+    ]);
     return {
         estimatedGas,
         isBalanceEnough,
-        tokenPaysNetworkFee: chainFeeParams?.fromTokenPaysNetworkFee ?? false,
         isLoading,
-        isGasBalanceEnough: gasBalanceEnough,
+        isNativeBalanceEnoughToPayGasFees,
         minAmountValueWarnMsg,
     };
 }
@@ -32447,7 +32283,7 @@ const useApproval = ({ squidRoute, }) => {
             // This is to ensure we're using the latest expiry timestamp
             if (squidRoute) {
                 queryClient.refetchQueries({
-                    queryKey: keys().transaction(squidRoute.params.fromChain, squidRoute.params.toChain, squidRoute.params.toToken, squidRoute.params.fromToken, fromPrice, squidRoute.params.slippage, squidRoute.params.fromAddress, squidRoute.params.bypassGuardrails, squidRoute.params.toAddress, squidRoute.params.fallbackAddresses?.[0]?.address, squidRoute.params.quoteOnly, getChainType(squidRoute.params.fromChain), squidRoute.params.preHook, squidRoute.params.postHook, 
+                    queryKey: keys().transaction(squidRoute.params.fromChain, squidRoute.params.toChain, squidRoute.params.toToken, squidRoute.params.fromToken, fromPrice, squidRoute.params.slippage, squidRoute.params.receiveGasOnDestination, squidRoute.params.fromAddress, squidRoute.params.bypassGuardrails, squidRoute.params.toAddress, squidRoute.params.fallbackAddresses?.[0]?.address, squidRoute.params.quoteOnly, getChainType(squidRoute.params.fromChain), squidRoute.params.preHook, squidRoute.params.postHook, 
                     // TODO: update types
                     squidRoute.params?.overrideGasRefundAddress),
                 });
@@ -32466,10 +32302,8 @@ const AXELAR_PROVIDER_IMAGE_URL = "https://raw.githubusercontent.com/0xsquid/ass
 const useEstimate = (squidRoute) => {
     const collectFees = useConfigStore((state) => state.config.collectFees);
     const { tokens } = useSquidTokens();
-    const { fromChain, toChain, fromPrice } = useSwap();
+    const { fromChain, toChain } = useSwap();
     const { nativeBalance } = useNativeBalance(fromChain);
-    const fromToken = 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,
@@ -32477,17 +32311,8 @@ const useEstimate = (squidRoute) => {
         toChain,
         collectFees: !!collectFees && collectFees.fee > 0,
         nativeTokenBalanceFromChainWei: nativeBalance?.value ?? BigInt("0"),
-        tempoFeeData: tempoFeeData ?? undefined,
-    }), [
-        squidRoute,
-        tokens,
-        fromChain,
-        toChain,
-        collectFees,
-        nativeBalance,
-        tempoFeeData,
-    ]);
-    const fromBalanceFormatted = useMultiChainBalance({
+    }), [squidRoute, tokens, fromChain, toChain, collectFees, nativeBalance]);
+    const balanceFormatted = useMultiChainBalance({
         chain: fromChain,
         token: estimateResults.fromToken,
         userAddress: squidRoute?.params.fromAddress ?? "",
@@ -32499,6 +32324,7 @@ 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 = [];
@@ -32557,18 +32383,19 @@ const useEstimate = (squidRoute) => {
             totalFeeCostsUsd: totalFeeCostsUsdFormatted,
         };
     }, [squidRoute?.estimate.feeCosts]);
-    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]);
+    const slippageFormatted = 
+    // TODO: update types
+    Number(squidRoute?.estimate?.aggregateSlippage ?? 0).toFixed(2) +
+        "%";
+    const enoughBalanceToSwap = +balanceFormatted >= 0 &&
+        +balanceFormatted > +estimateResults.fromAmountFormatted;
     return {
         ...estimateResults,
-        fromBalanceFormatted,
+        balanceFormatted,
         slippageFormatted,
         totalWithRefundEstimate,
-        fromBalanceEnoughToSwap,
+        proposedGasDestinationAmount,
+        enoughBalanceToSwap,
         feeCostsFormatted,
         totalFeeCostsUsd,
     };
@@ -36316,7 +36143,7 @@ const useGetRoute = () => {
         });
         // Cache the route data
         // Useful when the getRoute mutation is called from another hook
-        queryClient.setQueryData(keys().transaction(fromChain, toChain, toToken.address, fromToken.address, fromPrice, config.slippage, sourceUserAddress, config.degenMode, destinationAddress, swapRoute?.fallbackAddress, quoteOnly, fromChainType, config.preHook, config.postHook, overrideGasRefundAddress), route);
+        queryClient.setQueryData(keys().transaction(fromChain, toChain, toToken.address, fromToken.address, fromPrice, config.slippage, config.enableGetGasOnDestination, sourceUserAddress, config.degenMode, destinationAddress, swapRoute?.fallbackAddress, quoteOnly, fromChainType, config.preHook, config.postHook, overrideGasRefundAddress), route);
         return route;
     });
 };
@@ -36339,13 +36166,14 @@ 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, fromPrice, config.slippage, 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, config.enableGetGasOnDestination, sourceUserAddress, config.degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChain?.chainType, config.preHook, config.postHook, config.overrideGasRefundAddress), [
         fromChain?.chainId,
         toChain?.chainId,
         toToken?.address,
         fromToken?.address,
         fromPrice,
         config.slippage,
+        config.enableGetGasOnDestination,
         sourceUserAddress,
         config.degenMode,
         destinationAddress,
@@ -36617,6 +36445,35 @@ const useAvatar = (seed = zeroAddress) => {
     return avatar || "";
 };
 
+const useUserParams = () => {
+    const enableGetGasOnDestination = useConfigStore((state) => state.config.enableGetGasOnDestination);
+    const { fromToken, toToken, toChain, fromChain } = useSwap();
+    //   =============
+    //       GAS
+    //   =============
+    const getGasOnDestSupportedForThisRoute = 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();
@@ -37158,7 +37015,6 @@ exports.isChainflipBridgeTransaction = isChainflipBridgeTransaction;
 exports.isCoralBridgeAction = isCoralBridgeAction;
 exports.isCosmosAddressValid = isCosmosAddressValid;
 exports.isDepositRoute = isDepositRoute;
-exports.isDepositWithSignatureTxData = isDepositWithSignatureTxData;
 exports.isEmptyObject = isEmptyObject;
 exports.isEvmChainNotSupportedError = isEvmChainNotSupportedError;
 exports.isEvmosChain = isEvmosChain;
@@ -37269,7 +37125,6 @@ exports.useSendTransactionStore = useSendTransactionStore;
 exports.useSigner = useSigner;
 exports.useSingleTokenPrice = useSingleTokenPrice;
 exports.useSolanaNativeBalance = useSolanaNativeBalance;
-exports.useSourceChainGasToken = useSourceChainGasToken;
 exports.useSquid = useSquid;
 exports.useSquidChains = useSquidChains;
 exports.useSquidQueryClient = useSquidQueryClient;
@@ -37285,6 +37140,7 @@ exports.useSwapTransactionStatus = useSwapTransactionStatus;
 exports.useTokensData = useTokensData;
 exports.useTrackSearchEmpty = useTrackSearchEmpty;
 exports.useTransactionStore = useTransactionStore;
+exports.useUserParams = useUserParams;
 exports.useWallet = useWallet;
 exports.useWalletStore = useWalletStore;
 exports.useWallets = useWallets;
@@ -37293,4 +37149,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-CaI-xWCW.js.map
+//# sourceMappingURL=index-5cyMUZhY.js.map