@abstraxn/signer-react 1.0.0

package/dist/src/hooks.js

@@ -0,0 +1,1358 @@
+/**
+ * React Hooks for Abstraxn Wallet SDK
+ */
+import { useState, useCallback, useEffect, useMemo } from 'react';
+import { useAbstraxnWallet } from './AbstraxnProvider';
+import { createPublicClient, createWalletClient, http, getContract, serializeTransaction, parseEther, encodeFunctionData } from 'viem';
+import { useWalletClient as useWagmiWalletClient, useAccount, useConfig, useChainId as useWagmiChainId, useSwitchChain as useWagmiSwitchChain, useSignMessage as useWagmiSignMessage } from 'wagmi';
+import { getWalletClient, switchChain } from '@wagmi/core';
+import { getConnectorMeta } from './connectors';
+import { getChainById } from './chains';
+/**
+ * Hook to check if wallet is connected
+ */
+export function useIsConnected() {
+    const { isConnected } = useAbstraxnWallet();
+    return isConnected;
+}
+/**
+ * Hook to get wallet address
+ */
+export function useAddress() {
+    const { address } = useAbstraxnWallet();
+    return address;
+}
+/**
+ * Hook to get current user and whoami information
+ * Returns an object with both user and whoami data
+ */
+export function useAuthContext() {
+    const { user, whoami } = useAbstraxnWallet();
+    return { user, whoami };
+}
+/**
+ * Hook to get current chain ID
+ */
+export function useChainId() {
+    const { chainId } = useAbstraxnWallet();
+    return chainId;
+}
+/**
+ * Hook to get error state
+ */
+export function useError() {
+    const { error } = useAbstraxnWallet();
+    return error;
+}
+// Re-export core hook for modules that import from './hooks'
+export { useAbstraxnWallet } from './AbstraxnProvider';
+/**
+ * Hook to get wallet instance (for advanced usage)
+ */
+export function useWallet() {
+    const { wallet } = useAbstraxnWallet();
+    return wallet;
+}
+/**
+ * Hook to export wallet private key
+ * Returns the export bundle containing the private key
+ * Automatically picks the connected wallet address (EVM or Solana) from whoami
+ */
+export function useExportWallet() {
+    const { wallet, isConnected, address } = useAbstraxnWallet();
+    const exportWallet = async (targetPublicKey, privateKey, blockchain) => {
+        if (!isConnected || !wallet) {
+            throw new Error('Wallet is not connected');
+        }
+        // Pass blockchain type to wallet.exportWallet, which will load address from whoami
+        return await wallet.exportWallet(targetPublicKey, privateKey, blockchain);
+    };
+    return { exportWallet, isConnected, address };
+}
+/**
+ * Hook to call whoami API
+ * Returns whoami data, loading state, error, and a refresh function
+ *
+ * @example
+ * ```tsx
+ * const { whoami, loading, error, refreshWhoami } = useWhoami();
+ *
+ * useEffect(() => {
+ *   refreshWhoami();
+ * }, []);
+ * ```
+ */
+export function useWhoami() {
+    const { isConnected, whoami: cachedWhoami, refreshWhoami: refreshWhoamiFromContext, loading: contextLoading, error: contextError } = useAbstraxnWallet();
+    const [whoami, setWhoami] = useState(cachedWhoami);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const refreshWhoami = useCallback(async () => {
+        if (!isConnected) {
+            setError(new Error('Wallet is not connected'));
+            return null;
+        }
+        setLoading(true);
+        setError(null);
+        try {
+            // Use refreshWhoami from context which updates both API and context state
+            // This will handle the check for external wallets and connection status internally
+            const whoamiData = await refreshWhoamiFromContext();
+            setWhoami(whoamiData);
+            return whoamiData;
+        }
+        catch (err) {
+            // Don't throw error if wallet is not connected (might be during disconnect)
+            const error = err instanceof Error ? err : new Error('Failed to refresh whoami information');
+            // Only set error if it's not a connection error
+            if (!error.message.includes('not connected') && !error.message.includes('Wallet is not connected')) {
+                setError(error);
+            }
+            return null;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [isConnected, refreshWhoamiFromContext]);
+    // Update whoami when cached value changes
+    useEffect(() => {
+        if (cachedWhoami) {
+            setWhoami(cachedWhoami);
+        }
+    }, [cachedWhoami]);
+    // Use context loading/error if hook is not in loading state
+    const displayLoading = loading || contextLoading;
+    const displayError = error || contextError;
+    return {
+        whoami,
+        loading: displayLoading,
+        error: displayError,
+        refreshWhoami,
+        isConnected,
+    };
+}
+/**
+ * Hook to access external wallet functionality
+ * Returns external wallet connection state and methods
+ */
+export function useExternalWallet() {
+    const { connectExternalWallet, disconnectExternalWallet, isExternalWalletConnected, externalWalletAddress, externalWalletChainId, externalWalletBalance, externalWalletNetwork, availableConnectors, switchExternalWalletChain, } = useAbstraxnWallet();
+    return {
+        connectExternalWallet: connectExternalWallet || (async () => {
+            throw new Error('External wallets are not enabled');
+        }),
+        disconnectExternalWallet: disconnectExternalWallet || (async () => {
+            throw new Error('External wallets are not enabled');
+        }),
+        isExternalWalletConnected: isExternalWalletConnected ?? false,
+        externalWalletAddress: externalWalletAddress ?? null,
+        externalWalletChainId: externalWalletChainId ?? null,
+        externalWalletBalance: externalWalletBalance ?? null,
+        externalWalletNetwork: externalWalletNetwork ?? null,
+        availableConnectors: availableConnectors ?? [],
+        switchExternalWalletChain: switchExternalWalletChain || (async () => {
+            throw new Error('External wallets are not enabled');
+        }),
+    };
+}
+/**
+ * Hook to get external wallet balance
+ * Returns balance in wei (BigInt) and formatted balance
+ */
+export function useExternalWalletBalance() {
+    const { externalWalletBalance, externalWalletAddress, isExternalWalletConnected } = useExternalWallet();
+    const [formattedBalance, setFormattedBalance] = useState('0');
+    useEffect(() => {
+        if (externalWalletBalance && externalWalletBalance > 0n) {
+            // Convert from wei to ETH (18 decimals)
+            const balanceInEth = Number(externalWalletBalance) / 1e18;
+            setFormattedBalance(balanceInEth.toFixed(6));
+        }
+        else {
+            setFormattedBalance('0');
+        }
+    }, [externalWalletBalance]);
+    return {
+        balance: externalWalletBalance,
+        formattedBalance,
+        address: externalWalletAddress,
+        isConnected: isExternalWalletConnected,
+    };
+}
+/**
+ * Hook to get external wallet chain information
+ * Returns chainId, network name, and switch chain function
+ */
+export function useExternalWalletChain() {
+    const { externalWalletChainId, externalWalletNetwork, switchExternalWalletChain, isExternalWalletConnected } = useExternalWallet();
+    return {
+        chainId: externalWalletChainId,
+        network: externalWalletNetwork,
+        switchChain: switchExternalWalletChain,
+        isConnected: isExternalWalletConnected,
+    };
+}
+/**
+ * Comprehensive hook for external wallet information
+ * Returns chainId, network, balance, switchChain function, connection status, and walletClient
+ * This is the main hook to use for external wallet operations
+ *
+ * @example
+ * ```tsx
+ * const { chainId, network, balance, formattedBalance, switchChain, isConnected, address, walletClient } = useExternalWalletInfo();
+ *
+ * // Switch chain
+ * await switchChain(137); // Switch to Polygon
+ *
+ * // Send transaction using walletClient
+ * const txHash = await walletClient.sendTransaction({
+ *   to: '0x...',
+ *   value: '0.1',
+ * });
+ *
+ * // Sign message using walletClient
+ * const signature = await walletClient.signMessage('Hello World');
+ *
+ * // Display info
+ * <div>
+ *   <p>Network: {network}</p>
+ *   <p>Balance: {formattedBalance} ETH</p>
+ * </div>
+ * ```
+ */
+export function useExternalWalletInfo() {
+    const { externalWalletChainId, externalWalletNetwork, switchExternalWalletChain, isExternalWalletConnected, externalWalletAddress, externalWalletBalance, } = useExternalWallet();
+    const { sendTransaction, signMessage, signTransaction, switchChain, } = useAbstraxnWallet();
+    const [formattedBalance, setFormattedBalance] = useState('0');
+    useEffect(() => {
+        if (externalWalletBalance && externalWalletBalance > 0n) {
+            // Convert from wei to ETH (18 decimals)
+            const balanceInEth = Number(externalWalletBalance) / 1e18;
+            setFormattedBalance(balanceInEth.toFixed(6));
+        }
+        else {
+            setFormattedBalance('0');
+        }
+    }, [externalWalletBalance]);
+    // Create walletClient object for external wallet transactions
+    const walletClient = {
+        /**
+         * Send a transaction using external wallet
+         * @param tx - Transaction request object
+         * @returns Promise resolving to transaction response with hash
+         */
+        sendTransaction: async (tx) => {
+            if (!isExternalWalletConnected) {
+                throw new Error('External wallet is not connected');
+            }
+            return await sendTransaction(tx);
+        },
+        /**
+         * Sign a message using external wallet
+         * @param message - Message string to sign
+         * @returns Promise resolving to signature string
+         */
+        signMessage: async (message) => {
+            if (!isExternalWalletConnected) {
+                throw new Error('External wallet is not connected');
+            }
+            return await signMessage(message);
+        },
+        /**
+         * Sign a transaction using external wallet
+         * @param tx - Transaction request object
+         * @returns Promise resolving to signed transaction string
+         */
+        signTransaction: async (tx) => {
+            if (!isExternalWalletConnected) {
+                throw new Error('External wallet is not connected');
+            }
+            return await signTransaction(tx);
+        },
+        /**
+         * Switch chain on external wallet
+         * @param chainId - Chain ID to switch to
+         * @returns Promise that resolves when chain is switched
+         */
+        switchChain: async (chainId) => {
+            if (!isExternalWalletConnected) {
+                throw new Error('External wallet is not connected');
+            }
+            return await switchChain(chainId);
+        },
+    };
+    return {
+        // Chain information
+        chainId: externalWalletChainId,
+        network: externalWalletNetwork,
+        // Balance information
+        balance: externalWalletBalance, // BigInt in wei
+        formattedBalance, // String formatted as ETH (e.g., "0.123456")
+        // Chain switching
+        switchChain: switchExternalWalletChain,
+        // Connection status
+        isConnected: isExternalWalletConnected,
+        address: externalWalletAddress,
+        // Wallet client for executing transactions
+        walletClient,
+    };
+}
+/**
+ * Hook to create a publicClient using viem
+ * Works for all wallet types: external wallet, Google, email OTP, Discord, X, passkey
+ *
+ * @param chain - Viem chain object (can use from 'viem/chains' or create custom)
+ * @param rpcUrl - RPC URL for the chain
+ * @returns Object with publicClient instance from viem
+ *
+ * @example
+ * ```tsx
+ * import { usePublicClient } from '@abstraxn/signer-react';
+ * import { polygonAmoy } from 'viem/chains';
+ *
+ * function MyComponent() {
+ *   const { publicClient } = usePublicClient(
+ *     polygonAmoy,
+ *     'https://rpc-amoy.polygon.technology'
+ *   );
+ *
+ *   // Read operations
+ *   const balance = await publicClient.getBalance({ address: '0x...' });
+ *   const tokenBalance = await publicClient.readContract({
+ *     address: '0x...',
+ *     abi: erc20Abi,
+ *     functionName: 'balanceOf',
+ *     args: ['0x...'],
+ *   });
+ * }
+ * ```
+ */
+export function usePublicClient(chain, rpcUrl) {
+    const publicClient = useMemo(() => {
+        if (!chain || !rpcUrl) {
+            throw new Error('Chain and RPC URL are required');
+        }
+        return createPublicClient({
+            chain,
+            transport: http(rpcUrl),
+        });
+    }, [chain, rpcUrl]);
+    return { publicClient };
+}
+/**
+ * Hook to create a walletClient using viem
+ * Used ONLY to broadcast signed transactions. No private key involved.
+ * Works for all wallet types: external wallet, Google, email OTP, Discord, X, passkey
+ *
+ * @param chain - Viem chain object (can use from 'viem/chains' or create custom)
+ * @param rpcUrl - RPC URL for the chain (optional, will use chain's default RPC if not provided)
+ * @returns Object with walletClient instance from viem
+ *
+ * @example
+ * ```tsx
+ * import { useWalletClient } from '@abstraxn/signer-react';
+ * import { polygonAmoy } from 'viem/chains';
+ *
+ * function MyComponent() {
+ *   const { walletClient } = useWalletClient(
+ *     polygonAmoy,
+ *     'https://rpc-amoy.polygon.technology'
+ *   );
+ *
+ *   // Broadcast signed transaction
+ *   const hash = await walletClient.sendRawTransaction({
+ *     serializedTransaction: signedTx,
+ *   });
+ * }
+ * ```
+ */
+export function useWalletClient(chain, rpcUrl) {
+    const walletClient = useMemo(() => {
+        if (!chain) {
+            throw new Error('Chain is required');
+        }
+        // Extract RPC URL from chain if not provided
+        let finalRpcUrl = rpcUrl;
+        if (!finalRpcUrl) {
+            if (chain.rpcUrls?.default?.http) {
+                finalRpcUrl = Array.isArray(chain.rpcUrls.default.http)
+                    ? chain.rpcUrls.default.http[0]
+                    : chain.rpcUrls.default.http;
+            }
+            else if (chain.rpcUrls?.public?.http) {
+                finalRpcUrl = Array.isArray(chain.rpcUrls.public.http)
+                    ? chain.rpcUrls.public.http[0]
+                    : chain.rpcUrls.public.http;
+            }
+        }
+        if (!finalRpcUrl) {
+            throw new Error('RPC URL is required. Either provide it as a parameter or ensure the chain has an RPC URL configured.');
+        }
+        return createWalletClient({
+            chain: chain,
+            transport: http(finalRpcUrl),
+        });
+    }, [chain, rpcUrl]);
+    return { walletClient };
+}
+/**
+ * Hook to create a contract instance using viem
+ * Works for all wallet types: external wallet, Google, email OTP, Discord, X, passkey
+ *
+ * @param address - Contract address
+ * @param abi - Contract ABI
+ * @param provider - PublicClient instance (can be created using usePublicClient hook)
+ * @returns Object with contract instance from viem
+ *
+ * @example
+ * ```tsx
+ * import { useContract, usePublicClient } from '@abstraxn/signer-react';
+ * import { polygonAmoy } from 'viem/chains';
+ * import erc20Abi from './erc20Abi.json';
+ *
+ * function MyComponent() {
+ *   const { publicClient } = usePublicClient(
+ *     polygonAmoy,
+ *     'https://rpc-amoy.polygon.technology'
+ *   );
+ *
+ *   const { contract } = useContract({
+ *     address: '0x...',
+ *     abi: erc20Abi,
+ *     provider: publicClient,
+ *   });
+ *
+ *   // Read from contract
+ *   const balance = await contract.read.balanceOf(['0x...']);
+ *
+ *   // Write to contract (requires walletClient)
+ *   const hash = await contract.write.transfer(['0x...', '1000000000000000000']);
+ * }
+ * ```
+ */
+export function useContract({ address, abi, provider, }) {
+    const contract = useMemo(() => {
+        if (!address) {
+            throw new Error('Contract address is required');
+        }
+        if (!abi) {
+            throw new Error('Contract ABI is required');
+        }
+        if (!provider) {
+            throw new Error('Provider (publicClient) is required');
+        }
+        return getContract({
+            address,
+            abi,
+            client: provider,
+        });
+    }, [address, abi, provider]);
+    return { contract };
+}
+/**
+ * Hook to prepare raw transaction data with encoding support
+ * Returns { to, value, data } for both native transfers and contract calls
+ * Can encode function data internally when ABI, functionName, and args are provided
+ *
+ * @param provider - PublicClient instance (can be created using usePublicClient hook)
+ * @returns Object with prepareRawTxn function
+ *
+ * @example
+ * ```tsx
+ * // Native transfer
+ * const { prepareRawTxn } = usePrepareRawTxn(publicClient);
+ * const nativeTx = await prepareRawTxn({
+ *   from: address!,
+ *   to: '0x...',
+ *   value: '0.001', // ETH amount
+ * });
+ * // Returns: { to: '0x...', value: '0x...', data: '0x' }
+ *
+ * // Contract call with encoding (recommended)
+ * const contractTx = await prepareRawTxn({
+ *   from: address!,
+ *   to: '0x...', // Contract address
+ *   abi: erc20Abi,
+ *   functionName: 'transfer',
+ *   args: ['0x...', '0.001'], // Automatically converts ETH to wei
+ *   value: '0', // Optional ETH value
+ * });
+ * // Returns: { to: '0x...', value: '0x', data: '0xa9059cbb...' }
+ *
+ * // Contract call with pre-encoded data
+ * const contractTx2 = await prepareRawTxn({
+ *   from: address!,
+ *   to: '0x...',
+ *   data: '0xa9059cbb...', // Already encoded
+ * });
+ * // Returns: { to: '0x...', value: '0x', data: '0xa9059cbb...' }
+ * ```
+ */
+export function usePrepareRawTxn(provider) {
+    const prepareRawTxn = useCallback(async ({ from, to, value, data, abi, functionName, args, }) => {
+        if (!provider) {
+            throw new Error('Provider (publicClient) is required');
+        }
+        if (!from) {
+            throw new Error('From address is required');
+        }
+        if (!to) {
+            throw new Error('To address is required');
+        }
+        let finalValue;
+        let finalData;
+        // Check if we need to encode function data
+        const needsEncoding = abi && functionName;
+        const hasPreEncodedData = data && data !== '0x';
+        if (needsEncoding && hasPreEncodedData) {
+            throw new Error('Cannot provide both encoded data and encoding parameters (abi/functionName). Use one or the other.');
+        }
+        // Determine if this is a native transfer
+        const isNativeTransfer = !needsEncoding && !hasPreEncodedData;
+        if (isNativeTransfer) {
+            // Native transfer: convert value to wei and set data to '0x'
+            if (!value || value === '0' || value === 0) {
+                throw new Error('Value is required for native transfer');
+            }
+            // Convert value to wei
+            const valueStr = typeof value === 'string' ? value.trim() : String(value);
+            let valueInWei;
+            try {
+                valueInWei = parseEther(valueStr);
+            }
+            catch (error) {
+                throw new Error(`Invalid value format: "${valueStr}". Value must be a valid number string (e.g., "0.001").`);
+            }
+            // Convert to hex string
+            finalValue = `0x${valueInWei.toString(16)}`;
+            finalData = '0x';
+        }
+        else {
+            // Contract call: encode data if needed, or use provided data
+            if (needsEncoding) {
+                // Encode function data
+                if (!abi) {
+                    throw new Error('ABI is required for encoding function data');
+                }
+                if (!functionName) {
+                    throw new Error('Function name is required for encoding function data');
+                }
+                // Process args to convert ETH amounts to wei for transfer functions
+                const processedArgs = (args || []).map((arg, index) => {
+                    // Check if this is likely an amount parameter for transfer/transferFrom functions
+                    const isAmountParam = (functionName === 'transfer' || functionName === 'transferFrom') && index === 1;
+                    if (isAmountParam) {
+                        // If arg is a string or number that looks like ETH (has decimal point)
+                        if (typeof arg === 'string' && arg.includes('.')) {
+                            try {
+                                // Convert ETH to wei
+                                const weiAmount = parseEther(arg);
+                                return weiAmount.toString();
+                            }
+                            catch (error) {
+                                throw new Error(`Failed to convert amount "${arg}" to wei. Make sure it's a valid number string (e.g., "0.001").`);
+                            }
+                        }
+                        else if (typeof arg === 'number' && arg % 1 !== 0) {
+                            // Number with decimal places - convert to wei
+                            try {
+                                const weiAmount = parseEther(arg.toString());
+                                return weiAmount.toString();
+                            }
+                            catch (error) {
+                                throw new Error(`Failed to convert amount ${arg} to wei. Make sure it's a valid number.`);
+                            }
+                        }
+                    }
+                    // For other args, just return as-is
+                    return arg;
+                });
+                try {
+                    finalData = encodeFunctionData({
+                        abi: abi,
+                        functionName: functionName,
+                        args: processedArgs,
+                    });
+                }
+                catch (error) {
+                    if (error instanceof Error && error.message.includes('BigInt')) {
+                        throw new Error(`Failed to encode function data: ${error.message}. Make sure all numeric arguments are in the correct format (e.g., use wei for amounts, not ETH).`);
+                    }
+                    throw error;
+                }
+            }
+            else if (hasPreEncodedData) {
+                // Use provided encoded data
+                finalData = data;
+            }
+            else {
+                throw new Error('Either provide encoded data, or provide abi/functionName/args for encoding.');
+            }
+            // Handle value for contract calls
+            if (value && value !== '0' && value !== 0) {
+                // Convert value to wei if provided
+                const valueStr = typeof value === 'string' ? value.trim() : String(value);
+                let valueInWei;
+                try {
+                    valueInWei = parseEther(valueStr);
+                }
+                catch (error) {
+                    throw new Error(`Invalid value format: "${valueStr}". Value must be a valid number string (e.g., "0.001").`);
+                }
+                finalValue = `0x${valueInWei.toString(16)}`;
+            }
+            else {
+                finalValue = '0x0';
+            }
+        }
+        return {
+            to,
+            value: finalValue,
+            data: finalData,
+        };
+    }, [provider]);
+    return { prepareRawTxn };
+}
+/**
+ * Hook to sign transaction using Turnkey API
+ * Accepts raw transaction data from usePrepareRawTxn, serializes it, and signs via API
+ *
+ * @param provider - PublicClient instance (can be created using usePublicClient hook)
+ * @returns Object with signTxn function
+ *
+ * @example
+ * ```tsx
+ * const { prepareRawTxn } = usePrepareRawTxn(publicClient);
+ * const { signTxn } = useSignTxn(publicClient);
+ *
+ * // Prepare transaction
+ * const rawTx = await prepareRawTxn({
+ *   from: address!,
+ *   to: '0x...',
+ *   value: '0.001',
+ * });
+ *
+ * // Sign transaction
+ * const signedTx = await signTxn({
+ *   from: address!,
+ *   ...rawTx, // Spread to, value, data from prepareRawTxn
+ * });
+ * ```
+ */
+export function useSignTxn(provider) {
+    const { wallet, isConnected, address, signTransactionViaAPI } = useAbstraxnWallet();
+    const signTxn = useCallback(async ({ from, to, value, data, chainId, }) => {
+        if (!isConnected || !wallet) {
+            throw new Error('Wallet is not connected');
+        }
+        if (!provider) {
+            throw new Error('Provider (publicClient) is required');
+        }
+        if (!from) {
+            throw new Error('From address is required');
+        }
+        if (!to) {
+            throw new Error('To address is required');
+        }
+        // Get chain ID from provider or use provided one
+        const targetChainId = chainId || provider.chain?.id;
+        if (!targetChainId) {
+            throw new Error('Chain ID is required. Either provide it or ensure provider has a chain configured.');
+        }
+        // Get nonce
+        const nonce = await provider.getTransactionCount({ address: from });
+        // Convert hex value to bigint
+        // Handle empty hex string "0x" by converting to "0x0"
+        const normalizedValue = value === '0x' ? '0x0' : value;
+        const valueInWei = BigInt(normalizedValue);
+        // Estimate gas
+        const gas = await provider.estimateGas({
+            account: from,
+            to,
+            data,
+            value: valueInWei,
+        });
+        // Estimate fees
+        const fee = await provider.estimateFeesPerGas();
+        // Create unsigned transaction
+        const unsignedTx = {
+            chainId: targetChainId,
+            from,
+            to,
+            data,
+            value: valueInWei,
+            nonce,
+            gas,
+            maxFeePerGas: fee.maxFeePerGas,
+            maxPriorityFeePerGas: fee.maxPriorityFeePerGas,
+            type: 'eip1559',
+        };
+        // Serialize transaction
+        const serializedTx = serializeTransaction(unsignedTx);
+        // Sign transaction via Turnkey API
+        const signResult = await signTransactionViaAPI(serializedTx, from);
+        return {
+            unsignedTransaction: serializedTx,
+            signedTransaction: signResult.signedTransaction,
+        };
+    }, [provider, isConnected, wallet, address, signTransactionViaAPI]);
+    return { signTxn, isConnected, address };
+}
+/**
+ * Hook to sign and send transaction using Turnkey API
+ * Same as useSignTxn but also sends the transaction on blockchain using publicClient
+ *
+ * @param provider - PublicClient instance (can be created using usePublicClient hook)
+ * @returns Object with signAndSendTxn function
+ *
+ * @example
+ * ```tsx
+ * const { prepareRawTxn } = usePrepareRawTxn(publicClient);
+ * const { signAndSendTxn } = useSignAndSendTxn(publicClient);
+ *
+ * // Prepare transaction
+ * const rawTx = await prepareRawTxn({
+ *   from: address!,
+ *   to: '0x...',
+ *   value: '0.001',
+ * });
+ *
+ * // Sign and send transaction
+ * const result = await signAndSendTxn({
+ *   from: address!,
+ *   ...rawTx, // Spread to, value, data from prepareRawTxn
+ * });
+ *
+ * console.log('Transaction hash:', result.hash);
+ * ```
+ */
+export function useSignAndSendTxn(provider) {
+    const { wallet, isConnected, address, signTransactionViaAPI } = useAbstraxnWallet();
+    const signAndSendTxn = useCallback(async ({ from, to, value, data, chainId, }) => {
+        if (!isConnected || !wallet) {
+            throw new Error('Wallet is not connected');
+        }
+        if (!provider) {
+            throw new Error('Provider (publicClient) is required');
+        }
+        if (!from) {
+            throw new Error('From address is required');
+        }
+        if (!to) {
+            throw new Error('To address is required');
+        }
+        // Get chain ID from provider or use provided one
+        const targetChainId = chainId || provider.chain?.id;
+        if (!targetChainId) {
+            throw new Error('Chain ID is required. Either provide it or ensure provider has a chain configured.');
+        }
+        // Get nonce
+        const nonce = await provider.getTransactionCount({ address: from });
+        // Convert hex value to bigint
+        // Handle empty hex string "0x" by converting to "0x0"
+        const normalizedValue = value === '0x' ? '0x0' : value;
+        const valueInWei = BigInt(normalizedValue);
+        // Estimate gas
+        const gas = await provider.estimateGas({
+            account: from,
+            to,
+            data,
+            value: valueInWei,
+        });
+        // Estimate fees
+        const fee = await provider.estimateFeesPerGas();
+        // Create unsigned transaction
+        const unsignedTx = {
+            chainId: targetChainId,
+            from,
+            to,
+            data,
+            value: valueInWei,
+            nonce,
+            gas,
+            maxFeePerGas: fee.maxFeePerGas,
+            maxPriorityFeePerGas: fee.maxPriorityFeePerGas,
+            type: 'eip1559',
+        };
+        // Serialize transaction
+        const serializedTx = serializeTransaction(unsignedTx);
+        // Sign transaction via Turnkey API
+        const signResult = await signTransactionViaAPI(serializedTx, from);
+        // Send the signed transaction
+        const hash = await provider.sendRawTransaction({
+            serializedTransaction: signResult.signedTransaction,
+        });
+        return {
+            hash,
+            unsignedTransaction: serializedTx,
+            signedTransaction: signResult.signedTransaction,
+        };
+    }, [provider, isConnected, wallet, address, signTransactionViaAPI]);
+    return { signAndSendTxn, isConnected, address };
+}
+/**
+ * Hook to wait for transaction receipt
+ * Waits for a transaction to be mined and returns the receipt
+ *
+ * @param provider - PublicClient instance (can be created using usePublicClient hook)
+ * @returns Object with waitForTxnReceipt function
+ *
+ * @example
+ * ```tsx
+ * const { publicClient } = usePublicClient(
+ *   polygonAmoy,
+ *   'https://rpc-amoy.polygon.technology'
+ * );
+ * const { waitForTxnReceipt } = useWaitForTxnReceipt(publicClient);
+ *
+ * // After sending a transaction
+ * const hash = '0x...'; // Transaction hash
+ *
+ * // Wait for receipt
+ * const receipt = await waitForTxnReceipt({
+ *   hash,
+ *   confirmations: 1, // Optional: number of confirmations to wait for
+ * });
+ *
+ * console.log('Transaction confirmed:', receipt);
+ * ```
+ */
+export function useWaitForTxnReceipt(provider) {
+    const waitForTxnReceipt = useCallback(async ({ hash, confirmations, timeout, }) => {
+        if (!provider) {
+            throw new Error('Provider (publicClient) is required');
+        }
+        if (!hash) {
+            throw new Error('Transaction hash is required');
+        }
+        try {
+            // waitForTransactionReceipt is a method on PublicClient
+            const receipt = await provider.waitForTransactionReceipt({
+                hash,
+                confirmations,
+                timeout,
+            });
+            return receipt;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to wait for transaction receipt: ${error.message}`);
+            }
+            throw error;
+        }
+    }, [provider]);
+    return { waitForTxnReceipt };
+}
+/**
+ * Hook to estimate gas price
+ * Estimates gas price and fees for transactions
+ *
+ * @param provider - PublicClient instance (can be created using usePublicClient hook)
+ * @returns Object with estimateGas function
+ *
+ * @example
+ * ```tsx
+ * const { publicClient } = usePublicClient(
+ *   polygonAmoy,
+ *   'https://rpc-amoy.polygon.technology'
+ * );
+ * const { estimateGas } = useEstimateGas(publicClient);
+ *
+ * // Estimate gas price
+ * const gasPrice = await estimateGas();
+ *
+ * // Returns:
+ * // {
+ * //   gasPrice?: bigint,           // Legacy gas price (for non-EIP-1559 chains)
+ * //   maxFeePerGas?: bigint,        // EIP-1559 max fee per gas
+ * //   maxPriorityFeePerGas?: bigint // EIP-1559 max priority fee per gas
+ * // }
+ * ```
+ */
+export function useEstimateGas(provider) {
+    const estimateGas = useCallback(async () => {
+        if (!provider) {
+            throw new Error('Provider (publicClient) is required');
+        }
+        try {
+            // Try to get EIP-1559 fees first (for modern chains)
+            const fees = await provider.estimateFeesPerGas();
+            return {
+                maxFeePerGas: fees.maxFeePerGas,
+                maxPriorityFeePerGas: fees.maxPriorityFeePerGas,
+                // Also get legacy gas price as fallback
+                gasPrice: fees.gasPrice,
+            };
+        }
+        catch (error) {
+            // If EIP-1559 fails, try legacy gas price
+            try {
+                const gasPrice = await provider.getGasPrice();
+                return {
+                    gasPrice,
+                };
+            }
+            catch (legacyError) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to estimate gas price: ${error.message}`);
+                }
+                throw error;
+            }
+        }
+    }, [provider]);
+    return { estimateGas };
+}
+/**
+ * Hook to read from contract
+ * Reads contract data using publicClient.readContract
+ *
+ * @param provider - PublicClient instance (can be created using usePublicClient hook)
+ * @returns Object with readContract function
+ *
+ * @example
+ * ```tsx
+ * const { publicClient } = usePublicClient(
+ *   polygonAmoy,
+ *   'https://rpc-amoy.polygon.technology'
+ * );
+ * const { readContract } = useReadContract(publicClient);
+ *
+ * // Read contract data
+ * const balance = await readContract({
+ *   address: '0x...',
+ *   abi: erc20Abi,
+ *   functionName: 'balanceOf',
+ *   args: ['0x...'],
+ * });
+ *
+ * const name = await readContract({
+ *   address: '0x...',
+ *   abi: erc20Abi,
+ *   functionName: 'name',
+ * });
+ * ```
+ */
+export function useReadContract(provider) {
+    const readContract = useCallback(({ address, abi, functionName, args, }) => {
+        if (!provider) {
+            throw new Error('Provider (publicClient) is required');
+        }
+        if (!address) {
+            throw new Error('Contract address is required');
+        }
+        if (!abi) {
+            throw new Error('Contract ABI is required');
+        }
+        if (!functionName) {
+            throw new Error('Function name is required');
+        }
+        try {
+            return provider.readContract({
+                address,
+                abi: abi,
+                functionName: functionName,
+                args: args,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to read contract: ${error.message}`);
+            }
+            throw error;
+        }
+    }, [provider]);
+    return { readContract };
+}
+/**
+ * Hook to get walletClient for external wallets (MetaMask, WalletConnect, etc.)
+ * Uses wagmi's useConnectorClient to get the walletClient
+ *
+ * @returns Object with walletClient instance (null if not connected)
+ *
+ * @example
+ * ```tsx
+ * import { useExternalWalletClient } from '@abstraxn/signer-react';
+ *
+ * function MyComponent() {
+ *   const { walletClient, isConnected } = useExternalWalletClient();
+ *
+ *   if (!walletClient || !isConnected) {
+ *     return <div>Please connect your wallet</div>;
+ *   }
+ *
+ *   // Use walletClient for transactions
+ * }
+ * ```
+ */
+export function useExternalWalletClient() {
+    const { isExternalWalletConnected } = useExternalWallet();
+    const { data: walletClient, isPending, isError, error } = useWagmiWalletClient();
+    const { isConnected: wagmiIsConnected, connector } = useAccount();
+    // Check both our internal state and wagmi's state
+    // useConnectorClient might return undefined even when connected, so we check both
+    // Edge case: connectorClient can be undefined/pending even when wallet appears connected
+    // This happens during:
+    // 1. Initial connection phase (connector is still initializing)
+    // 2. Chain switching (connector needs to re-initialize for new chain)
+    // 3. Connector re-initialization after page refresh/reconnect
+    const isActuallyConnected = isExternalWalletConnected && wagmiIsConnected;
+    // Return walletClient if available, even if isPending (might be refetching)
+    // Only return null if walletClient is actually undefined
+    const finalClient = (isActuallyConnected && walletClient) ? walletClient : null;
+    return {
+        walletClient: finalClient,
+        // isConnected should be true only when both states agree AND walletClient is available
+        // Note: isPending might be true even when walletClient exists (during refetch)
+        isConnected: isActuallyConnected && !!walletClient,
+        isPending,
+        isError,
+        error,
+        // Additional info for debugging edge cases
+        connector,
+    };
+}
+/**
+ * Hook to write to contract (for external wallets like MetaMask, WalletConnect, etc.)
+ * Uses walletClient from useExternalWalletClient to send transactions
+ *
+ * @returns Object with writeContract function
+ *
+ * @example
+ * ```tsx
+ * import { useWriteContract } from '@abstraxn/signer-react';
+ * import erc20Abi from './erc20Abi.json';
+ *
+ * function MyComponent() {
+ *   const { writeContract } = useWriteContract();
+ *
+ *   const handleTransfer = async () => {
+ *     try {
+ *       // Write to contract
+ *       const hash = await writeContract({
+ *         address: '0x...', // Contract address
+ *         abi: erc20Abi,
+ *         functionName: 'transfer',
+ *         args: ['0x...', '1000000000000000000'], // to, amount in wei
+ *       });
+ *
+ *       console.log('Transaction hash:', hash);
+ *     } catch (error) {
+ *       console.error('Transaction failed:', error);
+ *     }
+ *   };
+ *
+ *   // With ETH value
+ *   const handleDeposit = async () => {
+ *     const hash = await writeContract({
+ *       address: '0x...',
+ *       abi: contractAbi,
+ *       functionName: 'deposit',
+ *       value: parseEther('0.1'), // Send 0.1 ETH with the transaction
+ *     });
+ *   };
+ *
+ *   return <button onClick={handleTransfer}>Transfer Tokens</button>;
+ * }
+ * ```
+ */
+// ... (keep existing code)
+// ... (keep existing code)
+export function useWriteContract() {
+    const { walletClient: hookClient, isPending, isError, error, isConnected } = useExternalWalletClient();
+    const config = useConfig();
+    const currentChainId = useWagmiChainId();
+    const writeContract = useCallback(({ address, abi, functionName, args, value, account, gas, gasLimit, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, }) => {
+        return (async () => {
+            let activeClient = hookClient;
+            // If hook client is missing or in error, try to recover
+            if (!activeClient || isError) {
+                // Check if the initial error was a chain mismatch
+                const isMismatch = isError && (error?.name === 'ConnectorChainMismatchError' || error?.message?.includes('ChainMismatch'));
+                if (isMismatch) {
+                    try {
+                        if (!currentChainId)
+                            throw new Error('Current chain ID is not available');
+                        await switchChain(config, { chainId: currentChainId });
+                        // Retry getting client after switch
+                        activeClient = await getWalletClient(config);
+                    }
+                    catch (switchErr) {
+                        console.error("Failed to auto-switch chain:", switchErr);
+                        // Fall through to try getWalletClient directly or throw
+                    }
+                }
+                // If we still don't have a client (or switch failed), try to get it directly
+                if (!activeClient) {
+                    try {
+                        // Try to get client directly
+                        activeClient = await getWalletClient(config);
+                    }
+                    catch (err) {
+                        // If mismatch error (and we haven't tried switching yet or it failed differently), try to switch chain
+                        // This catches cases where getWalletClient throws mismatch but the hook error wasn't mismatch (unlikely but possible)
+                        if (err?.name === 'ConnectorChainMismatchError' || err?.message?.includes('ChainMismatch')) {
+                            try {
+                                if (!currentChainId)
+                                    throw new Error('Current chain ID is not available');
+                                await switchChain(config, { chainId: currentChainId });
+                                // Retry getting client
+                                activeClient = await getWalletClient(config);
+                            }
+                            catch (switchErr) {
+                                throw new Error(`Failed to switch chain: ${switchErr instanceof Error ? switchErr.message : 'Unknown error'}`);
+                            }
+                        }
+                        else {
+                            // Re-throw if it's not a mismatch we can handle
+                            if (isError && error) {
+                                console.error("WalletClient Initialization Error:", error);
+                                throw new Error(`Failed to initialize WalletClient: ${error.message}. Please try reconnecting your wallet.`);
+                            }
+                            throw err;
+                        }
+                    }
+                }
+            }
+            if (!activeClient) {
+                throw new Error('WalletClient is not available. Please connect an external wallet.');
+            }
+            // Cast to any to avoid type issues with different viem versions
+            const walletClientAny = activeClient;
+            // Try using writeContract method directly if available
+            if (walletClientAny && typeof walletClientAny.writeContract === 'function') {
+                return walletClientAny.writeContract({
+                    address,
+                    abi: abi,
+                    functionName: functionName,
+                    args: args,
+                    value,
+                    account,
+                    gas,
+                    gasPrice,
+                    maxFeePerGas,
+                    maxPriorityFeePerGas,
+                    nonce,
+                    chain: null, // Let the client determine the chain (or use current)
+                });
+            }
+            // If writeContract is not available, use getContract to create a contract instance
+            // This works with wagmi's connectorClient
+            const contract = getContract({
+                address,
+                abi: abi,
+                client: walletClientAny,
+            });
+            // Get the write function from the contract
+            const writeFunction = contract.write?.[functionName];
+            if (!writeFunction || typeof writeFunction !== 'function') {
+                throw new Error(`Function "${functionName}" not found in contract ABI or is not a write function. ` +
+                    'Make sure the function exists in the ABI and is a state-changing function.');
+            }
+            // Prepare the call options (viem contract write methods accept options as the last parameter)
+            const hasOptions = value !== undefined || account !== undefined || gas !== undefined || gasLimit !== undefined ||
+                gasPrice !== undefined || maxFeePerGas !== undefined ||
+                maxPriorityFeePerGas !== undefined || nonce !== undefined;
+            // Viem contract write methods expect args as an array, not spread
+            const functionArgs = args || [];
+            if (hasOptions) {
+                const callOptions = {};
+                if (value !== undefined)
+                    callOptions.value = value;
+                if (account !== undefined)
+                    callOptions.account = account;
+                // `gas` in viem is the gas *limit*. Allow either `gas` or `gasLimit` from the hook caller.
+                if (gas !== undefined) {
+                    callOptions.gas = gas;
+                }
+                else if (gasLimit !== undefined) {
+                    callOptions.gas = gasLimit;
+                }
+                if (gasPrice !== undefined)
+                    callOptions.gasPrice = gasPrice;
+                if (maxFeePerGas !== undefined)
+                    callOptions.maxFeePerGas = maxFeePerGas;
+                if (maxPriorityFeePerGas !== undefined)
+                    callOptions.maxPriorityFeePerGas = maxPriorityFeePerGas;
+                if (nonce !== undefined)
+                    callOptions.nonce = nonce;
+                // Call the write function with args array and options object
+                return writeFunction(functionArgs, callOptions);
+            }
+            else {
+                // Call the write function with args array only
+                return writeFunction(functionArgs);
+            }
+        })();
+    }, [hookClient, isPending, isError, error, isConnected, config, currentChainId]);
+    return { writeContract };
+}
+/**
+ * Hook to get the connection type (how the user connected)
+ * Returns the method used to connect: 'google', 'x', 'discord', 'metamask', 'walletconnect',
+ * 'email', 'passkey', or null if not connected
+ *
+ * @returns Object with connectionType and connector metadata
+ *
+ * @example
+ * ```tsx
+ * import { useConnectionType } from '@abstraxn/signer-react';
+ *
+ * function MyComponent() {
+ *   const { connectionType, connectorMeta } = useConnectionType();
+ *
+ *   if (!connectionType) {
+ *     return <div>Not connected</div>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       Connected via: {connectorMeta?.name || connectionType}
+ *       {connectionType === 'google' && <div>Welcome Google user!</div>}
+ *       {connectionType === 'metamask' && <div>MetaMask wallet connected</div>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useConnectionType() {
+    const { connectionType } = useAbstraxnWallet();
+    // Normalize connection type to match ConnectorType
+    const normalizedType = connectionType ? normalizeConnectionType(connectionType) : null;
+    const connectorMeta = getConnectorMeta(normalizedType);
+    return {
+        connectionType: normalizedType,
+        connectorMeta,
+    };
+}
+/**
+ * Normalize connection type string to match ConnectorType
+ */
+function normalizeConnectionType(type) {
+    const lower = type.toLowerCase();
+    // Map to standard connector types
+    if (lower.includes('google'))
+        return 'google';
+    if (lower.includes('twitter') || lower === 'x')
+        return 'x';
+    if (lower.includes('discord'))
+        return 'discord';
+    if (lower.includes('metamask') || lower.includes('io.metamask'))
+        return 'metamask';
+    if (lower.includes('walletconnect') || lower.includes('wallet_connect'))
+        return 'walletconnect';
+    if (lower.includes('email') || lower.includes('otp'))
+        return 'email';
+    if (lower.includes('passkey'))
+        return 'passkey';
+    // Return original if no match (for other wallet types like coinbase, phantom, etc.)
+    return type;
+}
+/**
+ * Hook to switch chain
+ * Handles both internal (social) and external wallets
+ */
+export function useSwitchChain() {
+    const { wallet, connectionType } = useAbstraxnWallet();
+    const { switchChainAsync } = useWagmiSwitchChain();
+    const { isConnected: isWagmiConnected } = useAccount();
+    const config = useConfig();
+    const switchChain = async (chainId) => {
+        // Normalize connection type
+        const type = connectionType ? connectionType.toLowerCase() : '';
+        // Check if it's a social login
+        const isSocial = ['google', 'email', 'otp', 'x', 'discord', 'passkey'].some(t => type.includes(t));
+        if (isSocial) {
+            if (!wallet)
+                throw new Error('Wallet not initialized');
+            // Use internal wallet switch
+            await wallet.switchChain(chainId);
+        }
+        else if (isWagmiConnected) {
+            // Use wagmi for external wallets
+            try {
+                await switchChainAsync({ chainId });
+            }
+            catch (error) {
+                // Check if error is related to chain not being added or RPC URL missing
+                // "UserRejectedRequestError" with "chain.rpcUrls is undefined" often means the chain isn't known to the wallet/viem
+                // Try to add the chain if we have its details
+                let chainParams = null;
+                // 1. Try to get from internal SDK chains
+                const chainData = getChainById(chainId);
+                if (chainData && chainData.type === 'evm') {
+                    chainParams = {
+                        chainName: chainData.displayName,
+                        nativeCurrency: chainData.nativeCurrency,
+                        rpcUrls: [chainData.rpcUrl],
+                        blockExplorerUrls: chainData.blockExplorer ? [chainData.blockExplorer.url] : undefined,
+                    };
+                }
+                // 2. If not found, try to get from wagmi config (includes custom chains passed to provider)
+                if (!chainParams) {
+                    const wagmiChain = config.chains.find(c => c.id === chainId);
+                    if (wagmiChain) {
+                        // Handle both viem Chain (rpcUrls) and CoreChain (rpcUrl) formats
+                        // The chain object in config might be a CoreChain if it wasn't converted correctly
+                        const rpcUrls = wagmiChain.rpcUrls?.default?.http || (wagmiChain.rpcUrl ? [wagmiChain.rpcUrl] : []);
+                        const blockExplorerUrls = wagmiChain.blockExplorers?.default?.url
+                            ? [wagmiChain.blockExplorers.default.url]
+                            : (wagmiChain.explorerUrl ? [wagmiChain.explorerUrl] : undefined);
+                        chainParams = {
+                            chainName: wagmiChain.name,
+                            nativeCurrency: wagmiChain.nativeCurrency,
+                            rpcUrls: rpcUrls,
+                            blockExplorerUrls: blockExplorerUrls,
+                        };
+                    }
+                }
+                if (chainParams) {
+                    try {
+                        await switchChainAsync({
+                            chainId,
+                            addEthereumChainParameter: chainParams
+                        });
+                    }
+                    catch (retryError) {
+                        console.error('Failed to add and switch chain:', retryError);
+                        throw retryError;
+                    }
+                }
+                else {
+                    // If we don't have chain data, rethrow the original error
+                    throw error;
+                }
+            }
+        }
+        else {
+            throw new Error('No active connection to switch chain');
+        }
+    };
+    return { switchChain };
+}
+/**
+ * Hook to sign a message
+ * Handles both internal (social) and external wallets
+ */
+export function useSignMessage() {
+    const { wallet, connectionType } = useAbstraxnWallet();
+    const { signMessageAsync } = useWagmiSignMessage();
+    const { isConnected: isWagmiConnected } = useAccount();
+    const signMessage = async (message) => {
+        // Normalize connection type
+        const type = connectionType ? connectionType.toLowerCase() : '';
+        // Check if it's a social login
+        const isSocial = ['google', 'email', 'otp', 'x', 'discord', 'passkey'].some(t => type.includes(t));
+        if (isSocial) {
+            throw new Error('Signing messages is not supported for embedded wallets');
+        }
+        else if (isWagmiConnected) {
+            // Use wagmi for external wallets
+            return await signMessageAsync({ message });
+        }
+        else {
+            throw new Error('No active connection to sign message');
+        }
+    };
+    return { signMessage };
+}
+//# sourceMappingURL=hooks.js.map