@abstraxn/signer-react 3.3.9 → 4.0.0

package/dist/src/hooks.js

@@ -4,6 +4,8 @@
 import { useState, useCallback, useEffect, useMemo } from 'react';
 import { useAbstraxnWallet } from './AbstraxnProvider';
 import { InvalidDeviceIdError, SignMfaRequiredError } from '@abstraxn/signer-core';
+import { requestSignMfaCode } from './signMfaBridge';
+import { TURNKEY_SUPPORTED_CAIP2, NATIVE_ASSET_SENTINEL, chainIdToCaip2, isNativeAssetEntry, extractAssetAddress, } from '@abstraxn/signer-core';
 import { createPublicClient, createWalletClient, http, getContract, serializeTransaction, encodeFunctionData, hashTypedData, hashMessage, parseSignature } from 'viem';
 import { toAccount } from 'viem/accounts';
 import { Connection as SolanaConnection, Transaction as SolanaTransaction, SystemProgram, PublicKey, LAMPORTS_PER_SOL, TransactionInstruction, } from '@solana/web3.js';
@@ -12,7 +14,7 @@ import { useWalletClient as useWagmiWalletClient, useAccount, useConfig, useChai
 import { getWalletClient, switchChain, getPublicClient } from '@wagmi/core';
 import { getConnectorMeta } from './connectors';
 import { getChainById } from './chains';
-import { waitUntilDocumentVisible, pollForOutgoingTx, clearWalletConnectPendingState, isWalletConnectConnector, isMobileDevice, } from './walletConnectMobile';
+import { waitUntilDocumentVisible, pollForOutgoingTx, clearWalletConnectPendingState, isWalletConnectConnector, isMobileDevice, isUserRejectionError, toUserRejectionError, } from './walletConnectMobile';
 /**
  * Hook to check if wallet is connected
  */
@@ -233,15 +235,8 @@ function isInvalidDeviceIdError(error) {
         candidate?.name === 'InvalidDeviceIdError' ||
         (typeof candidate?.message === 'string' && candidate.message.includes('INVALID_DEVICE_ID')));
 }
