Back to Course

Session 3.7 - Ethereum Jargon

Mastering Ethereum terminology and concepts

Module 3 45 minutes

Learning Objectives

  • Master Ethereum terminology and concepts
  • Understand the Ethereum ecosystem components
  • Navigate Ethereum development tools and resources
  • Communicate effectively using Ethereum terminology
Ethereum Ecosystem — Layers & Components

Ethereum Ecosystem — Layers & Components

Core Blockchain
Ethereum Virtual Machine (EVM) — Execution environment
Consensus Layer — Proof of Stake (validators, finality)
Networking Layer — Peer-to-peer protocol, tx/block propagation
Data Layer — Blocks, state trie, accounts
↓
Development & Infrastructure
Client Software — Geth, Nethermind, Besu, Erigon
Developer Tools — Truffle, Hardhat, Remix IDE, Foundry
Libraries & APIs — web3.js, ethers.js, JSON-RPC
Layer 2 Solutions — Optimism, Arbitrum
↓
Application Layer
Smart Contracts — Solidity, Vyper
Token Standards — ERC-20, ERC-721, ERC-1155
DeFi Protocols — Uniswap, Aave, MakerDAO
NFTs & Gaming — OpenSea, Axie Infinity
↓
User & Access Layer
Wallets — MetaMask, TrustWallet, Ledger, Coinbase Wallet
dApps — Decentralized applications & frontends
Explorers — Etherscan, Blockchair

Ecosystem Flow

Flow: Core blockchain (EVM + PoS) runs on client software → Developer tools & clients → Application layer (smart contracts, DeFi, NFTs) → User layer (wallets, dApps, explorers).

Layers of the Ethereum Ecosystem

1. Core Blockchain
  • EVM: Execution of smart contracts
  • Consensus (PoS): Validators secure the chain
  • Networking: Peer-to-peer transaction/block propagation
  • Data Layer: Blocks, state trie, mempool
2. Development & Infrastructure
  • Clients: Geth, Nethermind, Besu, Erigon
  • Dev Tools: Truffle, Hardhat, Remix, Foundry
  • Libraries/APIs: web3.js, ethers.js, JSON-RPC
  • Layer 2s: Optimism, Arbitrum, zkSync, Polygon
3. Application Layer
  • Smart Contracts: Solidity/Vyper code
  • Token Standards: ERC-20, ERC-721, ERC-1155
  • DeFi: Uniswap, Aave, MakerDAO
  • NFTs & Gaming: OpenSea, Axie, Decentraland
  • DAOs: Decentralized governance
4. User & Access Layer
  • Wallets: MetaMask, Ledger, Coinbase Wallet
  • dApps: Frontends for DeFi, NFTs, DAOs
  • Explorers: Etherscan, Blockchair

Core Ethereum Terms

Essential Vocabulary

Understanding Ethereum terminology is crucial for effective development and communication in the ecosystem.

Ether (ETH)

Native cryptocurrency of Ethereum network, used to pay for transactions and computational services.

Gas

Unit measuring computational effort required to execute operations on Ethereum.

Gwei

Denomination of Ether equal to 10^-9 ETH, commonly used for gas prices.

Block

Collection of transactions bundled together and added to the blockchain.

Hash

Fixed-length string representing data, used for identification and verification.

Nonce

Number used once, prevents replay attacks and enables proof-of-work.

Account and Address Terms

Term Definition Example
EOA Externally Owned Account - controlled by private key User wallets
Contract Account Account controlled by smart contract code DeFi protocols
Address 42-character hexadecimal identifier 0x742d35Cc6634C0532925a3b8D4...
Private Key Secret key controlling an EOA 256-bit random number
Public Key Cryptographic key derived from private key Used for address generation

Development Terms

Smart Contract Terms
  • Solidity: Primary smart contract language
  • Vyper: Python-like contract language
  • ABI: Application Binary Interface
  • Bytecode: Compiled contract code
  • Opcode: EVM operation codes
Ethereum Virtual Machine (EVM) - Layered Architecture

Ethereum Virtual Machine (EVM)

Layered Block Diagram

EVM Architecture Layers

