---
# System prepended metadata

title: week3

---

# **Week 3: Under the Hood of Ethereum—Transactions, Gas, Opcodes, and More**

By Week 3 of the Blockfuse Labs Web3 Cohort, I started to realize that Web3 is not just about coding smart contracts or launching dApps. It’s about understanding the engine that powers a decentralized future `and our tutor would always remind us of this fact`. This week felt like peeking under the hood of Ethereum. We didn’t write code (yet), but we studied the very things that make Ethereum what it is—from transactions and gas, to nodes and validators, to opcodes and consensus.

Let’s break down what I learned.
# **Ethereum Accounts: EOAs vs Contract Accounts**

In Ethereum, an account is like a digital identity. There are two main types:

    Externally Owned Accounts (EOAs)
    These are controlled by users like you and me using private keys. They can send ETH, deploy contracts, and trigger actions.

    Contract Accounts
    These are controlled by code, not humans. They act only when called by an EOA or another contract. Think of these like autonomous programs on-chain.

we learned that Only EOAs can initiate transactions. Contracts can only respond to them.
and also, that transactions are the Building Blocks of Activity

# WHAT ARE TRANSACTIONS
A transaction is the action you perform on Ethereum. Whether it’s sending ETH, minting an NFT, or interacting with a smart contract—you’re making a transaction.

Each transaction contains:

    A nonce – to ensure uniqueness

    A gas limit – how much computation you’re paying for

    A fee – how much you’re paying per unit of gas

    A recipient (address), a value, and optional data

We also learned that Ethereum supports different transaction types:

    Legacy (old format)

    Access List (EIP-2930) – helps predefine access to storage

    Dynamic Fee (EIP-1559) – introduced the concept of base fee + tip to make gas pricing predictable

# Gas: Ethereum’s Fuel

This was one of the concepts that finally “clicked” for me especially because i had alot of questions with regards to the manipulations and usage of ether within the ethereum network.

i understood that just like a car needs fuel, Ethereum needs gas to run computations. Every transaction and smart contract function requires gas, and you pay for it in ETH.

we learned that eth paid as gas fee is divided into:

    Base Fee – set by the network (burned)

    Priority Fee (tip) – optional, given to validators

    Max Fee – how much you’re willing to pay overall

Formula:
`Gas Used × (Base Fee + Priority Fee) = Total Fee`

Gas serves multiple purposes:

    Pays validators for processing transactions

    Prevents spam attacks

    Helps prioritize transactions in times of congestion

# Opcodes: The EVM’s Machine Language

We entered into the EVMs workable environment and discovered that the EVM is a stack based machine that performs its operations and computations from a stack. 
we also learned that at the lowest level, the Ethereum Virtual Machine (EVM) doesn't run JavaScript, Solidity, or Python. It runs opcodes like:

    PUSH – add value to stack

    POP – remove value

    ADD, MUL – arithmetic

    SSTORE, SLOAD – storage operations

    CALL – call another contract

    JUMP – move to specific code location

Understanding opcodes gave me a clearer picture of how smart contracts are really executed on-chain.

# Blocks and How They’re Formed

A block is like a container that holds multiple transactions. Each block contains:

    A batch of verified transactions

    Timestamp and metadata

    Hash of the previous block (which creates the chain in blockchain)

When users send transactions, they go into a mempool. Validators are then selected at random to bundle some of these into a block and add it to the blockchain. Once added, it becomes part of Ethereum’s permanent history.
Validators and Ethereum Clients

Since (The Merge) Ethereum moved from Proof of Work to Proof of Stake (thanks to EIP-3675), validators now do the job miners used to do.

Validators:

    Stake 32 ETH to join

    Propose/attest to new blocks

    Get rewarded or penalized based on behavior

We also learned about Ethereum clients, which come in two main types:

    Execution Clients (e.g., Geth, Nethermind) – execute transactions

    Consensus Clients (e.g., Lighthouse, Prysm) – coordinate validators

This client separation improves decentralization and helps Ethereum scale better.

# EIPs: How Ethereum Evolves

Ethereum evolves through Ethereum Improvement Proposals (EIPs). Here are a few we discussed:

    EIP-1559 – Introduced dynamic gas fees and burning base fees

    EIP-3675 – Transition from PoW to PoS

    EIP-2930 – Access list for gas optimization

we also learned how an EIP isnt just created out of the blue, you have to follow standards and procedure that is properly laid down in EIP-1.

The EIPs show how Ethereum keeps improving through a community-driven process—a true open-source evolution.

# Nodes and the Ethereum Network

Nodes are the computers that run the Ethereum protocol. They:

    Store a copy of the blockchain

    Validate transactions

    Share information with other nodes

    Run the EVM

There are different kinds of nodes:

    Full Nodes – store the full state

    Light Nodes – download minimal data

    Validator Nodes – actively participate in consensus

Without nodes, the Ethereum network simply wouldn't exist.

we learned that these nodes have to stay in sync and each have to hold the recent state of the blockchian in order for the network to remain decentralized and secure.


# Conclusion

This week wasn’t about writing code,but about understanding why and how things work under the surface. Ethereum is more than just a chain of blocks, it’s a powerful system built on rules, incentives, and decentralized architecture. The more I learn about it, the more I respect its design.

I now see why blockchain education starts here—before the code, you must understand the logic behind the ecosystem you’re building on.

