@0xsquid/react-hooks 8.13.1-beta.0 → 8.14.0

package/dist/core/types/solana.d.ts

@@ -1,2 +1,10 @@
 import type { StandardWalletAdapter } from "@solana/wallet-standard-wallet-adapter-base";
 export type SolanaConnector = StandardWalletAdapter;
+export declare const SOLANA_ON_CHAIN_ERROR_CODE = "SOLANA_ON_CHAIN_ERROR";
+export declare const SOLANA_BLOCKHASH_EXPIRED_CODE = "SOLANA_BLOCKHASH_EXPIRED";
+export type SolanaTransactionErrorCode = typeof SOLANA_ON_CHAIN_ERROR_CODE | typeof SOLANA_BLOCKHASH_EXPIRED_CODE;
+export declare class SolanaTransactionError extends Error {
+    readonly code: SolanaTransactionErrorCode;
+    readonly signature?: string;
+    constructor(code: SolanaTransactionErrorCode, message: string, signature?: string);
+}

package/dist/{index-OUfYMn5i.js → index-BjIX7utV.js}

@@ -252,6 +252,19 @@ class QrCodeGenerationError extends Error {
     }
 }
 
+const SOLANA_ON_CHAIN_ERROR_CODE = "SOLANA_ON_CHAIN_ERROR";
+const SOLANA_BLOCKHASH_EXPIRED_CODE = "SOLANA_BLOCKHASH_EXPIRED";
+class SolanaTransactionError extends Error {
+    code;
+    signature;
+    constructor(code, message, signature) {
+        super(message);
+        this.name = "SolanaTransactionError";
+        this.code = code;
+        this.signature = signature;
+    }
+}
+
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 function getDefaultExportFromCjs (x) {
@@ -4224,24 +4237,38 @@ class WidgetEvents extends EventTarget {
     }
 }
 
