3.2 ERC-20 (Ethereum)
The Gold Standard of Tokenization
ERC-20 created modern crypto. Before this standard, every token needed custom code. Exchanges wrote unique integrations for each asset. Wallets couldn't display new tokens without updates. The ecosystem was fragmented and unsustainable.
After ERC-20? Anyone could launch a compatible token in hours. The result: over $200 billion in tokens, the ICO boom, and the entire DeFi ecosystem. Every smart contract platform since has copied this blueprint.
Genesis and Motivation
In early Ethereum, before 2015, token creation was chaos. Each development team wrote their own unique smart contract from scratch. Different functions. Different naming conventions. Different operational logic.
This fragmentation created massive friction. Cryptocurrency exchanges, wallet providers, and applications needed custom code for every new token. Inefficient. Error-prone. Unsustainable.
Ethereum developer Fabian Vogelsteller, working with co-founder Vitalik Buterin, recognized this bottleneck. They proposed "Ethereum Request for Comment #20" in November 2015. Ethereum formalized it as EIP-20 in 2017 [1][2].
The goal wasn't inventing new assets. It was creating one standard that every token could follow. Any application could then interact with any ERC-20 token in a predictable, uniform manner. One integration. Thousands of tokens.
Technical Architecture: The ERC-20 Smart Contract Interface
ERC-20 isn't software. It's a rulebook. Six mandatory functions, two events, three optional metadata fields. Follow these rules, and your token works everywhere.
Mandatory Functions
These six functions define how tokens move and track balances:
totalSupply(): Returns total tokens in existence. Fixed supply like Bitcoin's 21 million cap? This number never changes. Mintable like USDC? It increases when Circle creates new tokens.
balanceOf(address _owner): Check any address's token balance. Free to call. No gas required. How your wallet shows your holdings.
transfer(address _to, uint256 _value): Direct peer-to-peer transfers. Send tokens to another address. The contract deducts from your balance, adds to theirs. Simple.
approve(address _spender, uint256 _value): This is where it gets interesting. Instead of sending tokens directly, you authorize a third party (usually a smart contract) to withdraw up to a specified amount from your account. This enables programmatic interactions.
allowance(address _owner, address _spender): Check how many tokens a spender can still withdraw from an owner's account. Set by approve, decreased each time transferFrom gets called.
transferFrom(address _from, address _to, uint256 _value): The spender executes the actual transfer. Moves tokens from the original owner to the final recipient. This mechanism powers all of DeFi.
Here's why approve/transferFrom matters: When you trade on Uniswap, you first approve the Uniswap contract to spend your USDC. Then the contract calls transferFrom to execute the swap. Two steps, but it enables billions in daily trading.
The security trade-off: Many dApps request "infinite" approval for convenience. Grant unlimited spending rights once, never approve again. But if that contract gets hacked or turns malicious, attackers can drain all your tokens. This pattern has cost users hundreds of millions.
Mandatory Events
Events create the audit trail that makes blockchain transactions trackable:
Transfer(address indexed _from, address indexed _to, uint256 _value): Fires whenever tokens move. Logs sender, recipient, amount. How block explorers track every transaction.
Approval(address indexed _owner, address indexed _spender, uint256 _value): Fires when approve gets called. Logs who authorized whom to spend how much.
Optional Functions
Almost every token implements these three functions despite them being technically optional:
name(): Returns the full token name ("Chainlink").
symbol(): Returns the ticker ("LINK").
decimals(): Returns divisibility. 18 is standard, matching Ether's smallest unit (wei). Enables fractional ownership.
These six functions and two events look simple. Watch how they support hundreds of billions in value.
Real-World Applications: ERC-20 in Action
The standard's true power shows in how billions of dollars flow through three very different tokens, each proving ERC-20's versatility.
Tether (USDT): The Liquidity Engine
Tether processes more daily volume than any cryptocurrency except Bitcoin. With over $137 billion in circulation (December 2024), USDT exists across multiple blockchains, but its ERC-20 implementation on Ethereum remains the institutional standard [8]. Banks moving $50 million don't care about $200 gas fees. They care about Ethereum's security guarantees and the deepest liquidity pools in crypto.
Tether's ERC-20 contract includes centralized controls that violate decentralization purists' principles. Tether can freeze addresses. They can blacklist wallets. They can mint new supply at will [9]. This isn't a bug. It's the feature that enabled regulatory compliance, banking partnerships, and institutional adoption at scale. When you're moving billions through traditional finance rails, you need an off switch.
The token processes roughly $50-80 billion in daily trading volume across all chains [10]. Ethereum's portion represents the majority despite higher fees. Traders pay for certainty. Settlement on Ethereum mainnet means finality backed by $40+ billion in staked ETH.
Chainlink (LINK): Infrastructure Money
Chainlink demonstrates ERC-20's role beyond simple transfers. LINK tokens pay for oracle services that connect smart contracts to real-world data. Price feeds. Weather data. Sports scores. API calls. Every request costs LINK.
The network secures over $15 billion in DeFi value through data feeds that update thousands of times daily [11]. Aave checks Chainlink for collateral prices. Synthetix uses it for synthetic assets. GMX relies on it for perpetual trading. When LINK oracles stop working, billions in DeFi stops functioning.
Node operators stake LINK as collateral. Submit bad data, lose your stake. This economic security model works because LINK follows ERC-20. Staking contracts can verify balances, lock tokens, and distribute rewards through standard functions. No custom integration needed across hundreds of protocols.
The token also serves governance purposes. LINK holders vote on network upgrades, fee structures, and treasury management [12]. Standard ERC-20 balance checks determine voting weight. Simple. Transparent. Auditable.
Uniswap (UNI): Governance at Scale
UNI exemplifies fair launch distribution through ERC-20. September 2020: Uniswap airdropped 400 UNI to every address that had used the protocol [13]. Users who'd made a single swap received $1,400 worth of governance rights overnight. Total distribution: 150 million UNI to 250,000 addresses.
This distribution method worked only because UNI followed ERC-20. Wallets displayed it automatically. Users could trade it immediately on the same platform that issued it. No new infrastructure required.
UNI holders now govern a protocol processing $4+ billion in daily volume [14]. Vote on fee splits. Approve grant funding. Control treasury assets worth hundreds of millions. Each vote weighs tokens through standard balanceOf() calls. Delegation works through approve() mechanisms. The entire governance system builds on ERC-20 primitives.
The token also captures value through fee switches under governance consideration. If activated, a percentage of trading fees converts to protocol revenue. UNI holders control this decision through proposals that anyone holding 2.5 million UNI (0.25% of supply) can submit [15].
These three tokens represent $160+ billion in combined value. Different purposes. Different governance models. Different security assumptions. All using identical technical foundations.
Ecosystem Impact: Fueling the ICO Boom and DeFi
ERC-20's adoption reshaped the entire crypto industry. By simplifying the process of creating and issuing new digital assets, it lowered the barrier to entry for blockchain projects and directly fueled the Initial Coin Offering (ICO) boom of 2017-2018. Startups could now raise capital by creating and selling their own tokens to a global pool of investors with relative ease, knowing their asset would be instantly compatible with a growing ecosystem of wallets and exchanges [3].
Beyond fundraising, ERC-20 became the foundational building block for the entire Decentralized Finance (DeFi) movement on Ethereum. The standard's composability makes DeFi possible. Smart contracts interact with each other seamlessly. Governance tokens grant voting rights in protocols. Stablecoins maintain pegs to fiat currencies. Yield-bearing tokens from lending platforms generate returns. Almost all are ERC-20 tokens [4].
This standard enabled a complex, interconnected "money lego" system for lending, borrowing, trading, and asset management, all operating on a decentralized public ledger.
The two-step approve/transferFrom mechanism makes this entire system possible. It allows users to grant DeFi protocols permission to interact with their funds programmatically, enabling complex transactions like swapping one token for another in a liquidity pool. However, this powerful feature also introduces significant security risk.
For convenience, many dApps request "infinite" approval, allowing the contract to spend unlimited amounts of a user's tokens to avoid repeated approval transactions. If that dApp's smart contract contains a vulnerability or gets compromised, attackers can exploit this pre-approved allowance to drain tokens from user wallets. Infinite approvals have become DeFi's biggest attack vector in DeFi, demonstrating how a feature designed for composability can also create systemic risk.
Challenges and Limitations
Despite its monumental success, the ERC-20 standard and Ethereum face significant challenges. The primary limitation is scalability.
Every ERC-20 token transaction must be processed and recorded on Ethereum mainnet. The standard is bound by the blockchain's inherent throughput limits. ERC-20's success created its own problem. Millions of token transactions compete for Ethereum's limited block space. This competition for transaction inclusion results in network congestion and creates extremely high and volatile transaction fees (gas). During periods of peak activity, a simple token transfer can cost tens or even hundreds of dollars, rendering many use cases economically unfeasible [5].
This very success paradoxically created the market conditions for its own competition. High fees and slow transaction times on Ethereum created powerful incentive for developing alternative, higher-throughput Layer 1 blockchains (Solana and Binance Smart Chain) and Layer 2 scaling solutions (Arbitrum and Optimism). These platforms exist specifically to solve the scalability bottlenecks that ERC-20's popularity exposed [4].
The standard itself has known technical shortcomings. A well-documented issue: the inability of a standard ERC-20 contract to reject an incoming transfer. If a user accidentally sends ERC-20 tokens to a smart contract that isn't designed to handle them (like the token contract itself), the tokens become permanently trapped and lost forever. This design flaw led to proposals for improved standards like ERC-223, which introduces a mechanism to prevent such accidental losses, and ERC-777, which offers more advanced functionalities like "hooks" for complex interactions [6].
Evolution and Future Direction
ERC-20 works, which is why most proposed improvements failed to gain traction.
ERC-223: The Safety Upgrade Nobody Adopted
ERC-223 launched in 2017 to fix the "lost tokens" problem [16]. Add a tokenFallback() function that contracts must implement to receive tokens. Send tokens to an unprepared contract, and the transaction reverts instead of locking funds forever.
Clean solution. Obvious improvement. Virtually no adoption.
Network effects beat technical superiority. Every wallet, exchange, and DeFi protocol already supported ERC-20. Switching meant rewriting integrations for marginal benefit. The ecosystem chose the imperfect standard everyone used over the improved standard nobody supported.
ERC-777: Advanced Features, Security Nightmares
ERC-777 arrived in 2017 with hooks that let contracts react to incoming tokens [17]. Seemed powerful. Then came the reentrancy attacks.
Imbtc, Lendf.Me, and other platforms lost millions to ERC-777 exploits [18]. When token transfers trigger function calls in receiving contracts, those contracts can call back before the first transaction completes. This pattern drained funds repeatedly.
The DeFi community's response? Avoid ERC-777 entirely. Major protocols explicitly blacklist it. OpenZeppelin stopped recommending it [19]. The additional features don't justify the security overhead.
ERC-4626: Purpose-Built for DeFi
ERC-4626 represents the successful approach: solve a specific problem for a specific use case [20].
Yield vaults became massive in DeFi, but each implemented different interfaces. Yearn, Rari Capital, Harvest Finance all used unique APIs. Building aggregators required custom code for each vault.
ERC-4626 standardized tokenized vaults with exact functions: deposit(), withdraw(), mint(), redeem(), plus standardized accounting like previewDeposit() and convertToAssets() [21].
Adoption actually happened. Metamask Pools, Balancer Boosted Pools, and major protocols implemented it. Why did this succeed?
Narrow scope: Solves one specific problem well
Clear benefits: Aggregators work immediately
Backward compatible: Extends ERC-20, doesn't replace it
Timing: Launched when yield vaults were already established
What's Actually Being Built
The future isn't replacing ERC-20. It's extending it for specific contexts.
ERC-1155 succeeded for gaming by enabling multiple token types in one contract [22]. ERC-4626 standardized DeFi vaults. Future standards will follow this pattern: identify a common use case, standardize the interface, maintain ERC-20 compatibility.
Account Abstraction (ERC-4337) changes how wallets interact with tokens, not how tokens work [23]. Users might pay gas in USDC instead of ETH, but underlying tokens remain ERC-20.
Permit functions (EIP-2612) add gasless approvals through cryptographic signatures [24]. Users sign messages instead of sending transactions. Optional extension, not replacement.
Why Adoption Is Limited
Every token standard faces the same challenge: switching costs exceed benefits.
ERC-20 integration exists everywhere. Wallet support is universal. Exchange listings are standardized. DeFi protocols know exactly how to handle it. New standards offer marginal improvements but require ecosystem-wide coordination.
Even if your token is 10% better, you lose access to 100% of existing infrastructure. The math doesn't work unless you're solving a problem painful enough that projects rebuild their entire stack.
ERC-4626 succeeded because yield aggregation was already being rebuilt constantly. ERC-223 and ERC-777 solved smaller problems that the ecosystem learned to work around.
Token standards evolve through addition, not replacement. ERC-20 remains the foundation. Specialized standards build on top for new use cases as DeFi matures.
These scalability constraints created an opening for alternative blockchain architectures. While Ethereum pioneered token standardization, its success exposed fundamental bottlenecks. The next generation of platforms would tackle these limitations through radically different technical approaches. None more striking than Solana's complete reimagining of token architecture.
References
[1] Why was the ERC20 Standard created and what they are? - https://medium.com/@ragunath12/why-was-the-erc20-standard-created-and-what-they-are-49d480dce6ab
[2] How ERC-20 Became the Standard for Token Development and What It Can Do for Your Business Growth - https://www.blockchainappfactory.com/blog/how-erc-20-became-standard-token-development-business-growth/
[3] What Are ERC-20 Tokens? All About Ethereum's Most Important Token Standard - https://crypto.com/en/university/what-are-erc-20-tokens-ethereum
[4] The Evolution of ERC-20 Tokens: Past, Present, and Future - https://dev.to/lisaward867/the-evolution-of-erc-20-tokens-past-present-and-future-9nc
[5] What Is The ERC-20 Token Standard? - https://cryptonews.com/academy/what-is-erc-20/
[6] Top ERC Token Standards in 2025 – An Ultimate Guide For Startups - https://www.bitget.com/news/detail/12560604607786
[7] ERC-20: Token Standard - https://eips.ethereum.org/EIPS/eip-20
[8] Tether Market Cap - https://tether.to/en/transparency/
[9] Tether's Blacklist Function - https://www.coindesk.com/tech/2020/07/08/tether-blacklists-39-ethereum-addresses-worth-over-46m/
[10] Tether Trading Volume - https://coinmarketcap.com/currencies/tether/
[11] Chainlink TVS - https://data.chain.link/
[12] Chainlink Governance - https://blog.chain.link/chainlink-staking-roadmap/
[13] Introducing UNI - https://blog.uniswap.org/uni
[14] Uniswap Trading Volume - https://info.uniswap.org/
[15] Uniswap Governance - https://docs.uniswap.org/concepts/governance/overview
[16] ERC-223 Token Standard - https://github.com/ethereum/EIPs/issues/223
[17] ERC-777 Token Standard - https://eips.ethereum.org/EIPS/eip-777
[18] ERC-777 Reentrancy Attacks - https://blog.openzeppelin.com/exploiting-uniswap-from-reentrancy-to-actual-profit
[19] OpenZeppelin ERC-777 Guidance - https://docs.openzeppelin.com/contracts/2.x/api/token/erc777
[20] EIP-4626: Tokenized Vault Standard - https://eips.ethereum.org/EIPS/eip-4626
[21] ERC-4626 Implementation Guide - https://ethereum.org/en/developers/docs/standards/tokens/erc-4626/
[22] ERC-1155 Multi-Token Standard - https://eips.ethereum.org/EIPS/eip-1155
[23] ERC-4337: Account Abstraction - https://eips.ethereum.org/EIPS/eip-4337
[24] EIP-2612: Permit Extension - https://eips.ethereum.org/EIPS/eip-2612
Last updated