Application Layer (Smart Contracts & dApps)
Solidity, Vyper, etc.
Compiled into EVM bytecode
ABI interface for function calls
↓
Execution Layer (EVM Runtime)
Opcode execution (ADD, SSTORE, CALL, etc.)
Stack-based architecture (max depth 1024)
Memory (temporary per-call, byte-addressable)
Storage (persistent key-value, Merkle Patricia Trie)
↓
Gas & Fee Management
Each opcode has gas cost
Prevents infinite loops / abuse
Unused gas refunded
Applies transactions to state
↓
State Transition Layer
Updates account balances, storage
Deterministic (same input → same output)
Proof of Stake validators order transactions
↓
Consensus Layer
Ensure all nodes agree on the same state
Finality via attestations/checkpoints
↓
Networking Layer
Peer-to-peer (devp2p protocol)
JSON-RPC APIs for external apps
Flow: dApp/contract (source code) → compiler generates bytecode & ABI → EVM (stack, memory, storage) → gas metering ensures limits → state changes applied → consensus validates → networking propagates.

Key: JSON-RPC APIs for external apps

Explanation of EVM Layers

1. Application Layer (Top)

  • Smart contracts written in Solidity, Vyper, etc.
  • Compiled into EVM bytecode
  • Interaction via ABI (Application Binary Interface)

2. Execution Layer (EVM Runtime)

  • Executes opcodes (ADD, CALL, SSTORE, etc.)
  • Stack-based (max depth 1024)
  • Memory: temporary, byte-addressable per call
  • Storage: persistent key-value mapping (saved in Merkle Patricia Trie)

3. Gas & Fee Management

  • Each operation consumes gas
  • Prevents infinite loops (halting guarantee)
  • Unused gas refunded; high-cost ops discourage spam

4. State Transition Layer

  • Applies transactions to world state
  • Updates balances, contract storage, and logs
  • Deterministic: same input → same output on all nodes

5. Consensus Layer

  • Ethereum now uses Proof of Stake (PoS)
  • Validators propose & attest blocks
  • Consensus ensures all nodes agree on final state

6. Networking Layer (Bottom)

  • Peer-to-peer protocol (devp2p)
  • Propagates transactions and blocks
  • Exposes JSON-RPC APIs for dApps, wallets, and explorers
Development Tools
  • Remix: Web-based IDE
  • Truffle: Development framework
  • Hardhat: Development environment
  • Ganache: Local blockchain
  • MetaMask: Browser wallet

DeFi and Token Terms

Token Standards
  • ERC-20: Fungible token standard
  • ERC-721: Non-fungible token (NFT) standard
  • ERC-1155: Multi-token standard
  • ERC-777: Advanced fungible token
DeFi Terms
  • DEX: Decentralized Exchange
  • AMM: Automated Market Maker
  • Liquidity Pool: Token reserves for trading
  • Yield Farming: Earning rewards by providing liquidity
  • Flash Loan: Uncollateralized instant loan
NFT Terms
  • Minting: Creating new NFTs
  • Metadata: NFT properties and attributes
  • IPFS: Decentralized storage for NFT data
  • Royalties: Creator fees on secondary sales
  • Floor Price: Lowest price in collection

Network and Scaling Terms

Networks
  • Mainnet: Main Ethereum network
  • Testnet: Testing networks (Goerli, Sepolia)
  • Devnet: Development networks
  • Fork: Network upgrade or split
Layer 2
  • Rollups: Batch transactions off-chain
  • Sidechains: Parallel blockchains
  • State Channels: Off-chain interactions
  • Plasma: Child chain framework
Sharding
  • Shard: Partition of blockchain
  • Beacon Chain: Ethereum 2.0 coordination layer
  • Validator: Node that validates transactions
  • Staking: Locking ETH to become validator

Security and Consensus Terms

Term Category Definition
Proof of Stake (PoS) Consensus Validators chosen based on stake amount
Proof of Work (PoW) Consensus Miners compete to solve cryptographic puzzles
Slashing Security Penalty for malicious validator behavior
Finality Consensus Point when transaction cannot be reversed
MEV Security Maximal Extractable Value from transaction ordering

Advanced Concepts

Oracles

Definition: Services that provide external data to smart contracts

  • Price Feeds: Real-time asset prices
  • Weather Data: For insurance contracts
  • Sports Results: For betting applications
  • Chainlink: Popular oracle network
Bridges

