What is an ERC-20 Token - The Standard That Changed Everything

Thousands of different tokens exist on Ethereum today—stablecoins like USDC, DeFi tokens like UNI, yield-bearing assets, governance tokens. Your MetaMask wallet displays them all seamlessly. Uniswap lets you trade between any pair instantly. Lending protocols accept them as collateral without custom integrations. This works because every fungible token on Ethereum follows the same rules.

That standard is ERC-20—the electrical outlet of crypto. Boring infrastructure enabling everything interesting. Without it, every token would need custom wallet support, specialized exchange integrations, and bespoke DeFi implementations. The ecosystem would have fragmented before it began.

What ERC-20 Actually Is

ERC-20 stands for Ethereum Request for Comment number 20, proposed by developer Fabian Vogelsteller in November 2015 and finalized in September 2017. It's the technical standard defining how fungible tokens behave on Ethereum—tokens where every unit is identical and interchangeable, like dollars rather than unique collectibles.

The standard specifies a common interface that all compliant tokens must implement. There are six mandatory functions and two required events. Build your wallet to support this interface once, and it automatically works with thousands of tokens. List one ERC-20 token on your exchange, and the infrastructure to list all of them already exists.

This is standardization creating massive network effects. The more tokens that adopted ERC-20, the more valuable the standard became, creating a self-reinforcing cycle that made it nearly universal.

Why Standards Matter

Before ERC-20, every token on Ethereum worked differently with unique functions and custom interfaces. Building a wallet meant writing separate code for each token. Exchanges needed custom integrations for every listing. DeFi protocols couldn't work with arbitrary tokens without massive engineering effort.

The ecosystem needed a standard so everyone could agree on how tokens should work. ERC-20 provided that common language, making the entire infrastructure composable.

The Six Functions That Run Everything

Let me explain how ERC-20 works using USDC as the example, since it demonstrates every function in real-world usage.

The totalSupply function returns how many USDC tokens exist—currently tens of billions worth. The balanceOf function takes an Ethereum address and returns how many USDC that address owns, like checking your bank balance.

The transfer function handles direct sends. When you transfer 100 USDC to someone, your wallet calls this function specifying the recipient and amount. The contract verifies you have sufficient balance, subtracts 100 from yours, adds 100 to theirs, and emits a Transfer event.

The remaining three functions—approve, transferFrom, and allowance—work together to enable delegated transfers, which is absolutely critical for DeFi. Here's how it works in practice.

Say you want to swap 1000 USDC for ETH on Uniswap. You don't send USDC directly to Uniswap—instead, you call USDC's approve function granting Uniswap permission to spend 1000 USDC on your behalf. This approval doesn't move tokens immediately; it just grants permission and records it in the contract.

Then when you execute the swap, Uniswap's smart contract calls USDC's transferFrom function to actually move the 1000 USDC from your address to Uniswap's liquidity pool. The USDC contract checks that Uniswap has approval to spend that amount, verifies you still have the balance, executes the transfer, and updates the approval to show that permission has been used.

The allowance function lets you or anyone check how much spending permission remains. After Uniswap spends your 1000 USDC, calling allowance for Uniswap on your address returns zero.

Most tokens include three optional elements: a name like "USD Coin," a symbol like "USDC," and a decimals value indicating divisibility. Most use 18 decimals matching ETH, though USDC uses 6.

How Token Balances Actually Work

Tokens don't exist in your wallet. The USDC smart contract maintains a ledger—a giant spreadsheet mapping every Ethereum address to how many tokens it owns. Your wallet holds the private keys to an address that the contract recognizes as owning X tokens.

When you "transfer" tokens, you're signing a transaction that tells the token contract to update its internal ledger—subtract from one address, add to another. The contract executes, updates storage, and emits an event. That's it.

This is why you need ETH to send ERC-20 tokens. The transaction requires computational work by Ethereum validators who get paid in ETH. The token contract doesn't have its own blockchain—it's code running on Ethereum.

Why ERC-20 Enabled DeFi

The killer application for ERC-20 is decentralized finance. Because every token follows the same standard, protocols build on each other like Lego blocks without custom integrations.

Uniswap creates trading pairs for any ERC-20 token automatically. Aave accepts any ERC-20 as collateral. Compound adds new lending markets programmatically. You can deposit USDC into Compound to earn interest, use the received cTokens as collateral in Aave, borrow DAI against that collateral, swap it on Uniswap, and stake it elsewhere for yield—all because everything follows the same interface.

