signer-test-sdk-react 0.0.22 → 0.0.24

package/dist/src/hooks.js

@@ -3,10 +3,11 @@
  */
 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 } from 'wagmi';
+import { createPublicClient, createWalletClient, http, getContract, serializeTransaction, 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
  */
@@ -25,7 +26,7 @@ export function useAddress() {
  * Hook to get current user and whoami information
  * Returns an object with both user and whoami data
  */
-export function useUser() {
+export function useAuthContext() {
     const { user, whoami } = useAbstraxnWallet();
     return { user, whoami };
 }
@@ -36,20 +37,6 @@ export function useChainId() {
     const { chainId } = useAbstraxnWallet();
     return chainId;
 }
-/**
- * Hook to check if wallet is initialized
- */
-export function useIsInitialized() {
-    const { isInitialized } = useAbstraxnWallet();
-    return isInitialized;
-}
-/**
- * Hook to get loading state
- */
-export function useLoading() {
-    const { loading } = useAbstraxnWallet();
-    return loading;
-}
 /**
  * Hook to get error state
  */
@@ -66,91 +53,6 @@ export function useWallet() {
     const { wallet } = useAbstraxnWallet();
     return wallet;
 }
-/**
- * Hook to prepare and sign transaction
- * Prepares the unsigned transaction, calls the sign API, and returns the signed transaction
- * User can execute this signed transaction themselves
- */
-export function usePrepareTransaction() {
-    const { wallet, isConnected, address, signTransactionViaAPI } = useAbstraxnWallet();
-    const prepareTransaction = async (to, value, rpcUrl, chainId) => {
-        if (!isConnected || !wallet || !address) {
-            throw new Error('Wallet is not connected');
-        }
-        // Import viem functions dynamically
-        const { createPublicClient, http, serializeTransaction } = await import('viem');
-        const { polygonAmoy } = await import('viem/chains');
-        const targetRpcUrl = rpcUrl || 'https://rpc-amoy.polygon.technology';
-        const targetChainId = chainId || polygonAmoy.id;
-        // Create public client
-        const publicClient = createPublicClient({
-            chain: polygonAmoy,
-            transport: http(targetRpcUrl),
-        });
-        // Get nonce
-        const nonce = await publicClient.getTransactionCount({ address: address });
-        // Get gas price
-        const gasPrice = await publicClient.getGasPrice();
-        // Convert amount to wei (18 decimals)
-        const valueInWei = BigInt(Math.floor(Number(value) * 10 ** 18));
-        // Create unsigned transaction
-        const unsignedTx = {
-            to: to,
-            value: valueInWei,
-            gas: 21000n,
-            nonce: nonce,
-            gasPrice: gasPrice,
-            chainId: targetChainId,
-            data: '0x',
-        };
-        // Serialize transaction
-        const serializedTx = serializeTransaction(unsignedTx);
-        // Sign transaction via API
-        const signResult = await signTransactionViaAPI(serializedTx, address);
-        return {
-            unsignedTransaction: serializedTx,
-            signedTransaction: signResult.signedTransaction,
-        };
-    };
-    return { prepareTransaction, isConnected, address };
-}
-/**
- * Hook to sign transaction via API
- * Returns the signed transaction that user can execute themselves
- */
-export function useSignTransaction() {
-    const { wallet, isConnected, address, signTransactionViaAPI } = useAbstraxnWallet();
-    const signTransaction = async (unsignedTransaction, fromAddress) => {
-        if (!isConnected || !wallet) {
-            throw new Error('Wallet is not connected');
-        }
-        const targetAddress = fromAddress || address;
-        if (!targetAddress) {
-            throw new Error('Address is required');
-        }
-        return await signTransactionViaAPI(unsignedTransaction, targetAddress);
-    };
-    return { signTransaction, isConnected, address };
-}
-/**
- * Hook to sign and send transaction
- * Signs transaction via API and then executes it internally
- * Returns transaction hash
- */
-export function useSignAndSendTransaction() {
-    const { wallet, isConnected, address, signAndSendTransaction } = useAbstraxnWallet();
-    const signAndSend = async (unsignedTransaction, fromAddress, rpcUrl) => {
-        if (!isConnected || !wallet) {
-            throw new Error('Wallet is not connected');
-        }
-        const targetAddress = fromAddress || address;
-        if (!targetAddress) {
-            throw new Error('Address is required');
-        }
-        return await signAndSendTransaction(unsignedTransaction, targetAddress, rpcUrl);
-    };
-    return { signAndSendTransaction: signAndSend, isConnected, address };
-}
 /**
  * Hook to export wallet private key
  * Returns the export bundle containing the private key
@@ -405,7 +307,7 @@ export function useExternalWalletInfo() {
  *
  * @example
  * ```tsx
- * import { usePublicClient } from 'signer-test-sdk-react';
+ * import { usePublicClient } from '@abstraxn/signer-react';
  * import { polygonAmoy } from 'viem/chains';
  *
  * function MyComponent() {
@@ -448,7 +350,7 @@ export function usePublicClient(chain, rpcUrl) {
  *
  * @example
  * ```tsx
- * import { useWalletClient } from 'signer-test-sdk-react';
+ * import { useWalletClient } from '@abstraxn/signer-react';
  * import { polygonAmoy } from 'viem/chains';
  *
  * function MyComponent() {
@@ -504,7 +406,7 @@ export function useWalletClient(chain, rpcUrl) {
  *
  * @example
  * ```tsx
- * import { useContract, usePublicClient } from 'signer-test-sdk-react';
+ * import { useContract, usePublicClient } from '@abstraxn/signer-react';
  * import { polygonAmoy } from 'viem/chains';
  * import erc20Abi from './erc20Abi.json';
  *
@@ -608,21 +510,11 @@ export function usePrepareRawTxn(provider) {
         // 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) {
+            // Native transfer: pass value through as-is (no hex conversion)
+            if (value === undefined || value === null || 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)}`;
+            finalValue = typeof value === 'bigint' ? value : (typeof value === 'string' ? value.trim() : String(value));
             finalData = '0x';
         }
         else {
@@ -635,36 +527,8 @@ export function usePrepareRawTxn(provider) {
                 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;
-                });
+                // Pass args through as-is (no conversion); caller must pass amounts in wei / correct format
+                const processedArgs = args ?? [];
                 try {
                     finalData = encodeFunctionData({
                         abi: abi,
@@ -686,18 +550,9 @@ export function usePrepareRawTxn(provider) {
             else {
                 throw new Error('Either provide encoded data, or provide abi/functionName/args for encoding.');
             }
-            // Handle value for contract calls
+            // Handle value for contract calls: pass through as-is (no hex conversion)
             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)}`;
+                finalValue = typeof value === 'bigint' ? value : (typeof value === 'string' ? value.trim() : String(value));
             }
             else {
                 finalValue = '0x0';
@@ -724,22 +579,108 @@ export function usePrepareRawTxn(provider) {
  * const { signTxn } = useSignTxn(publicClient);
  *
  * // Prepare transaction
- * const rawTx = await prepareRawTxn({
- *   from: address!,
- *   to: '0x...',
- *   value: '0.001',
- * });
- *
- * // Sign transaction
+ * const rawTx = await prepareRawTxn({ from: address!, to: '0x...', value: '0.001' });
+ * const { estimateGas } = useEstimateGas(publicClient);
+ * const { getGasPrice } = useGetGasPrice(publicClient);
+ * const { gasLimit } = await estimateGas({ account: address!, to: rawTx.to, data: rawTx.data, value: rawTx.value });
+ * const fees = await getGasPrice();
  * const signedTx = await signTxn({
  *   from: address!,
- *   ...rawTx, // Spread to, value, data from prepareRawTxn
+ *   ...rawTx,
+ *   gas: { gasLimit, maxFeePerGas: fees.maxFeePerGas!, maxPriorityFeePerGas: fees.maxPriorityFeePerGas! },
  * });
  * ```
  */
+// export function useSignTxn(provider: PublicClient) {
+//   const { wallet, isConnected, address, signTransactionViaAPI } = useAbstraxnWallet();
+//   const signTxn = useCallback(async ({
+//     from,
+//     to,
+//     value,
+//     data,
+//     chainId,
+//     gas,
+//   }: {
+//     from: Address;
+//     to: Address;
+//     value: string | bigint;
+//     data: `0x${string}`;
+//     chainId?: number;
+//     /** Gas: pass gasLimit + (maxFeePerGas & maxPriorityFeePerGas for EIP-1559) or (gasPrice for legacy). Use useEstimateGas and useGetGasPrice. */
+//     gas: {
+//       gasLimit: bigint;
+//       gasPrice?: bigint;
+//       maxFeePerGas?: bigint;
+//       maxPriorityFeePerGas?: bigint;
+//     };
+//   }) => {
+//     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');
+//     }
+//     if (gas.gasLimit === undefined) {
+//       throw new Error('gas.gasLimit is required. Use useEstimateGas to get values.');
+//     }
+//     const isLegacy = gas.gasPrice !== undefined;
+//     if (!isLegacy) {
+//       if (gas.maxFeePerGas === undefined || gas.maxPriorityFeePerGas === undefined) {
+//         throw new Error('gas.maxFeePerGas and gas.maxPriorityFeePerGas are required for EIP-1559, or pass gas.gasPrice for legacy.');
+//       }
+//     }
+//     // 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 });
+//     // Value in wei (pass-through from prepareRawTxn, no hex conversion)
+//     const valueInWei = typeof value === 'bigint' ? value : BigInt(value === '0x' || value === '' ? '0' : value);
+//     // Build unsigned tx from user gas (no estimation in hook)
+//     const unsignedTx = isLegacy
+//       ? {
+//           chainId: targetChainId,
+//           from,
+//           to,
+//           data,
+//           value: valueInWei,
+//           nonce,
+//           gas: gas.gasLimit,
+//           gasPrice: gas.gasPrice,
+//         }
+//       : {
+//           chainId: targetChainId,
+//           from,
+//           to,
+//           data,
+//           value: valueInWei,
+//           nonce,
+//           gas: gas.gasLimit,
+//           maxFeePerGas: gas.maxFeePerGas!,
+//           maxPriorityFeePerGas: gas.maxPriorityFeePerGas!,
+//         };
+//     // 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 };
+// }
 export function useSignTxn(provider) {
     const { wallet, isConnected, address, signTransactionViaAPI } = useAbstraxnWallet();
-    const signTxn = useCallback(async ({ from, to, value, data, chainId, }) => {
+    const signTxn = useCallback(async ({ from, to, value, data, chainId, gas, }) => {
         if (!isConnected || !wallet) {
             throw new Error('Wallet is not connected');
         }
@@ -759,32 +700,31 @@ export function useSignTxn(provider) {
         }
         // 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 = {
+        // Value in wei (pass-through from prepareRawTxn, no hex conversion)
+        const valueInWei = typeof value === 'bigint' ? value : BigInt(value === '0x' || value === '' ? '0' : value);
+        // Build base transaction object
+        const baseTx = {
             chainId: targetChainId,
             from,
             to,
             data,
             value: valueInWei,
             nonce,
-            gas,
-            maxFeePerGas: fee.maxFeePerGas,
-            maxPriorityFeePerGas: fee.maxPriorityFeePerGas,
-            type: 'eip1559',
         };
+        // Add gas properties if they exist
+        const unsignedTx = { ...baseTx };
+        if (gas?.gasLimit !== undefined) {
+            unsignedTx.gas = gas.gasLimit;
+        }
+        if (gas?.gasPrice !== undefined) {
+            unsignedTx.gasPrice = gas.gasPrice;
+        }
+        if (gas?.maxFeePerGas !== undefined) {
+            unsignedTx.maxFeePerGas = gas.maxFeePerGas;
+        }
+        if (gas?.maxPriorityFeePerGas !== undefined) {
+            unsignedTx.maxPriorityFeePerGas = gas.maxPriorityFeePerGas;
+        }
         // Serialize transaction
         const serializedTx = serializeTransaction(unsignedTx);
         // Sign transaction via Turnkey API
@@ -809,24 +749,114 @@ export function useSignTxn(provider) {
  * const { signAndSendTxn } = useSignAndSendTxn(publicClient);
  *
  * // Prepare transaction
- * const rawTx = await prepareRawTxn({
- *   from: address!,
- *   to: '0x...',
- *   value: '0.001',
- * });
- *
- * // Sign and send transaction
+ * const rawTx = await prepareRawTxn({ from: address!, to: '0x...', value: '0.001' });
+ * const { estimateGas } = useEstimateGas(publicClient);
+ * const { getGasPrice } = useGetGasPrice(publicClient);
+ * const { gasLimit } = await estimateGas({ account: address!, to: rawTx.to, data: rawTx.data, value: rawTx.value });
+ * const fees = await getGasPrice();
  * const result = await signAndSendTxn({
  *   from: address!,
- *   ...rawTx, // Spread to, value, data from prepareRawTxn
+ *   ...rawTx,
+ *   gas: { gasLimit, maxFeePerGas: fees.maxFeePerGas!, maxPriorityFeePerGas: fees.maxPriorityFeePerGas! },
  * });
- *
  * console.log('Transaction hash:', result.hash);
  * ```
  */
+// export function useSignAndSendTxn(provider: PublicClient) {
+//   const { wallet, isConnected, address, signTransactionViaAPI } = useAbstraxnWallet();
+//   const signAndSendTxn = useCallback(async ({
+//     from,
+//     to,
+//     value,
+//     data,
+//     chainId,
+//     gas,
+//   }: {
+//     from: Address;
+//     to: Address;
+//     value: string | bigint;
+//     data: `0x${string}`;
+//     chainId?: number;
+//     /** Gas: pass gasLimit + (maxFeePerGas & maxPriorityFeePerGas for EIP-1559) or (gasPrice for legacy). Use useEstimateGas and useGetGasPrice. */
+//     gas: {
+//       gasLimit: bigint;
+//       gasPrice?: bigint;
+//       maxFeePerGas?: bigint;
+//       maxPriorityFeePerGas?: bigint;
+//     };
+//   }) => {
+//     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');
+//     }
+//     if (gas.gasLimit === undefined) {
+//       throw new Error('gas.gasLimit is required. Use useEstimateGas to get values.');
+//     }
+//     const isLegacy = gas.gasPrice !== undefined;
+//     if (!isLegacy) {
+//       if (gas.maxFeePerGas === undefined || gas.maxPriorityFeePerGas === undefined) {
+//         throw new Error('gas.maxFeePerGas and gas.maxPriorityFeePerGas are required for EIP-1559, or pass gas.gasPrice for legacy.');
+//       }
+//     }
+//     // 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 });
+//     // Value in wei (pass-through from prepareRawTxn, no hex conversion)
+//     const valueInWei = typeof value === 'bigint' ? value : BigInt(value === '0x' || value === '' ? '0' : value);
+//     // Build unsigned tx from user gas (no estimation in hook)
+//     const unsignedTx = isLegacy
+//       ? {
+//           chainId: targetChainId,
+//           from,
+//           to,
+//           data,
+//           value: valueInWei,
+//           nonce,
+//           gas: gas.gasLimit,
+//           gasPrice: gas.gasPrice,
+//         }
+//       : {
+//           chainId: targetChainId,
+//           from,
+//           to,
+//           data,
+//           value: valueInWei,
+//           nonce,
+//           gas: gas.gasLimit,
+//           maxFeePerGas: gas.maxFeePerGas!,
+//           maxPriorityFeePerGas: gas.maxPriorityFeePerGas!,
+//         };
+//     // 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 as `0x${string}`,
+//     });
+//     return {
+//       hash,
+//       unsignedTransaction: serializedTx,
+//       signedTransaction: signResult.signedTransaction,
+//     };
+//   }, [provider, isConnected, wallet, address, signTransactionViaAPI]);
+//   return { signAndSendTxn, isConnected, address };
+// }
 export function useSignAndSendTxn(provider) {
     const { wallet, isConnected, address, signTransactionViaAPI } = useAbstraxnWallet();
-    const signAndSendTxn = useCallback(async ({ from, to, value, data, chainId, }) => {
+    const signAndSendTxn = useCallback(async ({ from, to, value, data, chainId, gas, }) => {
         if (!isConnected || !wallet) {
             throw new Error('Wallet is not connected');
         }
@@ -846,32 +876,31 @@ export function useSignAndSendTxn(provider) {
         }
         // 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 = {
+        // Value in wei (pass-through from prepareRawTxn, no hex conversion)
+        const valueInWei = typeof value === 'bigint' ? value : BigInt(value === '0x' || value === '' ? '0' : value);
+        // Build base transaction object
+        const baseTx = {
             chainId: targetChainId,
             from,
             to,
             data,
             value: valueInWei,
             nonce,
-            gas,
-            maxFeePerGas: fee.maxFeePerGas,
-            maxPriorityFeePerGas: fee.maxPriorityFeePerGas,
-            type: 'eip1559',
         };
+        // Add gas properties if they exist
+        const unsignedTx = { ...baseTx };
+        if (gas?.gasLimit !== undefined) {
+            unsignedTx.gas = gas.gasLimit;
+        }
+        if (gas?.gasPrice !== undefined) {
+            unsignedTx.gasPrice = gas.gasPrice;
+        }
+        if (gas?.maxFeePerGas !== undefined) {
+            unsignedTx.maxFeePerGas = gas.maxFeePerGas;
+        }
+        if (gas?.maxPriorityFeePerGas !== undefined) {
+            unsignedTx.maxPriorityFeePerGas = gas.maxPriorityFeePerGas;
+        }
         // Serialize transaction
         const serializedTx = serializeTransaction(unsignedTx);
         // Sign transaction via Turnkey API
@@ -941,6 +970,87 @@ export function useWaitForTxnReceipt(provider) {
     }, [provider]);
     return { waitForTxnReceipt };
 }
+/**
+ * Hook to estimate gas for a transaction
+ * Returns gasLimit to pass as gas.gasLimit to useSignTxn / useSignAndSendTxn (use useGetGasPrice for fees; no estimation inside those hooks).
+ *
+ * @param provider - PublicClient instance (can be created using usePublicClient hook)
+ * @returns Object with estimateGas function
+ *
+ * @example
+ * ```tsx
+ * const { estimateGas } = useEstimateGas(publicClient);
+ * const result = await estimateGas({
+ *   account: address!,
+ *   to: rawTx.to,
+ *   data: rawTx.data,
+ *   value: rawTx.value,
+ * });
+ * // gas: { gasLimit: result.gasLimit }
+ * ```
+ */
+export function useEstimateGas(provider) {
+    const estimateGas = useCallback(async ({ account, to, data = '0x', value = 0n, }) => {
+        if (!provider) {
+            throw new Error('Provider (publicClient) is required');
+        }
+        if (!account) {
+            throw new Error('Account (from) is required');
+        }
+        if (!to) {
+            throw new Error('To address is required');
+        }
+        const valueInWei = typeof value === 'bigint' ? value : (value === undefined || value === '' || value === '0x' ? 0n : BigInt(value));
+        const gasLimit = await provider.estimateGas({
+            account,
+            to,
+            data: data ?? '0x',
+            value: valueInWei,
+        });
+        return { gasLimit };
+    }, [provider]);
+    return { estimateGas };
+}
+/**
+ * Hook to get current gas price / EIP-1559 fees from the chain.
+ * Use with useEstimateGas when you need gas limit and gas price for the gas param in useSignTxn / useSignAndSendTxn.
+ *
+ * @param provider - PublicClient instance (can be created using usePublicClient hook)
+ * @returns Object with getGasPrice function returning maxFeePerGas, maxPriorityFeePerGas, and/or gasPrice
+ *
+ * @example
+ * ```tsx
+ * const { publicClient } = usePublicClient(...);
+ * const { getGasPrice } = useGetGasPrice(publicClient);
+ * const fees = await getGasPrice();
+ * // EIP-1559: gas: { gasLimit, maxFeePerGas: fees.maxFeePerGas!, maxPriorityFeePerGas: fees.maxPriorityFeePerGas! }
+ * // Legacy: gas: { gasLimit, gasPrice: fees.gasPrice! }
+ * ```
+ */
+export function useGetGasPrice(provider) {
+    const getGasPrice = useCallback(async () => {
+        if (!provider) {
+            throw new Error('Provider (publicClient) is required');
+        }
+        const result = {};
+        try {
+            const fees = await provider.estimateFeesPerGas();
+            result.maxFeePerGas = fees.maxFeePerGas;
+        }
+        catch {
+            // EIP-1559 not supported, will try legacy below
+        }
+        try {
+            result.gasPrice = await provider.getGasPrice();
+            result.maxPriorityFeePerGas = await provider.estimateMaxPriorityFeePerGas();
+        }
+        catch {
+            // Optional: gasPrice not available
+        }
+        return result;
+    }, [provider]);
+    return { getGasPrice };
+}
 /**
  * Hook to read from contract
  * Reads contract data using publicClient.readContract
@@ -1010,7 +1120,7 @@ export function useReadContract(provider) {
  *
  * @example
  * ```tsx
- * import { useExternalWalletClient } from 'signer-test-sdk-react';
+ * import { useExternalWalletClient } from '@abstraxn/signer-react';
  *
  * function MyComponent() {
  *   const { walletClient, isConnected } = useExternalWalletClient();
@@ -1058,7 +1168,7 @@ export function useExternalWalletClient() {
  *
  * @example
  * ```tsx
- * import { useWriteContract } from 'signer-test-sdk-react';
+ * import { useWriteContract } from '@abstraxn/signer-react';
  * import erc20Abi from './erc20Abi.json';
  *
  * function MyComponent() {
@@ -1100,36 +1210,55 @@ 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, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, }) => {
+    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) {
-                try {
-                    // Try to get client directly
-                    activeClient = await getWalletClient(config);
+                // 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
+                    }
                 }
-                catch (err) {
-                    // If mismatch error, try to switch chain
-                    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'}`);
-                        }
+                // 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);
                     }
-                    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.`);
+                    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;
                         }
-                        throw err;
                     }
                 }
             }
@@ -1169,7 +1298,7 @@ export function useWriteContract() {
                     '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 ||
+            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
@@ -1180,8 +1309,13 @@ export function useWriteContract() {
                     callOptions.value = value;
                 if (account !== undefined)
                     callOptions.account = account;
-                if (gas !== undefined)
+                // `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)
@@ -1210,7 +1344,7 @@ export function useWriteContract() {
  *
  * @example
  * ```tsx
- * import { useConnectionType } from 'signer-test-sdk-react';
+ * import { useConnectionType } from '@abstraxn/signer-react';
  *
  * function MyComponent() {
  *   const { connectionType, connectorMeta } = useConnectionType();
@@ -1262,4 +1396,112 @@ function normalizeConnectionType(type) {
     // 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