eth_estimateGas - Estimate Transaction Gas

import { JsonRpcProvider, Contract, parseEther, parseUnits } from 'ethers';

const provider = new JsonRpcProvider('https://api-neuroweb.n.dwellir.com/YOUR_API_KEY');

// Gas estimation utility
class GasEstimator {
  constructor(provider) {
    this.provider = provider;
    this.cache = new Map();
  }

  async estimateETHTransfer(from, to, value) {
    try {
      const gasEstimate = await this.provider.estimateGas({
        from: from,
        to: to,
        value: parseEther(value)
      });

      // Add 10% buffer for safety
      const gasWithBuffer = gasEstimate * 110n / 100n;

      // Get current gas prices
      const feeData = await this.provider.getFeeData();
      
      // Calculate costs
      const estimatedCost = gasWithBuffer * feeData.gasPrice;
      const estimatedCostEIP1559 = gasWithBuffer * feeData.maxFeePerGas;

      return {
        gasLimit: gasWithBuffer.toString(),
        gasPrice: feeData.gasPrice.toString(),
        maxFeePerGas: feeData.maxFeePerGas.toString(),
        maxPriorityFeePerGas: feeData.maxPriorityFeePerGas.toString(),
        estimatedCostWei: estimatedCost.toString(),
        estimatedCostETH: ethers.formatEther(estimatedCost),
        estimatedCostEIP1559Wei: estimatedCostEIP1559.toString(),
        estimatedCostEIP1559ETH: ethers.formatEther(estimatedCostEIP1559)
      };
    } catch (error) {
      throw new Error(`Gas estimation failed: ${error.message}`);
    }
  }

  async estimateContractCall(contractAddress, abi, method, params, from) {
    const contract = new Contract(contractAddress, abi, this.provider);
    
    try {
      // Build transaction
      const tx = await contract[method].populateTransaction(...params);
      tx.from = from;

      // Estimate gas
      const gasEstimate = await this.provider.estimateGas(tx);
      
      // Get L1 fee estimate for Neuroweb Mainnet
      const l1FeeEstimate = await this.estimateL1Fee(tx);
      
      // Calculate total with buffer
      const gasWithBuffer = gasEstimate * 115n / 100n; // 15% buffer for contracts
      
      const feeData = await this.provider.getFeeData();
      const l2Cost = gasWithBuffer * feeData.maxFeePerGas;
      const totalCost = l2Cost + l1FeeEstimate;

      return {
        gasLimit: gasWithBuffer.toString(),
        l2GasEstimate: gasEstimate.toString(),
        l1FeeEstimate: l1FeeEstimate.toString(),
        maxFeePerGas: feeData.maxFeePerGas.toString(),
        l2CostWei: l2Cost.toString(),
        l2CostETH: ethers.formatEther(l2Cost),
        totalCostWei: totalCost.toString(),
        totalCostETH: ethers.formatEther(totalCost),
        method: method,
        contract: contractAddress
      };
    } catch (error) {
      // Parse revert reason if available
      if (error.data) {
        const reason = this.parseRevertReason(error.data);
        throw new Error(`Estimation failed: ${reason}`);
      }
      throw error;
    }
  }

  async estimateL1Fee(transaction) {
    // Neuroweb Mainnet specific - estimate L1 data posting fee
    try {
      // This would call a Ethereum-specific method if available
      // For now, estimate based on transaction size
      const txData = JSON.stringify(transaction);
      const dataSize = new Blob([txData]).size;
      
      // Rough estimate: ~16 gas per byte on L1
      const l1GasEstimate = BigInt(dataSize * 16);
      const l1GasPrice = await this.provider.getGasPrice(); // L1 gas price
      
      return l1GasEstimate * l1GasPrice / 10n; // Adjusted for L2 economics
    } catch {
      return 0n;
    }
  }

  parseRevertReason(data) {
    if (typeof data === 'string' && data.startsWith('0x08c379a0')) {
      // Standard revert string
      const reason = ethers.AbiCoder.defaultAbiCoder().decode(
        ['string'],
        '0x' + data.slice(10)
      )[0];
      return reason;
    }
    return 'Unknown error';
  }

