Part 4: Ethereum and Smart Contracts. Programmable Money

In Part 3, we followed the money: how Bitcoin actually moves, what miners do, and why proof-of-work is expensive by design. That foundation matters here, because Ethereum starts with the same basic insight and then asks a different question entirely.

Bitcoin asks: how do we move value without a bank?

Ethereum asks: what else can a blockchain do?

The answer turned out to be a lot.

A Computer Nobody Can Turn Off

The one-line pitch that says it all

Ethereum is a computer that nobody can turn off.

That sentence sounds simple. Sit with it for a moment and it gets strange. Every computer you've ever used has an owner. A server farm somewhere. A company that can pull the plug, update the software, or lock your account. Even Bitcoin, for all its decentralization, is primarily a ledger. It records who owns what. It doesn't compute much.

Ethereum computes. It runs programs. Those programs live on a blockchain shared by thousands of nodes around the world, and no single government, company, or person controls whether they keep running. Deploy a program to Ethereum and it executes exactly as written, every time, for as long as the network exists.

Why Ethereum is more than a cryptocurrency

ETH, the currency, is real and valuable. But treating Ethereum as just another coin misses the point. The currency exists to pay for computation. The platform is the product.

This article covers the full picture: smart contracts, gas fees, ERC-20 tokens, decentralized finance, NFTs, and the 2022 event called The Merge that changed how Ethereum works at its core. No prior Ethereum knowledge required. If you know roughly what a blockchain is, you're ready.

What Ethereum Added That Bitcoin Didn't

Bitcoin's intentional simplicity

Bitcoin's scripting language is deliberately limited. Satoshi Nakamoto designed it that way. The goal was a secure, predictable ledger for storing and transferring value. Complex programmability would have introduced complexity, and complexity introduces risk. Bitcoin does one thing and does it well. That's not a weakness. It's a choice.

But some developers looked at that intentional limitation and saw an opportunity.

Vitalik Buterin's big idea

In 2013, a nineteen-year-old programmer named Vitalik Buterin wrote a whitepaper proposing a blockchain with a built-in programming language. The idea was not to replace Bitcoin but to generalize it. Instead of a ledger that only records transactions, what if the ledger could also execute arbitrary programs?

"Ethereum is a platform that makes it possible for any developer to write smart contracts and decentralized applications where they can create their own arbitrary rules for ownership, transaction formats and state transition functions.". Vitalik Buterin, 2013 Ethereum Whitepaper

Buterin's insight was that the trust mechanism underlying Bitcoin, distributed consensus across thousands of nodes, could apply to computation, not just currency transfers. If every node agrees on the state of a ledger, every node can also agree on the output of a program.

A blockchain with a scripting engine

The result is the Ethereum Virtual Machine, or EVM. Think of it as a shared global computer running on thousands of machines simultaneously. When you send a transaction that triggers a program on Ethereum, every node runs that program independently and compares results. If they agree, the outcome is recorded. No single machine controls the result.

Bitcoin records transactions. Ethereum records transactions and executes programs. That distinction is everything.

The network has grown considerably since that launch. What started as an experiment in programmable consensus now processes millions of transactions daily and underpins an entire ecosystem of financial applications, digital assets, and decentralized protocols.

Smart Contracts: Vending Machines, Not Lawyers

The vending machine analogy explained

Picture a vending machine. You insert the correct amount of money, press a button, and the machine releases your snack. No cashier. No negotiation. No possibility the machine decides it doesn't feel like giving you the chips today. The rules are encoded in the machine's mechanism. Meet the conditions, get the outcome.

A smart contract works the same way, except the machine is code on a blockchain and the conditions can represent almost anything of value. Send ETH to this address, and the contract releases a digital asset. Reach a funding goal by a deadline, and the contract distributes the pooled funds. Miss the deadline, and it refunds every contributor automatically.

No intermediary. No waiting for a business to open. No trusting a stranger to follow through.

What a smart contract actually looks like

A smart contract is self-executing code deployed to the Ethereum blockchain with predefined rules written into it. Once deployed, it has its own address, just like a wallet. Anyone can send transactions to that address to interact with it. The contract responds according to its code, not according to anyone's preferences.

Solidity is the primary language for writing Ethereum smart contracts. It looks somewhat like JavaScript, but it compiles down to bytecode that the EVM can run. Developers write the logic, deploy it, and then step back. The contract runs itself.

