signer-test-sdk-react 0.0.12 → 0.0.14

package/dist/src/hooks.js

@@ -1,8 +1,10 @@
 /**
  * React Hooks for Abstraxn Wallet SDK
  */
-import { useState, useCallback, useEffect } from 'react';
+import { useState, useCallback, useEffect, useMemo } from 'react';
 import { useAbstraxnWallet } from './AbstraxnProvider';
+import { createPublicClient, createWalletClient, http, getContract, serializeTransaction, parseEther, encodeFunctionData } from 'viem';
+import { useConnectorClient, useAccount } from 'wagmi';
 /**
  * Hook to check if wallet is connected
  */
@@ -391,4 +393,777 @@ export function useExternalWalletInfo() {
         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 'signer-test-sdk-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 'signer-test-sdk-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 'signer-test-sdk-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 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 'signer-test-sdk-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: connectorClient, isPending, isError } = useConnectorClient();
+    const { isConnected: wagmiIsConnected } = useAccount();
+    // Check both our internal state and wagmi's state
+    // useConnectorClient might return undefined even when connected, so we check both
+    const isActuallyConnected = isExternalWalletConnected && wagmiIsConnected;
+    const walletClient = (isActuallyConnected && connectorClient) ? connectorClient : null;
+    return {
+        walletClient,
+        isConnected: isActuallyConnected && !!connectorClient,
+        isPending,
+        isError,
+    };
+}
+/**
+ * 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 'signer-test-sdk-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>;
+ * }
+ * ```
+ */
+export function useWriteContract() {
+    const { walletClient } = useExternalWalletClient();
+    const writeContract = useCallback(({ address, abi, functionName, args, value, account, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, }) => {
+        if (!walletClient) {
+            throw new Error('WalletClient is not available. Please connect an external wallet (MetaMask, WalletConnect, etc.).');
+        }
+        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 {
+            // Cast to any to avoid type issues with different viem versions
+            const walletClientAny = walletClient;
+            // 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,
+                });
+            }
+            // 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 ||
+                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;
+                if (gas !== undefined)
+                    callOptions.gas = gas;
+                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);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to write contract: ${error.message}`);
+            }
+            throw error;
+        }
+    }, [walletClient]);
+    return { writeContract };
+}
 //# sourceMappingURL=hooks.js.map