  async batchEstimate(transactions) {
    const estimates = [];
    
    for (const tx of transactions) {
      try {
        const gasEstimate = await this.provider.estimateGas(tx);
        const feeData = await this.provider.getFeeData();
        
        estimates.push({
          transaction: tx,
          gasLimit: gasEstimate.toString(),
          estimatedCost: (gasEstimate * feeData.maxFeePerGas).toString(),
          success: true
        });
      } catch (error) {
        estimates.push({
          transaction: tx,
          error: error.message,
          success: false
        });
      }
    }
    
    return estimates;
  }

  async compareGasStrategies(transaction) {
    const gasEstimate = await this.provider.estimateGas(transaction);
    const feeData = await this.provider.getFeeData();
    const block = await this.provider.getBlock('latest');
    
    // Different gas strategies
    const strategies = {
      conservative: {
        gasLimit: gasEstimate * 150n / 100n, // 50% buffer
        maxFeePerGas: feeData.maxFeePerGas * 120n / 100n,
        maxPriorityFeePerGas: feeData.maxPriorityFeePerGas * 120n / 100n
      },
      standard: {
        gasLimit: gasEstimate * 110n / 100n, // 10% buffer
        maxFeePerGas: feeData.maxFeePerGas,
        maxPriorityFeePerGas: feeData.maxPriorityFeePerGas
      },
      aggressive: {
        gasLimit: gasEstimate * 105n / 100n, // 5% buffer
        maxFeePerGas: block.baseFeePerGas * 2n + feeData.maxPriorityFeePerGas / 2n,
        maxPriorityFeePerGas: feeData.maxPriorityFeePerGas / 2n
      }
    };
    
    const results = {};
    for (const [name, strategy] of Object.entries(strategies)) {
      const maxCost = strategy.gasLimit * strategy.maxFeePerGas;
      const likelyCost = strategy.gasLimit * 
        (block.baseFeePerGas + strategy.maxPriorityFeePerGas);
      
      results[name] = {
        ...strategy,
        maxCostWei: maxCost.toString(),
        maxCostETH: ethers.formatEther(maxCost),
        likelyCostWei: likelyCost.toString(),
        likelyCostETH: ethers.formatEther(likelyCost)
      };
    }
    
    return results;
  }
}

// Usage example
const estimator = new GasEstimator(provider);

// Estimate simple transfer
const transferEstimate = await estimator.estimateETHTransfer(
  '0xYourAddress',
  '0xRecipientAddress',
  '0.1'
);
console.log('Transfer cost:', transferEstimate.estimatedCostETH, 'ETH');

// Estimate contract interaction
const contractEstimate = await estimator.estimateContractCall(
  '0xContractAddress',
  ['function transfer(address to, uint256 amount)'],
  'transfer',
  ['0xRecipient', parseUnits('100', 18)],
  '0xYourAddress'
);
console.log('Contract call cost:', contractEstimate.totalCostETH, 'ETH');

from web3 import Web3
from eth_utils import to_wei, from_wei
import json
from typing import Dict, Any, List, Optional

w3 = Web3(Web3.HTTPProvider('https://api-neuroweb.n.dwellir.com/YOUR_API_KEY'))

