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

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

@@ -1,5 +1,5 @@
 import { ChainType, ActionType, SquidDataType, BridgeType, BridgeProvider, FeeType } from '@0xsquid/squid-types';
-import { zeroAddress as zeroAddress$1, parseUnits, formatUnits, isAddress, SwitchChainError, UserRejectedRequestError, getAddress, defineChain, encodeFunctionData, erc20Abi } from 'viem';
+import { zeroAddress as zeroAddress$1, parseUnits, formatUnits, isAddress, SwitchChainError, UserRejectedRequestError, erc20Abi, getAddress, defineChain, encodeFunctionData } from 'viem';
 import React, { useMemo, useCallback, useState, useEffect, createContext, useContext, useRef } from 'react';
 import { useQuery, useMutation, useQueries, useQueryClient, QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { fromBech32 } from '@cosmjs/encoding';
@@ -13,22 +13,22 @@ import { isValidXAddress, isValidClassicAddress } from 'ripple-address-codec';
 import { getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction } from '@solana/spl-token';
 import { StandardWalletAdapter } from '@solana/wallet-standard-wallet-adapter-base';
 import { PublicKey, VersionedTransaction, Transaction, SystemProgram, Connection } from '@solana/web3.js';
-import { Networks, StrKey, nativeToScVal, Address, rpc, TransactionBuilder, BASE_FEE, Contract, TimeoutInfinite, scValToNative, Operation, Transaction as Transaction$1, xdr } from '@stellar/stellar-sdk';
+import { StrKey, Networks, nativeToScVal, Address, rpc, TransactionBuilder, BASE_FEE, Contract, TimeoutInfinite, scValToNative, Asset, Operation, Transaction as Transaction$1, xdr } from '@stellar/stellar-sdk';
 import { SUI_TESTNET_CHAIN, SUI_MAINNET_CHAIN } from '@mysten/wallet-standard';
-import { CloudflareProvider, BrowserProvider, JsonRpcSigner, JsonRpcProvider, ethers, Interface, Contract as Contract$1, isError } from 'ethers';
+import { CloudflareProvider, JsonRpcProvider, ethers, Interface, BrowserProvider, JsonRpcSigner, Contract as Contract$1, isError } from 'ethers';
 import BigNumber$1, { BigNumber } from 'bignumber.js';
 import { countries } from 'countries-list';
 import getSymbolFromCurrency from 'currency-symbol-map';
 import Fuse from 'fuse.js';
 import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
-import { useAccount, useConnectors, useConnect, useDisconnect, useSwitchChain, createConfig, http, useWalletClient, usePublicClient, useBalance, useReadContract, WagmiProvider } from 'wagmi';
+import { useAccount, useConnectors, useConnect, useDisconnect, useSwitchChain, useBalance, useReadContract, createConfig, http, useWalletClient, usePublicClient, WagmiProvider } from 'wagmi';
 import SafeAppsSDK, { TransactionStatus as TransactionStatus$1 } from '@safe-global/safe-apps-sdk';
 import { getWallets } from '@wallet-standard/core';
 import { SlushWallet } from '@mysten/slush-wallet';
-import { injected, safe, metaMask, coinbaseWallet, walletConnect } from 'wagmi/connectors';
 import { StargateClient, SigningStargateClient } from '@cosmjs/stargate';
 import { SuiClient } from '@mysten/sui/client';
+import { injected, safe, metaMask, coinbaseWallet, walletConnect } from 'wagmi/connectors';
 import { coin as coin$1 } from '@cosmjs/proto-signing';
 import { Transaction as Transaction$2 } from '@mysten/sui/transactions';
 import { SigningCosmWasmClient } from '@cosmjs/cosmwasm-stargate';
@@ -124,6 +124,9 @@ const CHAIN_IDS = {
     SONEIUM: "1868",
     PEAQ: "3338",
     HEDERA: "295",
+    MANTRA: "5888",
+    CITREA: "4114",
+    TEMPO: "4217",
     // others
     BITCOIN: "bitcoin",
     SOLANA: "solana-mainnet-beta",
@@ -20097,14 +20100,17 @@ function isXrplAddressValid(address) {
     return isValidXAddress(address) || isValidClassicAddress(address);
 }
 function buildXrplTrustSetTx({ amount, sourceAddress, token, }) {
-    const [currency, issuer] = token.address.split(".");
+    const asset = parseXrplTokenAddress(token.address);
+    if (!asset) {
+        throw new Error("Invalid asset");
+    }
     return {
         TransactionType: XrplTransactionType.TRUST_SET,
         Flags: XrplTransactionFlag.tfSetNoRipple,
         Account: sourceAddress,
         LimitAmount: {
-            currency,
-            issuer,
+            currency: asset.code,
+            issuer: asset.issuer,
             value: amount,
         },
     };
@@ -20133,6 +20139,16 @@ function parseXrplPaymentTx(data) {
         throw new Error("Could not parse payment transaction");
     }
 }
+function parseXrplTokenAddress(address) {
+    const [code, issuer] = address.split(".");
+    if (!code || !issuer) {
+        return null;
+    }
+    return {
+        code,
+        issuer,
+    };
+}
 
 const chains = [XrplCAIP2ChainId.MAINNET, XrplCAIP2ChainId.TESTNET];
 class XrplWalletConnect {
@@ -21115,8 +21131,10 @@ function isChainflipBridgeTransaction(actions = []) {
 function isOnChainTxData(squidData) {
     return [
         SquidDataType.OnChainExecution,
-        SquidDataType.DepositAddressWithSignature,
         SquidDataType.OnChainExecutionWithSignature,
+        SquidDataType.DepositAddressWithSignature,
+        SquidDataType.DepositAddressCalldata,
+        SquidDataType.DepositAddressWithMemo,
     ].includes(squidData.type);
 }
 function getHistoryTransactionId(tx) {
@@ -21393,6 +21411,28 @@ const executeSolanaTransfer = async ({ amount, target, signer, connection, sourc
     return signature;
 };
 
+var StellarHorizonAssetType;
+(function (StellarHorizonAssetType) {
+    /**
+     * XLM native token
+     */
+    StellarHorizonAssetType["NATIVE"] = "native";
+    /**
+     * 1-4 char asset code (e.g. USDC)
+     */
+    StellarHorizonAssetType["ALPHANUM4"] = "credit_alphanum4";
+    /**
+     * 5-12 char asset code (e.g. wstETH)
+     */
+    StellarHorizonAssetType["ALPHANUM12"] = "credit_alphanum12";
+})(StellarHorizonAssetType || (StellarHorizonAssetType = {}));
+var StellarTokenType;
+(function (StellarTokenType) {
+    StellarTokenType["NATIVE_TOKEN"] = "nativeToken";
+    StellarTokenType["ISSUER_TOKEN"] = "issuerToken";
+    StellarTokenType["CONTRACT_TOKEN"] = "contractToken";
+})(StellarTokenType || (StellarTokenType = {}));
+
 function isStellarAddressValid(address) {
     return StrKey.isValidEd25519PublicKey(address);
 }
@@ -21414,6 +21454,78 @@ function stellarAddressToScVal(addressString) {
         type: "address",
     });
 }
+function getStellarTrustLineAsset(token) {
+    // The address format for issued assets is `CODE-ISSUER`
+    // Example: USDC-GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN
+    const [code, issuer] = token.address.split("-");
+    if (!code || !issuer) {
+        return null;
+    }
+    return {
+        code,
+        issuer,
+    };
+}
+function isStellarToken(token) {
+    try {
+        const stellarToken = token;
+        return (Object.values(StellarTokenType).includes(stellarToken.chainAssetConfig.stellar.assetType) &&
+            typeof stellarToken.chainAssetConfig.stellar.contractAddress === "string");
+    }
+    catch {
+        return false;
+    }
+}
+function isStellarIssuedToken(token) {
+    try {
+        return (isStellarToken(token) &&
+            token.chainAssetConfig.stellar.assetType === StellarTokenType.ISSUER_TOKEN);
+    }
+    catch {
+        return false;
+    }
+}
+function getStellarHorizonApiUrl(chain) {
+    try {
+        const stellarChain = chain;
+        const [horizonApiUrl] = stellarChain.horizonRpcList;
+        if (typeof horizonApiUrl !== "string") {
+            throw new Error("Invalid Horizon API URL");
+        }
+        return horizonApiUrl;
+    }
+    catch {
+        return null;
+    }
+}
+const VALID_ASSET_TYPES = new Set(Object.values(StellarHorizonAssetType));
+function isValidNativeAsset(asset) {
+    return (typeof asset === "object" &&
+        asset !== null &&
+        "balance" in asset &&
+        typeof asset.balance === "string" &&
+        "asset_type" in asset &&
+        asset.asset_type === StellarHorizonAssetType.NATIVE);
+}
+function isValidIssuedAsset(asset) {
+    return (typeof asset === "object" &&
+        asset !== null &&
+        "balance" in asset &&
+        typeof asset.balance === "string" &&
+        "asset_type" in asset &&
+        typeof asset.asset_type === "string" &&
+        VALID_ASSET_TYPES.has(asset.asset_type) &&
+        asset.asset_type !== StellarHorizonAssetType.NATIVE &&
+        "asset_code" in asset &&
+        typeof asset.asset_code === "string" &&
+        "asset_issuer" in asset &&
+        typeof asset.asset_issuer === "string" &&
+        "limit" in asset &&
+        typeof asset.limit === "string");
+}
+function isValidHorizonAsset(asset) {
+    return isValidNativeAsset(asset) || isValidIssuedAsset(asset);
+}
 
 const SUI_FEATURES = ["sui:signTransaction"];
 function isSuiStandardWallet(wallet) {
@@ -22213,6 +22325,8 @@ var QueryKeys;
     QueryKeys["XrplAccountActivatedInfo"] = "xrplAccountActivatedInfo";
     QueryKeys["FiatToCryptoPaymentMethods"] = "fiatToCryptoPaymentMethods";
     QueryKeys["Stellar"] = "stellar";
+    QueryKeys["StellarTrustLine"] = "stellarTrustLine";
+    QueryKeys["IsStellarTrustLineApproved"] = "isStellarTrustLineApproved";
     QueryKeys["StellarAccountActivatedInfo"] = "stellarAccountActivatedInfo";
     QueryKeys["Hedera"] = "hedera";
     QueryKeys["IsHederaTokenAssociated"] = "isHederaTokenAssociated";
@@ -22277,7 +22391,7 @@ const keys = () => ({
     // ============
     // Transactions
     // ============
-    transaction: (fromChainId, toChainId, toTokenAddress, fromTokenAddress, price, slippage, getGasOnDestination, sourceUserAddress, degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChainType, preHook, postHook, overrideGasRefundAddress) => [
+    transaction: (fromChainId, toChainId, toTokenAddress, fromTokenAddress, price, slippage, sourceUserAddress, degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChainType, preHook, postHook, overrideGasRefundAddress) => [
         ...keys().transactions(),
         QueryKeys.Transaction,
         fromChainId,
@@ -22286,7 +22400,6 @@ const keys = () => ({
         fromTokenAddress,
         price,
         slippage,
-        getGasOnDestination,
         sourceUserAddress,
         degenMode,
         destinationAddress,
@@ -22320,7 +22433,7 @@ const keys = () => ({
     // ============
     // Approval
     // ============
-    routeApproved: (routeData, allowanceInWei) => [
+    routeApproved: (routeData, allowanceInWei, isAllowanceQueryEnabled, hasAllowance) => [
         ...keys().transactions(),
         QueryKeys.RouteApproved,
         routeData?.params.fromAddress,
@@ -22328,6 +22441,8 @@ const keys = () => ({
         routeData?.params.fromToken,
         routeData?.params.fromAmount,
         allowanceInWei?.toString(),
+        isAllowanceQueryEnabled,
+        hasAllowance,
     ],
     sendTransactionGas: (chainId, tokenAddress, from) => [
         QueryKeys.All,
@@ -22400,6 +22515,23 @@ const keys = () => ({
     // ============
     // Stellar
     // ============
+    stellarTrustLine: (tokenAddress, chainId, address) => [
+        ...keys().stellar(),
+        QueryKeys.StellarTrustLine,
+        tokenAddress,
+        chainId,
+        address,
+    ],
+    isStellarTrustLineApproved: (address, chainId, chainType, tokenAddress, trustLineLimit, amountToApprove) => [
+        ...keys().stellar(),
+        QueryKeys.IsStellarTrustLineApproved,
+        address,
+        chainId,
+        chainType,
+        tokenAddress,
+        trustLineLimit,
+        amountToApprove?.toString(),
+    ],
     stellarAccountActivatedInfo: (address, chainId, chainType) => [
         ...keys().stellar(),
         QueryKeys.StellarAccountActivatedInfo,
@@ -22435,6 +22567,8 @@ const getPrefixKey = (key) => {
             return [...keys().transactions(), key];
         case QueryKeys.XrplTrustLine:
             return [...keys().xrpl(), key];
+        case QueryKeys.StellarTrustLine:
+            return [...keys().stellar(), key];
         case QueryKeys.IsHederaTokenAssociated:
             return [...keys().hedera(), key];
         default:
@@ -22447,7 +22581,6 @@ const getConfigWithDefaults = (config) => {
         integratorId: get$2(config, "integratorId", defaultConfigValues.integratorId),
         slippage: get$2(config, "slippage", defaultConfigValues.slippage),
         collectFees: get$2(config, "collectFees", defaultConfigValues.collectFees),
-        enableGetGasOnDestination: get$2(config, "enableGetGasOnDestination", defaultConfigValues.enableGetGasOnDestination),
         apiUrl: get$2(config, "apiUrl", defaultConfigValues.apiUrl),
         priceImpactWarnings: get$2(config, "priceImpactWarnings", defaultConfigValues.priceImpactWarnings),
         initialAssets: get$2(config, "initialAssets", defaultConfigValues.initialAssets),
@@ -22937,8 +23070,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;
@@ -23149,7 +23282,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await import('./secretService-BMYOBXhv.js');
+    const { fetchAllSecretBalances } = await import('./secretService-ScgDU3bX.js');
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -24840,7 +24973,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() ===
@@ -26465,7 +26598,7 @@ function useStellarWallets() {
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
                 const { LedgerModule } = await import('@creit.tech/stellar-wallets-kit/modules/ledger.module');
-                const { formatStellarWallet } = await import('./stellarService.client-DOrCdvCd.js');
+                const { formatStellarWallet } = await import('./stellarService.client-BaDOSK8x.js');
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27772,580 +27905,310 @@ function useTrackSearchEmpty({ searchQuery, resultsLength, context, debounceMs =
     }, [context, debounceMs, resultsLength, searchQuery]);
 }
 
-var hrc20 = [
-	{
-		inputs: [
-		],
-		name: "associate",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "responseCode",
-				type: "uint256"
-			}
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	}
-];
-
-/**
- * Client for interacting with the Hedera Mirrornode API.
- *
- * @docs https://mainnet.mirrornode.hedera.com/api/v1/docs
- */
-class HederaApiClient {
-    apiUrl;
-    constructor(apiUrl) {
-        this.apiUrl = apiUrl;
-    }
-    async isTokenAssociated({ address, token, }) {
-        const accountInfo = await this.getAccountInfo(address);
-        // Unlimited auto associations
-        if (accountInfo.max_automatic_token_associations === -1) {
-            return true;
-        }
-        // If there's no unlimited auto-associations, we need to check if the token is already associated.
-        const { tokens: accountTokens } = await this.getAccountTokens(address);
-        const tokenId = convertEvmAddressToHederaAccountId(token.address);
-        if (accountTokens.some((t) => t.token_id === tokenId)) {
-            // Token is already associated
-            return true;
-        }
-        // Finally, if not auto-associated, check if there is an available auto-association slot
-        const autoAssociatedTokens = accountTokens.filter((t) => t.automatic_association);
-        const remainingAutoAssociations = accountInfo.max_automatic_token_associations -
-            autoAssociatedTokens.length;
-        return remainingAutoAssociations > 0;
+class StellarRpcClient {
+    server;
+    constructor(rpcUrl) {
+        this.server = new rpc.Server(rpcUrl);
     }
-    async getAccountInfo(address) {
-        const data = await this.fetch(`accounts/${address}`);
-        if (typeof data.max_automatic_token_associations !== "number") {
-            throw new Error("Invalid max_automatic_token_associations type, expected number");
+    /**
+     * Returns the balance of a Stellar Contract Token. This is different from an Issued Token.
+     *
+     * With Contract Tokens, we need to call the .balance method on the token contract
+     * and simulate the transaction to get the balance.
+     */
+    async getBalance(userAddress, tokenAddress, chainId) {
+        const account = await this.server.getAccount(userAddress);
+        const network = getStellarNetwork(chainId);
+        if (network == null) {
+            throw new Error(`No Stellar network found for chainId ${chainId}`);
         }
-        if (typeof data.balance.balance !== "number") {
-            throw new Error("Invalid balance type, expected number");
+        const txBuilder = new TransactionBuilder(account, {
+            fee: (BigInt(BASE_FEE) * BigInt(2)).toString(),
+            networkPassphrase: network,
+        });
+        const contract = new Contract(tokenAddress);
+        const tx = txBuilder
+            .addOperation(contract.call("balance", new Address(userAddress).toScVal()))
+            .setTimeout(TimeoutInfinite)
+            .build();
+        const simulateTxResponse = await this.server.simulateTransaction(tx);
+        if ("error" in simulateTxResponse) {
+            const isNoBalanceError = /trying to get non-existing value for contract instance|trustline entry is missing for account/.test(simulateTxResponse.error);
+            // If the error message indicates that the user has no balance just return 0
+            // We don't want to spam with this error as it's pretty common
+            if (isNoBalanceError) {
+                return "0";
+            }
+            throw new Error(`Failed to fetch balance. RPC response: ${simulateTxResponse.error}`);
         }
-        if (!Array.isArray(data.balance.tokens)) {
-            throw new Error("Invalid tokens type, expected array");
+        if ("result" in simulateTxResponse && simulateTxResponse.result != null) {
+            const native = scValToNative(simulateTxResponse.result.retval);
+            return native.toString();
         }
-        return data;
+        throw new Error("Failed to fetch balance");
     }
-    async getAccountTokens(address) {
-        const data = await this.fetch(`accounts/${address}/tokens`);
-        if (!Array.isArray(data.tokens)) {
-            throw new Error("Invalid tokens type, expected array");
+    async getAllBalances(userAddress, tokens) {
+        const balancePromises = tokens.map((token) => {
+            return this.getBalance(userAddress, token.chainAssetConfig.stellar.contractAddress, token.chainId);
+        });
+        const results = await Promise.allSettled(balancePromises);
+        const balances = results.map((result) => {
+            if (result.status === "fulfilled") {
+                return result.value;
+            }
+            return "0";
+        });
+        return balances.map((balance, index) => {
+            return {
+                ...tokens[index],
+                balance,
+            };
+        });
+    }
+    /**
+     * Resolves when the transaction is confirmed, or fails after a timeout.
+     */
+    async waitForTransaction(txHash, { interval = 2_000, timeout = 40_000 } = {}) {
+        const startTime = Date.now();
+        while (true) {
+            const result = await this.server.getTransaction(txHash);
+            if (result.status === rpc.Api.GetTransactionStatus.NOT_FOUND) {
+                if (Date.now() - startTime > timeout) {
+                    throw new Error(`Transaction ${txHash} not found within timeout`);
+                }
+                // eslint-disable-next-line @typescript-eslint/no-loop-func
+                await new Promise((res) => setTimeout(res, interval));
+                continue;
+            }
+            if (result.status === rpc.Api.GetTransactionStatus.SUCCESS) {
+                return result.status;
+            }
+            throw new Error(`Transaction failed with status: ${result.status}`);
         }
-        const firstToken = data.tokens[0];
-        if (typeof firstToken?.automatic_association !== "boolean") {
-            throw new Error("Invalid automatic_association type, expected boolean");
+    }
+    async isAccountActivated(address) {
+        try {
+            await this.getAccount(address);
+            return true;
         }
-        if (typeof firstToken?.token_id !== "string") {
-            throw new Error("Invalid token_id type, expected string");
+        catch (error) {
+            if (error?.message && error.message.includes("Account not found")) {
+                return false;
+            }
+            throw error;
         }
-        return data;
     }
-    async fetch(path) {
-        const url = new URL(path, this.apiUrl);
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Hedera API error: ${response.status}`);
+    async getAccount(address) {
+        return this.server.getAccount(address);
+    }
+    async sendTransaction(transaction) {
+        const transactionResponse = await this.server.sendTransaction(transaction);
+        if (transactionResponse.status === "ERROR") {
+            throw new Error("Error sending transaction");
         }
-        return response.json();
+        return transactionResponse;
+    }
+    async prepareTransaction(transaction) {
+        return this.server.prepareTransaction(transaction);
     }
 }
 
-hederaWalletConnect.type = "hederaWalletConnect";
-/**
- * Wagmi connector to interact with the Hedera EVM network via the WalletConnect protocol.
- *
- * The connector removes the need for a WalletConnect modal, and instead
- * communicates with the provided `extension` by opening the extension popup
- * for user interaction upon request.
- */
-function hederaWalletConnect(parameters) {
-    const { extension, ...restParameters } = parameters;
-    let provider_;
-    let providerPromise;
-    let connect;
-    let displayUri;
-    let sessionDelete;
-    let disconnect;
-    return createConnector((config) => ({
-        id: `hedera-wc-${extension.id}`,
-        name: extension.name,
-        icon: extension.icon,
-        type: hederaWalletConnect.type,
-        async setup() {
-            const provider = await this.getProvider().catch(() => null);
-            if (!provider)
-                return;
-            if (!connect) {
-                connect = this.onConnect.bind(this);
-                provider.on("connect", connect);
-            }
-            if (!sessionDelete) {
-                sessionDelete = this.onSessionDelete.bind(this);
-                provider.on("session_delete", sessionDelete);
+class XrplRpcClient {
+    rpcUrl;
+    constructor(rpcUrl) {
+        this.rpcUrl = rpcUrl;
+    }
+    async getBalance(address, tokenAddress) {
+        if (tokenAddress.toLowerCase() === nativeXrplTokenAddress.toLowerCase()) {
+            return this.getNativeBalance(address);
+        }
+        return this.getIssuedCurrencyBalance(address, tokenAddress);
+    }
+    async getAllBalances(address) {
+        const [nativeBalance, trustLineBalances] = await Promise.all([
+            this.getNativeBalance(address),
+            this.getTrustLines(address),
+        ]);
+        return [
+            {
+                balance: nativeBalance,
+                address: nativeXrplTokenAddress,
+            },
+            ...trustLineBalances.lines.map((line) => ({
+                balance: line.balance,
+                address: `${line.currency}.${line.account}`,
+            })),
+        ];
+    }
+    async getTrustLines(address, issuer) {
+        return this.call("account_lines", [
+            {
+                account: address,
+                ledger_index: "validated",
+                peer: issuer,
+            },
+        ]);
+    }
+    async getTrustLine(address, asset) {
+        const response = await this.getTrustLines(address, asset.issuer);
+        const trustLine = response.lines.find((line) => line.currency === asset.code);
+        return trustLine ?? null;
+    }
+    async accountActivatedInfo(address) {
+        const serverState = await this.getServerState();
+        const reserveBaseBn = BigInt(serverState.state.validated_ledger.reserve_base);
+        try {
+            const accountInfo = await this.getAccountInfo(address);
+            const balanceBn = BigInt(accountInfo.account_data.Balance);
+            return {
+                isActivated: balanceBn >= reserveBaseBn,
+                reserveBaseBn,
+            };
+        }
+        catch (error) {
+            if (error.message?.includes("actNotFound")) {
+                return { isActivated: false, reserveBaseBn };
             }
-        },
-        async connect(params = {}) {
+            throw error;
+        }
+    }
+    /**
+     * Waits for a transaction to be validated and returns its final status.
+     * Resolves to 'success' or throws an error with the failed status.
+     */
+    async waitForTransaction(txHash, { interval = 2_000, timeout = 20_000 } = {}) {
+        const startTime = Date.now();
+        while (true) {
             try {
-                const provider = await this.getProvider();
-                if (!provider)
-                    throw new ProviderNotFoundError();
-                if (!displayUri) {
-                    displayUri = this.onDisplayUri;
-                    provider.on("display_uri", displayUri);
-                }
-                if (!provider.session) {
-                    await provider.connect({
-                        ...("pairingTopic" in params
-                            ? { pairingTopic: params.pairingTopic }
-                            : {}),
-                    });
-                }
-                const accounts = (await provider.enable()).map((x) => getAddress(x));
-                const currentChainId = await this.getChainId();
-                if (displayUri) {
-                    provider.removeListener("display_uri", displayUri);
-                    displayUri = undefined;
-                }
-                if (connect) {
-                    provider.removeListener("connect", connect);
-                    connect = undefined;
+                const response = await this.call("tx", [
+                    {
+                        transaction: txHash,
+                        binary: false,
+                    },
+                ]);
+                if (!response.validated) {
+                    if (Date.now() - startTime > timeout) {
+                        throw new Error(`Transaction ${txHash} not validated within timeout`);
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-loop-func
+                    await new Promise((res) => setTimeout(res, interval));
+                    continue;
                 }
-                if (!disconnect) {
-                    disconnect = this.onDisconnect.bind(this);
-                    provider.on("disconnect", disconnect);
+                const status = response.meta?.TransactionResult;
+                if (status === XrplTxStatus.SUCCESS) {
+                    return status;
                 }
-                if (!sessionDelete) {
-                    sessionDelete = this.onSessionDelete.bind(this);
-                    provider.on("session_delete", sessionDelete);
+                else {
+                    throw new Error(`Transaction failed with status: ${status}`);
                 }
-                return { accounts, chainId: currentChainId };
             }
             catch (error) {
-                if (/(user rejected|connection request reset)/i.test(error?.message)) {
-                    throw new UserRejectedRequestError(error);
+                // txnNotFound = still pending or non-existent
+                if (error?.message?.includes("txnNotFound")) {
+                    if (Date.now() - startTime > timeout) {
+                        throw new Error(`Transaction ${txHash} not found within timeout`);
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-loop-func
+                    await new Promise((res) => setTimeout(res, interval));
+                    continue;
                 }
                 throw error;
             }
-        },
-        async disconnect() {
-            const provider = await this.getProvider();
-            try {
-                await provider?.disconnect();
-            }
-            catch (error) {
-                if (!/No matching key/i.test(error.message))
-                    throw error;
-            }
-            finally {
-                if (disconnect) {
-                    provider?.removeListener("disconnect", disconnect);
-                    disconnect = undefined;
-                }
-                if (!connect) {
-                    connect = this.onConnect.bind(this);
-                    provider?.on("connect", connect);
-                }
-                if (sessionDelete) {
-                    provider?.removeListener("session_delete", sessionDelete);
-                    sessionDelete = undefined;
-                }
-            }
-        },
-        async getAccounts() {
-            const provider = await this.getProvider();
-            return provider.accounts.map((x) => getAddress(x));
-        },
-        async getProvider() {
-            async function initProvider() {
-                const optionalChains = config.chains.map((x) => x.id);
-                if (!optionalChains.length)
-                    return;
-                const { EthereumProvider } = await import('./index.es-BfdAGErV.js');
-                const rawProvider = await EthereumProvider.init({
-                    ...restParameters,
-                    disableProviderPing: true,
-                    optionalChains,
-                    projectId: restParameters.projectId,
-                    rpcMap: Object.fromEntries(config.chains.map((chain) => {
-                        const [url] = extractRpcUrls({
-                            chain,
-                            transports: config.transports,
-                        });
-                        return [chain.id, url];
-                    })),
-                    showQrModal: false,
-                    // We need to specify a custom storage prefix to avoid conflicts with Wagmi's walletConnect instance
-                    // https://docs.reown.com/walletkit/web/usage#core-instance-sharing
-                    customStoragePrefix: "squid-hedera",
-                });
-                const proxiedProvider = new Proxy(rawProvider, {
-                    get(target, prop, receiver) {
-                        if (prop === "request") {
-                            return async (args) => {
-                                const signingMethods = [
-                                    "eth_sendTransaction",
-                                    "eth_signTransaction",
-                                ];
-                                if (signingMethods.includes(args.method)) {
-                                    try {
-                                        HederaExtensionHelper.extensionOpen(extension.id);
-                                    }
-                                    catch { }
-                                }
-                                // forward request to original provider
-                                return target.request(args);
-                            };
-                        }
-                        // forward all other properties/methods
-                        return Reflect.get(target, prop, receiver);
-                    },
-                });
-                return proxiedProvider;
-            }
-            if (!provider_) {
-                if (!providerPromise)
-                    providerPromise = initProvider();
-                provider_ = await providerPromise;
-                provider_?.events.setMaxListeners(Number.POSITIVE_INFINITY);
-            }
-            return provider_;
-        },
-        async getChainId() {
-            const provider = await this.getProvider();
-            return provider.chainId;
-        },
-        async isAuthorized() {
-            try {
-                const accounts = await this.getAccounts();
-                return accounts.length > 0;
-            }
-            catch {
-                return false;
-            }
-        },
-        onAccountsChanged(accounts) {
-            if (accounts.length === 0)
-                this.onDisconnect();
-            else
-                config.emitter.emit("change", {
-                    accounts: accounts.map((x) => getAddress(x)),
-                });
-        },
-        onChainChanged(chain) {
-            const chainId = Number(chain);
-            config.emitter.emit("change", { chainId });
-        },
-        async onConnect(connectInfo) {
-            const chainId = Number(connectInfo.chainId);
-            const accounts = await this.getAccounts();
-            config.emitter.emit("connect", { accounts, chainId });
-        },
-        async onDisconnect() {
-            config.emitter.emit("disconnect");
-            const provider = await this.getProvider();
-            if (disconnect) {
-                provider.removeListener("disconnect", disconnect);
-                disconnect = undefined;
-            }
-            if (sessionDelete) {
-                provider.removeListener("session_delete", sessionDelete);
-                sessionDelete = undefined;
-            }
-            if (!connect) {
-                connect = this.onConnect.bind(this);
-                provider.on("connect", connect);
-            }
-        },
-        onDisplayUri(uri) {
-            config.emitter.emit("message", { type: "display_uri", data: uri });
-            HederaExtensionHelper.extensionConnect(extension.id, uri);
-        },
-        onSessionDelete() {
-            this.onDisconnect();
-        },
-    }));
-}
-
-const createWagmiConfig = (squidChains, hederaExtensions) => {
-    const filteredEvmChains = squidChains.filter((chain) => chain.chainType === ChainType.EVM);
-    if (filteredEvmChains.length === 0) {
-        throw new Error("At least one chain is required");
+        }
     }
-    const wagmiChains = filteredEvmChains.map((chain) => {
-        return defineChain({
-            id: Number(chain.chainId),
-            name: chain.networkName,
-            nativeCurrency: {
-                name: chain.nativeCurrency.name,
-                symbol: chain.nativeCurrency.symbol,
-                decimals: chain.nativeCurrency.decimals,
+    async getServerState() {
+        return this.call("server_state", [{}]);
+    }
+    async getAccountInfo(address) {
+        return this.call("account_info", [
+            {
+                account: address,
+                ledger_index: "validated",
             },
-            rpcUrls: {
-                public: {
-                    http: [chain.rpc],
-                },
-                default: {
-                    http: [chain.rpc],
-                },
+        ]);
+    }
+    /**
+     * 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",
             },
-        });
-    });
-    const wcMetadata = {
-        url: SQUID_METADATA.url,
-        name: SQUID_METADATA.name,
-        icons: [SQUID_METADATA.icon],
-        description: SQUID_METADATA.description,
-    };
-    return createConfig({
-        chains: wagmiChains,
-        transports: Object.fromEntries(wagmiChains.map((chain) => [
-            chain.id,
-            http(chain.rpcUrls.public.http[0] ?? ""),
-        ])),
-        connectors: [
-            injected(),
-            safe({
-                allowedDomains: [/app.safe.global$/],
-            }),
-            metaMask({
-                dappMetadata: {
-                    name: SQUID_METADATA.name,
-                    url: SQUID_METADATA.url,
-                    iconUrl: SQUID_METADATA.icon,
-                },
-            }),
-            coinbaseWallet({
-                appName: SQUID_METADATA.name,
-                appLogoUrl: SQUID_METADATA.icon,
-            }),
-            walletConnect({
-                projectId: WALLETCONNECT_PROJECT_ID,
-                metadata: wcMetadata,
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method,
+                params,
             }),
-            ...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 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 network = {
-        chainId: chain.id,
-        name: chain.name,
-        ensAddress: chain.contracts?.ensRegistry?.address,
-    };
-    const provider = new BrowserProvider(transport, network);
-    const signer = new JsonRpcSigner(provider, account.address);
-    return signer;
 }
 
-function useEvmSigner({ chainId }) {
-    const { connector } = useAccount();
-    const { data: client } = useWalletClient({ chainId, connector });
-    const signer = useMemo(() => (client ? clientToSigner(client) : undefined), [client]);
-    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;
 }
-const useSigner = ({ chain }) => {
-    const evmChainId = chain?.chainType === ChainType.EVM ? Number(chain.chainId) : undefined;
-    // EVM and Cosmos need a different signer for each chain
-    // This is not the case for Solana or Bitcoin as there's only one chain in those ecosystems
-    const { signer: evmSigner } = useEvmSigner({ chainId: evmChainId });
-    const { signer: cosmosSigner } = useCosmosSigner({ chain });
-    const { signer: solanaSigner } = useSolanaContext();
-    const { signer: bitcoinSigner } = useBitcoinContext();
-    const { signer: suiSigner } = useSuiContext();
-    const { signer: xrplSigner } = useXrplContext();
-    const { signer: stellarSigner } = useStellarContext();
-    const isEvmSignerReady = !!evmSigner;
-    const isSolanaSignerReady = !!solanaSigner;
-    const isCosmosSignerReady = !!cosmosSigner;
-    const isBitcoinSignerReady = !!bitcoinSigner;
-    const isSuiSignerReady = !!suiSigner;
-    const isXrplSignerReady = !!xrplSigner;
-    const isStellarSignerReady = !!stellarSigner;
-    const isSignerReady = useMemo(() => {
-        if (!chain?.chainType)
-            return false;
-        switch (chain.chainType) {
-            case ChainType.EVM:
-                return isEvmSignerReady;
-            case ChainType.COSMOS:
-                return isCosmosSignerReady;
-            case ChainType.BTC:
-                return isBitcoinSignerReady;
-            case ChainType.SOLANA:
-                return isSolanaSignerReady;
-            case ChainType.SUI:
-                return isSuiSignerReady;
-            case ChainType.XRPL:
-                return isXrplSignerReady;
-            case ChainType.STELLAR:
-                return isStellarSignerReady;
-        }
-    }, [
-        chain?.chainType,
-        isEvmSignerReady,
-        isCosmosSignerReady,
-        isBitcoinSignerReady,
-        isSolanaSignerReady,
-        isSuiSignerReady,
-        isXrplSignerReady,
-        isStellarSignerReady,
-    ]);
-    return {
-        isSignerReady,
-        evmSigner,
-        cosmosSigner,
-        bitcoinSigner,
-        solanaSigner,
-        suiSigner,
-        xrplSigner,
-        stellarSigner,
-    };
-};
-
-function useHederaTokenAssociations({ address, chain, token }) {
-    const publicClient = usePublicClient({
-        chainId: Number(CHAIN_IDS.HEDERA),
-    });
-    const { evmSigner } = useSigner({ chain });
-    const queryClient = useQueryClient();
-    /**
-     * Creates a token association transaction where the destination account authorizes to receive the given token
-     */
-    const associateToken = useMutation({
-        mutationFn: async () => {
-            try {
-                if (!evmSigner) {
-                    throw new Error("EVM signer not found");
-                }
-                if (chain?.chainId !== CHAIN_IDS.HEDERA ||
-                    token?.chainId !== CHAIN_IDS.HEDERA) {
-                    throw new Error("Chain and token to associate must be on Hedera");
-                }
-                const tokenAddress = parseEvmAddress(token.address);
-                if (!tokenAddress) {
-                    throw new Error("Invalid token address");
-                }
-                const userAddress = parseEvmAddress(address);
-                if (!userAddress) {
-                    throw new Error("Invalid user address");
-                }
-                const encodedData = encodeFunctionData({
-                    abi: hrc20,
-                    functionName: "associate",
-                    args: [],
-                });
-                const txRes = await evmSigner.sendTransaction({
-                    data: encodedData,
-                    to: tokenAddress,
-                    chainId: chain.chainId,
-                });
-                const receipt = await txRes.wait();
-                if (receipt?.status !== 1) {
-                    throw new Error(`Transaction failed with status: ${receipt?.status}`);
-                }
-                return true;
-            }
-            catch (error) {
-                console.error("Error associating Hedera token:", error);
-                return false;
-            }
-        },
-        async onSuccess() {
-            queryClient.refetchQueries({
-                queryKey: getPrefixKey(QueryKeys.IsHederaTokenAssociated),
-            });
-        },
-    });
-    /**
-     * Checks if the destination account has associated the given token.
-     *
-     * Hedera requires accounts to associate a token before being able to receive it.
-     *
-     * Accounts which have max. associations set to -1 can receive any token without previous association
-     */
-    const isTokenAssociated = useQuery({
-        queryKey: keys().isHederaTokenAssociated(address, token?.chainId, token?.type, token?.address),
-        queryFn: async () => {
-            if (token?.chainId !== CHAIN_IDS.HEDERA) {
-                return true;
-            }
-            // The native HBAR token doesn't need an association
-            if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase()) {
-                return true;
-            }
-            if (!chain || !address || !publicClient) {
-                throw new Error("Missing required parameters");
-            }
-            // TODO: update types
-            const apiUrl = chain?.chainConfig?.hedera?.mirrorNodeUrl;
-            if (!apiUrl) {
-                throw new Error("Missing Hedera mirror node URL in chain config");
-            }
-            const hederaApiClient = new HederaApiClient(apiUrl);
-            return hederaApiClient.isTokenAssociated({
-                address,
-                token,
+async function createClient(chain) {
+    switch (chain.chainType) {
+        case ChainType.EVM:
+            return new JsonRpcProvider(chain.rpc);
+        case ChainType.COSMOS:
+            const rpcUrl = await getWorkingCosmosRpcUrl(chain);
+            return (await StargateClient.connect(rpcUrl));
+        case ChainType.SOLANA:
+            return new Connection(SOLANA_RPC_URL);
+        case ChainType.BTC:
+            return null;
+        case ChainType.SUI:
+            return new SuiClient({
+                url: chain.rpc,
             });
-        },
-        enabled: !!address && !!publicClient && token?.chainId === CHAIN_IDS.HEDERA,
-    });
-    return {
-        isTokenAssociated,
-        associateToken,
-    };
+        case ChainType.XRPL:
+            return new XrplRpcClient(chain.rpc);
+        case ChainType.STELLAR:
+            return new StellarRpcClient(chain.rpc);
+    }
 }
 
-const useKeyboardNavigation = ({ onEscape }) => {
-    const onKeyDown = useCallback((event) => {
-        if (event.key === "Escape") {
-            onEscape?.();
-            return;
-        }
-    }, [onEscape]);
-    useEffect(() => {
-        document.addEventListener("keydown", onKeyDown, false);
-        return () => {
-            document.removeEventListener("keydown", onKeyDown, false);
-        };
-    }, [onKeyDown]);
-};
-
-const useSquidQueryClient = () => {
-    const queryClient = useQueryClient();
-    const invalidateQueries = (key) => {
-        const prefixKey = getPrefixKey(key);
-        queryClient.invalidateQueries(prefixKey);
-    };
-    const refetchQueries = (key) => {
-        const prefixKey = getPrefixKey(key);
-        queryClient.refetchQueries(prefixKey);
-    };
-    const invalidateAndRefetchQueries = (key) => {
-        invalidateQueries(key);
-        refetchQueries(key);
-    };
-    return {
-        invalidateQueries,
-        refetchQueries,
-        invalidateAndRefetchQueries,
-    };
-};
-
 /**
  * The default multicall3 address
  * available on most EVM chains
@@ -29328,12 +29191,15 @@ const getAllXrplTokensBalance = async (userAddress, xrplTokens, xrplChains) => {
 };
 const getStellarTokenBalance = async (userAddress, token, chain) => {
     const stellarClient = await getClient(chain);
-    const balance = await stellarClient.getBalance(userAddress, token.address, chain.chainId);
+    if (!isStellarToken(token)) {
+        throw new Error("Token must be a Stellar token");
+    }
+    const balance = await stellarClient.getBalance(userAddress, token.chainAssetConfig.stellar.contractAddress, chain.chainId);
     return BigInt(balance);
 };
 const getAllStellarTokensBalance = async (userAddress, stellarTokens, stellarChains) => {
     const getBalancesForChain = async (chain) => {
-        const tokensForChain = stellarTokens.filter((t) => t.chainId === chain.chainId);
+        const tokensForChain = stellarTokens.filter((t) => t.chainId === chain.chainId && isStellarToken(t));
         const stellarClient = await getClient(chain);
         const allBalances = await stellarClient.getAllBalances(userAddress, tokensForChain);
         return allBalances.map((token) => {
@@ -29360,372 +29226,6 @@ function timeout(ms, promise) {
     return Promise.race([promise, timeoutPromise]);
 }
 
-class StellarRpcClient {
-    server;
-    constructor(rpcUrl) {
-        this.server = new rpc.Server(rpcUrl);
-    }
-    /**
-     * Returns the balance of a Stellar Contract Token. This is different from an Issued Token.
-     *
-     * With Contract Tokens, we need to call the .balance method on the token contract
-     * and simulate the transaction to get the balance.
-     */
-    async getBalance(userAddress, tokenAddress, chainId) {
-        const account = await this.server.getAccount(userAddress);
-        const network = getStellarNetwork(chainId);
-        if (network == null) {
-            throw new Error(`No Stellar network found for chainId ${chainId}`);
-        }
-        const txBuilder = new TransactionBuilder(account, {
-            fee: (BigInt(BASE_FEE) * BigInt(2)).toString(),
-            networkPassphrase: network,
-        });
-        const contract = new Contract(tokenAddress);
-        const tx = txBuilder
-            .addOperation(contract.call("balance", new Address(userAddress).toScVal()))
-            .setTimeout(TimeoutInfinite)
-            .build();
-        const simulateTxResponse = await this.server.simulateTransaction(tx);
-        if ("error" in simulateTxResponse) {
-            const isNoBalanceError = simulateTxResponse.error.includes("trying to get non-existing value for contract instance");
-            // If the error message indicates that the user has no balance just return 0
-            // We don't want to spam with this error as it's pretty common
-            if (isNoBalanceError) {
-                return "0";
-            }
-            throw new Error(`Failed to fetch balance. RPC response: ${simulateTxResponse.error}`);
-        }
-        if ("result" in simulateTxResponse && simulateTxResponse.result != null) {
-            const native = scValToNative(simulateTxResponse.result.retval);
-            return native.toString();
-        }
-        throw new Error("Failed to fetch balance");
-    }
-    async getAllBalances(userAddress, tokens) {
-        const balancePromises = tokens.map((token) => {
-            return this.getBalance(userAddress, token.address, token.chainId);
-        });
-        const results = await Promise.allSettled(balancePromises);
-        const balances = results.map((result) => {
-            if (result.status === "fulfilled") {
-                return result.value;
-            }
-            return "0";
-        });
-        return balances.map((balance, index) => {
-            return {
-                ...tokens[index],
-                balance,
-            };
-        });
-    }
-    /**
-     * Resolves when the transaction is confirmed, or fails after a timeout.
-     */
-    async waitForTransaction(txHash, { interval = 2_000, timeout = 40_000 } = {}) {
-        const startTime = Date.now();
-        while (true) {
-            const result = await this.server.getTransaction(txHash);
-            if (result.status === rpc.Api.GetTransactionStatus.NOT_FOUND) {
-                if (Date.now() - startTime > timeout) {
-                    throw new Error(`Transaction ${txHash} not found within timeout`);
-                }
-                // eslint-disable-next-line @typescript-eslint/no-loop-func
-                await new Promise((res) => setTimeout(res, interval));
-                continue;
-            }
-            if (result.status === rpc.Api.GetTransactionStatus.SUCCESS) {
-                return result.status;
-            }
-            throw new Error(`Transaction failed with status: ${result.status}`);
-        }
-    }
-    async isAccountActivated(address) {
-        try {
-            await this.getAccount(address);
-            return true;
-        }
-        catch (error) {
-            if (error?.message && error.message.includes("Account not found")) {
-                return false;
-            }
-            throw error;
-        }
-    }
-    async getAccount(address) {
-        return this.server.getAccount(address);
-    }
-    async sendTransaction(transaction) {
-        const transactionResponse = await this.server.sendTransaction(transaction);
-        if (transactionResponse.status === "ERROR") {
-            throw new Error("Error sending transaction");
-        }
-        return transactionResponse;
-    }
-    async prepareTransaction(transaction) {
-        return this.server.prepareTransaction(transaction);
-    }
-}
-
-class XrplRpcClient {
-    rpcUrl;
-    constructor(rpcUrl) {
-        this.rpcUrl = rpcUrl;
-    }
-    async getBalance(address, tokenAddress) {
-        if (tokenAddress.toLowerCase() === nativeXrplTokenAddress.toLowerCase()) {
-            return this.getNativeBalance(address);
-        }
-        return this.getIssuedCurrencyBalance(address, tokenAddress);
-    }
-    async getAllBalances(address) {
-        const [nativeBalance, trustLineBalances] = await Promise.all([
-            this.getNativeBalance(address),
-            this.getTrustLines(address),
-        ]);
-        return [
-            {
-                balance: nativeBalance,
-                address: nativeXrplTokenAddress,
-            },
-            ...trustLineBalances.lines.map((line) => ({
-                balance: line.balance,
-                address: `${line.currency}.${line.account}`,
-            })),
-        ];
-    }
-    async getTrustLines(address, issuer) {
-        return this.call("account_lines", [
-            {
-                account: address,
-                ledger_index: "validated",
-                peer: issuer,
-            },
-        ]);
-    }
-    async getTrustLine(address, issuer, currency) {
-        const response = await this.getTrustLines(address, issuer);
-        const trustLine = response.lines.find((line) => line.currency === currency);
-        return trustLine ?? null;
-    }
-    async accountActivatedInfo(address) {
-        const serverState = await this.getServerState();
-        const reserveBaseBn = BigInt(serverState.state.validated_ledger.reserve_base);
-        try {
-            const accountInfo = await this.getAccountInfo(address);
-            const balanceBn = BigInt(accountInfo.account_data.Balance);
-            return {
-                isActivated: balanceBn >= reserveBaseBn,
-                reserveBaseBn,
-            };
-        }
-        catch (error) {
-            if (error.message?.includes("actNotFound")) {
-                return { isActivated: false, reserveBaseBn };
-            }
-            throw error;
-        }
-    }
-    /**
-     * Waits for a transaction to be validated and returns its final status.
-     * Resolves to 'success' or throws an error with the failed status.
-     */
-    async waitForTransaction(txHash, { interval = 2_000, timeout = 20_000 } = {}) {
-        const startTime = Date.now();
-        while (true) {
-            try {
-                const response = await this.call("tx", [
-                    {
-                        transaction: txHash,
-                        binary: false,
-                    },
-                ]);
-                if (!response.validated) {
-                    if (Date.now() - startTime > timeout) {
-                        throw new Error(`Transaction ${txHash} not validated within timeout`);
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-loop-func
-                    await new Promise((res) => setTimeout(res, interval));
-                    continue;
-                }
-                const status = response.meta?.TransactionResult;
-                if (status === XrplTxStatus.SUCCESS) {
-                    return status;
-                }
-                else {
-                    throw new Error(`Transaction failed with status: ${status}`);
-                }
-            }
-            catch (error) {
-                // txnNotFound = still pending or non-existent
-                if (error?.message?.includes("txnNotFound")) {
-                    if (Date.now() - startTime > timeout) {
-                        throw new Error(`Transaction ${txHash} not found within timeout`);
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-loop-func
-                    await new Promise((res) => setTimeout(res, interval));
-                    continue;
-                }
-                throw error;
-            }
-        }
-    }
-    async getServerState() {
-        return this.call("server_state", [{}]);
-    }
-    async getAccountInfo(address) {
-        return this.call("account_info", [
-            {
-                account: address,
-                ledger_index: "validated",
-            },
-        ]);
-    }
-    /**
-     * Returns the balance of the user in the native XRP token
-     * formatted as a string
-     */
-    async getNativeBalance(address) {
-        const [accountInfo, serverState] = await Promise.all([
-            this.getAccountInfo(address),
-            this.getServerState(),
-        ]);
-        const balance = BigInt(accountInfo.account_data.Balance);
-        const ownerCount = BigInt(accountInfo.account_data.OwnerCount);
-        const reserveBase = BigInt(serverState.state.validated_ledger.reserve_base);
-        const reserveIncrement = BigInt(serverState.state.validated_ledger.reserve_inc);
-        const reserveBalance = reserveBase + ownerCount * reserveIncrement;
-        const spendableBalance = balance - reserveBalance;
-        return formatBNToReadable(spendableBalance, 6);
-    }
-    /**
-     * Returns the balance of the user in the given issued currency (e.g. RLUSD)
-     * formatted as a string
-     */
-    async getIssuedCurrencyBalance(address, tokenAddress) {
-        const response = await this.getTrustLines(address);
-        const tokenBalance = response.lines.find((line) => `${line.currency}.${line.account}` === tokenAddress);
-        return tokenBalance?.balance || "0";
-    }
-    async call(method, params) {
-        const response = await fetch(this.rpcUrl, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                jsonrpc: "2.0",
-                id: 1,
-                method,
-                params,
-            }),
-        });
-        const data = await response.json();
-        if (!data.result) {
-            throw new Error(`Invalid response from RPC (${method})`);
-        }
-        if ("error" in data.result) {
-            throw new Error(`Error from RPC (${method}): ${data.result.error}`);
-        }
-        return data.result;
-    }
-}
-
-const clientCache = new Map();
-async function getClient(chain) {
-    const key = `${chain.chainType}:${chain.chainId}`;
-    if (clientCache.has(key)) {
-        return clientCache.get(key);
-    }
-    const client = await createClient(chain);
-    clientCache.set(key, client);
-    return client;
-}
-async function createClient(chain) {
-    switch (chain.chainType) {
-        case ChainType.EVM:
-            return new JsonRpcProvider(chain.rpc);
-        case ChainType.COSMOS:
-            const rpcUrl = await getWorkingCosmosRpcUrl(chain);
-            return (await StargateClient.connect(rpcUrl));
-        case ChainType.SOLANA:
-            return new Connection(SOLANA_RPC_URL);
-        case ChainType.BTC:
-            return null;
-        case ChainType.SUI:
-            return new SuiClient({
-                url: chain.rpc,
-            });
-        case ChainType.XRPL:
-            return new XrplRpcClient(chain.rpc);
-        case ChainType.STELLAR:
-            return new StellarRpcClient(chain.rpc);
-    }
-}
-
-class StellarApiClient {
-    apiUrl;
-    constructor(apiUrl) {
-        this.apiUrl = apiUrl;
-    }
-    async getBaseReserve() {
-        const response = await fetch(`${this.apiUrl}/ledgers?order=desc&limit=1`);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch ledgers: ${response.status}`);
-        }
-        const ledgers = await response.json();
-        const latestLedger = ledgers?._embedded.records?.[0];
-        if (latestLedger?.base_reserve_in_stroops == null) {
-            throw new Error("Invalid ledger data");
-        }
-        const baseReserveBn = BigInt(latestLedger.base_reserve_in_stroops);
-        return baseReserveBn;
-    }
-}
-
-const DEFAULT_REFETCH_INTERVAL$1 = 20_000;
-function useStellarAccountActivation({ address, chain, token, }) {
-    /**
-     * Checks if the destination account exists on the Stellar network
-     * Stellar accounts need to have a minimum balance before they can receive payments
-     */
-    const accountActivatedInfo = useQuery({
-        queryKey: keys().stellarAccountActivatedInfo(address, chain?.chainId, chain?.chainType),
-        queryFn: async () => {
-            if (chain?.chainType !== ChainType.STELLAR ||
-                token?.type !== ChainType.STELLAR) {
-                return null;
-            }
-            if (!address) {
-                throw new Error("Destination address is required");
-            }
-            // TODO: update types
-            const [horizonApiUrl] = chain?.horizonRpcList;
-            if (typeof horizonApiUrl !== "string") {
-                throw new Error("Invalid Horizon API URL");
-            }
-            const stellarApiClient = new StellarApiClient(horizonApiUrl);
-            const reserveBase = await stellarApiClient.getBaseReserve();
-            // Stellar accounts require two base reserves to be activated
-            // https://developers.stellar.org/docs/learn/fundamentals/lumens#minimum-balance
-            const accountReserveBase = reserveBase * BigInt(2);
-            const stellarRpcClient = await getClient(chain);
-            const isActivated = await stellarRpcClient.isAccountActivated(address);
-            return {
-                isActivated,
-                reserveBaseBn: accountReserveBase,
-            };
-        },
-        enabled: !!address && chain?.chainType === ChainType.STELLAR,
-        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
-        refetchOnWindowFocus: true,
-    });
-    return {
-        accountActivatedInfo,
-    };
-}
-
 const DEFAULT_REFRESH_INTERVAL_MS = 15000;
 const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
     const { isChainTypeConnected } = useWallet();
@@ -29920,6 +29420,8 @@ function useNativeTokenForChain(chain) {
         }
     };
     const nativeTokenForChainType = useMemo(() => {
+        if (!chain)
+            return undefined;
         return findNativeToken(getTokensForChainType(), chain);
     }, [chain]);
     return { nativeToken: nativeTokenForChainType };
@@ -30166,47 +29668,842 @@ const useNativeBalance = (chain) => {
             return false;
         switch (chain.chainType) {
             case ChainType.EVM:
-                return isEvmLoading;
+                return isEvmLoading;
+            case ChainType.COSMOS:
+                return isCosmosLoading;
+            case ChainType.BTC:
+                return isBitcoinLoading;
+            case ChainType.SOLANA:
+                return isSolanaLoading;
+            case ChainType.SUI:
+                return isSuiLoading;
+            case ChainType.XRPL:
+                return isXrpLoading;
+            case ChainType.STELLAR:
+                return isStellarLoading;
+        }
+    }, [
+        chain?.chainType,
+        isEvmLoading,
+        isCosmosLoading,
+        isBitcoinLoading,
+        isSolanaLoading,
+        isSuiLoading,
+        isXrpLoading,
+        isStellarLoading,
+    ]);
+    return { nativeBalance, nativeBalanceFormatted, isLoading };
+};
+
+function useHederaAccountActivation({ address, chain, token }) {
+    const { balance: destNativeEvmBalance } = useEvmNativeBalance({
+        chain,
+        address,
+    });
+    const isHederaAccountActivated = useMemo(() => {
+        if (token?.chainId !== CHAIN_IDS.HEDERA)
+            return true;
+        if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase())
+            return true;
+        return (!!destNativeEvmBalance?.value && destNativeEvmBalance.value > BigInt(0));
+    }, [token?.chainId, token?.address, destNativeEvmBalance?.value]);
+    return {
+        isHederaAccountActivated,
+    };
+}
+
+var hrc20 = [
+	{
+		inputs: [
+		],
+		name: "associate",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "responseCode",
+				type: "uint256"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	}
+];
+
+/**
+ * Client for interacting with the Hedera Mirrornode API.
+ *
+ * @docs https://mainnet.mirrornode.hedera.com/api/v1/docs
+ */
+class HederaApiClient {
+    apiUrl;
+    constructor(apiUrl) {
+        this.apiUrl = apiUrl;
+    }
+    async isTokenAssociated({ address, token, }) {
+        const accountInfo = await this.getAccountInfo(address);
+        // Unlimited auto associations
+        if (accountInfo.max_automatic_token_associations === -1) {
+            return true;
+        }
+        // If there's no unlimited auto-associations, we need to check if the token is already associated.
+        const { tokens: accountTokens } = await this.getAccountTokens(address);
+        const tokenId = convertEvmAddressToHederaAccountId(token.address);
+        if (accountTokens.some((t) => t.token_id === tokenId)) {
+            // Token is already associated
+            return true;
+        }
+        // Finally, if not auto-associated, check if there is an available auto-association slot
+        const autoAssociatedTokens = accountTokens.filter((t) => t.automatic_association);
+        const remainingAutoAssociations = accountInfo.max_automatic_token_associations -
+            autoAssociatedTokens.length;
+        return remainingAutoAssociations > 0;
+    }
+    async getAccountInfo(address) {
+        const data = await this.fetch(`accounts/${address}`);
+        if (typeof data.max_automatic_token_associations !== "number") {
+            throw new Error("Invalid max_automatic_token_associations type, expected number");
+        }
+        if (typeof data.balance.balance !== "number") {
+            throw new Error("Invalid balance type, expected number");
+        }
+        if (!Array.isArray(data.balance.tokens)) {
+            throw new Error("Invalid tokens type, expected array");
+        }
+        return data;
+    }
+    async getAccountTokens(address) {
+        const data = await this.fetch(`accounts/${address}/tokens`);
+        if (!Array.isArray(data.tokens)) {
+            throw new Error("Invalid tokens type, expected array");
+        }
+        const firstToken = data.tokens[0];
+        if (typeof firstToken?.automatic_association !== "boolean") {
+            throw new Error("Invalid automatic_association type, expected boolean");
+        }
+        if (typeof firstToken?.token_id !== "string") {
+            throw new Error("Invalid token_id type, expected string");
+        }
+        return data;
+    }
+    async fetch(path) {
+        const url = new URL(path, this.apiUrl);
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Hedera API error: ${response.status}`);
+        }
+        return response.json();
+    }
+}
+
+hederaWalletConnect.type = "hederaWalletConnect";
+/**
+ * Wagmi connector to interact with the Hedera EVM network via the WalletConnect protocol.
+ *
+ * The connector removes the need for a WalletConnect modal, and instead
+ * communicates with the provided `extension` by opening the extension popup
+ * for user interaction upon request.
+ */
+function hederaWalletConnect(parameters) {
+    const { extension, ...restParameters } = parameters;
+    let provider_;
+    let providerPromise;
+    let connect;
+    let displayUri;
+    let sessionDelete;
+    let disconnect;
+    return createConnector((config) => ({
+        id: `hedera-wc-${extension.id}`,
+        name: extension.name,
+        icon: extension.icon,
+        type: hederaWalletConnect.type,
+        async setup() {
+            const provider = await this.getProvider().catch(() => null);
+            if (!provider)
+                return;
+            if (!connect) {
+                connect = this.onConnect.bind(this);
+                provider.on("connect", connect);
+            }
+            if (!sessionDelete) {
+                sessionDelete = this.onSessionDelete.bind(this);
+                provider.on("session_delete", sessionDelete);
+            }
+        },
+        async connect(params = {}) {
+            try {
+                const provider = await this.getProvider();
+                if (!provider)
+                    throw new ProviderNotFoundError();
+                if (!displayUri) {
+                    displayUri = this.onDisplayUri;
+                    provider.on("display_uri", displayUri);
+                }
+                if (!provider.session) {
+                    await provider.connect({
+                        ...("pairingTopic" in params
+                            ? { pairingTopic: params.pairingTopic }
+                            : {}),
+                    });
+                }
+                const accounts = (await provider.enable()).map((x) => getAddress(x));
+                const currentChainId = await this.getChainId();
+                if (displayUri) {
+                    provider.removeListener("display_uri", displayUri);
+                    displayUri = undefined;
+                }
+                if (connect) {
+                    provider.removeListener("connect", connect);
+                    connect = undefined;
+                }
+                if (!disconnect) {
+                    disconnect = this.onDisconnect.bind(this);
+                    provider.on("disconnect", disconnect);
+                }
+                if (!sessionDelete) {
+                    sessionDelete = this.onSessionDelete.bind(this);
+                    provider.on("session_delete", sessionDelete);
+                }
+                return { accounts, chainId: currentChainId };
+            }
+            catch (error) {
+                if (/(user rejected|connection request reset)/i.test(error?.message)) {
+                    throw new UserRejectedRequestError(error);
+                }
+                throw error;
+            }
+        },
+        async disconnect() {
+            const provider = await this.getProvider();
+            try {
+                await provider?.disconnect();
+            }
+            catch (error) {
+                if (!/No matching key/i.test(error.message))
+                    throw error;
+            }
+            finally {
+                if (disconnect) {
+                    provider?.removeListener("disconnect", disconnect);
+                    disconnect = undefined;
+                }
+                if (!connect) {
+                    connect = this.onConnect.bind(this);
+                    provider?.on("connect", connect);
+                }
+                if (sessionDelete) {
+                    provider?.removeListener("session_delete", sessionDelete);
+                    sessionDelete = undefined;
+                }
+            }
+        },
+        async getAccounts() {
+            const provider = await this.getProvider();
+            return provider.accounts.map((x) => getAddress(x));
+        },
+        async getProvider() {
+            async function initProvider() {
+                const optionalChains = config.chains.map((x) => x.id);
+                if (!optionalChains.length)
+                    return;
+                const { EthereumProvider } = await import('./index.es-CczeKjuj.js');
+                const rawProvider = await EthereumProvider.init({
+                    ...restParameters,
+                    disableProviderPing: true,
+                    optionalChains,
+                    projectId: restParameters.projectId,
+                    rpcMap: Object.fromEntries(config.chains.map((chain) => {
+                        const [url] = extractRpcUrls({
+                            chain,
+                            transports: config.transports,
+                        });
+                        return [chain.id, url];
+                    })),
+                    showQrModal: false,
+                    // We need to specify a custom storage prefix to avoid conflicts with Wagmi's walletConnect instance
+                    // https://docs.reown.com/walletkit/web/usage#core-instance-sharing
+                    customStoragePrefix: "squid-hedera",
+                });
+                const proxiedProvider = new Proxy(rawProvider, {
+                    get(target, prop, receiver) {
+                        if (prop === "request") {
+                            return async (args) => {
+                                const signingMethods = [
+                                    "eth_sendTransaction",
+                                    "eth_signTransaction",
+                                ];
+                                if (signingMethods.includes(args.method)) {
+                                    try {
+                                        HederaExtensionHelper.extensionOpen(extension.id);
+                                    }
+                                    catch { }
+                                }
+                                // forward request to original provider
+                                return target.request(args);
+                            };
+                        }
+                        // forward all other properties/methods
+                        return Reflect.get(target, prop, receiver);
+                    },
+                });
+                return proxiedProvider;
+            }
+            if (!provider_) {
+                if (!providerPromise)
+                    providerPromise = initProvider();
+                provider_ = await providerPromise;
+                provider_?.events.setMaxListeners(Number.POSITIVE_INFINITY);
+            }
+            return provider_;
+        },
+        async getChainId() {
+            const provider = await this.getProvider();
+            return provider.chainId;
+        },
+        async isAuthorized() {
+            try {
+                const accounts = await this.getAccounts();
+                return accounts.length > 0;
+            }
+            catch {
+                return false;
+            }
+        },
+        onAccountsChanged(accounts) {
+            if (accounts.length === 0)
+                this.onDisconnect();
+            else
+                config.emitter.emit("change", {
+                    accounts: accounts.map((x) => getAddress(x)),
+                });
+        },
+        onChainChanged(chain) {
+            const chainId = Number(chain);
+            config.emitter.emit("change", { chainId });
+        },
+        async onConnect(connectInfo) {
+            const chainId = Number(connectInfo.chainId);
+            const accounts = await this.getAccounts();
+            config.emitter.emit("connect", { accounts, chainId });
+        },
+        async onDisconnect() {
+            config.emitter.emit("disconnect");
+            const provider = await this.getProvider();
+            if (disconnect) {
+                provider.removeListener("disconnect", disconnect);
+                disconnect = undefined;
+            }
+            if (sessionDelete) {
+                provider.removeListener("session_delete", sessionDelete);
+                sessionDelete = undefined;
+            }
+            if (!connect) {
+                connect = this.onConnect.bind(this);
+                provider.on("connect", connect);
+            }
+        },
+        onDisplayUri(uri) {
+            config.emitter.emit("message", { type: "display_uri", data: uri });
+            HederaExtensionHelper.extensionConnect(extension.id, uri);
+        },
+        onSessionDelete() {
+            this.onDisconnect();
+        },
+    }));
+}
+
+const createWagmiConfig = (squidChains, hederaExtensions) => {
+    const filteredEvmChains = squidChains.filter((chain) => chain.chainType === ChainType.EVM);
+    if (filteredEvmChains.length === 0) {
+        throw new Error("At least one chain is required");
+    }
+    const wagmiChains = filteredEvmChains.map((chain) => {
+        return defineChain({
+            id: Number(chain.chainId),
+            name: chain.networkName,
+            nativeCurrency: {
+                name: chain.nativeCurrency.name,
+                symbol: chain.nativeCurrency.symbol,
+                decimals: chain.nativeCurrency.decimals,
+            },
+            rpcUrls: {
+                public: {
+                    http: [chain.rpc],
+                },
+                default: {
+                    http: [chain.rpc],
+                },
+            },
+        });
+    });
+    const wcMetadata = {
+        url: SQUID_METADATA.url,
+        name: SQUID_METADATA.name,
+        icons: [SQUID_METADATA.icon],
+        description: SQUID_METADATA.description,
+    };
+    return createConfig({
+        chains: wagmiChains,
+        transports: Object.fromEntries(wagmiChains.map((chain) => [
+            chain.id,
+            http(chain.rpcUrls.public.http[0] ?? ""),
+        ])),
+        connectors: [
+            injected(),
+            safe({
+                allowedDomains: [/app.safe.global$/],
+            }),
+            metaMask({
+                dappMetadata: {
+                    name: SQUID_METADATA.name,
+                    url: SQUID_METADATA.url,
+                    iconUrl: SQUID_METADATA.icon,
+                },
+            }),
+            coinbaseWallet({
+                appName: SQUID_METADATA.name,
+                appLogoUrl: SQUID_METADATA.icon,
+            }),
+            walletConnect({
+                projectId: WALLETCONNECT_PROJECT_ID,
+                metadata: wcMetadata,
+            }),
+            ...hederaExtensions.map((extension) => hederaWalletConnect({
+                projectId: WALLETCONNECT_PROJECT_ID,
+                metadata: wcMetadata,
+                extension,
+            })),
+        ],
+    });
+};
+// Taken from wagmi docs
+// https://wagmi.sh/react/guides/ethers
+function clientToSigner(client) {
+    const { account, chain, transport } = client;
+    if (!account || !chain || !transport) {
+        return undefined;
+    }
+    const network = {
+        chainId: chain.id,
+        name: chain.name,
+        ensAddress: chain.contracts?.ensRegistry?.address,
+    };
+    const provider = new BrowserProvider(transport, network);
+    const signer = new JsonRpcSigner(provider, account.address);
+    return signer;
+}
+
+function useEvmSigner({ chainId }) {
+    const { connector } = useAccount();
+    const { data: client } = useWalletClient({ chainId, connector });
+    const signer = useMemo(() => (client ? clientToSigner(client) : undefined), [client]);
+    return { signer };
+}
+const useSigner = ({ chain }) => {
+    const evmChainId = chain?.chainType === ChainType.EVM ? Number(chain.chainId) : undefined;
+    // EVM and Cosmos need a different signer for each chain
+    // This is not the case for Solana or Bitcoin as there's only one chain in those ecosystems
+    const { signer: evmSigner } = useEvmSigner({ chainId: evmChainId });
+    const { signer: cosmosSigner } = useCosmosSigner({ chain });
+    const { signer: solanaSigner } = useSolanaContext();
+    const { signer: bitcoinSigner } = useBitcoinContext();
+    const { signer: suiSigner } = useSuiContext();
+    const { signer: xrplSigner } = useXrplContext();
+    const { signer: stellarSigner } = useStellarContext();
+    const isEvmSignerReady = !!evmSigner;
+    const isSolanaSignerReady = !!solanaSigner;
+    const isCosmosSignerReady = !!cosmosSigner;
+    const isBitcoinSignerReady = !!bitcoinSigner;
+    const isSuiSignerReady = !!suiSigner;
+    const isXrplSignerReady = !!xrplSigner;
+    const isStellarSignerReady = !!stellarSigner;
+    const isSignerReady = useMemo(() => {
+        if (!chain?.chainType)
+            return false;
+        switch (chain.chainType) {
+            case ChainType.EVM:
+                return isEvmSignerReady;
             case ChainType.COSMOS:
-                return isCosmosLoading;
+                return isCosmosSignerReady;
             case ChainType.BTC:
-                return isBitcoinLoading;
+                return isBitcoinSignerReady;
             case ChainType.SOLANA:
-                return isSolanaLoading;
+                return isSolanaSignerReady;
             case ChainType.SUI:
-                return isSuiLoading;
+                return isSuiSignerReady;
             case ChainType.XRPL:
-                return isXrpLoading;
+                return isXrplSignerReady;
             case ChainType.STELLAR:
-                return isStellarLoading;
+                return isStellarSignerReady;
         }
     }, [
         chain?.chainType,
-        isEvmLoading,
-        isCosmosLoading,
-        isBitcoinLoading,
-        isSolanaLoading,
-        isSuiLoading,
-        isXrpLoading,
-        isStellarLoading,
+        isEvmSignerReady,
+        isCosmosSignerReady,
+        isBitcoinSignerReady,
+        isSolanaSignerReady,
+        isSuiSignerReady,
+        isXrplSignerReady,
+        isStellarSignerReady,
     ]);
-    return { nativeBalance, nativeBalanceFormatted, isLoading };
+    return {
+        isSignerReady,
+        evmSigner,
+        cosmosSigner,
+        bitcoinSigner,
+        solanaSigner,
+        suiSigner,
+        xrplSigner,
+        stellarSigner,
+    };
 };
 
-function useHederaAccountActivation({ address, chain, token }) {
-    const { balance: destNativeEvmBalance } = useEvmNativeBalance({
-        chain,
-        address,
+function useHederaTokenAssociations({ address, chain, token }) {
+    const publicClient = usePublicClient({
+        chainId: Number(CHAIN_IDS.HEDERA),
+    });
+    const { evmSigner } = useSigner({ chain });
+    const queryClient = useQueryClient();
+    /**
+     * Creates a token association transaction where the destination account authorizes to receive the given token
+     */
+    const associateToken = useMutation({
+        mutationFn: async () => {
+            try {
+                if (!evmSigner) {
+                    throw new Error("EVM signer not found");
+                }
+                if (chain?.chainId !== CHAIN_IDS.HEDERA ||
+                    token?.chainId !== CHAIN_IDS.HEDERA) {
+                    throw new Error("Chain and token to associate must be on Hedera");
+                }
+                const tokenAddress = parseEvmAddress(token.address);
+                if (!tokenAddress) {
+                    throw new Error("Invalid token address");
+                }
+                const userAddress = parseEvmAddress(address);
+                if (!userAddress) {
+                    throw new Error("Invalid user address");
+                }
+                const encodedData = encodeFunctionData({
+                    abi: hrc20,
+                    functionName: "associate",
+                    args: [],
+                });
+                const txRes = await evmSigner.sendTransaction({
+                    data: encodedData,
+                    to: tokenAddress,
+                    chainId: chain.chainId,
+                });
+                const receipt = await txRes.wait();
+                if (receipt?.status !== 1) {
+                    throw new Error(`Transaction failed with status: ${receipt?.status}`);
+                }
+                return true;
+            }
+            catch (error) {
+                console.error("Error associating Hedera token:", error);
+                return false;
+            }
+        },
+        async onSuccess() {
+            queryClient.refetchQueries({
+                queryKey: getPrefixKey(QueryKeys.IsHederaTokenAssociated),
+            });
+        },
+    });
+    /**
+     * Checks if the destination account has associated the given token.
+     *
+     * Hedera requires accounts to associate a token before being able to receive it.
+     *
+     * Accounts which have max. associations set to -1 can receive any token without previous association
+     */
+    const isTokenAssociated = useQuery({
+        queryKey: keys().isHederaTokenAssociated(address, token?.chainId, token?.type, token?.address),
+        queryFn: async () => {
+            if (token?.chainId !== CHAIN_IDS.HEDERA) {
+                return true;
+            }
+            // The native HBAR token doesn't need an association
+            if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase()) {
+                return true;
+            }
+            if (!chain || !address || !publicClient) {
+                throw new Error("Missing required parameters");
+            }
+            // TODO: update types
+            const apiUrl = chain?.chainConfig?.hedera?.mirrorNodeUrl;
+            if (!apiUrl) {
+                throw new Error("Missing Hedera mirror node URL in chain config");
+            }
+            const hederaApiClient = new HederaApiClient(apiUrl);
+            return hederaApiClient.isTokenAssociated({
+                address,
+                token,
+            });
+        },
+        enabled: !!address && !!publicClient && token?.chainId === CHAIN_IDS.HEDERA,
     });
-    const isHederaAccountActivated = useMemo(() => {
-        if (token?.chainId !== CHAIN_IDS.HEDERA)
-            return true;
-        if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase())
-            return true;
-        return (!!destNativeEvmBalance?.value && destNativeEvmBalance.value > BigInt(0));
-    }, [token?.chainId, token?.address, destNativeEvmBalance?.value]);
     return {
-        isHederaAccountActivated,
+        isTokenAssociated,
+        associateToken,
+    };
+}
+
+const useKeyboardNavigation = ({ onEscape }) => {
+    const onKeyDown = useCallback((event) => {
+        if (event.key === "Escape") {
+            onEscape?.();
+            return;
+        }
+    }, [onEscape]);
+    useEffect(() => {
+        document.addEventListener("keydown", onKeyDown, false);
+        return () => {
+            document.removeEventListener("keydown", onKeyDown, false);
+        };
+    }, [onKeyDown]);
+};
+
+const useSquidQueryClient = () => {
+    const queryClient = useQueryClient();
+    const invalidateQueries = (key) => {
+        const prefixKey = getPrefixKey(key);
+        queryClient.invalidateQueries(prefixKey);
+    };
+    const refetchQueries = (key) => {
+        const prefixKey = getPrefixKey(key);
+        queryClient.refetchQueries(prefixKey);
+    };
+    const invalidateAndRefetchQueries = (key) => {
+        invalidateQueries(key);
+        refetchQueries(key);
+    };
+    return {
+        invalidateQueries,
+        refetchQueries,
+        invalidateAndRefetchQueries,
+    };
+};
+
+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;
+    }
+    async getTrustLines(userAddress) {
+        const response = await fetch(`${this.apiUrl}/accounts/${userAddress}`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch account data: ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (!Array.isArray(data?.balances)) {
+            throw new Error("Invalid response from Horizon API");
+        }
+        const assets = data.balances.filter(isValidHorizonAsset);
+        return assets.filter(isValidIssuedAsset);
+    }
+    async getTrustLine(address, asset) {
+        const trustLines = await this.getTrustLines(address);
+        const trustLine = trustLines.find((line) => line.asset_code === asset.code && line.asset_issuer === asset.issuer);
+        return trustLine ?? null;
+    }
+}
+
+const DEFAULT_REFETCH_INTERVAL$2 = 20_000;
+function useStellarAccountActivation({ address, chain, token, }) {
+    /**
+     * Checks if the destination account exists on the Stellar network
+     * Stellar accounts need to have a minimum balance before they can receive payments
+     */
+    const accountActivatedInfo = useQuery({
+        queryKey: keys().stellarAccountActivatedInfo(address, chain?.chainId, chain?.chainType),
+        queryFn: async () => {
+            if (chain?.chainType !== ChainType.STELLAR ||
+                token?.type !== ChainType.STELLAR) {
+                return null;
+            }
+            if (!address) {
+                throw new Error("Destination address is required");
+            }
+            const horizonApiUrl = getStellarHorizonApiUrl(chain);
+            if (!horizonApiUrl) {
+                throw new Error("Invalid Horizon API URL");
+            }
+            const stellarApiClient = new StellarApiClient(horizonApiUrl);
+            const reserveBase = await stellarApiClient.getBaseReserve();
+            // Stellar accounts require two base reserves to be activated
+            // https://developers.stellar.org/docs/learn/fundamentals/lumens#minimum-balance
+            const accountReserveBase = reserveBase * BigInt(2);
+            const stellarRpcClient = await getClient(chain);
+            const isActivated = await stellarRpcClient.isAccountActivated(address);
+            return {
+                isActivated,
+                reserveBaseBn: accountReserveBase,
+            };
+        },
+        enabled: !!address && chain?.chainType === ChainType.STELLAR,
+        refetchInterval: DEFAULT_REFETCH_INTERVAL$2,
+        refetchOnWindowFocus: true,
+    });
+    return {
+        accountActivatedInfo,
+    };
+}
+
+/**
+ * Maximum asset amount on Stellar
+ * @see https://developers.stellar.org/docs/learn/fundamentals/stellar-data-structures/assets#amount-precision
+ */
+const MAX_ASSET_AMOUNT = "922337203685.4775807";
+const DEFAULT_REFETCH_INTERVAL$1 = 20_000;
+function useStellarTrustLine({ address, chain, token, amount }) {
+    const { stellarSigner } = useSigner({ chain });
+    const queryClient = useQueryClient();
+    /**
+     * Retrieves the destination account's trust line data for the given token
+     */
+    const trustLineQuery = useQuery({
+        queryKey: keys().stellarTrustLine(token?.address, chain?.chainId, address),
+        queryFn: async () => {
+            if (chain?.chainType !== ChainType.STELLAR ||
+                token?.type !== ChainType.STELLAR) {
+                return null;
+            }
+            if (!address || !isStellarAddressValid(address)) {
+                return null;
+            }
+            // Only issued tokens require trust lines
+            // Other token types like contract tokens don't need trust lines
+            if (!isStellarIssuedToken(token)) {
+                return null;
+            }
+            const asset = getStellarTrustLineAsset(token);
+            if (!asset) {
+                throw new Error("Invalid asset");
+            }
+            const horizonApiUrl = getStellarHorizonApiUrl(chain);
+            if (!horizonApiUrl) {
+                throw new Error("Invalid Horizon API URL");
+            }
+            const stellarApiClient = new StellarApiClient(horizonApiUrl);
+            return stellarApiClient.getTrustLine(address, asset);
+        },
+        enabled: !!address &&
+            chain?.chainType === ChainType.STELLAR &&
+            token?.type === ChainType.STELLAR,
+        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
+    });
+    /**
+     * Creates a trust line where the destination account authorizes to receive the given token
+     */
+    const createTrustLine = useMutation({
+        mutationFn: async () => {
+            try {
+                if (!stellarSigner) {
+                    throw new Error("Stellar signer not found");
+                }
+                if (!address) {
+                    throw new Error("Destination address is required");
+                }
+                if (chain?.chainType !== ChainType.STELLAR ||
+                    token?.type !== ChainType.STELLAR) {
+                    throw new Error("Chain and token to approve must be a Stellar token");
+                }
+                if (!isStellarIssuedToken(token)) {
+                    throw new Error("Token must be a Stellar issued token");
+                }
+                const assetInfo = getStellarTrustLineAsset(token);
+                if (!assetInfo) {
+                    throw new Error("Invalid asset");
+                }
+                const network = getStellarNetwork(chain.chainId);
+                if (network == null) {
+                    throw new Error(`Stellar network not found for chain ${chain.chainId}`);
+                }
+                const client = await getClient(chain);
+                const account = await client.getAccount(address);
+                const asset = new Asset(assetInfo.code, assetInfo.issuer);
+                const changeTrustOperation = Operation.changeTrust({
+                    asset,
+                    limit: MAX_ASSET_AMOUNT,
+                });
+                const builtTransaction = new TransactionBuilder(account, {
+                    fee: (BigInt(BASE_FEE) * BigInt(2)).toString(),
+                    networkPassphrase: network,
+                })
+                    .addOperation(changeTrustOperation)
+                    .setTimeout(300)
+                    .build();
+                const { signedTxXdr } = await stellarSigner.signTransaction(builtTransaction.toXDR(), {
+                    networkPassphrase: network,
+                });
+                const signedTransaction = new Transaction$1(signedTxXdr, network);
+                const sentTransaction = await client.sendTransaction(signedTransaction);
+                const txStatus = await client.waitForTransaction(sentTransaction.hash, {
+                    interval: 1_000,
+                });
+                if (txStatus !== rpc.Api.GetTransactionStatus.SUCCESS) {
+                    throw new Error(`Transaction failed with status: ${txStatus}`);
+                }
+                return true;
+            }
+            catch (error) {
+                console.error("Error creating trust line:", error);
+                return false;
+            }
+        },
+        async onSuccess() {
+            queryClient.invalidateQueries({
+                queryKey: getPrefixKey(QueryKeys.StellarTrustLine),
+            });
+        },
+    });
+    /**
+     * Checks if the destination account has created a trust line to receive the given token.
+     */
+    const isTrustLineApproved = useQuery({
+        queryKey: keys().isStellarTrustLineApproved(address, token?.chainId, token?.type, token?.address, trustLineQuery.data?.limit, amount),
+        queryFn: async () => {
+            if (token?.type !== ChainType.STELLAR) {
+                return true;
+            }
+            // The native Stellar token doesn't need a trust line
+            if (token.address.toLowerCase() === nativeStellarTokenAddress.toLowerCase()) {
+                return true;
+            }
+            if (!amount) {
+                throw new Error("Amount is required");
+            }
+            const limitBn = BigNumber$1(trustLineQuery.data?.limit || "0");
+            const balanceBn = BigNumber$1(trustLineQuery.data?.balance || "0");
+            const availableAllowanceBn = limitBn.minus(balanceBn);
+            const amountBn = BigNumber$1(formatBNToReadable(amount, token.decimals));
+            return availableAllowanceBn.gte(amountBn);
+        },
+        enabled: !!address &&
+            !!amount &&
+            !trustLineQuery?.isLoading &&
+            trustLineQuery?.isFetched &&
+            token?.type === ChainType.STELLAR,
+    });
+    return {
+        createTrustLine,
+        trustLineQuery,
+        isTrustLineApproved,
     };
 }
 
@@ -30734,6 +31031,143 @@ 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);
+
+const BALANCE_QUERY_STALE_TIME = 10_000;
+/**
+ * Returns raw on-chain gas token data for Tempo chains, or null when the source
+ * chain is not Tempo.
+ */
+const useTempoFeeCheck = ({ fromChain, fromToken, }) => {
+    const { connectedAddresses } = useWallet();
+    const evmAddress = parseEvmAddress(connectedAddresses[ChainType.EVM]);
+    const isTempo = isTempoChain(fromChain?.chainId);
+    const chainId = Number(fromChain?.chainId);
+    // Read account-level gas token preference from FeeManager precompile
+    // See docs: https://docs.tempo.xyz/protocol/fees/spec-fee#account-level
+    const { data: accountGasTokenAddress } = useReadContract({
+        address: TEMPO_FEE_MANAGER_ADDRESS,
+        abi: feeManagerAbi,
+        functionName: "userTokens",
+        args: evmAddress ? [evmAddress] : undefined,
+        chainId,
+        query: {
+            enabled: isTempo && !!evmAddress,
+            staleTime: 30_000,
+        },
+    });
+    const hasAccountFeePreference = !!accountGasTokenAddress &&
+        // By default, the zero address is returned when the user has no preference set
+        zeroAddress$1.toLowerCase() !== accountGasTokenAddress.toLowerCase();
+    // Fetch balance of the account-preferred gas token (if set)
+    const { data: accountGasTokenBalance } = useBalance({
+        address: evmAddress,
+        token: hasAccountFeePreference ? accountGasTokenAddress : undefined,
+        chainId,
+        query: {
+            enabled: isTempo && hasAccountFeePreference && !!evmAddress,
+            staleTime: BALANCE_QUERY_STALE_TIME,
+        },
+    });
+    const fromTokenAddress = parseEvmAddress(fromToken?.address);
+    const { data: fromTokenBalance } = useBalance({
+        address: evmAddress,
+        token: fromTokenAddress,
+        chainId,
+        query: {
+            enabled: isTempo && !!evmAddress,
+            staleTime: BALANCE_QUERY_STALE_TIME,
+        },
+    });
+    if (!isTempo)
+        return null;
+    if (hasAccountFeePreference) {
+        if (!accountGasTokenAddress || !accountGasTokenBalance)
+            return null;
+        return {
+            gasTokenAddress: accountGasTokenAddress,
+            gasBalance: accountGasTokenBalance.value,
+        };
+    }
+    if (!fromTokenAddress || !fromTokenBalance)
+        return null;
+    return {
+        gasTokenAddress: fromTokenAddress,
+        gasBalance: fromTokenBalance.value,
+    };
+};
+
+function useSourceChainGasToken({ fromChain, fromToken, }) {
+    const { nativeToken } = useNativeTokenForChain(fromChain);
+    const { evmTokens } = useSquidTokens();
+    const { nativeBalance } = useNativeBalance(fromChain);
+    const tempoFeeData = useTempoFeeCheck({ fromChain, fromToken });
+    const chainFeeParams = useMemo(() => {
+        if (fromToken?.address == null ||
+            fromChain?.chainId == null ||
+            nativeBalance?.value == null) {
+            return null;
+        }
+        if (isTempoChain(fromChain.chainId)) {
+            if (!tempoFeeData)
+                return null;
+            const fromTokenPaysNetworkFee = tempoFeeData.gasTokenAddress.toLowerCase() ===
+                fromToken.address.toLowerCase();
+            return {
+                fromTokenPaysNetworkFee,
+                gasTokenBalanceWei: tempoFeeData.gasBalance,
+                normalizeFee: convertTempoFeeToStablecoinUnits,
+            };
+        }
+        return {
+            fromTokenPaysNetworkFee: fromToken.address.toLowerCase() ===
+                chainTypeToNativeTokenAddressMap[fromToken.type].toLowerCase(),
+            gasTokenBalanceWei: nativeBalance.value,
+            normalizeFee: (fee) => fee,
+        };
+    }, [
+        fromToken?.address,
+        fromToken?.type,
+        fromChain?.chainId,
+        nativeBalance?.value,
+        tempoFeeData,
+    ]);
+    const gasToken = useMemo(() => {
+        if (fromChain?.chainId == null || fromToken?.address == null)
+            return undefined;
+        if (isTempoChain(fromChain.chainId)) {
+            if (!tempoFeeData)
+                return undefined;
+            return evmTokens.find((t) => t.chainId === fromChain.chainId &&
+                t.address.toLowerCase() === tempoFeeData.gasTokenAddress.toLowerCase());
+        }
+        return nativeToken;
+    }, [
+        fromChain?.chainId,
+        fromToken?.address,
+        nativeToken,
+        tempoFeeData,
+        evmTokens,
+    ]);
+    return { gasToken, chainFeeParams };
+}
+
 const MAX_COINGECKO_QUERY_TOKENS = 100;
 const fetchHistoricalData = async (coingeckoId, timeFrame) => {
     const now = Math.floor(Date.now() / 1000);
@@ -30884,24 +31318,23 @@ const calculateTotalNativeFees = ({ expressFeeCost, firstFeeCost, firstGasCost,
     (sameTokenBetweenFees
         ? BigInt(firstFeeCost?.amount ?? "0") + BigInt(firstGasCost?.amount ?? "0")
         : BigInt(firstGasCost?.amount ?? "0"));
-const isFromBalanceEnoughToSwap = ({ isFromTokenNative, fromAmount, totalFeesInNativeTokenPlusRatio, nativeTokenBalanceFromChainWei, }) => {
-    const fromAmountBigInt = BigInt(fromAmount ?? "0");
-    const totalFeesInNativeTokenPlusRatioBigInt = totalFeesInNativeTokenPlusRatio;
-    const nativeTokenBalanceFromChainWeiBigInt = nativeTokenBalanceFromChainWei;
-    return isFromTokenNative
-        ? fromAmountBigInt + totalFeesInNativeTokenPlusRatioBigInt <=
-            nativeTokenBalanceFromChainWeiBigInt
-        : totalFeesInNativeTokenPlusRatioBigInt <=
-            nativeTokenBalanceFromChainWeiBigInt;
-};
-const calculateMinAmountValueWarnMsg = ({ isFromTokenNative, nativeTokenBalanceFromChainWei, sourceChainNativeTokenDecimals, totalFeesInNativeTokenPlusRatio, }) => isFromTokenNative
-    ? (() => {
-        const minAmount = nativeTokenBalanceFromChainWei - totalFeesInNativeTokenPlusRatio;
-        return minAmount > BigInt(0)
-            ? formatBNToReadable(minAmount, sourceChainNativeTokenDecimals)
-            : "0";
-    })()
-    : undefined;
+const isGasBalanceEnough = ({ fromAmount, networkFeesWei, chainFeeParams, }) => {
+    if (!chainFeeParams)
+        return false;
+    if (chainFeeParams.fromTokenPaysNetworkFee) {
+        return (BigInt(fromAmount ?? "0") + networkFeesWei <=
+            chainFeeParams.gasTokenBalanceWei);
+    }
+    return networkFeesWei <= chainFeeParams.gasTokenBalanceWei;
+};
+const calculateMinAmountValueWarnMsg = ({ networkFeesWei, chainFeeParams, fromTokenDecimals, }) => {
+    if (!chainFeeParams?.fromTokenPaysNetworkFee)
+        return undefined;
+    const minAmount = chainFeeParams.gasTokenBalanceWei - networkFeesWei;
+    if (minAmount <= BigInt(0))
+        return undefined;
+    return formatBNToReadable(minAmount, fromTokenDecimals);
+};
 /**
  * Calculates the estimated duration of a route
  *
@@ -30940,12 +31373,10 @@ const formatEstimatedRouteDuration = ({ estimatedRouteDuration, isSingleChainRou
  * @returns {Object} An object containing various estimate results and calculations, including token information,
  *                   amounts, fees, gas costs, and other relevant data for the transaction.
  */
-const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, collectFees, nativeTokenBalanceFromChainWei, }) => {
+const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, collectFees, chainFeeParams, gasToken, }) => {
     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";
@@ -30964,10 +31395,6 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
     const expectedGasRefundCostUSD = convertTokenAmountToUSD(formatBNToReadable(expectedGasRefundCost, firstFeeCost?.token.decimals ?? 18), firstFeeCost?.token.usdPrice ?? "0");
     const sameTokenBetweenFees = firstFeeCost?.token.address === firstGasCost?.token.address &&
         firstFeeCost?.token.chainId === firstGasCost?.token.chainId;
-    const isFromTokenNative = 
-    // TODO: temporary fix, currently nativeCurrency.symbol is not always in uppercase
-    fromToken?.symbol.toUpperCase() ===
-        fromChain?.nativeCurrency.symbol.toUpperCase();
     const totalNativeFees = calculateTotalNativeFees({
         expressFeeCost,
         firstFeeCost,
@@ -30975,30 +31402,32 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         sameTokenBetweenFees,
     });
     const totalFeesInNativeTokenPlusRatio = (totalNativeFees * BigInt(110)) / BigInt(100);
-    const fromBalanceEnoughToSwap = isFromBalanceEnoughToSwap({
-        isFromTokenNative,
+    const networkFeesWei = chainFeeParams?.normalizeFee(totalFeesInNativeTokenPlusRatio) ?? BigInt(0);
+    const gasBalanceEnough = isGasBalanceEnough({
+        chainFeeParams,
         fromAmount,
-        fromTokenDecimals: fromToken?.decimals,
-        totalFeesInNativeTokenPlusRatio,
-        nativeTokenBalanceFromChainWei,
+        networkFeesWei,
     });
     const minAmountValueWarnMsg = calculateMinAmountValueWarnMsg({
-        isFromTokenNative,
-        nativeTokenBalanceFromChainWei,
-        sourceChainNativeTokenDecimals: sourceChainNativeToken?.decimals,
-        totalFeesInNativeTokenPlusRatio,
+        chainFeeParams,
+        networkFeesWei,
+        fromTokenDecimals: fromToken?.decimals,
     });
     const isSingleChainRoute = fromChain?.chainId === toChain?.chainId;
     const estimatedRouteDuration = formatEstimatedRouteDuration({
         estimatedRouteDuration: squidRoute?.estimate?.estimatedRouteDuration,
         isSingleChainRoute,
     });
+    // native fees + fromAmount (if native)
+    const totalGasBalanceNeeded = networkFeesWei +
+        BigInt(chainFeeParams?.fromTokenPaysNetworkFee ? fromAmount ?? 0 : 0);
+    const gasBalanceNeeded = gasToken
+        ? formatBNToReadable(totalGasBalanceNeeded, gasToken.decimals)
+        : undefined;
     return {
         fromToken,
         fromAmount,
         fromAmountFormatted,
-        sourceChainNativeToken,
-        destChainNativeToken,
         toAmountUSD,
         exchangeRate,
         toAmountMinUSD,
@@ -31013,12 +31442,12 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         expectedGasRefundCost,
         expectedGasRefundCostUSD,
         sameTokenBetweenFees,
-        isFromTokenNative,
+        fromTokenPaysNetworkFee: chainFeeParams?.fromTokenPaysNetworkFee ?? false,
         totalNativeFees,
-        totalFeesInNativeTokenPlusRatio,
-        fromBalanceEnoughToSwap,
+        gasBalanceEnough,
         minAmountValueWarnMsg,
         estimatedRouteDuration,
+        gasBalanceNeeded,
     };
 };
 /**
@@ -31052,28 +31481,6 @@ const calculateTotalWithRefundEstimate = (allFeeCosts, expectedGasRefundCost, ge
         feeToken: firstFeeCost?.token,
     };
 };
-/**
- * Calculates the proposed gas amount for the destination chain.
- *
- * @param destChainNativeToken - The symbol of the native token for the destination chain.
- * @returns An object containing the proposed gas amount value and the currency symbol.
- */
-const getProposedGasDestinationAmount = (destChainNativeToken) => {
-    const gasAmounts = {
-        GLMR: 5.289,
-        ETH: 0.0009,
-        AVAX: 0.115,
-        BNB: 0.00425,
-        FTM: 4.45,
-        CELO: 3.052,
-        KAVA: 2.339,
-        MATIC: 1.795,
-    };
-    return {
-        value: gasAmounts[destChainNativeToken ?? ""] ?? 0,
-        currency: destChainNativeToken,
-    };
-};
 
 function useSendTransactionGas({ chain, token, from, }) {
     return useQuery({
@@ -31095,7 +31502,11 @@ function useSendTransactionGas({ chain, token, from, }) {
                     // Some RPC providers require the sender to have enough balance, otherwise estimation reverts
                     // so we'll try to use the user provided address when possible
                     const sender = from || dummyAddress;
-                    if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase()) {
+                    // Tempo has no native token, so `value` transfers are rejected by the EVM.
+                    // We can simulate an ERC20 transfer instead
+                    const supportsNativeTransfers = chain.chainId !== CHAIN_IDS.TEMPO;
+                    const isNativeToken = token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase();
+                    if (isNativeToken && supportsNativeTransfers) {
                         const gas = await client.estimateGas({
                             from: sender,
                             to: dummyAddress,
@@ -31115,7 +31526,14 @@ function useSendTransactionGas({ chain, token, from, }) {
                         data,
                         chainId: chain.chainId,
                     });
-                    return gas * maxFeePerGas;
+                    const feeWei = gas * maxFeePerGas;
+                    // Tempo fees are denominated in virtual USD (18 dec, 1e-18 USD units).
+                    // Convert to 6-dec stablecoin units so all callers receive a
+                    // consistent unit without needing to know about the chain.
+                    if (chain.chainId === CHAIN_IDS.TEMPO) {
+                        return convertTempoFeeToStablecoinUnits(feeWei);
+                    }
+                    return feeWei;
                 }
                 case ChainType.COSMOS: {
                     // TODO: get gas estimation from backend
@@ -31162,19 +31580,33 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
         token,
         from,
     });
-    const { nativeBalance } = useNativeBalance(chain);
-    const isNativeBalanceEnoughToPayGasFees = useMemo(() => {
-        if (!nativeBalance?.value || !amount || !token?.decimals) {
+    const { chainFeeParams, gasToken } = useSourceChainGasToken({
+        fromChain: chain,
+        fromToken: token,
+    });
+    const gasBalanceEnough = useMemo(() => {
+        if (!amount || !token?.decimals)
             return false;
-        }
-        const isTokenNative = token.address.toLowerCase() ===
-            chainTypeToNativeTokenAddressMap[token.type].toLowerCase();
-        if (isTokenNative) {
-            return (parseToBigInt(amount, token.decimals) + estimatedGas <=
-                nativeBalance.value);
-        }
-        return estimatedGas <= nativeBalance.value;
-    }, [amount, estimatedGas, nativeBalance?.value, token]);
+        return isGasBalanceEnough({
+            fromAmount: parseToBigInt(amount, token.decimals).toString(),
+            networkFeesWei: estimatedGas,
+            chainFeeParams,
+        });
+    }, [amount, estimatedGas, token, chainFeeParams]);
+    const gasBalanceNeeded = useMemo(() => {
+        if (!amount || !token?.decimals || !gasToken?.decimals)
+            return undefined;
+        // native fees + fromAmount (if native)
+        const totalGasBalanceNeeded = estimatedGas +
+            parseToBigInt(chainFeeParams?.fromTokenPaysNetworkFee ? amount ?? "0" : "0", token.decimals);
+        return formatBNToReadable(totalGasBalanceNeeded, gasToken.decimals);
+    }, [
+        amount,
+        chainFeeParams?.fromTokenPaysNetworkFee,
+        estimatedGas,
+        gasToken?.decimals,
+        token?.decimals,
+    ]);
     const isBalanceEnough = useMemo(() => {
         if (token?.decimals == null || !balance || !amount)
             return false;
@@ -31182,28 +31614,21 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
             parseToBigInt(amount, token.decimals));
     }, [amount, balance, token?.decimals]);
     const minAmountValueWarnMsg = useMemo(() => {
-        if (!token?.address || !nativeBalance?.value || !estimatedGas)
+        if (!token?.address || !estimatedGas || !chainFeeParams)
             return undefined;
-        const isFromTokenNative = token.address.toLowerCase() ===
-            chainTypeToNativeTokenAddressMap[token.type].toLowerCase();
         return calculateMinAmountValueWarnMsg({
-            isFromTokenNative,
-            nativeTokenBalanceFromChainWei: nativeBalance.value,
-            sourceChainNativeTokenDecimals: nativeBalance.decimals,
-            totalFeesInNativeTokenPlusRatio: estimatedGas,
+            chainFeeParams,
+            networkFeesWei: estimatedGas,
+            fromTokenDecimals: token.decimals,
         });
-    }, [
-        estimatedGas,
-        nativeBalance?.decimals,
-        nativeBalance?.value,
-        token?.address,
-        token?.type,
-    ]);
+    }, [estimatedGas, token, chainFeeParams]);
     return {
         estimatedGas,
+        gasBalanceNeeded,
         isBalanceEnough,
+        tokenPaysNetworkFee: chainFeeParams?.fromTokenPaysNetworkFee ?? false,
         isLoading,
-        isNativeBalanceEnoughToPayGasFees,
+        isGasBalanceEnough: gasBalanceEnough,
         minAmountValueWarnMsg,
     };
 }
@@ -31373,15 +31798,18 @@ async function sendTransactionXrpl({ amount, signer, to, token, from, }) {
             txHash: hash,
         };
     }
-    const [currency, issuer] = token.address.split(".");
+    const asset = parseXrplTokenAddress(token.address);
+    if (!asset) {
+        throw new Error("Invalid asset");
+    }
     const amountFormatted = formatBNToReadable(amount, token.decimals);
     const { hash } = await signer.signAndSubmit({
         network: xrplNetwork,
         tx: {
             ...baseTransaction,
             Amount: {
-                currency,
-                issuer,
+                currency: asset.code,
+                issuer: asset.issuer,
                 value: amountFormatted,
             },
         },
@@ -32119,7 +32547,7 @@ const useApproval = ({ squidRoute, }) => {
      * On Error: Showing the error message if any
      * @returns {boolean} approved
      */
-    const routeApproved = useQuery(keys().routeApproved(squidRoute, allowanceInWei), async () => {
+    const routeApproved = useQuery(keys().routeApproved(squidRoute, allowanceInWei, erc20AllowanceQueryEnabled, hasAllowance), async () => {
         if (erc20AllowanceQueryEnabled) {
             return hasAllowance;
         }
@@ -32262,7 +32690,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.receiveGasOnDestination, squidRoute.params.fromAddress, squidRoute.params.bypassGuardrails, squidRoute.params.toAddress, squidRoute.params.fallbackAddresses?.[0]?.address, squidRoute.params.quoteOnly, getChainType(squidRoute.params.fromChain), squidRoute.params.preHook, squidRoute.params.postHook, 
+                    queryKey: keys().transaction(squidRoute.params.fromChain, squidRoute.params.toChain, squidRoute.params.toToken, squidRoute.params.fromToken, fromPrice, squidRoute.params.slippage, squidRoute.params.fromAddress, squidRoute.params.bypassGuardrails, squidRoute.params.toAddress, squidRoute.params.fallbackAddresses?.[0]?.address, squidRoute.params.quoteOnly, getChainType(squidRoute.params.fromChain), squidRoute.params.preHook, squidRoute.params.postHook, 
                     // TODO: update types
                     squidRoute.params?.overrideGasRefundAddress),
                 });
@@ -32281,17 +32709,30 @@ const AXELAR_PROVIDER_IMAGE_URL = "https://raw.githubusercontent.com/0xsquid/ass
 const useEstimate = (squidRoute) => {
     const collectFees = useConfigStore((state) => state.config.collectFees);
     const { tokens } = useSquidTokens();
-    const { fromChain, toChain } = useSwap();
-    const { nativeBalance } = useNativeBalance(fromChain);
+    const { fromChain, toChain, fromPrice } = useSwap();
+    const fromToken = useMemo(() => findToken(tokens, squidRoute?.params.fromChain, squidRoute?.params.fromToken), [tokens, squidRoute?.params.fromChain, squidRoute?.params.fromToken]);
+    const { chainFeeParams, gasToken } = useSourceChainGasToken({
+        fromChain,
+        fromToken,
+    });
     const estimateResults = useMemo(() => calculateEstimateResults({
         squidRoute,
         tokens,
         fromChain,
         toChain,
         collectFees: !!collectFees && collectFees.fee > 0,
-        nativeTokenBalanceFromChainWei: nativeBalance?.value ?? BigInt("0"),
-    }), [squidRoute, tokens, fromChain, toChain, collectFees, nativeBalance]);
-    const balanceFormatted = useMultiChainBalance({
+        chainFeeParams,
+        gasToken,
+    }), [
+        squidRoute,
+        tokens,
+        fromChain,
+        toChain,
+        collectFees,
+        chainFeeParams,
+        gasToken,
+    ]);
+    const fromBalanceFormatted = useMultiChainBalance({
         chain: fromChain,
         token: estimateResults.fromToken,
         userAddress: squidRoute?.params.fromAddress ?? "",
@@ -32303,7 +32744,6 @@ const useEstimate = (squidRoute) => {
         estimateResults.expectedGasRefundCost,
         getUSDValue,
     ]);
-    const proposedGasDestinationAmount = useMemo(() => getProposedGasDestinationAmount(estimateResults.destChainNativeToken?.symbol), [estimateResults.destChainNativeToken]);
     const { feeCostsFormatted, totalFeeCostsUsd } = useMemo(() => {
         const feeCosts = squidRoute?.estimate.feeCosts ?? [];
         const feeCostsRenamed = [];
@@ -32362,21 +32802,21 @@ const useEstimate = (squidRoute) => {
             totalFeeCostsUsd: totalFeeCostsUsdFormatted,
         };
     }, [squidRoute?.estimate.feeCosts]);
-    const slippageFormatted = 
-    // TODO: update types
-    Number(squidRoute?.estimate?.aggregateSlippage ?? 0).toFixed(2) +
-        "%";
-    const enoughBalanceToSwap = +balanceFormatted >= 0 &&
-        +balanceFormatted > +estimateResults.fromAmountFormatted;
+    const slippageFormatted = Number(squidRoute?.estimate?.aggregateSlippage ?? 0).toFixed(2) + "%";
+    const fromBalanceEnoughToSwap = useMemo(() => {
+        const fromBalanceNum = Number(fromBalanceFormatted ?? 0);
+        const fromPriceNum = Number(fromPrice ?? 0);
+        return fromBalanceNum >= fromPriceNum;
+    }, [fromBalanceFormatted, fromPrice]);
     return {
         ...estimateResults,
-        balanceFormatted,
+        fromBalanceFormatted,
         slippageFormatted,
         totalWithRefundEstimate,
-        proposedGasDestinationAmount,
-        enoughBalanceToSwap,
+        fromBalanceEnoughToSwap,
         feeCostsFormatted,
         totalFeeCostsUsd,
+        gasToken,
     };
 };
 
@@ -35836,20 +36276,42 @@ const useExecuteTransaction = (squidRoute) => {
         if (stellarNetwork == null) {
             throw new Error(`No Stellar network found for chainId ${fromChainId}`);
         }
-        const { data: xdrHex, gasPrice } = route.transactionRequest;
-        const { address } = await stellarSigner.getAddress();
         const client = await getClient(fromChain);
-        const account = await client.getAccount(address);
-        const operation = xdr.Operation.fromXDR(xdrHex, "hex");
-        const builtTransaction = new TransactionBuilder(account, {
-            fee: gasPrice || (BigInt(BASE_FEE) * BigInt(2)).toString(),
-            networkPassphrase: stellarNetwork,
-        })
-            .addOperation(operation)
-            .setTimeout(300)
-            .build();
-        const preparedTransaction = await client.prepareTransaction(builtTransaction);
-        const { signedTxXdr } = await stellarSigner.signTransaction(preparedTransaction.toXDR(), {
+        // TODO: at the moment we're receiving different formats depending on the route type.
+        //
+        // For OnChainExecution we get a single operation xdr string, so we need to build
+        // a full transaction frontend-side (by adding the operation to a new transaction).
+        //
+        // For DepositAddressCalldata we get the full transaction xdr,
+        // so we just need to send it to the wallet for signing.
+        //
+        // In the future this will be standardized backend-side so we have a unified flow for all route types.
+        let txXdrToSign;
+        if (route.transactionRequest.type === SquidDataType.OnChainExecution) {
+            const { data: operationXdrHex, gasPrice } = route.transactionRequest;
+            const { address } = await stellarSigner.getAddress();
+            const account = await client.getAccount(address);
+            const operation = xdr.Operation.fromXDR(operationXdrHex, "hex");
+            const builtTransaction = new TransactionBuilder(account, {
+                fee: gasPrice || (BigInt(BASE_FEE) * BigInt(2)).toString(),
+                networkPassphrase: stellarNetwork,
+            })
+                .addOperation(operation)
+                .setTimeout(300)
+                .build();
+            // This is a smart-contract transaction, so it needs to be simulated first
+            const preparedTransaction = await client.prepareTransaction(builtTransaction);
+            txXdrToSign = preparedTransaction.toXDR();
+        }
+        else if (route.transactionRequest.type === SquidDataType.DepositAddressCalldata) {
+            // For this route type, we get the full transaction xdr in the data field.
+            // This is a payment transaction, so simulation must be skipped.
+            txXdrToSign = route.transactionRequest.data;
+        }
+        else {
+            throw new Error(`Invalid route type ${route.transactionRequest.type}`);
+        }
+        const { signedTxXdr } = await stellarSigner.signTransaction(txXdrToSign, {
             networkPassphrase: stellarNetwork,
         });
         const signedTransaction = new Transaction$1(signedTxXdr, stellarNetwork);
@@ -36122,7 +36584,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, config.enableGetGasOnDestination, sourceUserAddress, config.degenMode, destinationAddress, swapRoute?.fallbackAddress, quoteOnly, fromChainType, config.preHook, config.postHook, overrideGasRefundAddress), route);
+        queryClient.setQueryData(keys().transaction(fromChain, toChain, toToken.address, fromToken.address, fromPrice, config.slippage, sourceUserAddress, config.degenMode, destinationAddress, swapRoute?.fallbackAddress, quoteOnly, fromChainType, config.preHook, config.postHook, overrideGasRefundAddress), route);
         return route;
     });
 };
@@ -36145,14 +36607,13 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     const sourceUserAddress = isDepositAddressEnabled && isAvailableAsPaymentMethod
         ? depositRefundAddress ?? sourceConnectedAddress
         : sourceConnectedAddress;
-    const squidRouteQueryKeys = useMemo(() => keys().transaction(fromChain?.chainId, toChain?.chainId, toToken?.address, fromToken?.address, fromPrice, config.slippage, config.enableGetGasOnDestination, sourceUserAddress, config.degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChain?.chainType, config.preHook, config.postHook, config.overrideGasRefundAddress), [
+    const squidRouteQueryKeys = useMemo(() => keys().transaction(fromChain?.chainId, toChain?.chainId, toToken?.address, fromToken?.address, fromPrice, config.slippage, 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,
@@ -36424,35 +36885,6 @@ const useAvatar = (seed = zeroAddress) => {
     return avatar || "";
 };
 
-const useUserParams = () => {
-    const enableGetGasOnDestination = useConfigStore((state) => state.config.enableGetGasOnDestination);
-    const { fromToken, toToken, toChain, fromChain } = useSwap();
-    //   =============
-    //       GAS
-    //   =============
-    const getGasOnDestSupportedForThisRoute = useMemo(() => 
-    // Not supporting get gas on dest for same chains
-    fromChain?.chainId !== toChain?.chainId &&
-        // If the destination chain is cosmos, we don't support getting gas there
-        toChain?.chainType !== ChainType.COSMOS &&
-        // Not supporting get gas on dest for same tokens (bridge)
-        ((fromToken?.subGraphIds?.some((sgi) => !!toToken?.subGraphIds?.includes(sgi)) &&
-            toToken?.subGraphIds?.some((sgi) => !!fromToken?.subGraphIds?.includes(sgi))) ||
-            // Except for uusdc -> uusdc
-            (fromToken?.subGraphIds?.includes("uusdc") &&
-                toToken?.subGraphIds?.includes("uusdc"))), [
-        fromChain?.chainId,
-        fromToken?.subGraphIds,
-        toChain?.chainId,
-        toToken?.subGraphIds,
-        toChain?.chainType,
-    ]);
-    return {
-        gasEnabled: enableGetGasOnDestination && getGasOnDestSupportedForThisRoute,
-        getGasOnDestSupportedForThisRoute,
-    };
-};
-
 const useAddToken = (chainToCompare, tokenToCompare) => {
     const { chain: currentEvmChain } = useAccount();
     const { connector } = useAccount();
@@ -36637,12 +37069,12 @@ function useXrplTrustLine({ address, chain, token, amount }) {
             if (!address || !isXrplAddressValid(address)) {
                 return null;
             }
-            const [currency, issuer] = token.address.split(".");
-            if (!currency || !issuer) {
+            const trustLineAsset = parseXrplTokenAddress(token.address);
+            if (!trustLineAsset) {
                 return null;
             }
             const xrplClient = await getClient(chain);
-            const trustLine = await xrplClient.getTrustLine(address, issuer, currency);
+            const trustLine = await xrplClient.getTrustLine(address, trustLineAsset);
             return trustLine;
         },
         enabled: !!address &&
@@ -36880,5 +37312,5 @@ const SquidProvider = ({ children, config, placeholder, }) => {
                                     React.createElement(CosmosProvider, null, children)))))))))) : (placeholder);
 };
 
-export { useSwap as $, AxelarStatusResponseType as A, useKeyboardNavigation as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useSquidQueryClient as E, useSquid as F, useStellarAccountActivation as G, HistoryTxType as H, useHederaAccountActivation as I, useAddressBookStore as J, useAssetsColorsStore as K, useFavoriteTokensStore as L, useHistoryStore as M, Nr as N, useSendTransactionStore as O, useConfigStore as P, QueryKeys as Q, useSquidStore as R, SquidStatusErrorType as S, TransactionErrorType as T, useSwapRoutePersistStore as U, useTransactionStore as V, Wo as W, XamanXrplNetwork as X, ConnectingWalletStatus as Y, useWalletStore as Z, useDepositAddress as _, WindowWalletFlag as a, getXummClient as a$, useAllConnectedWalletBalances as a0, useAllTokensWithBalanceForChainType as a1, useCosmosBalance as a2, useEvmBalance as a3, useMultiChainBalance as a4, useMultipleTokenPrices as a5, useBitcoinNativeBalance as a6, useCosmosNativeBalance as a7, useEvmNativeBalance as a8, useNativeBalance as a9, useAddToken as aA, useAutoConnect as aB, useEnsDataForAddress as aC, useEnsSearch as aD, useGnosisContext as aE, useIsSameAddressAndGnosisContext as aF, useIntegratorContext as aG, useMultiChainWallet as aH, useSigner as aI, useWallet as aJ, useWallets as aK, useXrplTrustLine as aL, TX_STATUS_CONSTANTS as aM, FINAL_TRANSACTION_STATUSES as aN, useGetFiatQuote as aO, useGetOnRampConfig as aP, useExecuteFiatQuote as aQ, useFiatOnRampTxStatus as aR, useFiatTransactions as aS, useCurrencyDetails as aT, useCountryDetails as aU, useAvailableQuotes as aV, useRecommendedQuote as aW, useGetOnrampPaymentTypes as aX, useSuggestedFiatAmounts as aY, SquidProvider as aZ, EnsService as a_, useSolanaNativeBalance as aa, useStellarNativeBalance as ab, useSuiNativeBalance as ac, useXrplNativeBalance as ad, useNativeTokenForChain as ae, useSingleTokenPrice as af, useSquidTokens as ag, useHistoricalData as ah, useTokensData as ai, useEstimateSendTransaction as aj, useSendTransaction as ak, useSendTransactionGas as al, useAllTransactionsStatus as am, useApproval as an, useEstimate as ao, useEstimatePriceImpact as ap, useExecuteTransaction as aq, useGetRoute as ar, useGetRouteWrapper as as, useRouteWarnings as at, useSendTransactionStatus as au, useSwapTransactionStatus as av, useAvatar as aw, useHistory as ax, useUserParams as ay, useDebouncedValue as az, chainTypeToZeroAddressMap as b, adaptiveRound as b$, isXamanXAppContext as b0, getQueryHeaders as b1, getStatusCode as b2, is404Error as b3, assetsBaseUrl as b4, shareSubgraphId as b5, sortTokensBySharedSubgraphIds as b6, getSupportedChainIdsForDirection as b7, filterChains as b8, filterTokens as b9, getCosmosKey as bA, getKeysSettled as bB, getAllKeysForSupportedCosmosChains as bC, isCosmosAddressValid as bD, getCosmosSigningClient as bE, getCosmosChainInfosObject as bF, connectCosmosWallet as bG, isFallbackAddressNeeded as bH, suggestChainOrThrow as bI, normalizeError as bJ, transactionErrorCode as bK, isUserRejectionError as bL, getTransactionError as bM, handleTransactionErrorEvents as bN, isSwapRouteError as bO, isStatusError as bP, createQuoteRequestParamsHash as bQ, WidgetEvents as bR, EvmNetworkNotSupportedErrorCode as bS, addEthereumChain as bT, parseEvmAddress as bU, formatEvmWallet as bV, filterWagmiConnector as bW, waitForReceiptWithRetry as bX, getUserCountry as bY, getCountryData as bZ, getCurrencyData as b_, getTokenImage as ba, getNewSwapParamsFromInput as bb, sortAllTokens as bc, findToken as bd, findNativeToken as be, normalizeIbcAddress as bf, groupTokensBySymbol as bg, groupTokensByChainId as bh, filterViewableTokens as bi, getSecretNetworkBalances as bj, getTokenAssetsKey as bk, fetchAssetsColors as bl, initializeSquidWithAssetsColors as bm, isEmptyObject as bn, normalizeTokenSymbol as bo, areTokenSymbolsCompatible as bp, isEvmosChain as bq, getConfigWithDefaults as br, randomIntFromInterval as bs, getTokensForChain as bt, getFirstAvailableChainId as bu, fetchHighestBalanceToken as bv, getInitialOrDefaultTokenAddressForChain as bw, getInitialTokenAddressForChain as bx, filterTokensForDestination as by, getInitialChainIdFromConfig as bz, chainTypeToNativeTokenAddressMap as c, isEvmChainNotSupportedError as c$, getSuggestedAmountsForCurrency as c0, HederaExtensionHelper as c1, convertHederaAccountIdToEvmAddress as c2, convertEvmAddressToHederaAccountId as c3, scaleHbarToWei as c4, scaleWeiToHbar as c5, parseToBigInt as c6, roundNumericValue as c7, formatUnitsRounded as c8, formatTokenAmount as c9, isChainflipBridgeTransaction as cA, isOnChainTxData as cB, getHistoryTransactionId as cC, getStepStatuses as cD, getHalfSuccessState as cE, getStepsInfos as cF, getSwapTxStatusRefetchInterval as cG, getSendTxStatusRefetchInterval as cH, chainflipMultihopBridgeType as cI, getBridgeType as cJ, getTransactionStatus as cK, getTransactionEndStatus as cL, isHistoryTransactionPending as cM, isHistoryTransactionFailed as cN, isHistoryTransactionWarning as cO, isHistoryTransactionEnded as cP, formatHash as cQ, isWalletAddressValid as cR, redirectToExtensionsStore as cS, accessProperty as cT, populateWallets as cU, getDefaultChain as cV, sortWallets as cW, areSameAddress as cX, sortAddressBook as cY, calculateTotalUsdBalanceUSD as cZ, addTokenToWallet as c_, formatUsdAmount as ca, trimExtraDecimals as cb, getNumericValue as cc, cleanAmount as cd, convertTokenAmountToUSD as ce, convertUSDToTokenAmount as cf, calculateTotal24hChange as cg, getRouteExpiry as ch, searchTokens as ci, filterSolanaWallets as cj, isSolanaAddressValid as ck, executeSolanaSwap as cl, executeSolanaTransfer as cm, formatTransactionHistoryDate as cn, getAxelarExplorerTxUrl as co, getSourceExplorerTxUrl as cp, getMainExplorerUrl as cq, formatDistance as cr, formatSeconds as cs, formatSwapTxStatusResponseForStorage as ct, simplifyRouteAction as cu, fetchSwapTransactionStatus as cv, compareTransactionIds as cw, isCoralBridgeAction as cx, sleep as cy, isDepositRoute as cz, definedInWindow as d, getWalletSupportedChainTypes as d0, getConnectorForChainType as d1, walletSupportsChainType as d2, connectWallet as d3, cancelConnectWallet as d4, isProblematicConnector as d5, mergeWallets as d6, isXionSmartContractAddress as d7, isXrplAddressValid as d8, buildXrplTrustSetTx as d9, getXrplNetwork as da, parseXrplPaymentTx as db, er as e, formatBNToReadable as f, DEFAULT_ROUTE_REFETCH_INTERVAL as g, destinationAddressResetValue as h, fallbackAddressResetValue as i, nativeCosmosTokenAddress as j, nativeEvmTokenAddress as k, nativeSolanaTokenAddress as l, nativeStellarTokenAddress as m, nativeBitcoinTokenAddress as n, nativeSuiTokenAddress as o, nativeXrplTokenAddress as p, CosmosProvider as q, SendTransactionStatus as r, TransactionStatus as s, useTrackSearchEmpty as t, useCosmosContext as u, useSquidChains as v, walletIconBaseUrl as w, useClient as x, useCosmosForChain as y, useHederaTokenAssociations as z };
-//# sourceMappingURL=index-BGVXRZI6.js.map
+export { useDepositAddress as $, AxelarStatusResponseType as A, useHederaTokenAssociations as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useKeyboardNavigation as E, useSquidQueryClient as F, useSquid as G, HistoryTxType as H, useStellarAccountActivation as I, useStellarTrustLine as J, useAddressBookStore as K, useAssetsColorsStore as L, useFavoriteTokensStore as M, Nr as N, useHistoryStore as O, useSendTransactionStore as P, QueryKeys as Q, useConfigStore as R, SquidStatusErrorType as S, TransactionErrorType as T, useSquidStore as U, useSwapRoutePersistStore as V, Wo as W, XamanXrplNetwork as X, useTransactionStore as Y, ConnectingWalletStatus as Z, useWalletStore as _, WindowWalletFlag as a, EnsService as a$, useSwap as a0, useAllConnectedWalletBalances as a1, useAllTokensWithBalanceForChainType as a2, useCosmosBalance as a3, useEvmBalance as a4, useMultiChainBalance as a5, useMultipleTokenPrices as a6, useBitcoinNativeBalance as a7, useCosmosNativeBalance as a8, useEvmNativeBalance as a9, useDebouncedValue as aA, useAddToken as aB, useAutoConnect as aC, useEnsDataForAddress as aD, useEnsSearch as aE, useGnosisContext as aF, useIsSameAddressAndGnosisContext as aG, useIntegratorContext as aH, useMultiChainWallet as aI, useSigner as aJ, useWallet as aK, useWallets as aL, useXrplTrustLine as aM, TX_STATUS_CONSTANTS as aN, FINAL_TRANSACTION_STATUSES as aO, useGetFiatQuote as aP, useGetOnRampConfig as aQ, useExecuteFiatQuote as aR, useFiatOnRampTxStatus as aS, useFiatTransactions as aT, useCurrencyDetails as aU, useCountryDetails as aV, useAvailableQuotes as aW, useRecommendedQuote as aX, useGetOnrampPaymentTypes as aY, useSuggestedFiatAmounts as aZ, SquidProvider as a_, useNativeBalance as aa, useSolanaNativeBalance as ab, useStellarNativeBalance as ac, useSuiNativeBalance as ad, useXrplNativeBalance as ae, useNativeTokenForChain as af, useSingleTokenPrice as ag, useSourceChainGasToken as ah, useSquidTokens as ai, useHistoricalData as aj, useTokensData as ak, useEstimateSendTransaction as al, useSendTransaction as am, useSendTransactionGas as an, useAllTransactionsStatus as ao, useApproval as ap, useEstimate as aq, useEstimatePriceImpact as ar, useExecuteTransaction as as, useGetRoute as at, useGetRouteWrapper as au, useRouteWarnings as av, useSendTransactionStatus as aw, useSwapTransactionStatus as ax, useAvatar as ay, useHistory as az, chainTypeToZeroAddressMap as b, getCurrencyData as b$, getXummClient as b0, isXamanXAppContext as b1, getQueryHeaders as b2, getStatusCode as b3, is404Error as b4, assetsBaseUrl as b5, shareSubgraphId as b6, sortTokensBySharedSubgraphIds as b7, getSupportedChainIdsForDirection as b8, filterChains as b9, getInitialChainIdFromConfig as bA, getCosmosKey as bB, getKeysSettled as bC, getAllKeysForSupportedCosmosChains as bD, isCosmosAddressValid as bE, getCosmosSigningClient as bF, getCosmosChainInfosObject as bG, connectCosmosWallet as bH, isFallbackAddressNeeded as bI, suggestChainOrThrow as bJ, normalizeError as bK, transactionErrorCode as bL, isUserRejectionError as bM, getTransactionError as bN, handleTransactionErrorEvents as bO, isSwapRouteError as bP, isStatusError as bQ, createQuoteRequestParamsHash as bR, WidgetEvents as bS, EvmNetworkNotSupportedErrorCode as bT, addEthereumChain as bU, parseEvmAddress as bV, formatEvmWallet as bW, filterWagmiConnector as bX, waitForReceiptWithRetry as bY, getUserCountry as bZ, getCountryData as b_, filterTokens as ba, getTokenImage as bb, getNewSwapParamsFromInput as bc, sortAllTokens as bd, findToken as be, findNativeToken as bf, normalizeIbcAddress as bg, groupTokensBySymbol as bh, groupTokensByChainId as bi, filterViewableTokens as bj, getSecretNetworkBalances as bk, getTokenAssetsKey as bl, fetchAssetsColors as bm, initializeSquidWithAssetsColors as bn, isEmptyObject as bo, normalizeTokenSymbol as bp, areTokenSymbolsCompatible as bq, isEvmosChain as br, getConfigWithDefaults as bs, randomIntFromInterval as bt, getTokensForChain as bu, getFirstAvailableChainId as bv, fetchHighestBalanceToken as bw, getInitialOrDefaultTokenAddressForChain as bx, getInitialTokenAddressForChain as by, filterTokensForDestination as bz, chainTypeToNativeTokenAddressMap as c, isWalletAddressValid as c$, adaptiveRound as c0, getSuggestedAmountsForCurrency as c1, HederaExtensionHelper as c2, convertHederaAccountIdToEvmAddress as c3, convertEvmAddressToHederaAccountId as c4, scaleHbarToWei as c5, scaleWeiToHbar as c6, parseToBigInt as c7, roundNumericValue as c8, formatUnitsRounded as c9, getMainExplorerUrl as cA, formatDistance as cB, formatSeconds as cC, formatSwapTxStatusResponseForStorage as cD, simplifyRouteAction as cE, fetchSwapTransactionStatus as cF, compareTransactionIds as cG, isCoralBridgeAction as cH, sleep as cI, isDepositRoute as cJ, isChainflipBridgeTransaction as cK, isOnChainTxData as cL, getHistoryTransactionId as cM, getStepStatuses as cN, getHalfSuccessState as cO, getStepsInfos as cP, getSwapTxStatusRefetchInterval as cQ, getSendTxStatusRefetchInterval as cR, chainflipMultihopBridgeType as cS, getBridgeType as cT, getTransactionStatus as cU, getTransactionEndStatus as cV, isHistoryTransactionPending as cW, isHistoryTransactionFailed as cX, isHistoryTransactionWarning as cY, isHistoryTransactionEnded as cZ, formatHash as c_, formatTokenAmount as ca, formatUsdAmount as cb, trimExtraDecimals as cc, getNumericValue as cd, cleanAmount as ce, convertTokenAmountToUSD as cf, convertUSDToTokenAmount as cg, calculateTotal24hChange as ch, getRouteExpiry as ci, searchTokens as cj, filterSolanaWallets as ck, isSolanaAddressValid as cl, executeSolanaSwap as cm, executeSolanaTransfer as cn, isStellarAddressValid as co, getStellarNetwork as cp, stellarAddressToScVal as cq, getStellarTrustLineAsset as cr, isStellarToken as cs, isStellarIssuedToken as ct, getStellarHorizonApiUrl as cu, isValidIssuedAsset as cv, isValidHorizonAsset as cw, formatTransactionHistoryDate as cx, getAxelarExplorerTxUrl as cy, getSourceExplorerTxUrl as cz, definedInWindow as d, redirectToExtensionsStore as d0, accessProperty as d1, populateWallets as d2, getDefaultChain as d3, sortWallets as d4, areSameAddress as d5, sortAddressBook as d6, calculateTotalUsdBalanceUSD as d7, addTokenToWallet as d8, isEvmChainNotSupportedError as d9, getWalletSupportedChainTypes as da, getConnectorForChainType as db, walletSupportsChainType as dc, connectWallet as dd, cancelConnectWallet as de, isProblematicConnector as df, mergeWallets as dg, isXionSmartContractAddress as dh, isXrplAddressValid as di, buildXrplTrustSetTx as dj, getXrplNetwork as dk, parseXrplPaymentTx as dl, parseXrplTokenAddress as dm, er as e, formatBNToReadable as f, DEFAULT_ROUTE_REFETCH_INTERVAL as g, destinationAddressResetValue as h, fallbackAddressResetValue as i, nativeCosmosTokenAddress as j, nativeEvmTokenAddress as k, nativeSolanaTokenAddress as l, nativeStellarTokenAddress as m, nativeBitcoinTokenAddress as n, nativeSuiTokenAddress as o, nativeXrplTokenAddress as p, CosmosProvider as q, SendTransactionStatus as r, TransactionStatus as s, useTrackSearchEmpty as t, useCosmosContext as u, useSquidChains as v, walletIconBaseUrl as w, useClient as x, useCosmosForChain as y, useHederaAccountActivation as z };
+//# sourceMappingURL=index-XR8ODWxH.js.map