Definition: Protocols connecting different blockchains

  • Cross-chain: Between different blockchains
  • Wrapped Tokens: Tokens representing assets from other chains
  • Lock and Mint: Common bridge mechanism
  • Multichain: Supporting multiple networks

Governance Terms

Decentralized Governance

How decisions are made in decentralized protocols and organizations.

DAO

Decentralized Autonomous Organization - community-governed entity

Proposal

Suggested change or action submitted for community vote

Governance Token

Token granting voting rights in protocol decisions

Ethereum Glossary — Key Reference

Core Concepts
  • Ethereum Virtual Machine (EVM): The runtime environment that executes smart contracts.
  • Smart Contract: Program deployed on Ethereum, written in Solidity/Vyper, executed by EVM.
  • Gas: The unit of computational cost for executing operations on Ethereum.
  • Gas Limit: Max gas a user is willing to spend on a transaction.
  • Gas Price / Base Fee: The cost per unit of gas; combined with priority fee (tip).
  • Transaction (Tx): Signed data package that changes state (transfer ETH, call contract).
  • Mempool: Temporary pool where pending transactions wait before being mined/validated.
  • Block: A batch of validated transactions, chained cryptographically.
  • Nonce: Number of transactions sent from an address (prevents replay attacks).
  • Address: 20-byte identifier derived from a public key.
  • Account Types:
    • EOA (Externally Owned Account): Controlled by private keys (wallets).
    • Contract Account: Controlled by deployed code (smart contracts).
  • ETH (Ether): Native currency used for gas fees, payments, and staking.
  • Staking / Validators: In Proof-of-Stake, validators lock ETH to propose/attest blocks.
  • Fork: Protocol change (soft fork = backward compatible, hard fork = not).
  • Layer 2 (L2): Scaling solutions on top of Ethereum (Optimism, Arbitrum, zkSync).
  • Rollups: Bundling many transactions off-chain into a single L1 submission.
Smart Contract Keywords
  • ABI (Application Binary Interface): Defines how to encode/decode function calls.
  • Bytecode: Compiled machine-readable code executed on EVM.
  • Constructor: Special function executed once at deployment.
  • Modifiers: Restrict/extend function behavior (e.g., onlyOwner, nonReentrant).
  • Events: Logs emitted by contracts, stored in receipts for off-chain indexing.
  • Fallback / Receive: Special functions for handling unmatched calls or raw ETH transfers.
  • Reentrancy: Vulnerability where external calls re-enter before state update.
  • Multisig: Contract requiring multiple signatures to authorize actions.
Frequently Used ERC Standards
  • ERC-20: Fungible token standard (cryptocurrencies, stablecoins).
    • Functions: totalSupply(), balanceOf(), transfer(), approve(), transferFrom()
  • ERC-721: Non-fungible token (NFT) standard.
    • Functions: ownerOf(), safeTransferFrom(), tokenURI()
  • ERC-1155: Multi-token standard (fungible + non-fungible in one contract).
    • Batch transfer efficiency.
  • ERC-777: Advanced fungible tokens (operator model, hooks).
Wallet & Identity
  • ERC-4337 (Account Abstraction): Smart contract wallets, sponsored transactions.
  • ERC-725: Identity standard for self-sovereign identity.
Utility & Extensions
  • ERC-165: Standard interface detection.
  • ERC-2981: NFT royalty standard.
  • ERC-4626: Tokenized Vaults (DeFi yield aggregators).
  • ERC-1820: Registry of interfaces for contracts.
Quick Mnemonics
  • ERC-20 = Fungible (like ETH, USDT)
  • ERC-721 = Unique NFT (art, land, collectibles)
  • ERC-1155 = Hybrid (gaming assets, multi-token)
  • ERC-4337 = Smart wallets (no private keys, social recovery)

Summary

Key Takeaways
  • Ethereum terminology covers core concepts, development tools, and ecosystem components
  • Understanding gas, addresses, and accounts is fundamental for Ethereum development
  • DeFi and NFT terms are essential for modern blockchain applications
  • Layer 2 solutions and scaling terminology is increasingly important
  • Governance and DAO concepts represent the future of decentralized organizations

What's Next?

Next, we'll explore Ethereum 2.0 and Future Developments.

Next: Ethereum 2.0 Previous: Property Transfer Case Back to Course Home