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

package/dist/{index-5cyMUZhY.js → index-BSX11dad.js}

@@ -27,9 +27,9 @@ var wagmi = require('wagmi');
 var SafeAppsSDK = require('@safe-global/safe-apps-sdk');
 var core$1 = require('@wallet-standard/core');
 var slushWallet = require('@mysten/slush-wallet');
-var connectors = require('wagmi/connectors');
 var stargate = require('@cosmjs/stargate');
 var client = require('@mysten/sui/client');
+var connectors = require('wagmi/connectors');
 var protoSigning = require('@cosmjs/proto-signing');
 var transactions = require('@mysten/sui/transactions');
 var cosmwasmStargate = require('@cosmjs/cosmwasm-stargate');
@@ -145,6 +145,9 @@ const CHAIN_IDS = {
     SONEIUM: "1868",
     PEAQ: "3338",
     HEDERA: "295",
+    MANTRA: "5888",
+    CITREA: "4114",
+    TEMPO: "4217",
     // others
     BITCOIN: "bitcoin",
     SOLANA: "solana-mainnet-beta",
@@ -20118,14 +20121,17 @@ function isXrplAddressValid(address) {
     return rippleAddressCodec.isValidXAddress(address) || rippleAddressCodec.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,
         },
     };
@@ -20154,6 +20160,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 {
@@ -21136,8 +21152,10 @@ function isChainflipBridgeTransaction(actions = []) {
 function isOnChainTxData(squidData) {
     return [
         squidTypes.SquidDataType.OnChainExecution,
-        squidTypes.SquidDataType.DepositAddressWithSignature,
         squidTypes.SquidDataType.OnChainExecutionWithSignature,
+        squidTypes.SquidDataType.DepositAddressWithSignature,
+        squidTypes.SquidDataType.DepositAddressCalldata,
+        squidTypes.SquidDataType.DepositAddressWithMemo,
     ].includes(squidData.type);
 }
 function getHistoryTransactionId(tx) {
@@ -21414,6 +21432,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 stellarSdk.StrKey.isValidEd25519PublicKey(address);
 }
@@ -21435,6 +21475,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) {
@@ -22234,6 +22346,8 @@ exports.QueryKeys = void 0;
     QueryKeys["XrplAccountActivatedInfo"] = "xrplAccountActivatedInfo";
     QueryKeys["FiatToCryptoPaymentMethods"] = "fiatToCryptoPaymentMethods";
     QueryKeys["Stellar"] = "stellar";
+    QueryKeys["StellarTrustLine"] = "stellarTrustLine";
+    QueryKeys["IsStellarTrustLineApproved"] = "isStellarTrustLineApproved";
     QueryKeys["StellarAccountActivatedInfo"] = "stellarAccountActivatedInfo";
     QueryKeys["Hedera"] = "hedera";
     QueryKeys["IsHederaTokenAssociated"] = "isHederaTokenAssociated";
@@ -22298,7 +22412,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(),
         exports.QueryKeys.Transaction,
         fromChainId,
@@ -22307,7 +22421,6 @@ const keys = () => ({
         fromTokenAddress,
         price,
         slippage,
-        getGasOnDestination,
         sourceUserAddress,
         degenMode,
         destinationAddress,
@@ -22341,7 +22454,7 @@ const keys = () => ({
     // ============
     // Approval
     // ============
-    routeApproved: (routeData, allowanceInWei) => [
+    routeApproved: (routeData, allowanceInWei, isAllowanceQueryEnabled, hasAllowance) => [
         ...keys().transactions(),
         exports.QueryKeys.RouteApproved,
         routeData?.params.fromAddress,
@@ -22349,6 +22462,8 @@ const keys = () => ({
         routeData?.params.fromToken,
         routeData?.params.fromAmount,
         allowanceInWei?.toString(),
+        isAllowanceQueryEnabled,
+        hasAllowance,
     ],
     sendTransactionGas: (chainId, tokenAddress, from) => [
         exports.QueryKeys.All,
@@ -22421,6 +22536,23 @@ const keys = () => ({
     // ============
     // Stellar
     // ============
+    stellarTrustLine: (tokenAddress, chainId, address) => [
+        ...keys().stellar(),
+        exports.QueryKeys.StellarTrustLine,
+        tokenAddress,
+        chainId,
+        address,
+    ],
+    isStellarTrustLineApproved: (address, chainId, chainType, tokenAddress, trustLineLimit, amountToApprove) => [
+        ...keys().stellar(),
+        exports.QueryKeys.IsStellarTrustLineApproved,
+        address,
+        chainId,
+        chainType,
+        tokenAddress,
+        trustLineLimit,
+        amountToApprove?.toString(),
+    ],
     stellarAccountActivatedInfo: (address, chainId, chainType) => [
         ...keys().stellar(),
         exports.QueryKeys.StellarAccountActivatedInfo,
@@ -22456,6 +22588,8 @@ const getPrefixKey = (key) => {
             return [...keys().transactions(), key];
         case exports.QueryKeys.XrplTrustLine:
             return [...keys().xrpl(), key];
+        case exports.QueryKeys.StellarTrustLine:
+            return [...keys().stellar(), key];
         case exports.QueryKeys.IsHederaTokenAssociated:
             return [...keys().hedera(), key];
         default:
@@ -22468,7 +22602,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),
@@ -22958,8 +23091,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;
@@ -23170,7 +23303,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-D_d3CFdp.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-ChCrHmS3.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -24861,7 +24994,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() ===
@@ -26486,7 +26619,7 @@ function useStellarWallets() {
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
                 const { LedgerModule } = await import('@creit.tech/stellar-wallets-kit/modules/ledger.module');
-                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-CIkvwxPo.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-D65n-wCV.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27793,580 +27926,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 stellarSdk.rpc.Server(rpcUrl);
     }
-    async getAccountInfo(address) {
-        const data = await this.fetch(`accounts/${address}`);
-        if (typeof data.max_automatic_token_associations !== "number") {
-            throw new Error("Invalid max_automatic_token_associations type, expected number");
+    /**
+     * Returns the balance of a Stellar Contract Token. This is different from an Issued Token.
+     *
+     * With Contract Tokens, we need to call the .balance method on the token contract
+     * and simulate the transaction to get the balance.
+     */
+    async getBalance(userAddress, tokenAddress, chainId) {
+        const account = await this.server.getAccount(userAddress);
+        const network = getStellarNetwork(chainId);
+        if (network == null) {
+            throw new Error(`No Stellar network found for chainId ${chainId}`);
         }
-        if (typeof data.balance.balance !== "number") {
-            throw new Error("Invalid balance type, expected number");
+        const txBuilder = new stellarSdk.TransactionBuilder(account, {
+            fee: (BigInt(stellarSdk.BASE_FEE) * BigInt(2)).toString(),
+            networkPassphrase: network,
+        });
+        const contract = new stellarSdk.Contract(tokenAddress);
+        const tx = txBuilder
+            .addOperation(contract.call("balance", new stellarSdk.Address(userAddress).toScVal()))
+            .setTimeout(stellarSdk.TimeoutInfinite)
+            .build();
+        const simulateTxResponse = await this.server.simulateTransaction(tx);
+        if ("error" in simulateTxResponse) {
+            const isNoBalanceError = /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 = stellarSdk.scValToNative(simulateTxResponse.result.retval);
+            return native.toString();
         }
-        return data;
+        throw new Error("Failed to fetch balance");
     }
-    async getAccountTokens(address) {
-        const data = await this.fetch(`accounts/${address}/tokens`);
-        if (!Array.isArray(data.tokens)) {
-            throw new Error("Invalid tokens type, expected array");
+    async getAllBalances(userAddress, tokens) {
+        const balancePromises = tokens.map((token) => {
+            return this.getBalance(userAddress, token.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 === stellarSdk.rpc.Api.GetTransactionStatus.NOT_FOUND) {
+                if (Date.now() - startTime > timeout) {
+                    throw new Error(`Transaction ${txHash} not found within timeout`);
+                }
+                // eslint-disable-next-line @typescript-eslint/no-loop-func
+                await new Promise((res) => setTimeout(res, interval));
+                continue;
+            }
+            if (result.status === stellarSdk.rpc.Api.GetTransactionStatus.SUCCESS) {
+                return result.status;
+            }
+            throw new Error(`Transaction failed with status: ${result.status}`);
         }
-        const firstToken = data.tokens[0];
-        if (typeof firstToken?.automatic_association !== "boolean") {
-            throw new Error("Invalid automatic_association type, expected boolean");
+    }
+    async isAccountActivated(address) {
+        try {
+            await this.getAccount(address);
+            return true;
         }
-        if (typeof firstToken?.token_id !== "string") {
-            throw new Error("Invalid token_id type, expected string");
+        catch (error) {
+            if (error?.message && error.message.includes("Account not found")) {
+                return false;
+            }
+            throw error;
         }
-        return data;
     }
-    async fetch(path) {
-        const url = new URL(path, this.apiUrl);
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Hedera API error: ${response.status}`);
+    async getAccount(address) {
+        return this.server.getAccount(address);
+    }
+    async sendTransaction(transaction) {
+        const transactionResponse = await this.server.sendTransaction(transaction);
+        if (transactionResponse.status === "ERROR") {
+            throw new Error("Error sending transaction");
         }
-        return response.json();
+        return transactionResponse;
+    }
+    async prepareTransaction(transaction) {
+        return this.server.prepareTransaction(transaction);
     }
 }
 
-hederaWalletConnect.type = "hederaWalletConnect";
-/**
- * Wagmi connector to interact with the Hedera EVM network via the WalletConnect protocol.
- *
- * The connector removes the need for a WalletConnect modal, and instead
- * communicates with the provided `extension` by opening the extension popup
- * for user interaction upon request.
- */
-function hederaWalletConnect(parameters) {
-    const { extension, ...restParameters } = parameters;
-    let provider_;
-    let providerPromise;
-    let connect;
-    let displayUri;
-    let sessionDelete;
-    let disconnect;
-    return createConnector((config) => ({
-        id: `hedera-wc-${extension.id}`,
-        name: extension.name,
-        icon: extension.icon,
-        type: hederaWalletConnect.type,
-        async setup() {
-            const provider = await this.getProvider().catch(() => null);
-            if (!provider)
-                return;
-            if (!connect) {
-                connect = this.onConnect.bind(this);
-                provider.on("connect", connect);
-            }
-            if (!sessionDelete) {
-                sessionDelete = this.onSessionDelete.bind(this);
-                provider.on("session_delete", sessionDelete);
+class XrplRpcClient {
+    rpcUrl;
+    constructor(rpcUrl) {
+        this.rpcUrl = rpcUrl;
+    }
+    async getBalance(address, tokenAddress) {
+        if (tokenAddress.toLowerCase() === nativeXrplTokenAddress.toLowerCase()) {
+            return this.getNativeBalance(address);
+        }
+        return this.getIssuedCurrencyBalance(address, tokenAddress);
+    }
+    async getAllBalances(address) {
+        const [nativeBalance, trustLineBalances] = await Promise.all([
+            this.getNativeBalance(address),
+            this.getTrustLines(address),
+        ]);
+        return [
+            {
+                balance: nativeBalance,
+                address: nativeXrplTokenAddress,
+            },
+            ...trustLineBalances.lines.map((line) => ({
+                balance: line.balance,
+                address: `${line.currency}.${line.account}`,
+            })),
+        ];
+    }
+    async getTrustLines(address, issuer) {
+        return this.call("account_lines", [
+            {
+                account: address,
+                ledger_index: "validated",
+                peer: issuer,
+            },
+        ]);
+    }
+    async getTrustLine(address, 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) => viem.getAddress(x));
-                const currentChainId = await this.getChainId();
-                if (displayUri) {
-                    provider.removeListener("display_uri", displayUri);
-                    displayUri = undefined;
-                }
-                if (connect) {
-                    provider.removeListener("connect", connect);
-                    connect = undefined;
+                const response = await this.call("tx", [
+                    {
+                        transaction: txHash,
+                        binary: false,
+                    },
+                ]);
+                if (!response.validated) {
+                    if (Date.now() - startTime > timeout) {
+                        throw new Error(`Transaction ${txHash} not validated within timeout`);
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-loop-func
+                    await new Promise((res) => setTimeout(res, interval));
+                    continue;
                 }
-                if (!disconnect) {
-                    disconnect = this.onDisconnect.bind(this);
-                    provider.on("disconnect", disconnect);
+                const status = response.meta?.TransactionResult;
+                if (status === XrplTxStatus.SUCCESS) {
+                    return status;
                 }
-                if (!sessionDelete) {
-                    sessionDelete = this.onSessionDelete.bind(this);
-                    provider.on("session_delete", sessionDelete);
+                else {
+                    throw new Error(`Transaction failed with status: ${status}`);
                 }
-                return { accounts, chainId: currentChainId };
             }
             catch (error) {
-                if (/(user rejected|connection request reset)/i.test(error?.message)) {
-                    throw new viem.UserRejectedRequestError(error);
+                // txnNotFound = still pending or non-existent
+                if (error?.message?.includes("txnNotFound")) {
+                    if (Date.now() - startTime > timeout) {
+                        throw new Error(`Transaction ${txHash} not found within timeout`);
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-loop-func
+                    await new Promise((res) => setTimeout(res, interval));
+                    continue;
                 }
                 throw error;
             }
-        },
-        async disconnect() {
-            const provider = await this.getProvider();
-            try {
-                await provider?.disconnect();
-            }
-            catch (error) {
-                if (!/No matching key/i.test(error.message))
-                    throw error;
-            }
-            finally {
-                if (disconnect) {
-                    provider?.removeListener("disconnect", disconnect);
-                    disconnect = undefined;
-                }
-                if (!connect) {
-                    connect = this.onConnect.bind(this);
-                    provider?.on("connect", connect);
-                }
-                if (sessionDelete) {
-                    provider?.removeListener("session_delete", sessionDelete);
-                    sessionDelete = undefined;
-                }
-            }
-        },
-        async getAccounts() {
-            const provider = await this.getProvider();
-            return provider.accounts.map((x) => viem.getAddress(x));
-        },
-        async getProvider() {
-            async function initProvider() {
-                const optionalChains = config.chains.map((x) => x.id);
-                if (!optionalChains.length)
-                    return;
-                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-CeHwkxPw.js'); });
-                const rawProvider = await EthereumProvider.init({
-                    ...restParameters,
-                    disableProviderPing: true,
-                    optionalChains,
-                    projectId: restParameters.projectId,
-                    rpcMap: Object.fromEntries(config.chains.map((chain) => {
-                        const [url] = extractRpcUrls({
-                            chain,
-                            transports: config.transports,
-                        });
-                        return [chain.id, url];
-                    })),
-                    showQrModal: false,
-                    // We need to specify a custom storage prefix to avoid conflicts with Wagmi's walletConnect instance
-                    // https://docs.reown.com/walletkit/web/usage#core-instance-sharing
-                    customStoragePrefix: "squid-hedera",
-                });
-                const proxiedProvider = new Proxy(rawProvider, {
-                    get(target, prop, receiver) {
-                        if (prop === "request") {
-                            return async (args) => {
-                                const signingMethods = [
-                                    "eth_sendTransaction",
-                                    "eth_signTransaction",
-                                ];
-                                if (signingMethods.includes(args.method)) {
-                                    try {
-                                        HederaExtensionHelper.extensionOpen(extension.id);
-                                    }
-                                    catch { }
-                                }
-                                // forward request to original provider
-                                return target.request(args);
-                            };
-                        }
-                        // forward all other properties/methods
-                        return Reflect.get(target, prop, receiver);
-                    },
-                });
-                return proxiedProvider;
-            }
-            if (!provider_) {
-                if (!providerPromise)
-                    providerPromise = initProvider();
-                provider_ = await providerPromise;
-                provider_?.events.setMaxListeners(Number.POSITIVE_INFINITY);
-            }
-            return provider_;
-        },
-        async getChainId() {
-            const provider = await this.getProvider();
-            return provider.chainId;
-        },
-        async isAuthorized() {
-            try {
-                const accounts = await this.getAccounts();
-                return accounts.length > 0;
-            }
-            catch {
-                return false;
-            }
-        },
-        onAccountsChanged(accounts) {
-            if (accounts.length === 0)
-                this.onDisconnect();
-            else
-                config.emitter.emit("change", {
-                    accounts: accounts.map((x) => viem.getAddress(x)),
-                });
-        },
-        onChainChanged(chain) {
-            const chainId = Number(chain);
-            config.emitter.emit("change", { chainId });
-        },
-        async onConnect(connectInfo) {
-            const chainId = Number(connectInfo.chainId);
-            const accounts = await this.getAccounts();
-            config.emitter.emit("connect", { accounts, chainId });
-        },
-        async onDisconnect() {
-            config.emitter.emit("disconnect");
-            const provider = await this.getProvider();
-            if (disconnect) {
-                provider.removeListener("disconnect", disconnect);
-                disconnect = undefined;
-            }
-            if (sessionDelete) {
-                provider.removeListener("session_delete", sessionDelete);
-                sessionDelete = undefined;
-            }
-            if (!connect) {
-                connect = this.onConnect.bind(this);
-                provider.on("connect", connect);
-            }
-        },
-        onDisplayUri(uri) {
-            config.emitter.emit("message", { type: "display_uri", data: uri });
-            HederaExtensionHelper.extensionConnect(extension.id, uri);
-        },
-        onSessionDelete() {
-            this.onDisconnect();
-        },
-    }));
-}
-
-const createWagmiConfig = (squidChains, hederaExtensions) => {
-    const filteredEvmChains = squidChains.filter((chain) => chain.chainType === squidTypes.ChainType.EVM);
-    if (filteredEvmChains.length === 0) {
-        throw new Error("At least one chain is required");
+        }
     }
-    const wagmiChains = filteredEvmChains.map((chain) => {
-        return viem.defineChain({
-            id: Number(chain.chainId),
-            name: chain.networkName,
-            nativeCurrency: {
-                name: chain.nativeCurrency.name,
-                symbol: chain.nativeCurrency.symbol,
-                decimals: chain.nativeCurrency.decimals,
+    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 wagmi.createConfig({
-        chains: wagmiChains,
-        transports: Object.fromEntries(wagmiChains.map((chain) => [
-            chain.id,
-            wagmi.http(chain.rpcUrls.public.http[0] ?? ""),
-        ])),
-        connectors: [
-            connectors.injected(),
-            connectors.safe({
-                allowedDomains: [/app.safe.global$/],
-            }),
-            connectors.metaMask({
-                dappMetadata: {
-                    name: SQUID_METADATA.name,
-                    url: SQUID_METADATA.url,
-                    iconUrl: SQUID_METADATA.icon,
-                },
-            }),
-            connectors.coinbaseWallet({
-                appName: SQUID_METADATA.name,
-                appLogoUrl: SQUID_METADATA.icon,
-            }),
-            connectors.walletConnect({
-                projectId: WALLETCONNECT_PROJECT_ID,
-                metadata: wcMetadata,
+            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 ethers.BrowserProvider(transport, network);
-    const signer = new ethers.JsonRpcSigner(provider, account.address);
-    return signer;
 }
 
-function useEvmSigner({ chainId }) {
-    const { connector } = wagmi.useAccount();
-    const { data: client } = wagmi.useWalletClient({ chainId, connector });
-    const signer = React.useMemo(() => (client ? clientToSigner(client) : undefined), [client]);
-    return { signer };
+const 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 === squidTypes.ChainType.EVM ? Number(chain.chainId) : undefined;
-    // EVM and Cosmos need a different signer for each chain
-    // This is not the case for Solana or Bitcoin as there's only one chain in those ecosystems
-    const { signer: evmSigner } = useEvmSigner({ chainId: evmChainId });
-    const { signer: cosmosSigner } = useCosmosSigner({ chain });
-    const { signer: solanaSigner } = useSolanaContext();
-    const { signer: bitcoinSigner } = useBitcoinContext();
-    const { signer: suiSigner } = useSuiContext();
-    const { signer: xrplSigner } = useXrplContext();
-    const { signer: stellarSigner } = useStellarContext();
-    const isEvmSignerReady = !!evmSigner;
-    const isSolanaSignerReady = !!solanaSigner;
-    const isCosmosSignerReady = !!cosmosSigner;
-    const isBitcoinSignerReady = !!bitcoinSigner;
-    const isSuiSignerReady = !!suiSigner;
-    const isXrplSignerReady = !!xrplSigner;
-    const isStellarSignerReady = !!stellarSigner;
-    const isSignerReady = React.useMemo(() => {
-        if (!chain?.chainType)
-            return false;
-        switch (chain.chainType) {
-            case squidTypes.ChainType.EVM:
-                return isEvmSignerReady;
-            case squidTypes.ChainType.COSMOS:
-                return isCosmosSignerReady;
-            case squidTypes.ChainType.BTC:
-                return isBitcoinSignerReady;
-            case squidTypes.ChainType.SOLANA:
-                return isSolanaSignerReady;
-            case squidTypes.ChainType.SUI:
-                return isSuiSignerReady;
-            case squidTypes.ChainType.XRPL:
-                return isXrplSignerReady;
-            case squidTypes.ChainType.STELLAR:
-                return isStellarSignerReady;
-        }
-    }, [
-        chain?.chainType,
-        isEvmSignerReady,
-        isCosmosSignerReady,
-        isBitcoinSignerReady,
-        isSolanaSignerReady,
-        isSuiSignerReady,
-        isXrplSignerReady,
-        isStellarSignerReady,
-    ]);
-    return {
-        isSignerReady,
-        evmSigner,
-        cosmosSigner,
-        bitcoinSigner,
-        solanaSigner,
-        suiSigner,
-        xrplSigner,
-        stellarSigner,
-    };
-};
-
-function useHederaTokenAssociations({ address, chain, token }) {
-    const publicClient = wagmi.usePublicClient({
-        chainId: Number(CHAIN_IDS.HEDERA),
-    });
-    const { evmSigner } = useSigner({ chain });
-    const queryClient = reactQuery.useQueryClient();
-    /**
-     * Creates a token association transaction where the destination account authorizes to receive the given token
-     */
-    const associateToken = reactQuery.useMutation({
-        mutationFn: async () => {
-            try {
-                if (!evmSigner) {
-                    throw new Error("EVM signer not found");
-                }
-                if (chain?.chainId !== CHAIN_IDS.HEDERA ||
-                    token?.chainId !== CHAIN_IDS.HEDERA) {
-                    throw new Error("Chain and token to associate must be on Hedera");
-                }
-                const tokenAddress = parseEvmAddress(token.address);
-                if (!tokenAddress) {
-                    throw new Error("Invalid token address");
-                }
-                const userAddress = parseEvmAddress(address);
-                if (!userAddress) {
-                    throw new Error("Invalid user address");
-                }
-                const encodedData = viem.encodeFunctionData({
-                    abi: hrc20,
-                    functionName: "associate",
-                    args: [],
-                });
-                const txRes = await evmSigner.sendTransaction({
-                    data: encodedData,
-                    to: tokenAddress,
-                    chainId: chain.chainId,
-                });
-                const receipt = await txRes.wait();
-                if (receipt?.status !== 1) {
-                    throw new Error(`Transaction failed with status: ${receipt?.status}`);
-                }
-                return true;
-            }
-            catch (error) {
-                console.error("Error associating Hedera token:", error);
-                return false;
-            }
-        },
-        async onSuccess() {
-            queryClient.refetchQueries({
-                queryKey: getPrefixKey(exports.QueryKeys.IsHederaTokenAssociated),
-            });
-        },
-    });
-    /**
-     * Checks if the destination account has associated the given token.
-     *
-     * Hedera requires accounts to associate a token before being able to receive it.
-     *
-     * Accounts which have max. associations set to -1 can receive any token without previous association
-     */
-    const isTokenAssociated = reactQuery.useQuery({
-        queryKey: keys().isHederaTokenAssociated(address, token?.chainId, token?.type, token?.address),
-        queryFn: async () => {
-            if (token?.chainId !== CHAIN_IDS.HEDERA) {
-                return true;
-            }
-            // The native HBAR token doesn't need an association
-            if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase()) {
-                return true;
-            }
-            if (!chain || !address || !publicClient) {
-                throw new Error("Missing required parameters");
-            }
-            // TODO: update types
-            const apiUrl = chain?.chainConfig?.hedera?.mirrorNodeUrl;
-            if (!apiUrl) {
-                throw new Error("Missing Hedera mirror node URL in chain config");
-            }
-            const hederaApiClient = new HederaApiClient(apiUrl);
-            return hederaApiClient.isTokenAssociated({
-                address,
-                token,
+async function createClient(chain) {
+    switch (chain.chainType) {
+        case squidTypes.ChainType.EVM:
+            return new ethers.JsonRpcProvider(chain.rpc);
+        case squidTypes.ChainType.COSMOS:
+            const rpcUrl = await getWorkingCosmosRpcUrl(chain);
+            return (await stargate.StargateClient.connect(rpcUrl));
+        case squidTypes.ChainType.SOLANA:
+            return new web3_js.Connection(SOLANA_RPC_URL);
+        case squidTypes.ChainType.BTC:
+            return null;
+        case squidTypes.ChainType.SUI:
+            return new client.SuiClient({
+                url: chain.rpc,
             });
-        },
-        enabled: !!address && !!publicClient && token?.chainId === CHAIN_IDS.HEDERA,
-    });
-    return {
-        isTokenAssociated,
-        associateToken,
-    };
+        case squidTypes.ChainType.XRPL:
+            return new XrplRpcClient(chain.rpc);
+        case squidTypes.ChainType.STELLAR:
+            return new StellarRpcClient(chain.rpc);
+    }
 }
 
-const useKeyboardNavigation = ({ onEscape }) => {
-    const onKeyDown = React.useCallback((event) => {
-        if (event.key === "Escape") {
-            onEscape?.();
-            return;
-        }
-    }, [onEscape]);
-    React.useEffect(() => {
-        document.addEventListener("keydown", onKeyDown, false);
-        return () => {
-            document.removeEventListener("keydown", onKeyDown, false);
-        };
-    }, [onKeyDown]);
-};
-
-const useSquidQueryClient = () => {
-    const queryClient = reactQuery.useQueryClient();
-    const invalidateQueries = (key) => {
-        const prefixKey = getPrefixKey(key);
-        queryClient.invalidateQueries(prefixKey);
-    };
-    const refetchQueries = (key) => {
-        const prefixKey = getPrefixKey(key);
-        queryClient.refetchQueries(prefixKey);
-    };
-    const invalidateAndRefetchQueries = (key) => {
-        invalidateQueries(key);
-        refetchQueries(key);
-    };
-    return {
-        invalidateQueries,
-        refetchQueries,
-        invalidateAndRefetchQueries,
-    };
-};
-
 /**
  * The default multicall3 address
  * available on most EVM chains
@@ -29349,12 +29212,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) => {
@@ -29381,372 +29247,6 @@ function timeout(ms, promise) {
     return Promise.race([promise, timeoutPromise]);
 }
 
-class StellarRpcClient {
-    server;
-    constructor(rpcUrl) {
-        this.server = new stellarSdk.rpc.Server(rpcUrl);
-    }
-    /**
-     * Returns the balance of a Stellar Contract Token. This is different from an Issued Token.
-     *
-     * With Contract Tokens, we need to call the .balance method on the token contract
-     * and simulate the transaction to get the balance.
-     */
-    async getBalance(userAddress, tokenAddress, chainId) {
-        const account = await this.server.getAccount(userAddress);
-        const network = getStellarNetwork(chainId);
-        if (network == null) {
-            throw new Error(`No Stellar network found for chainId ${chainId}`);
-        }
-        const txBuilder = new stellarSdk.TransactionBuilder(account, {
-            fee: (BigInt(stellarSdk.BASE_FEE) * BigInt(2)).toString(),
-            networkPassphrase: network,
-        });
-        const contract = new stellarSdk.Contract(tokenAddress);
-        const tx = txBuilder
-            .addOperation(contract.call("balance", new stellarSdk.Address(userAddress).toScVal()))
-            .setTimeout(stellarSdk.TimeoutInfinite)
-            .build();
-        const simulateTxResponse = await this.server.simulateTransaction(tx);
-        if ("error" in simulateTxResponse) {
-            const isNoBalanceError = simulateTxResponse.error.includes("trying to get non-existing value for contract instance");
-            // If the error message indicates that the user has no balance just return 0
-            // We don't want to spam with this error as it's pretty common
-            if (isNoBalanceError) {
-                return "0";
-            }
-            throw new Error(`Failed to fetch balance. RPC response: ${simulateTxResponse.error}`);
-        }
-        if ("result" in simulateTxResponse && simulateTxResponse.result != null) {
-            const native = stellarSdk.scValToNative(simulateTxResponse.result.retval);
-            return native.toString();
-        }
-        throw new Error("Failed to fetch balance");
-    }
-    async getAllBalances(userAddress, tokens) {
-        const balancePromises = tokens.map((token) => {
-            return this.getBalance(userAddress, token.address, token.chainId);
-        });
-        const results = await Promise.allSettled(balancePromises);
-        const balances = results.map((result) => {
-            if (result.status === "fulfilled") {
-                return result.value;
-            }
-            return "0";
-        });
-        return balances.map((balance, index) => {
-            return {
-                ...tokens[index],
-                balance,
-            };
-        });
-    }
-    /**
-     * Resolves when the transaction is confirmed, or fails after a timeout.
-     */
-    async waitForTransaction(txHash, { interval = 2_000, timeout = 40_000 } = {}) {
-        const startTime = Date.now();
-        while (true) {
-            const result = await this.server.getTransaction(txHash);
-            if (result.status === stellarSdk.rpc.Api.GetTransactionStatus.NOT_FOUND) {
-                if (Date.now() - startTime > timeout) {
-                    throw new Error(`Transaction ${txHash} not found within timeout`);
-                }
-                // eslint-disable-next-line @typescript-eslint/no-loop-func
-                await new Promise((res) => setTimeout(res, interval));
-                continue;
-            }
-            if (result.status === stellarSdk.rpc.Api.GetTransactionStatus.SUCCESS) {
-                return result.status;
-            }
-            throw new Error(`Transaction failed with status: ${result.status}`);
-        }
-    }
-    async isAccountActivated(address) {
-        try {
-            await this.getAccount(address);
-            return true;
-        }
-        catch (error) {
-            if (error?.message && error.message.includes("Account not found")) {
-                return false;
-            }
-            throw error;
-        }
-    }
-    async getAccount(address) {
-        return this.server.getAccount(address);
-    }
-    async sendTransaction(transaction) {
-        const transactionResponse = await this.server.sendTransaction(transaction);
-        if (transactionResponse.status === "ERROR") {
-            throw new Error("Error sending transaction");
-        }
-        return transactionResponse;
-    }
-    async prepareTransaction(transaction) {
-        return this.server.prepareTransaction(transaction);
-    }
-}
-
-class XrplRpcClient {
-    rpcUrl;
-    constructor(rpcUrl) {
-        this.rpcUrl = rpcUrl;
-    }
-    async getBalance(address, tokenAddress) {
-        if (tokenAddress.toLowerCase() === nativeXrplTokenAddress.toLowerCase()) {
-            return this.getNativeBalance(address);
-        }
-        return this.getIssuedCurrencyBalance(address, tokenAddress);
-    }
-    async getAllBalances(address) {
-        const [nativeBalance, trustLineBalances] = await Promise.all([
-            this.getNativeBalance(address),
-            this.getTrustLines(address),
-        ]);
-        return [
-            {
-                balance: nativeBalance,
-                address: nativeXrplTokenAddress,
-            },
-            ...trustLineBalances.lines.map((line) => ({
-                balance: line.balance,
-                address: `${line.currency}.${line.account}`,
-            })),
-        ];
-    }
-    async getTrustLines(address, issuer) {
-        return this.call("account_lines", [
-            {
-                account: address,
-                ledger_index: "validated",
-                peer: issuer,
-            },
-        ]);
-    }
-    async getTrustLine(address, issuer, currency) {
-        const response = await this.getTrustLines(address, issuer);
-        const trustLine = response.lines.find((line) => line.currency === currency);
-        return trustLine ?? null;
-    }
-    async accountActivatedInfo(address) {
-        const serverState = await this.getServerState();
-        const reserveBaseBn = BigInt(serverState.state.validated_ledger.reserve_base);
-        try {
-            const accountInfo = await this.getAccountInfo(address);
-            const balanceBn = BigInt(accountInfo.account_data.Balance);
-            return {
-                isActivated: balanceBn >= reserveBaseBn,
-                reserveBaseBn,
-            };
-        }
-        catch (error) {
-            if (error.message?.includes("actNotFound")) {
-                return { isActivated: false, reserveBaseBn };
-            }
-            throw error;
-        }
-    }
-    /**
-     * Waits for a transaction to be validated and returns its final status.
-     * Resolves to 'success' or throws an error with the failed status.
-     */
-    async waitForTransaction(txHash, { interval = 2_000, timeout = 20_000 } = {}) {
-        const startTime = Date.now();
-        while (true) {
-            try {
-                const response = await this.call("tx", [
-                    {
-                        transaction: txHash,
-                        binary: false,
-                    },
-                ]);
-                if (!response.validated) {
-                    if (Date.now() - startTime > timeout) {
-                        throw new Error(`Transaction ${txHash} not validated within timeout`);
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-loop-func
-                    await new Promise((res) => setTimeout(res, interval));
-                    continue;
-                }
-                const status = response.meta?.TransactionResult;
-                if (status === XrplTxStatus.SUCCESS) {
-                    return status;
-                }
-                else {
-                    throw new Error(`Transaction failed with status: ${status}`);
-                }
-            }
-            catch (error) {
-                // txnNotFound = still pending or non-existent
-                if (error?.message?.includes("txnNotFound")) {
-                    if (Date.now() - startTime > timeout) {
-                        throw new Error(`Transaction ${txHash} not found within timeout`);
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-loop-func
-                    await new Promise((res) => setTimeout(res, interval));
-                    continue;
-                }
-                throw error;
-            }
-        }
-    }
-    async getServerState() {
-        return this.call("server_state", [{}]);
-    }
-    async getAccountInfo(address) {
-        return this.call("account_info", [
-            {
-                account: address,
-                ledger_index: "validated",
-            },
-        ]);
-    }
-    /**
-     * Returns the balance of the user in the native XRP token
-     * formatted as a string
-     */
-    async getNativeBalance(address) {
-        const [accountInfo, serverState] = await Promise.all([
-            this.getAccountInfo(address),
-            this.getServerState(),
-        ]);
-        const balance = BigInt(accountInfo.account_data.Balance);
-        const ownerCount = BigInt(accountInfo.account_data.OwnerCount);
-        const reserveBase = BigInt(serverState.state.validated_ledger.reserve_base);
-        const reserveIncrement = BigInt(serverState.state.validated_ledger.reserve_inc);
-        const reserveBalance = reserveBase + ownerCount * reserveIncrement;
-        const spendableBalance = balance - reserveBalance;
-        return formatBNToReadable(spendableBalance, 6);
-    }
-    /**
-     * Returns the balance of the user in the given issued currency (e.g. RLUSD)
-     * formatted as a string
-     */
-    async getIssuedCurrencyBalance(address, tokenAddress) {
-        const response = await this.getTrustLines(address);
-        const tokenBalance = response.lines.find((line) => `${line.currency}.${line.account}` === tokenAddress);
-        return tokenBalance?.balance || "0";
-    }
-    async call(method, params) {
-        const response = await fetch(this.rpcUrl, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                jsonrpc: "2.0",
-                id: 1,
-                method,
-                params,
-            }),
-        });
-        const data = await response.json();
-        if (!data.result) {
-            throw new Error(`Invalid response from RPC (${method})`);
-        }
-        if ("error" in data.result) {
-            throw new Error(`Error from RPC (${method}): ${data.result.error}`);
-        }
-        return data.result;
-    }
-}
-
-const clientCache = new Map();
-async function getClient(chain) {
-    const key = `${chain.chainType}:${chain.chainId}`;
-    if (clientCache.has(key)) {
-        return clientCache.get(key);
-    }
-    const client = await createClient(chain);
-    clientCache.set(key, client);
-    return client;
-}
-async function createClient(chain) {
-    switch (chain.chainType) {
-        case squidTypes.ChainType.EVM:
-            return new ethers.JsonRpcProvider(chain.rpc);
-        case squidTypes.ChainType.COSMOS:
-            const rpcUrl = await getWorkingCosmosRpcUrl(chain);
-            return (await stargate.StargateClient.connect(rpcUrl));
-        case squidTypes.ChainType.SOLANA:
-            return new web3_js.Connection(SOLANA_RPC_URL);
-        case squidTypes.ChainType.BTC:
-            return null;
-        case squidTypes.ChainType.SUI:
-            return new client.SuiClient({
-                url: chain.rpc,
-            });
-        case squidTypes.ChainType.XRPL:
-            return new XrplRpcClient(chain.rpc);
-        case squidTypes.ChainType.STELLAR:
-            return new StellarRpcClient(chain.rpc);
-    }
-}
-
-class StellarApiClient {
-    apiUrl;
-    constructor(apiUrl) {
-        this.apiUrl = apiUrl;
-    }
-    async getBaseReserve() {
-        const response = await fetch(`${this.apiUrl}/ledgers?order=desc&limit=1`);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch ledgers: ${response.status}`);
-        }
-        const ledgers = await response.json();
-        const latestLedger = ledgers?._embedded.records?.[0];
-        if (latestLedger?.base_reserve_in_stroops == null) {
-            throw new Error("Invalid ledger data");
-        }
-        const baseReserveBn = BigInt(latestLedger.base_reserve_in_stroops);
-        return baseReserveBn;
-    }
-}
-
-const DEFAULT_REFETCH_INTERVAL$1 = 20_000;
-function useStellarAccountActivation({ address, chain, token, }) {
-    /**
-     * Checks if the destination account exists on the Stellar network
-     * Stellar accounts need to have a minimum balance before they can receive payments
-     */
-    const accountActivatedInfo = reactQuery.useQuery({
-        queryKey: keys().stellarAccountActivatedInfo(address, chain?.chainId, chain?.chainType),
-        queryFn: async () => {
-            if (chain?.chainType !== squidTypes.ChainType.STELLAR ||
-                token?.type !== squidTypes.ChainType.STELLAR) {
-                return null;
-            }
-            if (!address) {
-                throw new Error("Destination address is required");
-            }
-            // TODO: update types
-            const [horizonApiUrl] = chain?.horizonRpcList;
-            if (typeof horizonApiUrl !== "string") {
-                throw new Error("Invalid Horizon API URL");
-            }
-            const stellarApiClient = new StellarApiClient(horizonApiUrl);
-            const reserveBase = await stellarApiClient.getBaseReserve();
-            // Stellar accounts require two base reserves to be activated
-            // https://developers.stellar.org/docs/learn/fundamentals/lumens#minimum-balance
-            const accountReserveBase = reserveBase * BigInt(2);
-            const stellarRpcClient = await getClient(chain);
-            const isActivated = await stellarRpcClient.isAccountActivated(address);
-            return {
-                isActivated,
-                reserveBaseBn: accountReserveBase,
-            };
-        },
-        enabled: !!address && chain?.chainType === squidTypes.ChainType.STELLAR,
-        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
-        refetchOnWindowFocus: true,
-    });
-    return {
-        accountActivatedInfo,
-    };
-}
-
 const DEFAULT_REFRESH_INTERVAL_MS = 15000;
 const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
     const { isChainTypeConnected } = useWallet();
@@ -29941,6 +29441,8 @@ function useNativeTokenForChain(chain) {
         }
     };
     const nativeTokenForChainType = React.useMemo(() => {
+        if (!chain)
+            return undefined;
         return findNativeToken(getTokensForChainType(), chain);
     }, [chain]);
     return { nativeToken: nativeTokenForChainType };
@@ -30187,47 +29689,842 @@ const useNativeBalance = (chain) => {
             return false;
         switch (chain.chainType) {
             case squidTypes.ChainType.EVM:
-                return isEvmLoading;
+                return isEvmLoading;
+            case squidTypes.ChainType.COSMOS:
+                return isCosmosLoading;
+            case squidTypes.ChainType.BTC:
+                return isBitcoinLoading;
+            case squidTypes.ChainType.SOLANA:
+                return isSolanaLoading;
+            case squidTypes.ChainType.SUI:
+                return isSuiLoading;
+            case squidTypes.ChainType.XRPL:
+                return isXrpLoading;
+            case squidTypes.ChainType.STELLAR:
+                return isStellarLoading;
+        }
+    }, [
+        chain?.chainType,
+        isEvmLoading,
+        isCosmosLoading,
+        isBitcoinLoading,
+        isSolanaLoading,
+        isSuiLoading,
+        isXrpLoading,
+        isStellarLoading,
+    ]);
+    return { nativeBalance, nativeBalanceFormatted, isLoading };
+};
+
+function useHederaAccountActivation({ address, chain, token }) {
+    const { balance: destNativeEvmBalance } = useEvmNativeBalance({
+        chain,
+        address,
+    });
+    const isHederaAccountActivated = React.useMemo(() => {
+        if (token?.chainId !== CHAIN_IDS.HEDERA)
+            return true;
+        if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase())
+            return true;
+        return (!!destNativeEvmBalance?.value && destNativeEvmBalance.value > BigInt(0));
+    }, [token?.chainId, token?.address, destNativeEvmBalance?.value]);
+    return {
+        isHederaAccountActivated,
+    };
+}
+
+var hrc20 = [
+	{
+		inputs: [
+		],
+		name: "associate",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "responseCode",
+				type: "uint256"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	}
+];
+
+/**
+ * Client for interacting with the Hedera Mirrornode API.
+ *
+ * @docs https://mainnet.mirrornode.hedera.com/api/v1/docs
+ */
+class HederaApiClient {
+    apiUrl;
+    constructor(apiUrl) {
+        this.apiUrl = apiUrl;
+    }
+    async isTokenAssociated({ address, token, }) {
+        const accountInfo = await this.getAccountInfo(address);
+        // Unlimited auto associations
+        if (accountInfo.max_automatic_token_associations === -1) {
+            return true;
+        }
+        // If there's no unlimited auto-associations, we need to check if the token is already associated.
+        const { tokens: accountTokens } = await this.getAccountTokens(address);
+        const tokenId = convertEvmAddressToHederaAccountId(token.address);
+        if (accountTokens.some((t) => t.token_id === tokenId)) {
+            // Token is already associated
+            return true;
+        }
+        // Finally, if not auto-associated, check if there is an available auto-association slot
+        const autoAssociatedTokens = accountTokens.filter((t) => t.automatic_association);
+        const remainingAutoAssociations = accountInfo.max_automatic_token_associations -
+            autoAssociatedTokens.length;
+        return remainingAutoAssociations > 0;
+    }
+    async getAccountInfo(address) {
+        const data = await this.fetch(`accounts/${address}`);
+        if (typeof data.max_automatic_token_associations !== "number") {
+            throw new Error("Invalid max_automatic_token_associations type, expected number");
+        }
+        if (typeof data.balance.balance !== "number") {
+            throw new Error("Invalid balance type, expected number");
+        }
+        if (!Array.isArray(data.balance.tokens)) {
+            throw new Error("Invalid tokens type, expected array");
+        }
+        return data;
+    }
+    async getAccountTokens(address) {
+        const data = await this.fetch(`accounts/${address}/tokens`);
+        if (!Array.isArray(data.tokens)) {
+            throw new Error("Invalid tokens type, expected array");
+        }
+        const firstToken = data.tokens[0];
+        if (typeof firstToken?.automatic_association !== "boolean") {
+            throw new Error("Invalid automatic_association type, expected boolean");
+        }
+        if (typeof firstToken?.token_id !== "string") {
+            throw new Error("Invalid token_id type, expected string");
+        }
+        return data;
+    }
+    async fetch(path) {
+        const url = new URL(path, this.apiUrl);
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Hedera API error: ${response.status}`);
+        }
+        return response.json();
+    }
+}
+
+hederaWalletConnect.type = "hederaWalletConnect";
+/**
+ * Wagmi connector to interact with the Hedera EVM network via the WalletConnect protocol.
+ *
+ * The connector removes the need for a WalletConnect modal, and instead
+ * communicates with the provided `extension` by opening the extension popup
+ * for user interaction upon request.
+ */
+function hederaWalletConnect(parameters) {
+    const { extension, ...restParameters } = parameters;
+    let provider_;
+    let providerPromise;
+    let connect;
+    let displayUri;
+    let sessionDelete;
+    let disconnect;
+    return createConnector((config) => ({
+        id: `hedera-wc-${extension.id}`,
+        name: extension.name,
+        icon: extension.icon,
+        type: hederaWalletConnect.type,
+        async setup() {
+            const provider = await this.getProvider().catch(() => null);
+            if (!provider)
+                return;
+            if (!connect) {
+                connect = this.onConnect.bind(this);
+                provider.on("connect", connect);
+            }
+            if (!sessionDelete) {
+                sessionDelete = this.onSessionDelete.bind(this);
+                provider.on("session_delete", sessionDelete);
+            }
+        },
+        async connect(params = {}) {
+            try {
+                const provider = await this.getProvider();
+                if (!provider)
+                    throw new ProviderNotFoundError();
+                if (!displayUri) {
+                    displayUri = this.onDisplayUri;
+                    provider.on("display_uri", displayUri);
+                }
+                if (!provider.session) {
+                    await provider.connect({
+                        ...("pairingTopic" in params
+                            ? { pairingTopic: params.pairingTopic }
+                            : {}),
+                    });
+                }
+                const accounts = (await provider.enable()).map((x) => viem.getAddress(x));
+                const currentChainId = await this.getChainId();
+                if (displayUri) {
+                    provider.removeListener("display_uri", displayUri);
+                    displayUri = undefined;
+                }
+                if (connect) {
+                    provider.removeListener("connect", connect);
+                    connect = undefined;
+                }
+                if (!disconnect) {
+                    disconnect = this.onDisconnect.bind(this);
+                    provider.on("disconnect", disconnect);
+                }
+                if (!sessionDelete) {
+                    sessionDelete = this.onSessionDelete.bind(this);
+                    provider.on("session_delete", sessionDelete);
+                }
+                return { accounts, chainId: currentChainId };
+            }
+            catch (error) {
+                if (/(user rejected|connection request reset)/i.test(error?.message)) {
+                    throw new viem.UserRejectedRequestError(error);
+                }
+                throw error;
+            }
+        },
+        async disconnect() {
+            const provider = await this.getProvider();
+            try {
+                await provider?.disconnect();
+            }
+            catch (error) {
+                if (!/No matching key/i.test(error.message))
+                    throw error;
+            }
+            finally {
+                if (disconnect) {
+                    provider?.removeListener("disconnect", disconnect);
+                    disconnect = undefined;
+                }
+                if (!connect) {
+                    connect = this.onConnect.bind(this);
+                    provider?.on("connect", connect);
+                }
+                if (sessionDelete) {
+                    provider?.removeListener("session_delete", sessionDelete);
+                    sessionDelete = undefined;
+                }
+            }
+        },
+        async getAccounts() {
+            const provider = await this.getProvider();
+            return provider.accounts.map((x) => viem.getAddress(x));
+        },
+        async getProvider() {
+            async function initProvider() {
+                const optionalChains = config.chains.map((x) => x.id);
+                if (!optionalChains.length)
+                    return;
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-CkrP1GZJ.js'); });
+                const rawProvider = await EthereumProvider.init({
+                    ...restParameters,
+                    disableProviderPing: true,
+                    optionalChains,
+                    projectId: restParameters.projectId,
+                    rpcMap: Object.fromEntries(config.chains.map((chain) => {
+                        const [url] = extractRpcUrls({
+                            chain,
+                            transports: config.transports,
+                        });
+                        return [chain.id, url];
+                    })),
+                    showQrModal: false,
+                    // We need to specify a custom storage prefix to avoid conflicts with Wagmi's walletConnect instance
+                    // https://docs.reown.com/walletkit/web/usage#core-instance-sharing
+                    customStoragePrefix: "squid-hedera",
+                });
+                const proxiedProvider = new Proxy(rawProvider, {
+                    get(target, prop, receiver) {
+                        if (prop === "request") {
+                            return async (args) => {
+                                const signingMethods = [
+                                    "eth_sendTransaction",
+                                    "eth_signTransaction",
+                                ];
+                                if (signingMethods.includes(args.method)) {
+                                    try {
+                                        HederaExtensionHelper.extensionOpen(extension.id);
+                                    }
+                                    catch { }
+                                }
+                                // forward request to original provider
+                                return target.request(args);
+                            };
+                        }
+                        // forward all other properties/methods
+                        return Reflect.get(target, prop, receiver);
+                    },
+                });
+                return proxiedProvider;
+            }
+            if (!provider_) {
+                if (!providerPromise)
+                    providerPromise = initProvider();
+                provider_ = await providerPromise;
+                provider_?.events.setMaxListeners(Number.POSITIVE_INFINITY);
+            }
+            return provider_;
+        },
+        async getChainId() {
+            const provider = await this.getProvider();
+            return provider.chainId;
+        },
+        async isAuthorized() {
+            try {
+                const accounts = await this.getAccounts();
+                return accounts.length > 0;
+            }
+            catch {
+                return false;
+            }
+        },
+        onAccountsChanged(accounts) {
+            if (accounts.length === 0)
+                this.onDisconnect();
+            else
+                config.emitter.emit("change", {
+                    accounts: accounts.map((x) => viem.getAddress(x)),
+                });
+        },
+        onChainChanged(chain) {
+            const chainId = Number(chain);
+            config.emitter.emit("change", { chainId });
+        },
+        async onConnect(connectInfo) {
+            const chainId = Number(connectInfo.chainId);
+            const accounts = await this.getAccounts();
+            config.emitter.emit("connect", { accounts, chainId });
+        },
+        async onDisconnect() {
+            config.emitter.emit("disconnect");
+            const provider = await this.getProvider();
+            if (disconnect) {
+                provider.removeListener("disconnect", disconnect);
+                disconnect = undefined;
+            }
+            if (sessionDelete) {
+                provider.removeListener("session_delete", sessionDelete);
+                sessionDelete = undefined;
+            }
+            if (!connect) {
+                connect = this.onConnect.bind(this);
+                provider.on("connect", connect);
+            }
+        },
+        onDisplayUri(uri) {
+            config.emitter.emit("message", { type: "display_uri", data: uri });
+            HederaExtensionHelper.extensionConnect(extension.id, uri);
+        },
+        onSessionDelete() {
+            this.onDisconnect();
+        },
+    }));
+}
+
+const createWagmiConfig = (squidChains, hederaExtensions) => {
+    const filteredEvmChains = squidChains.filter((chain) => chain.chainType === squidTypes.ChainType.EVM);
+    if (filteredEvmChains.length === 0) {
+        throw new Error("At least one chain is required");
+    }
+    const wagmiChains = filteredEvmChains.map((chain) => {
+        return viem.defineChain({
+            id: Number(chain.chainId),
+            name: chain.networkName,
+            nativeCurrency: {
+                name: chain.nativeCurrency.name,
+                symbol: chain.nativeCurrency.symbol,
+                decimals: chain.nativeCurrency.decimals,
+            },
+            rpcUrls: {
+                public: {
+                    http: [chain.rpc],
+                },
+                default: {
+                    http: [chain.rpc],
+                },
+            },
+        });
+    });
+    const wcMetadata = {
+        url: SQUID_METADATA.url,
+        name: SQUID_METADATA.name,
+        icons: [SQUID_METADATA.icon],
+        description: SQUID_METADATA.description,
+    };
+    return wagmi.createConfig({
+        chains: wagmiChains,
+        transports: Object.fromEntries(wagmiChains.map((chain) => [
+            chain.id,
+            wagmi.http(chain.rpcUrls.public.http[0] ?? ""),
+        ])),
+        connectors: [
+            connectors.injected(),
+            connectors.safe({
+                allowedDomains: [/app.safe.global$/],
+            }),
+            connectors.metaMask({
+                dappMetadata: {
+                    name: SQUID_METADATA.name,
+                    url: SQUID_METADATA.url,
+                    iconUrl: SQUID_METADATA.icon,
+                },
+            }),
+            connectors.coinbaseWallet({
+                appName: SQUID_METADATA.name,
+                appLogoUrl: SQUID_METADATA.icon,
+            }),
+            connectors.walletConnect({
+                projectId: WALLETCONNECT_PROJECT_ID,
+                metadata: wcMetadata,
+            }),
+            ...hederaExtensions.map((extension) => hederaWalletConnect({
+                projectId: WALLETCONNECT_PROJECT_ID,
+                metadata: wcMetadata,
+                extension,
+            })),
+        ],
+    });
+};
+// Taken from wagmi docs
+// https://wagmi.sh/react/guides/ethers
+function clientToSigner(client) {
+    const { account, chain, transport } = client;
+    if (!account || !chain || !transport) {
+        return undefined;
+    }
+    const network = {
+        chainId: chain.id,
+        name: chain.name,
+        ensAddress: chain.contracts?.ensRegistry?.address,
+    };
+    const provider = new ethers.BrowserProvider(transport, network);
+    const signer = new ethers.JsonRpcSigner(provider, account.address);
+    return signer;
+}
+
+function useEvmSigner({ chainId }) {
+    const { connector } = wagmi.useAccount();
+    const { data: client } = wagmi.useWalletClient({ chainId, connector });
+    const signer = React.useMemo(() => (client ? clientToSigner(client) : undefined), [client]);
+    return { signer };
+}
+const useSigner = ({ chain }) => {
+    const evmChainId = chain?.chainType === squidTypes.ChainType.EVM ? Number(chain.chainId) : undefined;
+    // EVM and Cosmos need a different signer for each chain
+    // This is not the case for Solana or Bitcoin as there's only one chain in those ecosystems
+    const { signer: evmSigner } = useEvmSigner({ chainId: evmChainId });
+    const { signer: cosmosSigner } = useCosmosSigner({ chain });
+    const { signer: solanaSigner } = useSolanaContext();
+    const { signer: bitcoinSigner } = useBitcoinContext();
+    const { signer: suiSigner } = useSuiContext();
+    const { signer: xrplSigner } = useXrplContext();
+    const { signer: stellarSigner } = useStellarContext();
+    const isEvmSignerReady = !!evmSigner;
+    const isSolanaSignerReady = !!solanaSigner;
+    const isCosmosSignerReady = !!cosmosSigner;
+    const isBitcoinSignerReady = !!bitcoinSigner;
+    const isSuiSignerReady = !!suiSigner;
+    const isXrplSignerReady = !!xrplSigner;
+    const isStellarSignerReady = !!stellarSigner;
+    const isSignerReady = React.useMemo(() => {
+        if (!chain?.chainType)
+            return false;
+        switch (chain.chainType) {
+            case squidTypes.ChainType.EVM:
+                return isEvmSignerReady;
             case squidTypes.ChainType.COSMOS:
-                return isCosmosLoading;
+                return isCosmosSignerReady;
             case squidTypes.ChainType.BTC:
-                return isBitcoinLoading;
+                return isBitcoinSignerReady;
             case squidTypes.ChainType.SOLANA:
-                return isSolanaLoading;
+                return isSolanaSignerReady;
             case squidTypes.ChainType.SUI:
-                return isSuiLoading;
+                return isSuiSignerReady;
             case squidTypes.ChainType.XRPL:
-                return isXrpLoading;
+                return isXrplSignerReady;
             case squidTypes.ChainType.STELLAR:
-                return isStellarLoading;
+                return isStellarSignerReady;
         }
     }, [
         chain?.chainType,
-        isEvmLoading,
-        isCosmosLoading,
-        isBitcoinLoading,
-        isSolanaLoading,
-        isSuiLoading,
-        isXrpLoading,
-        isStellarLoading,
+        isEvmSignerReady,
+        isCosmosSignerReady,
+        isBitcoinSignerReady,
+        isSolanaSignerReady,
+        isSuiSignerReady,
+        isXrplSignerReady,
+        isStellarSignerReady,
     ]);
-    return { nativeBalance, nativeBalanceFormatted, isLoading };
+    return {
+        isSignerReady,
+        evmSigner,
+        cosmosSigner,
+        bitcoinSigner,
+        solanaSigner,
+        suiSigner,
+        xrplSigner,
+        stellarSigner,
+    };
 };
 
-function useHederaAccountActivation({ address, chain, token }) {
-    const { balance: destNativeEvmBalance } = useEvmNativeBalance({
-        chain,
-        address,
+function useHederaTokenAssociations({ address, chain, token }) {
+    const publicClient = wagmi.usePublicClient({
+        chainId: Number(CHAIN_IDS.HEDERA),
+    });
+    const { evmSigner } = useSigner({ chain });
+    const queryClient = reactQuery.useQueryClient();
+    /**
+     * Creates a token association transaction where the destination account authorizes to receive the given token
+     */
+    const associateToken = reactQuery.useMutation({
+        mutationFn: async () => {
+            try {
+                if (!evmSigner) {
+                    throw new Error("EVM signer not found");
+                }
+                if (chain?.chainId !== CHAIN_IDS.HEDERA ||
+                    token?.chainId !== CHAIN_IDS.HEDERA) {
+                    throw new Error("Chain and token to associate must be on Hedera");
+                }
+                const tokenAddress = parseEvmAddress(token.address);
+                if (!tokenAddress) {
+                    throw new Error("Invalid token address");
+                }
+                const userAddress = parseEvmAddress(address);
+                if (!userAddress) {
+                    throw new Error("Invalid user address");
+                }
+                const encodedData = viem.encodeFunctionData({
+                    abi: hrc20,
+                    functionName: "associate",
+                    args: [],
+                });
+                const txRes = await evmSigner.sendTransaction({
+                    data: encodedData,
+                    to: tokenAddress,
+                    chainId: chain.chainId,
+                });
+                const receipt = await txRes.wait();
+                if (receipt?.status !== 1) {
+                    throw new Error(`Transaction failed with status: ${receipt?.status}`);
+                }
+                return true;
+            }
+            catch (error) {
+                console.error("Error associating Hedera token:", error);
+                return false;
+            }
+        },
+        async onSuccess() {
+            queryClient.refetchQueries({
+                queryKey: getPrefixKey(exports.QueryKeys.IsHederaTokenAssociated),
+            });
+        },
+    });
+    /**
+     * Checks if the destination account has associated the given token.
+     *
+     * Hedera requires accounts to associate a token before being able to receive it.
+     *
+     * Accounts which have max. associations set to -1 can receive any token without previous association
+     */
+    const isTokenAssociated = reactQuery.useQuery({
+        queryKey: keys().isHederaTokenAssociated(address, token?.chainId, token?.type, token?.address),
+        queryFn: async () => {
+            if (token?.chainId !== CHAIN_IDS.HEDERA) {
+                return true;
+            }
+            // The native HBAR token doesn't need an association
+            if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase()) {
+                return true;
+            }
+            if (!chain || !address || !publicClient) {
+                throw new Error("Missing required parameters");
+            }
+            // TODO: update types
+            const apiUrl = chain?.chainConfig?.hedera?.mirrorNodeUrl;
+            if (!apiUrl) {
+                throw new Error("Missing Hedera mirror node URL in chain config");
+            }
+            const hederaApiClient = new HederaApiClient(apiUrl);
+            return hederaApiClient.isTokenAssociated({
+                address,
+                token,
+            });
+        },
+        enabled: !!address && !!publicClient && token?.chainId === CHAIN_IDS.HEDERA,
     });
-    const isHederaAccountActivated = React.useMemo(() => {
-        if (token?.chainId !== CHAIN_IDS.HEDERA)
-            return true;
-        if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase())
-            return true;
-        return (!!destNativeEvmBalance?.value && destNativeEvmBalance.value > BigInt(0));
-    }, [token?.chainId, token?.address, destNativeEvmBalance?.value]);
     return {
-        isHederaAccountActivated,
+        isTokenAssociated,
+        associateToken,
+    };
+}
+
+const useKeyboardNavigation = ({ onEscape }) => {
+    const onKeyDown = React.useCallback((event) => {
+        if (event.key === "Escape") {
+            onEscape?.();
+            return;
+        }
+    }, [onEscape]);
+    React.useEffect(() => {
+        document.addEventListener("keydown", onKeyDown, false);
+        return () => {
+            document.removeEventListener("keydown", onKeyDown, false);
+        };
+    }, [onKeyDown]);
+};
+
+const useSquidQueryClient = () => {
+    const queryClient = reactQuery.useQueryClient();
+    const invalidateQueries = (key) => {
+        const prefixKey = getPrefixKey(key);
+        queryClient.invalidateQueries(prefixKey);
+    };
+    const refetchQueries = (key) => {
+        const prefixKey = getPrefixKey(key);
+        queryClient.refetchQueries(prefixKey);
+    };
+    const invalidateAndRefetchQueries = (key) => {
+        invalidateQueries(key);
+        refetchQueries(key);
+    };
+    return {
+        invalidateQueries,
+        refetchQueries,
+        invalidateAndRefetchQueries,
+    };
+};
+
+class StellarApiClient {
+    apiUrl;
+    constructor(apiUrl) {
+        this.apiUrl = apiUrl;
+    }
+    async getBaseReserve() {
+        const response = await fetch(`${this.apiUrl}/ledgers?order=desc&limit=1`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ledgers: ${response.status}`);
+        }
+        const ledgers = await response.json();
+        const latestLedger = ledgers?._embedded.records?.[0];
+        if (latestLedger?.base_reserve_in_stroops == null) {
+            throw new Error("Invalid ledger data");
+        }
+        const baseReserveBn = BigInt(latestLedger.base_reserve_in_stroops);
+        return baseReserveBn;
+    }
+    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 = reactQuery.useQuery({
+        queryKey: keys().stellarAccountActivatedInfo(address, chain?.chainId, chain?.chainType),
+        queryFn: async () => {
+            if (chain?.chainType !== squidTypes.ChainType.STELLAR ||
+                token?.type !== squidTypes.ChainType.STELLAR) {
+                return null;
+            }
+            if (!address) {
+                throw new Error("Destination address is required");
+            }
+            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 === squidTypes.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 = reactQuery.useQueryClient();
+    /**
+     * Retrieves the destination account's trust line data for the given token
+     */
+    const trustLineQuery = reactQuery.useQuery({
+        queryKey: keys().stellarTrustLine(token?.address, chain?.chainId, address),
+        queryFn: async () => {
+            if (chain?.chainType !== squidTypes.ChainType.STELLAR ||
+                token?.type !== squidTypes.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 === squidTypes.ChainType.STELLAR &&
+            token?.type === squidTypes.ChainType.STELLAR,
+        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
+    });
+    /**
+     * Creates a trust line where the destination account authorizes to receive the given token
+     */
+    const createTrustLine = reactQuery.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 !== squidTypes.ChainType.STELLAR ||
+                    token?.type !== squidTypes.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 stellarSdk.Asset(assetInfo.code, assetInfo.issuer);
+                const changeTrustOperation = stellarSdk.Operation.changeTrust({
+                    asset,
+                    limit: MAX_ASSET_AMOUNT,
+                });
+                const builtTransaction = new stellarSdk.TransactionBuilder(account, {
+                    fee: (BigInt(stellarSdk.BASE_FEE) * BigInt(2)).toString(),
+                    networkPassphrase: network,
+                })
+                    .addOperation(changeTrustOperation)
+                    .setTimeout(300)
+                    .build();
+                const { signedTxXdr } = await stellarSigner.signTransaction(builtTransaction.toXDR(), {
+                    networkPassphrase: network,
+                });
+                const signedTransaction = new stellarSdk.Transaction(signedTxXdr, network);
+                const sentTransaction = await client.sendTransaction(signedTransaction);
+                const txStatus = await client.waitForTransaction(sentTransaction.hash, {
+                    interval: 1_000,
+                });
+                if (txStatus !== stellarSdk.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(exports.QueryKeys.StellarTrustLine),
+            });
+        },
+    });
+    /**
+     * Checks if the destination account has created a trust line to receive the given token.
+     */
+    const isTrustLineApproved = reactQuery.useQuery({
+        queryKey: keys().isStellarTrustLineApproved(address, token?.chainId, token?.type, token?.address, trustLineQuery.data?.limit, amount),
+        queryFn: async () => {
+            if (token?.type !== squidTypes.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(trustLineQuery.data?.limit || "0");
+            const balanceBn = BigNumber(trustLineQuery.data?.balance || "0");
+            const availableAllowanceBn = limitBn.minus(balanceBn);
+            const amountBn = BigNumber(formatBNToReadable(amount, token.decimals));
+            return availableAllowanceBn.gte(amountBn);
+        },
+        enabled: !!address &&
+            !!amount &&
+            !trustLineQuery?.isLoading &&
+            trustLineQuery?.isFetched &&
+            token?.type === squidTypes.ChainType.STELLAR,
+    });
+    return {
+        createTrustLine,
+        trustLineQuery,
+        isTrustLineApproved,
     };
 }
 
@@ -30755,6 +31052,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[squidTypes.ChainType.EVM]);
+    const isTempo = isTempoChain(fromChain?.chainId);
+    const chainId = Number(fromChain?.chainId);
+    // Read account-level gas token preference from FeeManager precompile
+    // See docs: https://docs.tempo.xyz/protocol/fees/spec-fee#account-level
+    const { data: accountGasTokenAddress } = wagmi.useReadContract({
+        address: TEMPO_FEE_MANAGER_ADDRESS,
+        abi: feeManagerAbi,
+        functionName: "userTokens",
+        args: evmAddress ? [evmAddress] : undefined,
+        chainId,
+        query: {
+            enabled: isTempo && !!evmAddress,
+            staleTime: 30_000,
+        },
+    });
+    const hasAccountFeePreference = !!accountGasTokenAddress &&
+        // By default, the zero address is returned when the user has no preference set
+        viem.zeroAddress.toLowerCase() !== accountGasTokenAddress.toLowerCase();
+    // Fetch balance of the account-preferred gas token (if set)
+    const { data: accountGasTokenBalance } = wagmi.useBalance({
+        address: evmAddress,
+        token: hasAccountFeePreference ? accountGasTokenAddress : undefined,
+        chainId,
+        query: {
+            enabled: isTempo && hasAccountFeePreference && !!evmAddress,
+            staleTime: BALANCE_QUERY_STALE_TIME,
+        },
+    });
+    const fromTokenAddress = parseEvmAddress(fromToken?.address);
+    const { data: fromTokenBalance } = wagmi.useBalance({
+        address: evmAddress,
+        token: fromTokenAddress,
+        chainId,
+        query: {
+            enabled: isTempo && !!evmAddress,
+            staleTime: BALANCE_QUERY_STALE_TIME,
+        },
+    });
+    if (!isTempo)
+        return null;
+    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 = React.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 = React.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);
@@ -30905,24 +31339,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
  *
@@ -30961,12 +31394,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";
@@ -30985,10 +31416,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,
@@ -30996,30 +31423,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,
@@ -31034,12 +31463,12 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         expectedGasRefundCost,
         expectedGasRefundCostUSD,
         sameTokenBetweenFees,
-        isFromTokenNative,
+        fromTokenPaysNetworkFee: chainFeeParams?.fromTokenPaysNetworkFee ?? false,
         totalNativeFees,
-        totalFeesInNativeTokenPlusRatio,
-        fromBalanceEnoughToSwap,
+        gasBalanceEnough,
         minAmountValueWarnMsg,
         estimatedRouteDuration,
+        gasBalanceNeeded,
     };
 };
 /**
@@ -31073,28 +31502,6 @@ const calculateTotalWithRefundEstimate = (allFeeCosts, expectedGasRefundCost, ge
         feeToken: firstFeeCost?.token,
     };
 };
-/**
- * Calculates the proposed gas amount for the destination chain.
- *
- * @param destChainNativeToken - The symbol of the native token for the destination chain.
- * @returns An object containing the proposed gas amount value and the currency symbol.
- */
-const getProposedGasDestinationAmount = (destChainNativeToken) => {
-    const gasAmounts = {
-        GLMR: 5.289,
-        ETH: 0.0009,
-        AVAX: 0.115,
-        BNB: 0.00425,
-        FTM: 4.45,
-        CELO: 3.052,
-        KAVA: 2.339,
-        MATIC: 1.795,
-    };
-    return {
-        value: gasAmounts[destChainNativeToken ?? ""] ?? 0,
-        currency: destChainNativeToken,
-    };
-};
 
 function useSendTransactionGas({ chain, token, from, }) {
     return reactQuery.useQuery({
@@ -31116,7 +31523,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,
@@ -31136,7 +31547,14 @@ function useSendTransactionGas({ chain, token, from, }) {
                         data,
                         chainId: chain.chainId,
                     });
-                    return gas * maxFeePerGas;
+                    const feeWei = gas * maxFeePerGas;
+                    // Tempo fees are denominated in virtual USD (18 dec, 1e-18 USD units).
+                    // Convert to 6-dec stablecoin units so all callers receive a
+                    // consistent unit without needing to know about the chain.
+                    if (chain.chainId === CHAIN_IDS.TEMPO) {
+                        return convertTempoFeeToStablecoinUnits(feeWei);
+                    }
+                    return feeWei;
                 }
                 case squidTypes.ChainType.COSMOS: {
                     // TODO: get gas estimation from backend
@@ -31183,19 +31601,33 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
         token,
         from,
     });
-    const { nativeBalance } = useNativeBalance(chain);
-    const isNativeBalanceEnoughToPayGasFees = React.useMemo(() => {
-        if (!nativeBalance?.value || !amount || !token?.decimals) {
+    const { chainFeeParams, gasToken } = useSourceChainGasToken({
+        fromChain: chain,
+        fromToken: token,
+    });
+    const gasBalanceEnough = React.useMemo(() => {
+        if (!amount || !token?.decimals)
             return false;
-        }
-        const isTokenNative = token.address.toLowerCase() ===
-            chainTypeToNativeTokenAddressMap[token.type].toLowerCase();
-        if (isTokenNative) {
-            return (parseToBigInt(amount, token.decimals) + estimatedGas <=
-                nativeBalance.value);
-        }
-        return estimatedGas <= nativeBalance.value;
-    }, [amount, estimatedGas, nativeBalance?.value, token]);
+        return isGasBalanceEnough({
+            fromAmount: parseToBigInt(amount, token.decimals).toString(),
+            networkFeesWei: estimatedGas,
+            chainFeeParams,
+        });
+    }, [amount, estimatedGas, token, chainFeeParams]);
+    const gasBalanceNeeded = React.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 = React.useMemo(() => {
         if (token?.decimals == null || !balance || !amount)
             return false;
@@ -31203,28 +31635,21 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
             parseToBigInt(amount, token.decimals));
     }, [amount, balance, token?.decimals]);
     const minAmountValueWarnMsg = React.useMemo(() => {
-        if (!token?.address || !nativeBalance?.value || !estimatedGas)
+        if (!token?.address || !estimatedGas || !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,
     };
 }
@@ -31394,15 +31819,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,
             },
         },
@@ -32140,7 +32568,7 @@ const useApproval = ({ squidRoute, }) => {
      * On Error: Showing the error message if any
      * @returns {boolean} approved
      */
-    const routeApproved = reactQuery.useQuery(keys().routeApproved(squidRoute, allowanceInWei), async () => {
+    const routeApproved = reactQuery.useQuery(keys().routeApproved(squidRoute, allowanceInWei, erc20AllowanceQueryEnabled, hasAllowance), async () => {
         if (erc20AllowanceQueryEnabled) {
             return hasAllowance;
         }
@@ -32283,7 +32711,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),
                 });
@@ -32302,17 +32730,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 = React.useMemo(() => findToken(tokens, squidRoute?.params.fromChain, squidRoute?.params.fromToken), [tokens, squidRoute?.params.fromChain, squidRoute?.params.fromToken]);
+    const { chainFeeParams, gasToken } = useSourceChainGasToken({
+        fromChain,
+        fromToken,
+    });
     const estimateResults = React.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 ?? "",
@@ -32324,7 +32765,6 @@ const useEstimate = (squidRoute) => {
         estimateResults.expectedGasRefundCost,
         getUSDValue,
     ]);
-    const proposedGasDestinationAmount = React.useMemo(() => getProposedGasDestinationAmount(estimateResults.destChainNativeToken?.symbol), [estimateResults.destChainNativeToken]);
     const { feeCostsFormatted, totalFeeCostsUsd } = React.useMemo(() => {
         const feeCosts = squidRoute?.estimate.feeCosts ?? [];
         const feeCostsRenamed = [];
@@ -32383,21 +32823,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 = React.useMemo(() => {
+        const fromBalanceNum = Number(fromBalanceFormatted ?? 0);
+        const fromPriceNum = Number(fromPrice ?? 0);
+        return fromBalanceNum >= fromPriceNum;
+    }, [fromBalanceFormatted, fromPrice]);
     return {
         ...estimateResults,
-        balanceFormatted,
+        fromBalanceFormatted,
         slippageFormatted,
         totalWithRefundEstimate,
-        proposedGasDestinationAmount,
-        enoughBalanceToSwap,
+        fromBalanceEnoughToSwap,
         feeCostsFormatted,
         totalFeeCostsUsd,
+        gasToken,
     };
 };
 
@@ -35857,20 +36297,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 = stellarSdk.xdr.Operation.fromXDR(xdrHex, "hex");
-        const builtTransaction = new stellarSdk.TransactionBuilder(account, {
-            fee: gasPrice || (BigInt(stellarSdk.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 === squidTypes.SquidDataType.OnChainExecution) {
+            const { data: operationXdrHex, gasPrice } = route.transactionRequest;
+            const { address } = await stellarSigner.getAddress();
+            const account = await client.getAccount(address);
+            const operation = stellarSdk.xdr.Operation.fromXDR(operationXdrHex, "hex");
+            const builtTransaction = new stellarSdk.TransactionBuilder(account, {
+                fee: gasPrice || (BigInt(stellarSdk.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 === squidTypes.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 stellarSdk.Transaction(signedTxXdr, stellarNetwork);
@@ -36143,7 +36605,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;
     });
 };
@@ -36166,14 +36628,13 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     const sourceUserAddress = isDepositAddressEnabled && isAvailableAsPaymentMethod
         ? depositRefundAddress ?? sourceConnectedAddress
         : sourceConnectedAddress;
-    const squidRouteQueryKeys = React.useMemo(() => keys().transaction(fromChain?.chainId, toChain?.chainId, toToken?.address, fromToken?.address, fromPrice, config.slippage, config.enableGetGasOnDestination, sourceUserAddress, config.degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChain?.chainType, config.preHook, config.postHook, config.overrideGasRefundAddress), [
+    const squidRouteQueryKeys = React.useMemo(() => keys().transaction(fromChain?.chainId, toChain?.chainId, toToken?.address, fromToken?.address, fromPrice, config.slippage, sourceUserAddress, config.degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChain?.chainType, config.preHook, config.postHook, config.overrideGasRefundAddress), [
         fromChain?.chainId,
         toChain?.chainId,
         toToken?.address,
         fromToken?.address,
         fromPrice,
         config.slippage,
-        config.enableGetGasOnDestination,
         sourceUserAddress,
         config.degenMode,
         destinationAddress,
@@ -36445,35 +36906,6 @@ const useAvatar = (seed = zeroAddress) => {
     return avatar || "";
 };
 
-const useUserParams = () => {
-    const enableGetGasOnDestination = useConfigStore((state) => state.config.enableGetGasOnDestination);
-    const { fromToken, toToken, toChain, fromChain } = useSwap();
-    //   =============
-    //       GAS
-    //   =============
-    const getGasOnDestSupportedForThisRoute = React.useMemo(() => 
-    // Not supporting get gas on dest for same chains
-    fromChain?.chainId !== toChain?.chainId &&
-        // If the destination chain is cosmos, we don't support getting gas there
-        toChain?.chainType !== squidTypes.ChainType.COSMOS &&
-        // Not supporting get gas on dest for same tokens (bridge)
-        ((fromToken?.subGraphIds?.some((sgi) => !!toToken?.subGraphIds?.includes(sgi)) &&
-            toToken?.subGraphIds?.some((sgi) => !!fromToken?.subGraphIds?.includes(sgi))) ||
-            // Except for uusdc -> uusdc
-            (fromToken?.subGraphIds?.includes("uusdc") &&
-                toToken?.subGraphIds?.includes("uusdc"))), [
-        fromChain?.chainId,
-        fromToken?.subGraphIds,
-        toChain?.chainId,
-        toToken?.subGraphIds,
-        toChain?.chainType,
-    ]);
-    return {
-        gasEnabled: enableGetGasOnDestination && getGasOnDestSupportedForThisRoute,
-        getGasOnDestSupportedForThisRoute,
-    };
-};
-
 const useAddToken = (chainToCompare, tokenToCompare) => {
     const { chain: currentEvmChain } = wagmi.useAccount();
     const { connector } = wagmi.useAccount();
@@ -36658,12 +37090,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 &&
@@ -36991,6 +37423,9 @@ exports.getSecretNetworkBalances = getSecretNetworkBalances;
 exports.getSendTxStatusRefetchInterval = getSendTxStatusRefetchInterval;
 exports.getSourceExplorerTxUrl = getSourceExplorerTxUrl;
 exports.getStatusCode = getStatusCode;
+exports.getStellarHorizonApiUrl = getStellarHorizonApiUrl;
+exports.getStellarNetwork = getStellarNetwork;
+exports.getStellarTrustLineAsset = getStellarTrustLineAsset;
 exports.getStepStatuses = getStepStatuses;
 exports.getStepsInfos = getStepsInfos;
 exports.getSuggestedAmountsForCurrency = getSuggestedAmountsForCurrency;
@@ -37027,8 +37462,13 @@ exports.isOnChainTxData = isOnChainTxData;
 exports.isProblematicConnector = isProblematicConnector;
 exports.isSolanaAddressValid = isSolanaAddressValid;
 exports.isStatusError = isStatusError;
+exports.isStellarAddressValid = isStellarAddressValid;
+exports.isStellarIssuedToken = isStellarIssuedToken;
+exports.isStellarToken = isStellarToken;
 exports.isSwapRouteError = isSwapRouteError;
 exports.isUserRejectionError = isUserRejectionError;
+exports.isValidHorizonAsset = isValidHorizonAsset;
+exports.isValidIssuedAsset = isValidIssuedAsset;
 exports.isWalletAddressValid = isWalletAddressValid;
 exports.isXamanXAppContext = isXamanXAppContext;
 exports.isXionSmartContractAddress = isXionSmartContractAddress;
@@ -37047,6 +37487,7 @@ exports.normalizeTokenSymbol = normalizeTokenSymbol;
 exports.parseEvmAddress = parseEvmAddress;
 exports.parseToBigInt = parseToBigInt;
 exports.parseXrplPaymentTx = parseXrplPaymentTx;
+exports.parseXrplTokenAddress = parseXrplTokenAddress;
 exports.populateWallets = populateWallets;
 exports.randomIntFromInterval = randomIntFromInterval;
 exports.redirectToExtensionsStore = redirectToExtensionsStore;
@@ -37061,6 +37502,7 @@ exports.sortAddressBook = sortAddressBook;
 exports.sortAllTokens = sortAllTokens;
 exports.sortTokensBySharedSubgraphIds = sortTokensBySharedSubgraphIds;
 exports.sortWallets = sortWallets;
+exports.stellarAddressToScVal = stellarAddressToScVal;
 exports.suggestChainOrThrow = suggestChainOrThrow;
 exports.transactionErrorCode = transactionErrorCode;
 exports.trimExtraDecimals = trimExtraDecimals;
@@ -37125,6 +37567,7 @@ exports.useSendTransactionStore = useSendTransactionStore;
 exports.useSigner = useSigner;
 exports.useSingleTokenPrice = useSingleTokenPrice;
 exports.useSolanaNativeBalance = useSolanaNativeBalance;
+exports.useSourceChainGasToken = useSourceChainGasToken;
 exports.useSquid = useSquid;
 exports.useSquidChains = useSquidChains;
 exports.useSquidQueryClient = useSquidQueryClient;
@@ -37132,6 +37575,7 @@ exports.useSquidStore = useSquidStore;
 exports.useSquidTokens = useSquidTokens;
 exports.useStellarAccountActivation = useStellarAccountActivation;
 exports.useStellarNativeBalance = useStellarNativeBalance;
+exports.useStellarTrustLine = useStellarTrustLine;
 exports.useSuggestedFiatAmounts = useSuggestedFiatAmounts;
 exports.useSuiNativeBalance = useSuiNativeBalance;
 exports.useSwap = useSwap;
@@ -37140,7 +37584,6 @@ exports.useSwapTransactionStatus = useSwapTransactionStatus;
 exports.useTokensData = useTokensData;
 exports.useTrackSearchEmpty = useTrackSearchEmpty;
 exports.useTransactionStore = useTransactionStore;
-exports.useUserParams = useUserParams;
 exports.useWallet = useWallet;
 exports.useWalletStore = useWalletStore;
 exports.useWallets = useWallets;
@@ -37149,4 +37592,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-5cyMUZhY.js.map
+//# sourceMappingURL=index-BSX11dad.js.map