class GasCalculator:
    """Calculate and optimize gas for Neuroweb Mainnet transactions"""
    
    def __init__(self, w3_instance):
        self.w3 = w3_instance
    
    def estimate_transfer(
        self, 
        from_address: str, 
        to_address: str, 
        value_eth: float
    ) -> Dict[str, Any]:
        """Estimate gas for ETH transfer"""
        
        try:
            # Build transaction
            transaction = {
                'from': from_address,
                'to': to_address,
                'value': to_wei(value_eth, 'ether')
            }
            
            # Estimate gas
            gas_estimate = self.w3.eth.estimate_gas(transaction)
            
            # Add buffer
            gas_limit = int(gas_estimate * 1.1)  # 10% buffer
            
            # Get current gas prices
            gas_price = self.w3.eth.gas_price
            base_fee = self.w3.eth.get_block('latest')['baseFeePerGas']
            max_priority_fee = self.w3.eth.max_priority_fee
            
            # Calculate costs
            estimated_cost = gas_limit * gas_price
            max_cost = gas_limit * (base_fee * 2 + max_priority_fee)
            
            return {
                'gas_estimate': gas_estimate,
                'gas_limit': gas_limit,
                'gas_price_gwei': from_wei(gas_price, 'gwei'),
                'base_fee_gwei': from_wei(base_fee, 'gwei'),
                'priority_fee_gwei': from_wei(max_priority_fee, 'gwei'),
                'estimated_cost_eth': from_wei(estimated_cost, 'ether'),
                'max_cost_eth': from_wei(max_cost, 'ether')
            }
            
        except Exception as e:
            return {'error': str(e)}
    
    def estimate_contract_call(
        self,
        from_address: str,
        to_address: str,
        data: str,
        value: int = 0
    ) -> Dict[str, Any]:
        """Estimate gas for contract interaction"""
        
        transaction = {
            'from': from_address,
            'to': to_address,
            'data': data,
            'value': value
        }
        
        try:
            # Estimate gas
            gas_estimate = self.w3.eth.estimate_gas(transaction)
            
            # Estimate L1 fee component (Neuroweb specific)
            l1_fee = self._estimate_l1_fee(transaction)
            
            # Calculate with buffer
            gas_limit = int(gas_estimate * 1.15)  # 15% buffer for contracts
            
            # Get fee data
            gas_price = self.w3.eth.gas_price
            
            # Calculate costs
            l2_cost = gas_limit * gas_price
            total_cost = l2_cost + l1_fee
            
            return {
                'success': True,
                'gas_estimate': gas_estimate,
                'gas_limit': gas_limit,
                'l1_fee_wei': l1_fee,
                'l2_cost_wei': l2_cost,
                'total_cost_wei': total_cost,
                'total_cost_eth': from_wei(total_cost, 'ether'),
                'breakdown': {
                    'l2_cost_eth': from_wei(l2_cost, 'ether'),
                    'l1_fee_eth': from_wei(l1_fee, 'ether')
                }
            }
            
        except Exception as e:
            # Try to extract revert reason
            error_msg = str(e)
            if 'execution reverted' in error_msg:
                return {
                    'success': False,
                    'error': 'Transaction would revert',
                    'reason': self._extract_revert_reason(error_msg)
                }
            return {'success': False, 'error': error_msg}
    
    def _estimate_l1_fee(self, transaction: Dict) -> int:
        """Estimate L1 data posting fee for Neuroweb Mainnet"""
        
        # Serialize transaction to estimate size
        tx_data = self.w3.to_json(transaction)
        data_size = len(tx_data.encode('utf-8'))
        
        # Neuroweb Mainnet formula approximation
        # L1 fee = data_size * l1_gas_price * scalar
        l1_gas_price = self.w3.eth.gas_price  # Use current L1 gas price
        scalar = 0.684  # Neuroweb Mainnet scalar (this changes over time)
        
        l1_fee = int(data_size * 16 * l1_gas_price * scalar)
        return l1_fee
    
    def _extract_revert_reason(self, error_msg: str) -> str:
        """Extract revert reason from error message"""
        
        # Common patterns
        if 'insufficient balance' in error_msg.lower():
            return 'Insufficient balance'
        elif 'transfer amount exceeds allowance' in error_msg.lower():
            return 'Transfer amount exceeds allowance'
        elif 'transfer amount exceeds balance' in error_msg.lower():
            return 'Transfer amount exceeds balance'
        
        # Try to extract custom revert message
        if '0x08c379a0' in error_msg:
            # Standard revert string
            try:
                start = error_msg.index('0x08c379a0')
                hex_msg = error_msg[start:start+138]  # Standard length
                # Decode would go here
                return 'Contract reverted'
            except:
                pass
        
        return 'Unknown revert reason'
    
    def optimize_gas_settings(
        self,
        transaction: Dict,
        speed: str = 'standard'
    ) -> Dict[str, Any]:
        """Get optimized gas settings based on network conditions"""
        
        # Get current network state
        latest_block = self.w3.eth.get_block('latest')
        base_fee = latest_block['baseFeePerGas']
        
        # Get gas estimate
        gas_estimate = self.w3.eth.estimate_gas(transaction)
        
        # Speed presets
        presets = {
            'slow': {
                'buffer': 1.05,
                'priority_multiplier': 0.8
            },
            'standard': {
                'buffer': 1.1,
                'priority_multiplier': 1.0
            },
            'fast': {
                'buffer': 1.2,
                'priority_multiplier': 1.5
            },
            'instant': {
                'buffer': 1.3,
                'priority_multiplier': 2.0
            }
        }
        
        preset = presets.get(speed, presets['standard'])
        
        # Calculate optimized settings
        gas_limit = int(gas_estimate * preset['buffer'])
        max_priority_fee = int(
            self.w3.eth.max_priority_fee * preset['priority_multiplier']
        )
        max_fee_per_gas = base_fee * 2 + max_priority_fee
        
        # Calculate estimated cost
        estimated_cost = gas_limit * (base_fee + max_priority_fee)
        max_cost = gas_limit * max_fee_per_gas
        
        return {
            'speed': speed,
            'gas_limit': gas_limit,
            'max_fee_per_gas': max_fee_per_gas,
            'max_priority_fee_per_gas': max_priority_fee,
            'estimated_cost_eth': from_wei(estimated_cost, 'ether'),
            'max_cost_eth': from_wei(max_cost, 'ether'),
            'estimated_confirmation_time': self._estimate_confirmation_time(speed)
        }
    
    def _estimate_confirmation_time(self, speed: str) -> str:
        """Estimate confirmation time based on speed setting"""
        
        times = {
            'slow': '2-5 minutes',
            'standard': '15-30 seconds',
            'fast': '5-15 seconds',
            'instant': '< 5 seconds'
        }
        return times.get(speed, 'Unknown')
    
    def batch_estimate(self, transactions: List[Dict]) -> List[Dict[str, Any]]:
        """Estimate gas for multiple transactions"""
        
        results = []
        total_gas = 0
        total_cost = 0
        
        for i, tx in enumerate(transactions):
            try:
                gas_estimate = self.w3.eth.estimate_gas(tx)
                gas_price = self.w3.eth.gas_price
                cost = gas_estimate * gas_price
                
                results.append({
                    'index': i,
                    'gas_estimate': gas_estimate,
                    'cost_wei': cost,
                    'cost_eth': from_wei(cost, 'ether'),
                    'success': True
                })
                
                total_gas += gas_estimate
                total_cost += cost
                
            except Exception as e:
                results.append({
                    'index': i,
                    'error': str(e),
                    'success': False
                })
        
        return {
            'estimates': results,
            'summary': {
                'total_gas': total_gas,
                'total_cost_wei': total_cost,
                'total_cost_eth': from_wei(total_cost, 'ether'),
                'successful': len([r for r in results if r['success']]),
                'failed': len([r for r in results if not r['success']])
            }
        }

# Usage examples
calculator = GasCalculator(w3)

# Estimate ETH transfer
transfer_estimate = calculator.estimate_transfer(
    '0xFromAddress',
    '0xToAddress',
    0.1  # 0.1 ETH
)
print(f"Gas needed: {transfer_estimate['gas_limit']}")
print(f"Estimated cost: {transfer_estimate['estimated_cost_eth']} ETH")

# Estimate contract call
contract_estimate = calculator.estimate_contract_call(
    '0xFromAddress',
    '0xContractAddress',
    '0xa9059cbb000000000000000000000000....'  # transfer function data
)
print(f"Total cost: {contract_estimate['total_cost_eth']} ETH")

# Get optimized settings
optimized = calculator.optimize_gas_settings(
    {'from': '0xFrom', 'to': '0xTo', 'value': to_wei(0.1, 'ether')},
    speed='fast'
)
print(f"Optimized gas limit: {optimized['gas_limit']}")
print(f"Max fee: {optimized['max_fee_per_gas']} wei")