Understanding Gas, gasPrice, and Ethereum Transaction Fees

Ethereum transactions involve several key components that determine their cost, speed, and execution. One of the most critical aspects is gas—the unit measuring computational effort on the Ethereum network. Whether you're sending ETH to a wallet or interacting with a smart contract, understanding how gas works ensures efficient and cost-effective operations.

This article breaks down the structure of an Ethereum transaction by analyzing real-world data from the Goerli testnet. We'll explore core concepts like gasPrice, baseFee, maxPriorityFee, and how they contribute to total transaction costs. Along the way, we’ll clarify common misconceptions about gas usage and demonstrate how to retrieve transaction details programmatically using ethers.js v6.

How Gas Works in Ethereum Transactions

When you submit a transaction on Ethereum—whether it's transferring ETH or calling a smart contract function—the network must execute computations. These computations require resources, so users pay for them in gas.

Each operation (like storing data or performing arithmetic) consumes a predefined amount of gas. The total fee is calculated as:

Transaction Fee = Gas Used × Effective Gas Price

Since the London upgrade (EIP-1559), gas pricing has evolved into a more predictable model composed of three elements:

• Base Fee: Automatically calculated per block and burned (removed from circulation).
• Max Priority Fee (Tip): Incentive paid directly to validators for faster inclusion.
• Max Fee: The upper limit a user is willing to pay per unit of gas.

👉 Discover how blockchain transactions are processed and optimized for speed and cost.

Decoding a Real Ethereum Transaction

Let’s analyze a real transaction from the Goerli testnet where 1 wei (0.000000000000000001 ETH) was sent to a smart contract:

Transaction Hash: 0xf836049be423723eba16b00b84ecfbfde4c98e10a57c153426bd8834a7136a43

Key Fields in the Transaction

Input Data

The "Input Data" field is empty, indicating this is a simple ETH transfer rather than a contract function call.

Gas Fees Breakdown

Modern Ethereum transactions use EIP-1559 pricing mechanics:

Effective Gas Price = Base Fee + Priority Fee

However, users set two values:

• maxFeePerGas: Maximum they’re willing to pay.
• maxPriorityFeePerGas: Maximum tip for validators.

The actual price paid will never exceed the effective network rate, even if the user offers more.

In this example:

• Base Fee: 0.000000111 Gwei (burned)
• Max Priority Fee: 1 Gwei (tip to validator)
• Max Fee Allowed: 1.5 Gwei

Since the market rate was lower than the cap:

Actual Gas Price = 1.000000111 Gwei

Gas Limit & Usage

• Gas Limit: 21,055 units (maximum allowed)
• Gas Used: 21,055 units

Unlike standard external account transfers (which use exactly 21,000 gas), this transaction consumed slightly more due to logic within the receiving contract.

Transaction Fee

Total cost:

21,055 × 1.000000111 Gwei = 0.000021055002337105 ETH

This includes both the base fee (burned) and priority fee (paid to validator).

Burnt & Txn Savings Fee

• Burnt Fee: Base fee portion × gas used
  0.000000111 Gwei × 21,055 = 0.000000000002337105 ETH (destroyed)
• Savings: Difference between max possible fee and actual fee
  (1.5 Gwei - 1.000000111 Gwei) × 21,055 = 0.000010527497662895 ETH

Users benefit because any unused portion of the max fee is refunded automatically.

Value Transferred

The transaction sent exactly 1 wei to the contract—an almost negligible amount used typically for testing or triggering events.

Why Is Gas Usage 21,055 Instead of 21,000?

A standard ETH transfer between externally owned accounts (EOAs) costs exactly 21,000 gas. However, sending ETH to a smart contract can incur additional costs if the contract contains executable code.

In this case, the recipient contract implements a receive() function:

receive() external payable {}

Even though this function appears empty, its presence triggers execution when ETH is received. During deployment or execution, certain initialization steps occur behind the scenes—such as memory allocation via MSTORE—which consume extra gas.