+const isRecord$1 = (value) => typeof value === "object" && value !== null;
+const isErrorCode = (value) => typeof value === "string" || typeof value === "number";
+const toErrorLike = (value) => {
+    if (!isRecord$1(value))
+        return undefined;
+    const { code, message, reason, error, data, cause } = value;
+    return {
+        code: isErrorCode(code) ? code : undefined,
+        message: typeof message === "string" ? message : undefined,
+        reason: typeof reason === "string" ? reason : undefined,
+        error: toErrorLike(error),
+        data: toErrorLike(data),
+        cause: toErrorLike(cause),
+    };
+};
 /**
  * Normalizes different error structures into a consistent format
  * This helps handle different wallet error formats uniformly
  */
 const normalizeError = (error) => {
+    const errorLike = toErrorLike(error);
+    if (!errorLike)
+        return {};
     // Handle nested error objects (like Rainbow's error.error structure)
-    if (error?.error && typeof error.error === "object") {
-        return {
-            code: error.error.code,
-            message: error.error.message,
-            reason: error.error.reason,
-        };
-    }
-    // Handle direct error properties
+    const source = errorLike.error ?? errorLike;
     return {
-        code: error?.code,
-        message: error?.message,
-        reason: error?.reason,
+        code: source.code,
+        message: source.message,
+        reason: source.reason,
+        dataCode: source.data?.code,
+        dataMessage: source.data?.message,
+        causeMessage: source.cause?.message,
     };
 };
 const transactionErrorCode = {
@@ -4275,11 +4302,6 @@ const transactionErrorCode = {
         type: exports.TransactionErrorType.REJECTED_BY_USER,
         internalLabel: "EVM: REJECTED: CODE 4001",
     },
-    // Rainbow
-    "-32603": {
-        type: exports.TransactionErrorType.REJECTED_BY_USER,
-        internalLabel: "EVM: REJECTED: CODE -32603",
-    },
     // Joey (XRPL)
     "User rejected.": {
         type: exports.TransactionErrorType.REJECTED_BY_USER,
@@ -4339,16 +4361,60 @@ const transactionErrorCode = {
         type: exports.TransactionErrorType.CALL_EXCEPTION,
         internalLabel: "EVM: CALL_EXCEPTION",
     },
+    [SOLANA_ON_CHAIN_ERROR_CODE]: {
+        type: exports.TransactionErrorType.CALL_EXCEPTION,
+        internalLabel: "SOL: Transaction failed on chain",
+    },
+    [SOLANA_BLOCKHASH_EXPIRED_CODE]: {
+        type: exports.TransactionErrorType.UNKNOWN,
+        internalLabel: "SOL: Transaction blockhash expired",
+    },
     UNKNOWN: {
         type: exports.TransactionErrorType.UNKNOWN,
         internalLabel: "UNKNOWN ERROR: Transaction failed",
     },
 };
+// Rainbow reports a user rejection with the generic JSON-RPC internal error
+// code, while Phantom uses the same code for real failures.
+const INTERNAL_RPC_ERROR_CODE = "-32603";
+const userRejectionMessagePatterns = [
+    /user rejected/i,
+    /rejected the request/i,
+    /rejected by the user/i,
+    /user denied/i,
+];
+const internalRpcRejectionError = {
+    type: exports.TransactionErrorType.REJECTED_BY_USER,
+    internalLabel: "EVM: REJECTED: CODE -32603",
+};
+const USER_REJECTED_CODE = "4001";
+const isUserRejectionMessage = (message) => message !== undefined &&
+    userRejectionMessagePatterns.some((pattern) => pattern.test(message));
+const isInternalRpcRejection = ({ code, message, dataCode, dataMessage, causeMessage, }) => code != undefined &&
+    code.toString() === INTERNAL_RPC_ERROR_CODE &&
+    (dataCode?.toString() === USER_REJECTED_CODE ||
+        [message, dataMessage, causeMessage].some(isUserRejectionMessage));
+// @solana/web3.js SendTransactionError carries no code; its message starts
+// with the preflight failure text.
+const messagePatternErrors = [
+    {
+        pattern: /^(Simulation failed|Transaction simulation failed)/i,
+        error: {
+            type: exports.TransactionErrorType.CALL_EXCEPTION,
+            internalLabel: "SOL: Transaction simulation failed",
+        },
+    },
+];
+const matchMessagePattern = (message) => message === undefined
+    ? undefined
+    : messagePatternErrors.find(({ pattern }) => pattern.test(message))?.error;
 /**
  * Detects if an error is a user rejection based on normalized error structure
  */
 const isUserRejectionError = (normalizedError) => {
     const { code, message } = normalizedError;
+    if (isInternalRpcRejection(normalizedError))
+        return true;
     // Check if the error matches any known rejection patterns from transactionErrorCode
     return Object.entries(transactionErrorCode).some(([key, value]) => {
         if (value.type !== exports.TransactionErrorType.REJECTED_BY_USER)
@@ -4369,6 +4435,8 @@ const isUserRejectionError = (normalizedError) => {
  */
 const getTransactionError = (error) => {
     const normalizedError = normalizeError(error);
+    if (isInternalRpcRejection(normalizedError))
+        return internalRpcRejectionError;
     if (isUserRejectionError(normalizedError)) {
         // Return the specific rejection error if we can find it
         if (normalizedError.code) {
@@ -4385,10 +4453,12 @@ const getTransactionError = (error) => {
     }
     if (normalizedError.code) {
         return (transactionErrorCode[normalizedError.code.toString()] ||
+            matchMessagePattern(normalizedError.message) ||
             transactionErrorCode.UNKNOWN);
     }
     if (normalizedError.message) {
         return (transactionErrorCode[normalizedError.message] ||
+            matchMessagePattern(normalizedError.message) ||
             transactionErrorCode.UNKNOWN);
     }
     return transactionErrorCode.UNKNOWN;
@@ -21667,14 +21737,71 @@ const isSolanaAddressValid = (address) => {
 };
 const deserializeSolanaTransaction = (transactionBuffer) => {
     // Squid can return legacy Solana transactions (ITS) or versioned transactions
-    // (Jupiter/Chainflip). Deserialize once to detect the payload type. Legacy
-    // transactions need to be converted to Transaction because their blockhash is
-    // mutable and must be refreshed before signing.
+    // (Jupiter/Chainflip). Deserialize once to detect the payload type.
     const versionedTransaction = web3_js.VersionedTransaction.deserialize(transactionBuffer);
     return versionedTransaction.version === "legacy"
         ? web3_js.Transaction.from(transactionBuffer)
         : versionedTransaction;
 };
+const isSignedTransaction = (transaction) => transaction instanceof web3_js.Transaction
+    ? transaction.signatures.some(({ signature }) => signature !== null)
+    : transaction.signatures.some((signature) => signature.some((byte) => byte !== 0));
+const getTransactionBlockhash = (transaction) => transaction instanceof web3_js.Transaction
+    ? transaction.recentBlockhash
+    : transaction.message.recentBlockhash;
+const setTransactionBlockhash = (transaction, blockhash) => {
+    if (transaction instanceof web3_js.Transaction) {
+        transaction.recentBlockhash = blockhash;
+    }
+    else {
+        transaction.message.recentBlockhash = blockhash;
+    }
+};
+// Squid builds the transaction server-side, so its blockhash can expire before
+// the wallet approves it. Pre-signed transactions keep their blockhash: a new
+// one would invalidate their signatures.
+const resolveBlockhash = async (transaction, connection) => {
+    const latestBlockhash = await connection.getLatestBlockhash();
+    if (!isSignedTransaction(transaction)) {
+        setTransactionBlockhash(transaction, latestBlockhash.blockhash);
+        return latestBlockhash;
+    }
+    const blockhash = getTransactionBlockhash(transaction);
+    if (!blockhash) {
+        throw new Error("Signed transaction has no blockhash");
+    }
+    const { value: isValid } = await connection.isBlockhashValid(blockhash);
+    if (!isValid) {
+        throw new SolanaTransactionError(SOLANA_BLOCKHASH_EXPIRED_CODE, "Transaction blockhash expired; request a new route");
+    }
+    // The kept blockhash is older than the latest one, so the latest expiry
+    // height is an upper bound: confirmation never gives up too early.
+    return {
+        blockhash,
+        lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+    };
+};
+const assertConfirmed = (signature, { err }) => {
+    if (err) {
+        throw new SolanaTransactionError(SOLANA_ON_CHAIN_ERROR_CODE, `Solana transaction failed on chain: ${JSON.stringify(err)}`, signature);
+    }
+};
+const SWAP_SEND_OPTIONS = {
+    skipPreflight: false,
+    maxRetries: 2,
+    preflightCommitment: "confirmed",
+};
+// Wallets that submit the transaction themselves (Phantom) run their own
+// preflight and hide its failure behind a generic error. Sign only and submit
+// through our connection so RPC errors stay visible.
+const sendSolanaTransaction = async (signer, connection, transaction) => {
+    if (!signer.signTransaction) {
+        return signer.sendTransaction(transaction, connection, SWAP_SEND_OPTIONS);
+    }
+    const signed = await signer.signTransaction(transaction);
+    const raw = signed.serialize();
+    return connection.sendRawTransaction(raw, SWAP_SEND_OPTIONS);
+};
 /**
  * Execute a Solana swap transaction
  * This will be used for the swap flow - Using Jupiter Dex under the hood
@@ -21687,21 +21814,15 @@ const executeSolanaSwap = async ({ route, signer, connection, onSigned, }) => {
     const swapTransactionBuf = Buffer.from(swapRequest, "base64");
     const transaction = deserializeSolanaTransaction(swapTransactionBuf);
     try {
-        const latestBlockhash = await connection.getLatestBlockhash();
-        if (transaction instanceof web3_js.Transaction) {
-            // ITS legacy transactions arrive with the placeholder blockhash
-            // 11111111111111111111111111111111.
-            // Refresh it right before signing so the submitted transaction
-            // uses a valid blockhash. Versioned transactions are not mutable here.
-            transaction.recentBlockhash = latestBlockhash.blockhash;
-        }
-        const signature = await signer.sendTransaction(transaction, connection);
+        const { blockhash, lastValidBlockHeight } = await resolveBlockhash(transaction, connection);
+        const signature = await sendSolanaTransaction(signer, connection, transaction);
         onSigned?.(signature);
-        await connection.confirmTransaction({
+        const { value } = await connection.confirmTransaction({
             signature,
-            blockhash: latestBlockhash.blockhash,
-            lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+            blockhash,
+            lastValidBlockHeight,
         });
+        assertConfirmed(signature, value);
         return signature;
     }
     catch (error) {
@@ -21766,11 +21887,12 @@ const executeSolanaTransfer = async ({ amount, target, signer, connection, sourc
     // Trigger callback for UI purposes (show loading state)
     onSigned?.(signature);
     // Wait for transaction confirmation
-    await connection.confirmTransaction({
+    const { value } = await connection.confirmTransaction({
         signature,
         blockhash,
         lastValidBlockHeight,
     });
+    assertConfirmed(signature, value);
     return signature;
 };
 
@@ -23699,7 +23821,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-C8zVh8hn.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-BebOsCud.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -23850,8 +23972,9 @@ async function addEthereumChain({ chain, provider, }) {
         console.debug("Error adding chain:", error);
     }
 }
+const isEvmAddressValid = (address) => !!address && viem.isAddress(address);
 const parseEvmAddress = (address) => {
-    if (address && viem.isAddress(address)) {
+    if (isEvmAddressValid(address)) {
         return address;
     }
 };
@@ -28100,7 +28223,7 @@ function useSolana() {
     };
 }
 const useSolanaConnection = () => {
-    const connectionRef = React.useRef(new web3_js.Connection(SOLANA_RPC_URL));
+    const connectionRef = React.useRef(new web3_js.Connection(SOLANA_RPC_URL, "confirmed"));
     return connectionRef.current;
 };
 
@@ -28126,7 +28249,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.mjs');
-                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-DE2oaaTW.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-B6_2UV4u.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -30840,18 +30963,24 @@ const DEFAULT_REFRESH_INTERVAL_MS$1 = 15000;
 const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS$1, }) => {
     const { isChainTypeConnected } = useWallet();
     const isNativeToken = token?.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase();
-    const userAddressParsed = userAddress;
+    const evmAddress = parseEvmAddress(userAddress);
+    const tokenAddress = parseEvmAddress(token?.address);
+    const isEvmChain = chain?.chainType === squidTypes.ChainType.EVM;
+    const chainId = isEvmChain ? Number(chain.chainId) : undefined;
+    const isEvmConnected = isChainTypeConnected(squidTypes.ChainType.EVM);
+    const isNativeQueryEnabled = enabled && isEvmChain && isEvmConnected && !!evmAddress && isNativeToken;
+    const isErc20QueryEnabled = enabled &&
+        isEvmChain &&
+        isEvmConnected &&
+        !!evmAddress &&
+        !!tokenAddress &&
+        !isNativeToken;
     // Only fetch using useBalance if it's a native token
     const { data: nativeBalance, isLoading: isNativeTokenLoading } = wagmi.useBalance({
-        address: userAddressParsed,
-        chainId: Number(chain?.chainId),
+        address: evmAddress,
+        chainId,
         query: {
-            enabled: enabled &&
-                !!userAddress &&
-                isNativeToken &&
-                !!chain &&
-                chain.chainType === squidTypes.ChainType.EVM &&
-                isChainTypeConnected(chain.chainType),
+            enabled: isNativeQueryEnabled,
             refetchInterval: refreshIntervalMs,
             retry: 2,
         },
@@ -30859,23 +30988,20 @@ const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshInter
     // Only fetch using useReadContract if it's not a native token
     // This is temporary, because of wagmi error: https://github.com/wevm/wagmi/issues/4353
     const { data: erc20Balance, isLoading: isErc20Loading } = wagmi.useReadContract({
-        address: token?.address,
+        address: tokenAddress,
         abi: viem.erc20Abi,
         functionName: "balanceOf",
-        args: [userAddressParsed],
-        chainId: Number(chain?.chainId),
+        args: evmAddress ? [evmAddress] : undefined,
+        chainId,
         query: {
-            enabled: isChainTypeConnected(squidTypes.ChainType.EVM) &&
-                enabled &&
-                !!userAddress &&
-                !isNativeToken,
+            enabled: isErc20QueryEnabled,
             refetchInterval: refreshIntervalMs,
             retry: 2,
         },
     });
     if (isNativeToken) {
         return {
-            isLoading: isNativeTokenLoading,
+            isLoading: isNativeQueryEnabled && isNativeTokenLoading,
             balance: nativeBalance
                 ? formatBNToReadable(nativeBalance.value, nativeBalance.decimals)
                 : "0",
@@ -30885,11 +31011,16 @@ const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshInter
         balance: erc20Balance && token
             ? formatBNToReadable(erc20Balance, token.decimals)
             : "0",
-        isLoading: isErc20Loading,
+        isLoading: isErc20QueryEnabled && isErc20Loading,
     };
 };
 const useCosmosBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS$1, }) => {
     const { isConnected } = useCosmosContext();
+    const isQueryEnabled = !!isConnected &&
+        enabled &&
+        !!token &&
+        chain?.chainType === squidTypes.ChainType.COSMOS &&
+        isWalletAddressValid(chain, userAddress);
     const { data: balance = "0", isLoading } = reactQuery.useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
@@ -30902,17 +31033,17 @@ const useCosmosBalance = ({ chain, token, userAddress, enabled = true, refreshIn
             const balanceBn = await getCosmosTokenBalance(chain, userAddress, token.address);
             return formatBNToReadable(balanceBn, token.decimals);
         },
-        enabled: isConnected &&
-            enabled &&
-            !!userAddress &&
-            !!token &&
-            chain?.chainType === squidTypes.ChainType.COSMOS,
+        enabled: isQueryEnabled,
         refetchInterval: refreshIntervalMs,
         retry: 2,
     });
-    return { balance, isLoading };
+    return { balance, isLoading: isQueryEnabled && isLoading };
 };
 const useSolanaBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS$1, }) => {
+    const isQueryEnabled = enabled &&
+        !!token &&
+        chain?.chainType === squidTypes.ChainType.SOLANA &&
+        isWalletAddressValid(chain, userAddress);
     const { data: balance = "0", isLoading } = reactQuery.useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
@@ -30921,14 +31052,11 @@ const useSolanaBalance = ({ chain, token, userAddress, enabled = true, refreshIn
             const balanceBn = await getSolanaTokenBalance(userAddress, token.address);
             return formatBNToReadable(balanceBn, token.decimals);
         },
-        enabled: enabled &&
-            !!userAddress &&
-            !!token &&
-            chain?.chainType === squidTypes.ChainType.SOLANA,
+        enabled: isQueryEnabled,
         refetchInterval: refreshIntervalMs,
         retry: 2,
     });
-    return { balance, isLoading };
+    return { balance, isLoading: isQueryEnabled && isLoading };
 };
 // TODO: implement fetching balances for all bitcoin tokens
 const useBitcoinBalance = ({ userAddress, chain, }) => {
@@ -31061,11 +31189,14 @@ function useNativeTokenForChain(chain) {
 
 const useEvmNativeBalance = ({ address, chain, }) => {
     const { isChainTypeConnected } = useWallet();
+    const isEvmChain = chain?.chainType === squidTypes.ChainType.EVM;
+    const evmAddress = parseEvmAddress(address);
+    const isQueryEnabled = isEvmChain && !!evmAddress && isChainTypeConnected(squidTypes.ChainType.EVM);
     const { data: nativeEvmBalance, isLoading } = wagmi.useBalance({
-        address: address,
-        chainId: Number(chain?.chainId),
+        address: evmAddress,
+        chainId: isEvmChain ? Number(chain.chainId) : undefined,
         query: {
-            enabled: isChainTypeConnected(squidTypes.ChainType.EVM) && !!address,
+            enabled: isQueryEnabled,
             refetchInterval: 10000,
             staleTime: 5000,
             refetchOnWindowFocus: true,
@@ -31089,7 +31220,7 @@ const useEvmNativeBalance = ({ address, chain, }) => {
     }, [nativeEvmBalance?.decimals, nativeEvmBalance?.value, chain?.chainId]);
     return {
         balance,
-        isLoading,
+        isLoading: isQueryEnabled && isLoading,
     };
 };
 const useCosmosNativeBalance = ({ address, chain, }) => {
@@ -31143,13 +31274,14 @@ const useBitcoinNativeBalance = ({ chain, address, }) => {
 };
 const useSolanaNativeBalance = ({ chain, address, }) => {
     const { nativeToken } = useNativeTokenForChain(chain);
+    const isQueryEnabled = nativeToken?.decimals != null &&
+        chain?.chainType === squidTypes.ChainType.SOLANA &&
+        isWalletAddressValid(chain, address);
     const { data: rawBalance, isLoading } = reactQuery.useQuery(keys().balance(chain?.chainId, nativeToken?.address, address), async () => {
         const balance = await getSolanaNativeBalance(address);
         return formatBNToReadable(balance, nativeToken.decimals);
     }, {
-        enabled: !!address &&
-            nativeToken?.decimals != null &&
-            chain?.chainType === squidTypes.ChainType.SOLANA,
+        enabled: isQueryEnabled,
         refetchInterval: 40000,
         staleTime: 20000,
         refetchOnWindowFocus: true,
@@ -31165,7 +31297,7 @@ const useSolanaNativeBalance = ({ chain, address, }) => {
     }, [nativeToken?.decimals, rawBalance]);
     return {
         balance,
-        isLoading,
+        isLoading: isQueryEnabled && isLoading,
     };
 };
 const useSuiNativeBalance = ({ address, chain, }) => {
@@ -31573,7 +31705,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-CoocBNVs.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-BQULJYpe.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -31917,7 +32049,10 @@ function useHederaTokenAssociations({ address, chain, token }) {
                 token,
             });
         },
-        enabled: !!address && !!publicClient && token?.chainId === CHAIN_IDS.HEDERA,
+        enabled: isEvmAddressValid(address) &&
+            !!publicClient &&
+            chain?.chainId === CHAIN_IDS.HEDERA &&
+            token?.chainId === CHAIN_IDS.HEDERA,
     });
     return {
         isTokenAssociated,
@@ -32030,7 +32165,9 @@ function useStellarAccountActivation({ address, chain, token, }) {
                 reserveBaseBn: accountReserveBase,
             };
         },
-        enabled: !!address && chain?.chainType === squidTypes.ChainType.STELLAR,
+        enabled: !!address &&
+            chain?.chainType === squidTypes.ChainType.STELLAR &&
+            isStellarAddressValid(address),
         refetchInterval: DEFAULT_REFETCH_INTERVAL$2,
         refetchOnWindowFocus: true,
     });
@@ -39124,7 +39261,9 @@ function useXrplTrustLine({ address, chain, token, amount }) {
             const xrplClient = await getClient(chain);
             return xrplClient.accountActivatedInfo(address);
         },
-        enabled: !!address && chain?.chainType === squidTypes.ChainType.XRPL,
+        enabled: !!address &&
+            chain?.chainType === squidTypes.ChainType.XRPL &&
+            isXrplAddressValid(address),
         refetchInterval: DEFAULT_REFETCH_INTERVAL,
         refetchOnWindowFocus: true,
     });
@@ -39386,6 +39525,7 @@ exports.isCoralBridgeAction = isCoralBridgeAction;
 exports.isCosmosAddressValid = isCosmosAddressValid;
 exports.isDepositAddressDirectTransferRoute = isDepositAddressDirectTransferRoute;
 exports.isEmptyObject = isEmptyObject;
+exports.isEvmAddressValid = isEvmAddressValid;
 exports.isEvmChainNotSupportedError = isEvmChainNotSupportedError;
 exports.isEvmosChain = isEvmosChain;
 exports.isFallbackAddressNeeded = isFallbackAddressNeeded;
@@ -39533,4 +39673,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-OUfYMn5i.js.map
+//# sourceMappingURL=index-BjIX7utV.js.map