-function promptForSignMfaCode() {
-    if (typeof window === 'undefined' || typeof window.prompt !== 'function') {
-        throw new Error('MFA step-up is required to sign, but no prompt UI is available in this environment.');
-    }
-    const code = window.prompt('Enter your MFA code to approve this signing request');
-    if (!code || code.trim() === '') {
-        throw new Error('MFA code is required to continue signing.');
-    }
-    return code.trim().toUpperCase();
+async function requestSignMfaCodeFromUi() {
+    return requestSignMfaCode();
 }
 async function runWithSignStepUpRetry(performSign, verifySignMfa) {
     try {
@@ -257,7 +252,7 @@ async function runWithSignStepUpRetry(performSign, verifySignMfa) {
         if (!verifySignMfa) {
             throw new Error('MFA step-up is required, but sign verification is not available.');
         }
-        const code = promptForSignMfaCode();
+        const code = await requestSignMfaCodeFromUi();
         let verifyResponse;
         try {
             verifyResponse = await verifySignMfa(code);
@@ -399,11 +394,11 @@ export function useEnableMfa() {
  * auth (otp/recovery) -> confirm disable.
  */
 export function useDisableMfa() {
-    const { verifyMfa, disableMfaWithSignedPayload } = useAbstraxnWallet();
+    const { verifySignMfa, disableMfaWithSignedPayload } = useAbstraxnWallet();
     const [disableState, setDisableState] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState(null);
-    const canDisableMfaFlow = !!verifyMfa && !!disableMfaWithSignedPayload;
+    const canDisableMfaFlow = !!verifySignMfa && !!disableMfaWithSignedPayload;
     const reset = useCallback(() => {
         setDisableState(null);
         setIsLoading(false);
@@ -420,7 +415,8 @@ export function useDisableMfa() {
         setDisableState({ step: 'auth', method });
     }, []);
     const verifyCode = useCallback(async (code) => {
-        if (!verifyMfa || disableState?.step !== 'auth')
+        // Sign step-up is required: disable MFA signs a payload via /sign/transaction.
+        if (!verifySignMfa || disableState?.step !== 'auth')
             return false;
         const { method } = disableState;
         const trimmed = method === 'recovery' ? code.trim().toUpperCase() : code.trim();
@@ -434,7 +430,7 @@ export function useDisableMfa() {
         setIsLoading(true);
         setError(null);
         try {
-            await verifyMfa(trimmed);
+            await verifySignMfa(trimmed);
             setDisableState({ step: 'confirm' });
             return true;
         }
@@ -446,7 +442,7 @@ export function useDisableMfa() {
         finally {
             setIsLoading(false);
         }
-    }, [verifyMfa, disableState]);
+    }, [verifySignMfa, disableState]);
     const confirmDisable = useCallback(async () => {
         if (!disableMfaWithSignedPayload)
             return null;
@@ -1049,7 +1045,7 @@ export function useSolanaPublicKey() {
  * RPC endpoint is taken from the current Solana ChainData (configured in AbstraxnProvider).
  */
 export function useSolanaBalance() {
-    const { currentChain, whoami, solanaWallet, solanaConnection } = useAbstraxnWallet();
+    const { currentChain, whoami, solanaWallet, solanaConnection, wallet } = useAbstraxnWallet();
     const [lamports, setLamports] = useState(null);
     const [formattedBalance, setFormattedBalance] = useState('0');
     const [loading, setLoading] = useState(false);
@@ -1062,6 +1058,9 @@ export function useSolanaBalance() {
         : null) ||
         // Fallback to provider connection endpoint
         (providerConnection && providerConnection.rpcEndpoint) || null;
+    // An external wallet (Phantom) address isn't a Turnkey wallet-account - only try
+    // Turnkey when using the embedded wallet's own address.
+    const isExternalSolanaWallet = !!solanaWallet?.publicKey;
     const address = (solanaWallet?.publicKey && solanaWallet.publicKey.toBase58()) ||
         whoami?.solanaAddress ||
         null;
@@ -1074,14 +1073,35 @@ export function useSolanaBalance() {
             return;
         }
         let cancelled = false;
+        const fetchViaRpc = async () => {
+            const connection = new SolanaConnection(rpcUrl, 'confirmed');
+            const balance = await connection.getBalance(new PublicKey(address), 'confirmed');
+            return BigInt(balance);
+        };
         const fetchBalance = async () => {
             setLoading(true);
             try {
-                const connection = new SolanaConnection(rpcUrl, 'confirmed');
-                const balance = await connection.getBalance(new PublicKey(address), 'confirmed');
+                let asBigInt = null;
+                if (!isExternalSolanaWallet && wallet && currentChain) {
+                    const caip2 = chainIdToCaip2(currentChain.id, TURNKEY_SUPPORTED_CAIP2);
+                    if (caip2) {
+                        try {
+                            const entries = await wallet.getTurnkeyBalances(caip2, address);
+                            const nativeEntry = entries.find((entry) => isNativeAssetEntry({ caip19: entry.caip19, symbol: entry.symbol, decimals: entry.decimals }, currentChain.nativeCurrency));
+                            if (nativeEntry?.balance !== undefined) {
+                                asBigInt = BigInt(nativeEntry.balance);
+                            }
+                        }
+                        catch (turnkeyError) {
+                            console.warn('Turnkey Solana balance fetch failed, falling back to RPC:', turnkeyError);
+                        }
+                    }
+                }
+                if (asBigInt === null) {
+                    asBigInt = await fetchViaRpc();
+                }
                 if (cancelled)
                     return;
-                const asBigInt = BigInt(balance);
                 setLamports(asBigInt);
                 const sol = Number(asBigInt) / LAMPORTS_PER_SOL;
                 setFormattedBalance(sol.toFixed(6));
@@ -1101,7 +1121,7 @@ export function useSolanaBalance() {
         return () => {
             cancelled = true;
         };
-    }, [providerConnection, rpcUrl, address]);
+    }, [providerConnection, rpcUrl, address, isExternalSolanaWallet, wallet, currentChain]);
     return {
         address,
         lamports,
@@ -1110,6 +1130,124 @@ export function useSolanaBalance() {
         error,
     };
 }
+/**
+ * Hook to get the full non-zero token list (native + SPL) for the active embedded
+ * Solana address, sourced from Turnkey with an RPC-derived native-only fallback.
+ * Mirrors useSolanaBalance()'s shape. Safe to call unconditionally regardless of the
+ * current chain type - no-ops (returns an empty, non-loading result) when the current
+ * chain isn't Solana or there's no embedded Solana address.
+ */
+export function useSolanaTokenBalances() {
+    const { currentChain, whoami, solanaWallet, wallet } = useAbstraxnWallet();
+    const [tokens, setTokens] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const isSolanaChain = currentChain && currentChain.type === 'solana';
+    const isExternalSolanaWallet = !!solanaWallet?.publicKey;
+    const address = !isExternalSolanaWallet ? whoami?.solanaAddress ?? null : null;
+    useEffect(() => {
+        setTokens([]);
+        setError(null);
+        if (!isSolanaChain || !address || !wallet || !currentChain) {
+            return;
+        }
+        const caip2 = chainIdToCaip2(currentChain.id, TURNKEY_SUPPORTED_CAIP2);
+        if (!caip2) {
+            return;
+        }
+        let cancelled = false;
+        const fetchTokens = async () => {
+            setLoading(true);
+            try {
+                const entries = await wallet.getTurnkeyBalances(caip2, address);
+                if (cancelled)
+                    return;
+                const nextTokens = [];
+                for (const entry of entries) {
+                    try {
+                        const isNative = isNativeAssetEntry({ caip19: entry.caip19, symbol: entry.symbol, decimals: entry.decimals }, currentChain.nativeCurrency);
+                        const tokenAddress = isNative
+                            ? NATIVE_ASSET_SENTINEL
+                            : extractAssetAddress({ caip19: entry.caip19 });
+                        if (!isNative && tokenAddress === undefined) {
+                            console.warn('Skipping unrecognized Solana asset in balance list:', entry.caip19);
+                            continue;
+                        }
+                        nextTokens.push({
+                            address: tokenAddress,
+                            symbol: entry.symbol ?? '',
+                            name: entry.name ?? entry.symbol ?? '',
+                            decimals: entry.decimals ?? 9,
+                            balance: entry.balance !== undefined ? BigInt(entry.balance) : 0n,
+                            isNative,
+                        });
+                    }
+                    catch (entryError) {
+                        console.warn('Skipping malformed Solana balance entry:', entryError);
+                    }
+                }
+                setTokens(nextTokens);
+                setError(null);
+            }
+            catch (turnkeyError) {
+                console.warn('Turnkey Solana token list fetch failed, falling back to RPC native-only:', turnkeyError);
+                // Fall back to a single native-only entry via RPC, so the list stays
+                // consistent with useSolanaBalance()'s own RPC fallback rather than going
+                // empty on a Turnkey outage.
+                try {
+                    const connection = new SolanaConnection(currentChain.rpcUrl, 'confirmed');
+                    const lamports = await connection.getBalance(new PublicKey(address), 'confirmed');
+                    if (cancelled)
+                        return;
+                    setTokens([
+                        {
+                            address: NATIVE_ASSET_SENTINEL,
+                            symbol: currentChain.nativeCurrency.symbol,
+                            name: currentChain.nativeCurrency.name,
+                            decimals: currentChain.nativeCurrency.decimals,
+                            balance: BigInt(lamports),
+                            isNative: true,
+                        },
+                    ]);
+                    setError(null);
+                }
+                catch (rpcError) {
+                    if (cancelled)
+                        return;
+                    setTokens([]);
+                    setError(rpcError instanceof Error ? rpcError : new Error('Failed to load Solana token balances'));
+                }
+            }
+            finally {
+                if (!cancelled) {
+                    setLoading(false);
+                }
+            }
+        };
+        fetchTokens();
+        return () => {
+            cancelled = true;
+        };
+    }, [isSolanaChain, address, wallet, currentChain]);
+    return { tokens, loading, error };
+}
+/**
+ * Hook to get the full non-zero token list (native + ERC-20) for the current EVM
+ * chain, sourced from AbstraxnProvider's centralized state (Turnkey-first with an
+ * RPC-derived native-only fallback - see AbstraxnProviderInner's refetchWalletBalance).
+ * Safe to call unconditionally regardless of the current chain type - no-ops (returns
+ * an empty, non-loading result) when the current chain isn't EVM.
+ */
+export function useTokenBalances() {
+    const { currentChain, tokenBalances, tokenBalancesLoading, tokenBalancesError, refetchTokenBalances } = useAbstraxnWallet();
+    const isEvmChain = currentChain && currentChain.type === 'evm';
+    return {
+        tokens: isEvmChain ? tokenBalances : [],
+        loading: isEvmChain ? tokenBalancesLoading : false,
+        error: isEvmChain ? tokenBalancesError : null,
+        refetch: refetchTokenBalances,
+    };
+}
 function base64ToUint8Array(base64) {
     if (typeof atob !== 'function') {
         throw new Error('Base64 decoding is not available in this environment');
@@ -1794,18 +1932,20 @@ export function useSignTxn(provider) {
             value: valueInWei,
             nonce,
         };
-        // Add gas properties if they exist
+        // Add gas properties if they exist. Never set both legacy and EIP-1559 —
+        // viem serializes as type-2 whenever maxFeePerGas is present, which can
+        // underpay Ethermint minimum-global-fee when gasPrice was the real floor.
         const unsignedTx = { ...baseTx };
         if (gas?.gasLimit !== undefined) {
             unsignedTx.gas = gas.gasLimit;
         }
-        if (gas?.gasPrice !== undefined) {
+        const hasEip1559 = gas?.maxFeePerGas !== undefined && gas?.maxPriorityFeePerGas !== undefined;
+        const hasLegacy = gas?.gasPrice !== undefined;
+        if (hasLegacy && (!hasEip1559 || gas.gasPrice >= gas.maxFeePerGas)) {
             unsignedTx.gasPrice = gas.gasPrice;
         }
-        if (gas?.maxFeePerGas !== undefined) {
+        else if (hasEip1559) {
             unsignedTx.maxFeePerGas = gas.maxFeePerGas;
-        }
-        if (gas?.maxPriorityFeePerGas !== undefined) {
             unsignedTx.maxPriorityFeePerGas = gas.maxPriorityFeePerGas;
         }
         // Serialize transaction
@@ -1999,18 +2139,20 @@ export function useSignAndSendTxn(provider) {
             value: valueInWei,
             nonce,
         };
-        // Add gas properties if they exist
+        // Add gas properties if they exist. Never set both legacy and EIP-1559 —
+        // viem serializes as type-2 whenever maxFeePerGas is present, which can
+        // underpay Ethermint minimum-global-fee when gasPrice was the real floor.
         const unsignedTx = { ...baseTx };
         if (gas?.gasLimit !== undefined) {
             unsignedTx.gas = gas.gasLimit;
         }
-        if (gas?.gasPrice !== undefined) {
+        const hasEip1559 = gas?.maxFeePerGas !== undefined && gas?.maxPriorityFeePerGas !== undefined;
+        const hasLegacy = gas?.gasPrice !== undefined;
+        if (hasLegacy && (!hasEip1559 || gas.gasPrice >= gas.maxFeePerGas)) {
             unsignedTx.gasPrice = gas.gasPrice;
         }
-        if (gas?.maxFeePerGas !== undefined) {
+        else if (hasEip1559) {
             unsignedTx.maxFeePerGas = gas.maxFeePerGas;
-        }
-        if (gas?.maxPriorityFeePerGas !== undefined) {
             unsignedTx.maxPriorityFeePerGas = gas.maxPriorityFeePerGas;
         }
         // Serialize transaction
@@ -2057,7 +2199,7 @@ export function useSignAndSendTxn(provider) {
  * ```
  */
 export function useWaitForTxnReceipt(provider) {
-    const waitForTxnReceipt = useCallback(async ({ hash, confirmations, timeout, }) => {
+    const waitForTxnReceipt = useCallback(async ({ hash, confirmations, timeout, throwOnRevert = true, }) => {
         if (!provider) {
             throw new Error('Provider (publicClient) is required');
         }
@@ -2080,9 +2222,18 @@ export function useWaitForTxnReceipt(provider) {
                         timeout: Math.min(20_000, remaining),
                         pollingInterval: 1_500,
                     });
+                    if (throwOnRevert &&
+                        (receipt.status === 'reverted' ||
+                            receipt.status === 0 ||
+                            receipt.status === '0x0')) {
+                        throw new Error('Transaction reverted');
+                    }
                     return receipt;
                 }
                 catch (error) {
+                    if (error instanceof Error && error.message === 'Transaction reverted') {
+                        throw error;
+                    }
                     lastError = error;
                     await waitUntilDocumentVisible();
                     await new Promise((resolve) => setTimeout(resolve, 1_000));
@@ -2096,6 +2247,9 @@ export function useWaitForTxnReceipt(provider) {
                 : new Error('Failed to wait for transaction receipt');
         }
         catch (error) {
+            if (error instanceof Error && error.message === 'Transaction reverted') {
+                throw error;
+            }
             if (error instanceof Error && error.message.startsWith('Failed to wait for transaction receipt')) {
                 throw error;
             }
@@ -2523,7 +2677,12 @@ export function useWriteContract() {
                 // Matching without selector is still useful (from + to).
             }
             const cancelPoll = { cancelled: false };
-            const sendPromise = sendWrite();
+            const sendPromise = sendWrite().then((hash) => hash, (err) => {
+                if (isUserRejectionError(err))
+                    throw toUserRejectionError(err);
+                throw err;
+            });
+            // Success-only chain recovery when WC hash never arrives.
             const pollPromise = pollForOutgoingTx({
                 publicClient,
                 from: fromAddress,
@@ -2532,12 +2691,11 @@ export function useWriteContract() {
                 value,
                 startBlock,
                 signal: cancelPoll,
-                initialDelayMs: 10_000,
-                timeoutMs: 90_000,
+                initialDelayMs: 1_000,
+                timeoutMs: 60_000,
             });
             try {
                 const hash = await Promise.race([sendPromise, pollPromise]);
-                // Poll may win while WC is still hanging — ignore a late reject.
                 void sendPromise.then(() => undefined, () => undefined);
                 return hash;
             }

package/dist/src/index.d.ts

@@ -4,7 +4,7 @@
  * when used in a React project
  */
 export { AbstraxnProvider, useAbstraxnWallet } from './AbstraxnProvider';
-export { useIsConnected, useAddress, useAuthContext, useChainId, useError, useEnableMfa, useDisableMfa, useAuthMethodLinking, useEmailForOtp, useWallet, useSmartAccountOwner, useExportWallet, useWhoami, useExternalWallet, useExternalWalletBalance, useExternalWalletChain, useExternalWalletInfo, usePublicClient, useWalletClient, useContract, usePrepareRawTxn, useSignTxn, useSignTypedTx, useSignAndSendTxn, useWaitForTxnReceipt, useReadContract, useExternalWalletClient, useWriteContract, useConnectionType, useSwitchChain, useSignMessage, useEstimateGas, useGetGasPrice, useSolanaConnection, useSolanaPublicKey, useSolanaBalance, usePrepareSolanaTxn, useSolanaExternalWallet, usePrepareSolanaProgramTxn, useSolanaProgramTransaction, useSignSolanaTxn, useSignAndSendSolanaTxn, useSolanaGasless, useSignAndSendSolanaGaslessTxn, useWaitForSolanaConfirmation, usePolicies, usePolicy, useCreatePolicy, useUpdatePolicy, useDeletePolicy, usePublishPolicy, useUnpublishPolicy, usePolicyTemplates, } from './hooks';
+export { useIsConnected, useAddress, useAuthContext, useChainId, useError, useEnableMfa, useDisableMfa, useAuthMethodLinking, useEmailForOtp, useWallet, useSmartAccountOwner, useExportWallet, useWhoami, useExternalWallet, useExternalWalletBalance, useExternalWalletChain, useExternalWalletInfo, usePublicClient, useWalletClient, useContract, usePrepareRawTxn, useSignTxn, useSignTypedTx, useSignAndSendTxn, useWaitForTxnReceipt, useReadContract, useExternalWalletClient, useWriteContract, useConnectionType, useSwitchChain, useSignMessage, useEstimateGas, useGetGasPrice, useSolanaConnection, useSolanaPublicKey, useSolanaBalance, useSolanaTokenBalances, useTokenBalances, usePrepareSolanaTxn, useSolanaExternalWallet, usePrepareSolanaProgramTxn, useSolanaProgramTransaction, useSignSolanaTxn, useSignAndSendSolanaTxn, useSolanaGasless, useSignAndSendSolanaGaslessTxn, useWaitForSolanaConfirmation, usePolicies, usePolicy, useCreatePolicy, useUpdatePolicy, useDeletePolicy, usePublishPolicy, useUnpublishPolicy, usePolicyTemplates, } from './hooks';
 export { ConnectButton } from './ConnectButton';
 export type { ConnectButtonProps, ConnectButtonVariant, ConnectButtonSize } from './ConnectButton';
 export { WalletModal } from './WalletModal';
@@ -16,4 +16,4 @@ export type { OnboardingUIComponentProps, OnboardingUIComponentRef } from './Onb
 export { ALL_CHAINS, EVM_CHAINS, SOLANA_CHAINS, getChainById, getChainsByType, getDefaultChains, toCoreChain, type ChainData, } from './chains';
 export { CONNECTORS, getConnectorMeta, isOAuthConnector, isWalletConnector, isAuthConnector, type ConnectorType, type ConnectorMeta, } from './connectors';
 export { createWagmiConfig } from './wagmiConfig';
-export { pollForOutgoingTx, clearWalletConnectPendingState, waitUntilDocumentVisible, isWalletConnectConnector, isMobileDevice, } from './walletConnectMobile';
+export { pollForOutgoingTx, clearWalletConnectPendingState, waitUntilDocumentVisible, isWalletConnectConnector, isMobileDevice, forceResumeWalletConnectOnReturn, isUserRejectionError, toUserRejectionError, } from './walletConnectMobile';

package/dist/src/index.js

@@ -4,12 +4,12 @@
  * when used in a React project
  */
 export { AbstraxnProvider, useAbstraxnWallet } from './AbstraxnProvider';
-export { useIsConnected, useAddress, useAuthContext, useChainId, useError, useEnableMfa, useDisableMfa, useAuthMethodLinking, useEmailForOtp, useWallet, useSmartAccountOwner, useExportWallet, useWhoami, useExternalWallet, useExternalWalletBalance, useExternalWalletChain, useExternalWalletInfo, usePublicClient, useWalletClient, useContract, usePrepareRawTxn, useSignTxn, useSignTypedTx, useSignAndSendTxn, useWaitForTxnReceipt, useReadContract, useExternalWalletClient, useWriteContract, useConnectionType, useSwitchChain, useSignMessage, useEstimateGas, useGetGasPrice, useSolanaConnection, useSolanaPublicKey, useSolanaBalance, usePrepareSolanaTxn, useSolanaExternalWallet, usePrepareSolanaProgramTxn, useSolanaProgramTransaction, useSignSolanaTxn, useSignAndSendSolanaTxn, useSolanaGasless, useSignAndSendSolanaGaslessTxn, useWaitForSolanaConfirmation, usePolicies, usePolicy, useCreatePolicy, useUpdatePolicy, useDeletePolicy, usePublishPolicy, useUnpublishPolicy, usePolicyTemplates, } from './hooks';
+export { useIsConnected, useAddress, useAuthContext, useChainId, useError, useEnableMfa, useDisableMfa, useAuthMethodLinking, useEmailForOtp, useWallet, useSmartAccountOwner, useExportWallet, useWhoami, useExternalWallet, useExternalWalletBalance, useExternalWalletChain, useExternalWalletInfo, usePublicClient, useWalletClient, useContract, usePrepareRawTxn, useSignTxn, useSignTypedTx, useSignAndSendTxn, useWaitForTxnReceipt, useReadContract, useExternalWalletClient, useWriteContract, useConnectionType, useSwitchChain, useSignMessage, useEstimateGas, useGetGasPrice, useSolanaConnection, useSolanaPublicKey, useSolanaBalance, useSolanaTokenBalances, useTokenBalances, usePrepareSolanaTxn, useSolanaExternalWallet, usePrepareSolanaProgramTxn, useSolanaProgramTransaction, useSignSolanaTxn, useSignAndSendSolanaTxn, useSolanaGasless, useSignAndSendSolanaGaslessTxn, useWaitForSolanaConfirmation, usePolicies, usePolicy, useCreatePolicy, useUpdatePolicy, useDeletePolicy, usePublishPolicy, useUnpublishPolicy, usePolicyTemplates, } from './hooks';
 export { ConnectButton } from './ConnectButton';
 export { WalletModal } from './WalletModal';
 export { OnboardingUIComponent as OnboardingUI } from './OnboardingUI';
 export { ALL_CHAINS, EVM_CHAINS, SOLANA_CHAINS, getChainById, getChainsByType, getDefaultChains, toCoreChain, } from './chains';
 export { CONNECTORS, getConnectorMeta, isOAuthConnector, isWalletConnector, isAuthConnector, } from './connectors';
 export { createWagmiConfig } from './wagmiConfig';
-export { pollForOutgoingTx, clearWalletConnectPendingState, waitUntilDocumentVisible, isWalletConnectConnector, isMobileDevice, } from './walletConnectMobile';
+export { pollForOutgoingTx, clearWalletConnectPendingState, waitUntilDocumentVisible, isWalletConnectConnector, isMobileDevice, forceResumeWalletConnectOnReturn, isUserRejectionError, toUserRejectionError, } from './walletConnectMobile';
 //# sourceMappingURL=index.js.map

package/dist/src/signMfaBridge.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Bridge so non-React signing helpers can request an MFA code via the
+ * provider-mounted MfaVerifyModal (replaces window.prompt).
+ */
+export type SignMfaCodeRequester = () => Promise<string>;
+export declare function registerSignMfaCodeRequester(requester: SignMfaCodeRequester | null): () => void;
+export declare function requestSignMfaCode(): Promise<string>;

package/dist/src/signMfaBridge.js

@@ -0,0 +1,20 @@
+let signMfaCodeRequester = null;
+export function registerSignMfaCodeRequester(requester) {
+    signMfaCodeRequester = requester;
+    return () => {
+        if (signMfaCodeRequester === requester) {
+            signMfaCodeRequester = null;
+        }
+    };
+}
+export async function requestSignMfaCode() {
+    if (!signMfaCodeRequester) {
+        throw new Error("MFA step-up is required to sign, but no MFA UI is available. Ensure AbstraxnProvider is mounted.");
+    }
+    const code = await signMfaCodeRequester();
+    if (!code || code.trim() === "") {
+        throw new Error("MFA code is required to continue signing.");
+    }
+    return code.trim().toUpperCase();
+}
+//# sourceMappingURL=signMfaBridge.js.map

package/dist/src/types.d.ts

@@ -313,6 +313,10 @@ export interface AbstraxnContextValue {
     walletBalance?: bigint | null;
     /** Refetch wallet balance from RPC (Abstraxn or external). Call when UI screen changes (e.g. back button, modal open/close). */
     refetchBalance?: () => Promise<void>;
+    tokenBalances: import("./components/WalletModal/components/TokenSelectorModal").TokenData[];
+    tokenBalancesLoading: boolean;
+    tokenBalancesError: Error | null;
+    refetchTokenBalances: () => Promise<void>;
     connectionType?: string | null;
     emailForOtp?: string;
     setEmailForOtp?: (email: string) => void;

package/dist/src/utils/shadowFocus.d.ts

@@ -0,0 +1,8 @@
+/**
+ * document.activeElement returns the shadow HOST element when focus is
+ * actually on a descendant inside its shadow tree, not the focused element
+ * itself. Tab-trap logic comparing `document.activeElement === someElement`
+ * silently breaks once that element lives inside a shadow root — this walks
+ * down through nested shadow roots to find the real focused element.
+ */
+export declare function getDeepActiveElement(): Element | null;

package/dist/src/utils/shadowFocus.js

@@ -0,0 +1,15 @@
+/**
+ * document.activeElement returns the shadow HOST element when focus is
+ * actually on a descendant inside its shadow tree, not the focused element
+ * itself. Tab-trap logic comparing `document.activeElement === someElement`
+ * silently breaks once that element lives inside a shadow root — this walks
+ * down through nested shadow roots to find the real focused element.
+ */
+export function getDeepActiveElement() {
+    let active = document.activeElement;
+    while (active && active.shadowRoot && active.shadowRoot.activeElement) {
+        active = active.shadowRoot.activeElement;
+    }
+    return active;
+}
+//# sourceMappingURL=shadowFocus.js.map

package/dist/src/utils/shadowRegistry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared registry of every currently-mounted shadow root (both React
+ * ShadowHost instances and the vanilla OnboardingUIWeb instances). Plain TS,
+ * no framework dependency, so both sides can use it.
+ *
+ * Invariant: every registerShadowRoot() call must be paired with exactly one
+ * call to its returned unregister function when — and only when — that
+ * specific shadow root is torn down. Violating this either leaks a reference
+ * to a detached shadow root (memory leak) or silently drops an active
+ * boundary from cross-boundary queries (correctness bug).
+ */
+export declare function registerShadowRoot(root: ShadowRoot): () => void;
+/**
+ * Unions document.querySelectorAll(selector) with the same query run against
+ * every currently-registered shadow root. Restores the pre-shadow-DOM
+ * cross-boundary "hide the other open modal overlay" behavior without
+ * requiring the separate shadow roots to nest inside one another.
+ *
+ * One-directional in practice today: only OnboardingUIWeb.showLoadingModal()
+ * calls this (to hide an open WalletModal). No symmetric call exists on the
+ * WalletModal/React side, matching pre-migration behavior exactly.
+ */
+export declare function queryAllAcrossShadowRoots(selector: string): Element[];

package/dist/src/utils/shadowRegistry.js

@@ -0,0 +1,36 @@
+/**
+ * Shared registry of every currently-mounted shadow root (both React
+ * ShadowHost instances and the vanilla OnboardingUIWeb instances). Plain TS,
+ * no framework dependency, so both sides can use it.
+ *
+ * Invariant: every registerShadowRoot() call must be paired with exactly one
+ * call to its returned unregister function when — and only when — that
+ * specific shadow root is torn down. Violating this either leaks a reference
+ * to a detached shadow root (memory leak) or silently drops an active
+ * boundary from cross-boundary queries (correctness bug).
+ */
+const shadowRoots = new Set();
+export function registerShadowRoot(root) {
+    shadowRoots.add(root);
+    return () => {
+        shadowRoots.delete(root);
+    };
+}
+/**
+ * Unions document.querySelectorAll(selector) with the same query run against
+ * every currently-registered shadow root. Restores the pre-shadow-DOM
+ * cross-boundary "hide the other open modal overlay" behavior without
+ * requiring the separate shadow roots to nest inside one another.
+ *
+ * One-directional in practice today: only OnboardingUIWeb.showLoadingModal()
+ * calls this (to hide an open WalletModal). No symmetric call exists on the
+ * WalletModal/React side, matching pre-migration behavior exactly.
+ */
+export function queryAllAcrossShadowRoots(selector) {
+    const results = Array.from(document.querySelectorAll(selector));
+    for (const root of shadowRoots) {
+        results.push(...Array.from(root.querySelectorAll(selector)));
+    }
+    return results;
+}
+//# sourceMappingURL=shadowRegistry.js.map

package/dist/src/walletConnectMobile.d.ts

@@ -107,9 +107,12 @@ export declare function waitUntilDocumentVisible(): Promise<void>;
  * (poll won while eth_sendTransaction is still hanging).
  */
 export declare function clearWalletConnectPendingState(provider: any): void;
+/** EIP-1193 4001 / WC 5000 (and common message shapes). */
+export declare function isUserRejectionError(error: unknown): boolean;
+export declare function toUserRejectionError(error?: unknown): Error;
 /**
- * When WalletConnect never returns eth_sendTransaction after MetaMask approve,
- * scan recent blocks for a matching outgoing tx (from/to + optional calldata prefix).
+ * Success-only recovery: find an on-chain hash when WC never returns one.
+ * Does not infer reject (that is handled by relay resume + reject fallback).
  */
 export declare function pollForOutgoingTx(params: {
     publicClient: {
@@ -123,7 +126,6 @@ export declare function pollForOutgoingTx(params: {
     };
     from: string;
     to: string;
-    /** Match tx.input prefix (e.g. 0x + 4-byte selector). */
     dataPrefix?: string;
     value?: bigint;
     startBlock: bigint;
@@ -133,13 +135,15 @@ export declare function pollForOutgoingTx(params: {
     timeoutMs?: number;
     initialDelayMs?: number;
 }): Promise<`0x${string}`>;
+/** Time-bounded force-resume (must not hang on transportOpen). */
+export declare function forceResumeWalletConnectOnReturn(provider: any, timeoutMs?: number): Promise<void>;
 /**
  * Patch the EIP-1193 provider so signing/tx requests resume the relay first.
  * Covers wagmi hooks, viem walletClient, and direct provider.request calls.
  */
 export declare function patchWalletConnectProviderForMobile(provider: any): void;
 /**
- * When the dapp tab is shown again (user left MetaMask), restart the relay so
- * the pending WalletConnect response can be received.
+ * When the dapp tab is shown again, restart the relay so pending
+ * approve/reject responses can be delivered (WalletConnect mobile linking).
  */
 export declare function subscribeWalletConnectForegroundResume(provider: any): () => void;