@abstraxn/signer-react 1.0.1 → 1.0.2

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.1] - 2026-01-28
+
+### Added
+- Added `useEstimateGas` hook for estimating gas costs for transactions

package/README.md

@@ -109,6 +109,10 @@ function HookConnectButton() {
 - **@abstraxn/signer-core** - Core SDK (dependency)
 - **@abstraxn/signer** - Backward compatible wrapper (deprecated)
 
+## 📋 Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for a list of changes and version history.
+
 ## 📝 License
 
 MIT

package/dist/src/hooks.d.ts

@@ -8366,14 +8366,14 @@ export declare function usePrepareRawTxn(provider: PublicClient): {
     prepareRawTxn: ({ from, to, value, data, abi, functionName, args, }: {
         from: Address;
         to: Address;
-        value?: string | number;
+        value?: string | number | bigint;
         data?: `0x${string}`;
         abi?: Abi;
         functionName?: string;
         args?: any[];
     }) => Promise<{
         to: Address;
-        value: `0x${string}`;
+        value: string | bigint;
         data: `0x${string}`;
     }>;
 };
@@ -8390,28 +8390,35 @@ export declare function usePrepareRawTxn(provider: PublicClient): {
  * 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 gasEstimate = await estimateGas({ account: address!, to: rawTx.to, data: rawTx.data, value: rawTx.value });
+ * // Sign (override required; no estimation in hook)
  * const signedTx = await signTxn({
  *   from: address!,
- *   ...rawTx, // Spread to, value, data from prepareRawTxn
+ *   ...rawTx,
+ *   override: { gasLimit: gasEstimate.gasLimit, maxFeePerGas: gasEstimate.maxFeePerGas!, maxPriorityFeePerGas: gasEstimate.maxPriorityFeePerGas! },
  * });
  * ```
  */
 export declare function useSignTxn(provider: PublicClient): {
-    signTxn: ({ from, to, value, data, chainId, }: {
+    signTxn: ({ from, to, value, data, chainId, override, }: {
         from: Address;
         to: Address;
-        value: `0x${string}`;
+        value: string | bigint;
         data: `0x${string}`;
         chainId?: number;
+        /** Gas and fees (user must pass; no estimation in hook). EIP-1559 or legacy. Use useEstimateGas to get values. */
+        override: {
+            gasLimit: bigint;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+        } | {
+            gasLimit: bigint;
+            gasPrice: bigint;
+        };
     }) => Promise<{
-        unsignedTransaction: `0x02${string}`;
+        unsignedTransaction: `0x02${string}` | import("viem").TransactionSerializedLegacy;
         signedTransaction: string;
     }>;
     isConnected: boolean;
@@ -8430,31 +8437,37 @@ export declare function useSignTxn(provider: PublicClient): {
  * 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 gasEstimate = await estimateGas({ account: address!, to: rawTx.to, data: rawTx.data, value: rawTx.value });
+ * // Sign and send (override required; no estimation in hook)
  * const result = await signAndSendTxn({
  *   from: address!,
- *   ...rawTx, // Spread to, value, data from prepareRawTxn
+ *   ...rawTx,
+ *   override: { gasLimit: gasEstimate.gasLimit, maxFeePerGas: gasEstimate.maxFeePerGas!, maxPriorityFeePerGas: gasEstimate.maxPriorityFeePerGas! },
  * });
- *
  * console.log('Transaction hash:', result.hash);
  * ```
  */
 export declare function useSignAndSendTxn(provider: PublicClient): {
-    signAndSendTxn: ({ from, to, value, data, chainId, }: {
+    signAndSendTxn: ({ from, to, value, data, chainId, override, }: {
         from: Address;
         to: Address;
-        value: `0x${string}`;
+        value: string | bigint;
         data: `0x${string}`;
         chainId?: number;
+        /** Gas and fees (user must pass; no estimation in hook). EIP-1559 or legacy. Use useEstimateGas to get values. */
+        override: {
+            gasLimit: bigint;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+        } | {
+            gasLimit: bigint;
+            gasPrice: bigint;
+        };
     }) => Promise<{
         hash: `0x${string}`;
-        unsignedTransaction: `0x02${string}`;
+        unsignedTransaction: `0x02${string}` | import("viem").TransactionSerializedLegacy;
         signedTransaction: string;
     }>;
     isConnected: boolean;
@@ -8495,33 +8508,33 @@ export declare function useWaitForTxnReceipt(provider: PublicClient): {
     }) => Promise<TransactionReceipt>;
 };
 /**
- * Hook to estimate gas price
- * Estimates gas price and fees for transactions
+ * Hook to estimate gas for a transaction
+ * Returns gasLimit and fees to pass as override to useSignTxn / useSignAndSendTxn (no estimation inside those hooks).
  *
  * @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
- * // }
+ * const result = await estimateGas({
+ *   account: address!,
+ *   to: rawTx.to,
+ *   data: rawTx.data,
+ *   value: rawTx.value,
+ * });
+ * // EIP-1559: override: { gasLimit: result.gasLimit, maxFeePerGas: result.maxFeePerGas!, maxPriorityFeePerGas: result.maxPriorityFeePerGas! }
+ * // Legacy: override: { gasLimit: result.gasLimit, gasPrice: result.gasPrice! }
  * ```
  */
 export declare function useEstimateGas(provider: PublicClient): {
-    estimateGas: () => Promise<{
+    estimateGas: ({ account, to, data, value, }: {
+        account: Address;
+        to: Address;
+        data?: `0x${string}`;
+        value?: string | bigint;
+    }) => Promise<{
+        gasLimit: bigint;
         gasPrice?: bigint;
         maxFeePerGas?: bigint;
         maxPriorityFeePerGas?: bigint;

package/dist/src/hooks.js

@@ -3,7 +3,7 @@
  */
 import { useState, useCallback, useEffect, useMemo } from 'react';
 import { useAbstraxnWallet } from './AbstraxnProvider';
-import { createPublicClient, createWalletClient, http, getContract, serializeTransaction, parseEther, encodeFunctionData } from 'viem';
+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';
@@ -510,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 {
@@ -537,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,
@@ -588,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';
@@ -626,22 +579,20 @@ 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 gasEstimate = await estimateGas({ account: address!, to: rawTx.to, data: rawTx.data, value: rawTx.value });
+ * // Sign (override required; no estimation in hook)
  * const signedTx = await signTxn({
  *   from: address!,
- *   ...rawTx, // Spread to, value, data from prepareRawTxn
+ *   ...rawTx,
+ *   override: { gasLimit: gasEstimate.gasLimit, maxFeePerGas: gasEstimate.maxFeePerGas!, maxPriorityFeePerGas: gasEstimate.maxPriorityFeePerGas! },
  * });
  * ```
  */
 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, override, }) => {
         if (!isConnected || !wallet) {
             throw new Error('Wallet is not connected');
         }
@@ -654,6 +605,16 @@ export function useSignTxn(provider) {
         if (!to) {
             throw new Error('To address is required');
         }
+        if (override.gasLimit === undefined) {
+            throw new Error('override.gasLimit is required. Use useEstimateGas to get values.');
+        }
+        const isLegacy = 'gasPrice' in override && override.gasPrice !== undefined;
+        if (!isLegacy) {
+            const o = override;
+            if (o.maxFeePerGas === undefined || o.maxPriorityFeePerGas === undefined) {
+                throw new Error('override.maxFeePerGas and maxPriorityFeePerGas are required for EIP-1559, or pass gasPrice for legacy.');
+            }
+        }
         // Get chain ID from provider or use provided one
         const targetChainId = chainId || provider.chain?.id;
         if (!targetChainId) {
@@ -661,32 +622,34 @@ 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 = {
-            chainId: targetChainId,
-            from,
-            to,
-            data,
-            value: valueInWei,
-            nonce,
-            gas,
-            maxFeePerGas: fee.maxFeePerGas,
-            maxPriorityFeePerGas: fee.maxPriorityFeePerGas,
-            type: 'eip1559',
-        };
+        // 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 override only (no estimateGas/estimateFeesPerGas)
+        const unsignedTx = isLegacy
+            ? {
+                chainId: targetChainId,
+                from,
+                to,
+                data,
+                value: valueInWei,
+                nonce,
+                gas: override.gasLimit,
+                gasPrice: override.gasPrice,
+            }
+            : (() => {
+                const o = override;
+                return {
+                    chainId: targetChainId,
+                    from,
+                    to,
+                    data,
+                    value: valueInWei,
+                    nonce,
+                    gas: o.gasLimit,
+                    maxFeePerGas: o.maxFeePerGas,
+                    maxPriorityFeePerGas: o.maxPriorityFeePerGas,
+                };
+            })();
         // Serialize transaction
         const serializedTx = serializeTransaction(unsignedTx);
         // Sign transaction via Turnkey API
@@ -711,24 +674,21 @@ 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 gasEstimate = await estimateGas({ account: address!, to: rawTx.to, data: rawTx.data, value: rawTx.value });
+ * // Sign and send (override required; no estimation in hook)
  * const result = await signAndSendTxn({
  *   from: address!,
- *   ...rawTx, // Spread to, value, data from prepareRawTxn
+ *   ...rawTx,
+ *   override: { gasLimit: gasEstimate.gasLimit, maxFeePerGas: gasEstimate.maxFeePerGas!, maxPriorityFeePerGas: gasEstimate.maxPriorityFeePerGas! },
  * });
- *
  * 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, }) => {
+    const signAndSendTxn = useCallback(async ({ from, to, value, data, chainId, override, }) => {
         if (!isConnected || !wallet) {
             throw new Error('Wallet is not connected');
         }
@@ -741,6 +701,16 @@ export function useSignAndSendTxn(provider) {
         if (!to) {
             throw new Error('To address is required');
         }
+        if (override.gasLimit === undefined) {
+            throw new Error('override.gasLimit is required. Use useEstimateGas to get values.');
+        }
+        const isLegacy = 'gasPrice' in override && override.gasPrice !== undefined;
+        if (!isLegacy) {
+            const o = override;
+            if (o.maxFeePerGas === undefined || o.maxPriorityFeePerGas === undefined) {
+                throw new Error('override.maxFeePerGas and maxPriorityFeePerGas are required for EIP-1559, or pass gasPrice for legacy.');
+            }
+        }
         // Get chain ID from provider or use provided one
         const targetChainId = chainId || provider.chain?.id;
         if (!targetChainId) {
@@ -748,32 +718,34 @@ 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 = {
-            chainId: targetChainId,
-            from,
-            to,
-            data,
-            value: valueInWei,
-            nonce,
-            gas,
-            maxFeePerGas: fee.maxFeePerGas,
-            maxPriorityFeePerGas: fee.maxPriorityFeePerGas,
-            type: 'eip1559',
-        };
+        // 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 override only (no estimateGas/estimateFeesPerGas)
+        const unsignedTx = isLegacy
+            ? {
+                chainId: targetChainId,
+                from,
+                to,
+                data,
+                value: valueInWei,
+                nonce,
+                gas: override.gasLimit,
+                gasPrice: override.gasPrice,
+            }
+            : (() => {
+                const o = override;
+                return {
+                    chainId: targetChainId,
+                    from,
+                    to,
+                    data,
+                    value: valueInWei,
+                    nonce,
+                    gas: o.gasLimit,
+                    maxFeePerGas: o.maxFeePerGas,
+                    maxPriorityFeePerGas: o.maxPriorityFeePerGas,
+                };
+            })();
         // Serialize transaction
         const serializedTx = serializeTransaction(unsignedTx);
         // Sign transaction via Turnkey API
@@ -844,59 +816,59 @@ export function useWaitForTxnReceipt(provider) {
     return { waitForTxnReceipt };
 }
 /**
- * Hook to estimate gas price
- * Estimates gas price and fees for transactions
+ * Hook to estimate gas for a transaction
+ * Returns gasLimit and fees to pass as override to useSignTxn / useSignAndSendTxn (no estimation inside those hooks).
  *
  * @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
- * // }
+ * const result = await estimateGas({
+ *   account: address!,
+ *   to: rawTx.to,
+ *   data: rawTx.data,
+ *   value: rawTx.value,
+ * });
+ * // EIP-1559: override: { gasLimit: result.gasLimit, maxFeePerGas: result.maxFeePerGas!, maxPriorityFeePerGas: result.maxPriorityFeePerGas! }
+ * // Legacy: override: { gasLimit: result.gasLimit, gasPrice: result.gasPrice! }
  * ```
  */
 export function useEstimateGas(provider) {
-    const estimateGas = useCallback(async () => {
+    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,
+        });
         try {
-            // Try to get EIP-1559 fees first (for modern chains)
             const fees = await provider.estimateFeesPerGas();
             return {
+                gasLimit,
                 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,
-                };
+                return { gasLimit, gasPrice };
             }
             catch (legacyError) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to estimate gas price: ${error.message}`);
-                }
-                throw error;
+                return { gasLimit };
             }
         }
     }, [provider]);