This composability means aggregators like 1inch route trades across any token pairs. Portfolio trackers automatically display all holdings. The infrastructure treats all compliant tokens uniformly, creating liquidity that fragmented custom tokens could never achieve.

The Security Problems Nobody Fixed

The approve function creates a persistent attack vector. When you approve Uniswap for 1000 USDC, that approval stays active until you explicitly revoke it. If the contract gets exploited or turns malicious, it can drain all approved tokens from your address.

Only approve the exact amount you need for immediate use. Never approve unlimited amounts. Use services like Revoke.cash to audit and revoke unnecessary approvals. Some newer implementations support EIP-2612 permits with temporary signature-based approvals, but adoption is limited.

Sending tokens to contract addresses that don't handle them usually means permanent loss. The standard doesn't prevent you from transferring tokens to a contract with no mechanism to transfer them back out.

Scam tokens are everywhere. Scammers create fake USDC tokens with similar names but different contract addresses. Your wallet might even display them because they implement the name and symbol functions correctly. Always verify token contract addresses from official sources before interacting.

Honeypot tokens implement ERC-20 perfectly but add hidden code preventing you from selling. You can buy them fine, but when you try to sell, the transaction fails. Check the contract code on Etherscan or use honeypot detection tools before trading.

Creating Tokens Is Easy, Value Is Hard

Anyone can create an ERC-20 token in minutes using OpenZeppelin's contract wizard. Configure the name, symbol, and initial supply, deploy it for twenty to two hundred dollars in gas fees, and you're done. Technically your token works perfectly.

But creating a token with actual value is extraordinarily hard. The space is littered with perfectly functional tokens that have zero demand, no users, and worthless prices. The 2017-2018 ICO boom saw thousands of projects raise billions by issuing ERC-20 tokens. Many were scams, many more were misguided, but the low barrier also enabled legitimate innovation.

Before creating a token, consider what problem it solves and what sustainable value it provides beyond speculation.

Why ERC-20 Won't Go Away

ERC-20 will remain Ethereum's dominant token standard indefinitely. Network effects and existing infrastructure create enormous switching costs. Every wallet supports it, every exchange lists ERC-20 tokens, every DeFi protocol integrates with it.

The standard evolves through backward-compatible extensions. EIP-2612 adds permit functions for signature-based approvals. ERC-4626 standardizes yield-bearing vault tokens. Layer 2 solutions like Arbitrum and Polygon support ERC-20 natively, extending the standard to faster and cheaper environments.

Other standards like ERC-721 for NFTs and ERC-1155 for multi-token contracts serve specific use cases. But for simple fungible tokens on Ethereum, ERC-20 is infrastructure that works, and working infrastructure tends to persist far longer than theoretically superior alternatives.

The Bottom Line

ERC-20 is boring infrastructure that enabled an entire ecosystem. It democratized token creation, made DeFi composability possible, and created the foundation for thousands of projects. The standard has real limitations and security issues, but its simplicity and universal adoption made it the electrical outlet of crypto.

Understanding ERC-20 means understanding how Ethereum tokens work—the six functions, the approval mechanism, how balances are tracked, and the security risks. Whether you're building on Ethereum, trading tokens, or just trying to understand your wallet, ERC-20 is the invisible standard making it all possible.

References

1. Ethereum.org - "ERC-20 Token Standard" - https://ethereum.org/en/developers/docs/standards/tokens/erc-20/
2. GitHub - "EIP-20: Token Standard" - https://eips.ethereum.org/EIPS/eip-20
3. OpenZeppelin - "ERC-20 Documentation and Contracts" - https://docs.openzeppelin.com/contracts/erc20
4. Etherscan - "Verified ERC-20 Token Contracts" - https://etherscan.io/tokens
5. CoinGecko - "ERC-20 Token Rankings" - https://www.coingecko.com/
6. ConsenSys - "ERC-20 Token Standard Security Best Practices"
7. Fabian Vogelsteller - Original ERC-20 Proposal (2015)
8. Ethereum Improvement Proposals - "Token Standards Documentation" - https://eips.ethereum.org/
9. OpenZeppelin Wizard - "Contract Generator" - https://wizard.openzeppelin.com/
10. Revoke.cash - "Token Approval Management" - https://revoke.cash/