Gas Estimation

// From src/__swaps__/types/gas.ts
enum GasSpeed {
  URGENT = 'urgent',
  FAST = 'fast',
  NORMAL = 'normal',
  CUSTOM = 'custom',
}

interface GasFeeParams {
  maxBaseFee: GasFeeParam;           // Max base fee willing to pay
  maxPriorityFeePerGas: GasFeeParam; // Tip for validators
  option: GasSpeed;                   // Speed selection
  estimatedTime: {                    // Estimated confirmation time
    amount: number;
    display: string;
  };
  gasFee: {                           // Total fee estimate
    amount: string;                   // In wei
    display: string;                  // Formatted
  };
  transactionGasParams: TransactionGasParams; // For transaction
}

interface TransactionGasParams {
  maxPriorityFeePerGas: string;      // In wei
  maxFeePerGas: string;              // In wei
}

// From src/__swaps__/screens/Swap/hooks/useSwapEstimatedGasLimit.ts
async function estimateUnlockAndSwap({
  chainId,
  quote,
}: {
  chainId: ChainId;
  quote: Quote;
}): Promise<string> {
  // Check if approval needed
  const requiresApproval = await checkTokenAllowance(
    quote.sellTokenAsset.address,
    quote.allowanceTarget,
    quote.sellAmount
  );
  
  let totalGas = BigNumber.from(0);
  
  // Add approval gas if needed
  if (requiresApproval) {
    const approvalGas = await estimateApprovalGas(
      quote.sellTokenAsset.address,
      quote.allowanceTarget,
      quote.sellAmount
    );
    totalGas = totalGas.add(approvalGas);
  }
  
  // Add swap gas
  const swapGas = await estimateSwapGas(quote);
  totalGas = totalGas.add(swapGas);
  
  // Add 10% safety margin
  const withMargin = totalGas.mul(110).div(100);
  
  return withMargin.toString();
}

async function estimateUnlockAndCrosschainSwap({
  chainId,
  quote,
}: {
  chainId: ChainId;
  quote: CrosschainQuote;
}): Promise<string> {
  let totalGas = BigNumber.from(0);
  
  // Estimate for each transaction in route
  for (const route of quote.routes) {
    for (const userTx of route.userTxs || []) {
      const txGas = await provider.estimateGas({
        to: userTx.to,
        data: userTx.data,
        value: userTx.value,
        from: currentAddress,
      });
      
      totalGas = totalGas.add(txGas);
    }
  }
  
  // Add safety margin
  return totalGas.mul(110).div(100).toString();
}

// Total maximum you're willing to pay per gas unit
maxFeePerGas = maxBaseFee + maxPriorityFeePerGas;

// Actual cost:
actualCost = gasUsed * (baseFee + priorityFee);

// Refund if base fee lower than max:
refund = gasUsed * (maxBaseFee - actualBaseFee);

// From providers/SyncSwapStateAndSharedValues.tsx
export function calculateGasFeeWorklet(
  gasSettings: GasSettings,
  gasLimit: string
): string {
  'worklet';
  
  if (!gasSettings || !gasLimit) return '0';
  
  // EIP-1559 transaction
  if ('maxFeePerGas' in gasSettings) {
    // Use maxFeePerGas as upper bound
    return mulWorklet(
      gasLimit,
      gasSettings.maxFeePerGas
    );
  }
  
  // Legacy transaction
  if ('gasPrice' in gasSettings) {
    return mulWorklet(
      gasLimit,
      gasSettings.gasPrice
    );
  }
  
  return '0';
}

// From src/__swaps__/screens/Swap/hooks/useEstimatedGasFee.ts
export function useEstimatedGasFee({
  chainId,
  gasLimit,
  gasSettings,
}: {
  chainId: ChainId;
  gasLimit: string | undefined;
  gasSettings: GasSettings | undefined;
}) {
  const nativeNetworkAsset = useNativeAsset({ chainId });
  const nativeCurrency = userAssetsStoreManager(state => state.currency);
  
  return useMemo(() => {
    if (!gasLimit || !gasSettings || !nativeNetworkAsset?.price) return;
    
    // Calculate total gas fee
    const gasFee = calculateGasFeeWorklet(gasSettings, gasLimit);
    if (isNaN(Number(gasFee))) return;
    
    const networkAssetPrice = nativeNetworkAsset.price.value?.toString();
    if (!networkAssetPrice) {
      // Show in Gwei if no price
      return `${formatNumber(weiToGwei(gasFee))} Gwei`;
    }
    
    // Convert to native token amount
    const feeFormatted = formatUnits(
      safeBigInt(gasFee),
      nativeNetworkAsset.decimals
    ).toString();
    
    // Calculate USD value
    const feeInUserCurrency = multiply(networkAssetPrice, feeFormatted);
    
    // Format in user's currency
    return convertAmountToNativeDisplayWorklet(
      feeInUserCurrency,
      nativeCurrency,
      true
    );
  }, [gasLimit, gasSettings, nativeCurrency, nativeNetworkAsset]);
}

// Choose route with best gas efficiency
const optimizedRoute = routes.reduce((best, current) => {
  const bestScore = divWorklet(
    best.outputAmount,
    best.estimatedGas
  );
  
  const currentScore = divWorklet(
    current.outputAmount,
    current.estimatedGas
  );
  
  return greaterThanWorklet(currentScore, bestScore) ? current : best;
});

const SAFETY_MARGIN = 1.1; // 10% buffer

const safeGasLimit = estimatedGas.mul(110).div(100);

interface CustomGasSettings {
  maxBaseFee: string;           // In Gwei
  maxPriorityFeePerGas: string; // In Gwei
  gasLimit?: string;            // Override estimated limit
}

const setCustomGas = (settings: CustomGasSettings) => {
  // Validate settings
  if (Number(settings.maxBaseFee) < currentBaseFee) {
    warn('Base fee too low, transaction may not confirm');
  }
  
  if (Number(settings.maxPriorityFeePerGas) < 1) {
    warn('Priority fee very low, confirmation may be slow');
  }
  
  // Apply custom settings
  swapsStore.setState({ customGas: settings });
};