Here's a concrete example. Suppose two parties agree to a freelance project. Instead of trusting each other or hiring an escrow service, they deploy a smart contract. The client deposits payment into the contract. The contract holds the funds until the freelancer submits proof of completion, at which point the funds release automatically. If the deadline passes without completion, the contract refunds the client. Neither party can override this logic once it's deployed.

Why 'trustless' matters

Trustless doesn't mean you trust nobody. It means you don't have to. You trust the code instead of a person or institution. That's a meaningful shift. Institutions fail, get corrupted, or change their policies. Code deployed to Ethereum executes as written, period.

The vending machine doesn't care if you're in a hurry or if you're having a bad day. It executes the rules. That reliability is the feature, not a limitation.

Gas, Fees, and Why Every Transaction Costs Something

What gas actually is

Every operation on Ethereum requires computation. Addition, storage, comparison, loops: each one costs a measurable amount of work. Gas is the unit that measures that work. It's not a currency itself. It's a unit of computational effort, like measuring distance in kilometers rather than dollars.

The car analogy is useful here. A short trip to the grocery store uses less fuel than a cross-country drive. A simple ETH transfer uses less gas than executing a complex smart contract with multiple conditions and storage operations. More computation, more gas.

How gas prices are determined

Gas is priced in Gwei, which is one billionth of one ETH. When you submit a transaction, you're effectively bidding for inclusion in the next block. The gas limit is the maximum amount of gas you're willing to consume for the transaction. The gas price is what you'll pay per unit of gas.

The EIP-1559 upgrade, implemented in August 2021, changed this model significantly. Instead of a pure auction, the network now sets a base fee for each block based on how full the previous block was. That base fee gets burned, permanently removing ETH from circulation. Users can add an optional priority tip to incentivize validators to include their transaction faster.

Why fees exist and why they fluctuate

Fees aren't arbitrary. They prevent spam. Without a cost per operation, someone could flood the network with meaningless transactions and grind it to a halt. Gas makes that prohibitively expensive.

But fees also spike sharply during congestion. When a popular NFT collection launches or a major DeFi protocol opens a new pool, thousands of users compete to get their transactions into the same blocks. The base fee rises automatically to ration the limited block space.

That number surprised a lot of people. Paying $50 to transfer a token worth $20 doesn't make sense for small transactions. It's one reason Layer 2 solutions exist, and it's a topic worth its own deep look later in this series. For now, the key point is that ETH is the currency used to pay gas regardless of which token you're actually moving. You can hold a thousand different tokens on Ethereum and still need ETH in your wallet to do anything with them.

ERC-20 Tokens: The Standard That Launched a Thousand Coins

What ERC-20 actually means

ERC-20 stands for Ethereum Request for Comment 20. The name is bureaucratic. The concept is elegant. It's a technical standard: a set of rules that any token contract on Ethereum must follow to be compatible with wallets, exchanges, and other contracts.

Think of it like an electrical socket standard. Different devices from different manufacturers all work in the same outlet because they conform to the same spec. ERC-20 does the same thing for tokens. Any wallet that understands the standard can hold any ERC-20 token. Any exchange that supports the standard can list any compliant token without custom integration work.

How tokens differ from ETH itself

ETH is Ethereum's native currency. It's built into the protocol. ERC-20 tokens are different: they're smart contracts deployed on top of Ethereum that track their own internal balances. When you "send" an ERC-20 token, you're actually calling a function on that token's smart contract, which updates its internal ledger to reflect the transfer.

The token isn't ETH. It doesn't behave like ETH at the protocol level. But because it follows the ERC-20 standard, every piece of Ethereum infrastructure treats it consistently.

Anyone can deploy an ERC-20 token. The barrier is low: write a compliant contract, pay the gas to deploy it, and your token exists. This is why there are so many of them.

Real-world examples

Some ERC-20 tokens have real utility and substantial networks behind them. USDC and DAI are stablecoins pegged to the US dollar, used widely in decentralized finance. UNI is the governance token for Uniswap, one of the largest decentralized exchanges. LINK powers the Chainlink oracle network, which feeds real-world data into smart contracts.

Others are worthless. Many are outright scams. The ERC-20 standard guarantees technical compatibility, not legitimacy. A token that follows the spec perfectly can still represent nothing of value, or exist solely to extract money from buyers before the creators disappear.

The standard is neutral. What you do with it is not.

Part 5 takes this infrastructure and asks what happens when you build a financial system on top of it. No banks, no brokers, no intermediaries: just smart contracts, liquidity pools, and protocols that run around the clock. That's decentralized finance, and it's stranger and more interesting than the headlines suggest.