Using tools like Remix IDE’s debugger, we can trace opcodes executed during the transaction. Analysis shows that initial setup operations added 55 extra gas units, bringing the total to 21,055.

For reference:

• MSTORE: Writes data to memory; cost depends on memory expansion.
• Memory growth follows a quadratic pricing model (defined in EIP-1559 specs).

Thus, seemingly simple functions may still generate minor overhead.

👉 Learn how smart contracts interact with gas mechanics during execution.

Querying Transaction Data Using ethers.js v6

You can programmatically retrieve all these details using ethers.js v6, a popular JavaScript library for Ethereum interaction.

Here’s how to fetch block base fee and transaction parameters:

(async () => {
  const ALCHEMY_GOERLI_URL = 'https://eth-goerli.alchemyapi.io/v2/GlaeWuylnNM3uuOo-SAwJxuwTdqHaY5l';
  const goerliProvider = new ethers.JsonRpcProvider(ALCHEMY_GOERLI_URL);

  // Fetch block data to get baseFeePerGas
  const block = await goerliProvider.getBlock(8871803, false);
  console.log(`Block 8871803 baseFeePerGas: ${block.baseFeePerGas} Gwei`);

  // Fetch transaction details
  const tx = await goerliProvider.getTransaction('0xf836049be423723eba16b00b84ecfbfde4c98e10a57c153426bd8834a7136a43');
  console.log(`Transaction maxPriorityFeePerGas: ${tx.maxPriorityFeePerGas}`);
  console.log(`Transaction maxFeePerGas: ${tx.maxFeePerGas}`);
})();

Output:

Block 8871803 baseFeePerGas: 111
Transaction maxPriorityFeePerGas: 1000000000
Transaction maxFeePerGas: 1500000000

These values match those shown on Etherscan, confirming consistency across APIs and explorers.

This approach allows developers to monitor network conditions, estimate fees dynamically, and optimize transaction strategies—essential for dApp development and automated systems.

Frequently Asked Questions (FAQ)

What is the difference between gasPrice and maxFeePerGas?

gasPrice was used in pre-London upgrade transactions as a flat rate per gas unit. Post-EIP-1559, maxFeePerGas sets the ceiling a user is willing to pay, combining base fee and priority fee. The actual price adjusts based on network demand but never exceeds this cap.

Why do some transactions use more than 21,000 gas?

Standard transfers use 21,000 gas. However, sending ETH to contracts with receive() or fallback() functions triggers code execution—even minimal logic like memory writes adds overhead due to EVM opcodes like MSTORE.

What happens to the base fee?

The base fee is permanently burned—removed from the ETH supply—to counter inflation and stabilize network economics under high load.

How is priority fee different from gas tip?

They mean the same thing: an additional payment offered to validators to prioritize your transaction. Higher tips increase chances of quick inclusion in the next block.

Can I lose money by setting a high maxFeePerGas?

No. You only pay what’s necessary up to your maximum. Any excess is refunded automatically. Setting a higher cap protects against sudden spikes in base fees without overpaying.

Does input data affect gas cost?

Yes. Sending data (e.g., calling a function) increases gas usage significantly compared to simple transfers. Empty input means no contract logic runs—keeping costs minimal.

Core Keywords for SEO Optimization

• Ethereum gas fees
• EIP-1559 transaction model
• Base fee vs priority fee
• Smart contract receive function
• Gas usage analysis
• ethers.js v6 tutorial
• Blockchain transaction breakdown
• How Ethereum burns gas

These terms naturally appear throughout this guide, aligning with search intent while maintaining readability and technical accuracy.

👉 Explore advanced tools for monitoring real-time Ethereum gas prices and optimizing your transactions.

By understanding how gas pricing works—from base fees to opcode-level execution—you gain greater control over transaction efficiency and cost management on Ethereum and EVM-compatible networks.