calculateEvmTransactionFee

Estimate the gas fee for an EVM transaction

Estimates the gas fee for an EVM transaction without running a full simulation. Returns fee data in native units (wei), human-readable format (ETH), and optionally USD — but no asset diffs or security validation.

Use this when you need a fee estimate only. Use simulateEvmTransaction when you also want to preview asset changes and security validation.

Installation

npm install @dynamic-labs-sdk/evm

Usage

JavaScript

import { calculateEvmTransactionFee } from '@dynamic-labs-sdk/evm';
import { getNetworksData } from '@dynamic-labs-sdk/client';
import { parseEther } from 'viem';

const networks = getNetworksData();
const networkData = networks.find((n) => n.networkId === '1'); // Ethereum mainnet

if (networkData) {
  const feeData = await calculateEvmTransactionFee({
    transaction: {
      from: walletAccount.address,
      to: recipientAddress,
      value: parseEther('0.1'),
    },
    networkData,
  });

  console.log(`Estimated fee: ${feeData.humanReadableAmount} ETH`);
}

React

Estimate fees inside a button handler or useEffect. Re-estimate whenever the transaction or network changes:

import { calculateEvmTransactionFee } from '@dynamic-labs-sdk/evm';
import { getNetworksData } from '@dynamic-labs-sdk/client';
import { useGetWalletAccounts } from '@dynamic-labs-sdk/react-hooks';
import { useState } from 'react';
import { parseEther } from 'viem';

function FeeEstimator({ recipientAddress }) {
  const { data: walletAccounts = [] } = useGetWalletAccounts();
  const walletAccount = walletAccounts[0];
  const [fee, setFee] = useState(null);

  const handleEstimate = async () => {
    if (!walletAccount) return;

    const networks = getNetworksData();
    const networkData = networks.find((n) => n.networkId === '1');
    if (!networkData) return;

    const feeData = await calculateEvmTransactionFee({
      transaction: {
        from: walletAccount.address,
        to: recipientAddress,
        value: parseEther('0.1'),
      },
      networkData,
    });

    setFee(feeData.humanReadableAmount);
  };

  return (
    <div>
      <button onClick={handleEstimate}>Estimate Fee</button>
      {fee && <p>Estimated fee: {fee} ETH</p>}
    </div>
  );
}

Parameters

Parameter	Type	Description
transaction	object	The transaction to estimate fees for
transaction.from	string	The sender address
transaction.to	string	The recipient or contract address
transaction.value	bigint (optional)	Native token amount in wei
transaction.data	string (optional)	Encoded contract call data
networkData	NetworkData	Network configuration. Get this from getNetworksData()
nativeTokenPriceUsd	number (optional)	USD price of the native token, used to calculate usdAmount

Returns

Promise<EvmTransactionFeeData>:

Field	Type	Description
nativeAmount	bigint	Total fee in wei
humanReadableAmount	string	Fee in ETH, formatted for display
usdAmount	string (optional)	Fee in USD. Present only when nativeTokenPriceUsd is provided
gasEstimate	bigint	Estimated gas units
maxFeePerGas	bigint (optional)	EIP-1559 max fee per gas
maxPriorityFeePerGas	bigint (optional)	EIP-1559 priority fee per gas
gasPrice	bigint (optional)	Legacy gas price. Present when EIP-1559 is not available

Examples

Simple ETH transfer

const feeData = await calculateEvmTransactionFee({
  transaction: {
    from: walletAccount.address,
    to: recipientAddress,
    value: parseEther('1'),
  },
  networkData,
});

console.log(`Fee: ${feeData.humanReadableAmount} ETH`);
console.log(`Gas units: ${feeData.gasEstimate}`);

With USD conversion

const ETH_PRICE_USD = 3200;

const feeData = await calculateEvmTransactionFee({
  transaction: {
    from: walletAccount.address,
    to: recipientAddress,
    value: parseEther('0.5'),
  },
  networkData,
  nativeTokenPriceUsd: ETH_PRICE_USD,
});

console.log(`Fee: ${feeData.humanReadableAmount} ETH`);
console.log(`≈ $${feeData.usdAmount}`);

Contract interaction

import { encodeFunctionData } from 'viem';

const feeData = await calculateEvmTransactionFee({
  transaction: {
    from: walletAccount.address,
    to: tokenContractAddress,
    data: encodeFunctionData({
      abi: erc20Abi,
      functionName: 'transfer',
      args: [recipientAddress, parseUnits('100', 18)],
    }),
  },
  networkData,
});

Error handling

import { FeeEstimationFailedError } from '@dynamic-labs-sdk/client';

try {
  const feeData = await calculateEvmTransactionFee({ transaction, networkData });
} catch (error) {
  if (error instanceof FeeEstimationFailedError) {
    console.error('Fee estimation failed:', error.message);
  }
}

Related functions

• simulateEvmTransaction - Full simulation with asset diffs and security validation
• calculateSolanaTransactionFee - Fee estimation for Solana
• calculateFeeForUserOperation - Fee calculation for ZeroDev user operations
• getNetworksData - Get network configuration objects