NFTs: What They Actually Are (And Aren't)

Non-fungible explained simply

In Part 3, you learned how ERC-20 tokens work as interchangeable units of value. One USDC equals any other USDC. One ETH equals any other ETH. That interchangeability has a name: fungibility. You can swap one unit for another and nothing changes.

Non-fungible tokens break that rule deliberately. Each one is unique. Token #4721 is not the same as token #4722, even if they come from the same contract. They might look similar, share the same artist, even belong to the same collection. But on-chain, they are distinct objects with distinct histories.

That distinction is the entire point.

The ERC-721 standard

ERC-721 is the token standard that defines non-fungible tokens on Ethereum. Where ERC-20 tracks balances (how many tokens does this address hold?), ERC-721 tracks ownership of individual token IDs (who owns token #4721?).

Each token ID is linked to metadata: typically a JSON file containing a name, description, and a URI pointing to an image or other media. That metadata might live on IPFS, on Arweave, or on a centralized server. The contract itself usually stores only the token ID and the pointer.

Why ownership is on-chain but the image usually isn't

Storing image data directly on Ethereum is prohibitively expensive. A single high-resolution image would cost thousands of dollars in gas to store on-chain. So most NFT contracts store a URI instead, a web address pointing to the actual file. If that server goes offline, the token still exists but the image it pointed to may disappear.

This is a real fragility in the ecosystem, and serious projects address it by using decentralized storage like IPFS with content-addressed hashes.

Beyond digital art, NFTs have genuine utility: verifiable event tickets that can't be counterfeited, in-game assets players actually own, identity credentials, and proof of membership. The speculative frenzy of 2021 and 2022 distorted public perception badly. Prices collapsed, scams proliferated, and the whole category got written off by many observers. But the underlying technology, a standard for unique on-chain ownership, didn't stop working when the bubble deflated.

ERC-1155 extends the model further, allowing a single contract to manage both fungible and non-fungible tokens simultaneously. A game might use one ERC-1155 contract to handle gold coins (fungible) and legendary swords (non-fungible) in the same deployment.

DeFi: Banking Without Banks

What decentralized finance actually means

Traditional finance runs on intermediaries. You deposit money at a bank; the bank lends it out. You want to trade stocks; a broker executes the order. You need a loan; a credit officer reviews your application. Every step involves a trusted third party taking a cut and controlling access.

Decentralized finance, or DeFi, replaces those intermediaries with smart contracts. The contract holds the funds. The contract executes the trade. The contract issues the loan. No compliance department, no business hours, no geographic restrictions. If you have a wallet and the right tokens, you can participate.

That's the promise. The reality is messier, but the core idea holds.

Key DeFi primitives: lending, swapping, earning

Three building blocks underpin most of DeFi.

Decentralized exchanges (DEXs) let users swap one token for another without a centralized order book. Uniswap, the most widely used DEX, pioneered the automated market maker (AMM) model. Instead of matching buyers with sellers, Uniswap uses a formula: x × y = k, where x and y are the reserves of two tokens in a pool. The price adjusts automatically based on the ratio of those reserves. No humans required.

Lending protocols like Aave and Compound let users deposit tokens to earn interest, or borrow against collateral they've locked in. Everything is overcollateralized: if you want to borrow $100 worth of tokens, you might need to lock up $150 in collateral. The contract liquidates your position automatically if the value drops too far.

Liquidity pools are the engine behind both. Users deposit token pairs into a pool and earn a share of trading fees in return. This is yield farming: putting your assets to work inside a protocol and earning rewards for doing so.

Composability is what makes DeFi genuinely interesting. Protocols can be stacked. You deposit ETH into Lido, receive stETH in return, deposit that stETH into Aave as collateral, borrow USDC, and deploy that USDC into a yield strategy. Each layer is a separate smart contract. They interlock like building blocks.

The risks nobody talks about enough

The risks in DeFi are real and serious.

Smart contract exploits happen when attackers find vulnerabilities in contract code. Hundreds of millions of dollars have been drained from protocols this way. Audits reduce the risk; they don't eliminate it. Rug pulls are simpler: developers launch a protocol, attract liquidity, then drain the pool and disappear. Impermanent loss is a subtler risk that affects liquidity providers when token prices diverge significantly from when they deposited.

Complexity is its own risk. Most DeFi interfaces are built for people who already understand the underlying mechanics. A single misclick, a wrong address, a misunderstood approval can result in permanent loss. The contracts don't have a customer service line.

The Merge: How Ethereum Switched Off Its Power Plants

Proof of Work vs. Proof of Stake: a quick recap

For most of its early history, Ethereum used Proof of Work, the same consensus mechanism Bitcoin uses. Miners competed to solve computationally expensive puzzles. The winner added the next block and earned the block reward. Security came from the sheer cost of the computation: attacking the network required controlling more hashing power than everyone else combined.

That security came at a price. Ethereum's Proof of Work network consumed roughly as much electricity as a mid-sized country. The hardware required was specialized, expensive, and generated significant electronic waste.

Proof of Stake replaces computation with collateral. Validators lock up ETH as a security deposit. They're selected to propose and attest to new blocks based on their stake. If they behave honestly, they earn rewards. If they try to cheat, their staked ETH gets slashed, partially or fully destroyed. Security comes from economic skin in the game rather than burned electricity.

What The Merge actually changed

On September 15, 2022, Ethereum executed one of the most technically complex transitions in the history of software. The existing Proof of Work execution layer merged with the Beacon Chain, a separate Proof of Stake chain that had been running in parallel since December 2020. The moment is called The Merge.

The environmental impact was immediate and dramatic. A network that had required industrial-scale mining infrastructure now ran on validators staking ETH from ordinary servers.

"The Merge was the most significant upgrade in Ethereum's history. It changed the security model, the issuance model, and the environmental footprint in a single transition.". Ethereum Foundation documentation

ETH issuance also dropped significantly after The Merge. Miners had earned new ETH as block rewards; validators earn considerably less. Combined with the EIP-1559 fee burn introduced in 2021, ETH issuance can turn net negative during periods of high network activity, making ETH potentially deflationary over time.

What it didn't change

The Merge did not lower gas fees. Gas prices are determined by network demand, not by the consensus mechanism. Anyone who expected cheaper transactions after The Merge was disappointed.

It did not immediately make transactions faster. Block times shifted slightly, from roughly 13 seconds under Proof of Work to a consistent 12 seconds under Proof of Stake, but that's not a meaningful difference for users.

Solo validators must stake exactly 32 ETH to run a validator node. That's a significant capital requirement. Liquid staking protocols like Lido and Rocket Pool solve this by pooling smaller amounts of ETH from many participants. You deposit any amount, receive a liquid token representing your staked position, and earn staking rewards proportionally. Liquid staking has grown substantially since The Merge, though it introduces its own centralization questions when a single protocol controls a large share of staked ETH.

Putting It All Together: The Ethereum Ecosystem at a Glance

How the layers connect

Start at the bottom. The EVM is the execution environment: a global computer that runs bytecode deterministically across every node. Smart contracts are programs deployed to that computer. Token standards like ERC-20 and ERC-721 are conventions written in those contracts, defining how fungible and non-fungible tokens behave. DeFi protocols and NFT platforms are applications built on top of those token standards.

Each layer depends on the one beneath it. A DEX is a smart contract. The tokens it swaps are ERC-20 contracts. The fees it charges are paid in ETH. The whole stack runs on the EVM.

ETH as money, fuel, and collateral

ETH plays three distinct roles simultaneously. It's a currency: people hold it, transfer it, and price things in it. It's fuel: every transaction on Ethereum requires ETH to pay gas fees, which means anyone using the network needs ETH regardless of what they're actually trying to do. And since The Merge, it's collateral: validators stake ETH to participate in consensus, tying the security of the network directly to ETH's economic value.

That triple role is unusual. Most assets serve one function. ETH serves three, and each reinforces the others.

The network effect compounds this. More developers building means more applications. More applications means more users. More users means more transaction fees burned and more demand for ETH. The cycle is self-reinforcing, though it also means the ecosystem inherits Ethereum's real challenges: scalability constraints, user experience complexity that still intimidates newcomers, and growing centralization concerns as large liquid staking providers accumulate influence.

The roadmap ahead addresses some of this. Layer 2 scaling, account abstraction, and future protocol upgrades are all in motion. Part 6 covers scaling in detail.

Check Your Understanding: Key Concepts from Part 4

Part 4 covered what Ethereum can do. Part 5 covers how you actually use it without making an irreversible mistake. Private keys, seed phrases, hardware wallets, phishing attacks: the mechanics of self-custody are where most people get hurt, and where most guides go too light. Part 5 goes deep.