What Is ERC-20? The Ethereum Token Standard Explained

What Is ERC-20?

ERC-20 is a technical standard that defines the rules any fungible token on the Ethereum blockchain must follow. The name breaks down simply: ERC stands for Ethereum Request for Comment — the process by which developers propose and ratify improvements to the Ethereum ecosystem — and 20 is the proposal number assigned to this particular standard when it was submitted in 2015 by developer Fabian Vogelsteller.

Before ERC-20 existed, there was no agreed-upon way to build a token on Ethereum. Every project invented its own approach, with its own function names and its own logic. That fragmentation made it nearly impossible for wallets and exchanges to support any new token without writing completely custom integration code. ERC-20 solved that problem by defining a common interface that every token contract must implement — a shared language that the rest of the ecosystem can rely on.

If you have ever held USDC, LINK, UNI, or AAVE in a wallet, you have used ERC-20 tokens. They are deployed as smart contracts on the Ethereum blockchain, and every single one of them speaks the same standard language.

Why Token Standards Matter

Imagine if every electrical outlet in the world had a different shape. Every device manufacturer would need to produce dozens of different plug types, and plugging in a lamp bought in one country would require an adapter for every other country. The outlet standard is boring infrastructure — but without it, everything above it breaks.

ERC-20 is that outlet standard for Ethereum tokens. When a new token launches and follows the ERC-20 interface, MetaMask can display its balance, Uniswap can trade it, Aave can accept it as collateral, and any Ethereum-compatible exchange can list it — all without any of those platforms writing a single line of custom code for that specific token.

The alternative — the pre-ERC-20 world — required bespoke engineering effort for every single integration. Standards create interoperability, and interoperability is what lets a thriving ecosystem exist at all.

It is also worth understanding where ERC-20 tokens fit in the broader taxonomy of crypto assets. Unlike ETH, which is the native coin of the Ethereum network, ERC-20 tokens are built on top of Ethereum via smart contracts. This is the core distinction covered in the token vs coin comparison: coins are native to their own blockchain; tokens live as contracts on someone else's chain.

The Six Required Functions of ERC-20

A contract qualifies as ERC-20 compliant if — and only if — it implements the following six functions. Each one is a precise, standardized operation that the outside world can call on the contract.

1. 'totalSupply()'

Returns the total number of tokens in existence for this contract. This is a simple read — it does not change any state, it just reports how many tokens were ever created (or remain, if the contract supports burning).

2. 'balanceOf(address)'

Returns the token balance held by a specific address. This is how your wallet knows how many USDC you own: it calls 'balanceOf()' on the USDC contract with your address and displays the result.

3. 'transfer(to, amount)'

Sends tokens from the caller's address to a recipient address. When you send LINK to a friend, this is the function that executes — the caller loses the tokens, the recipient gains them, and an event is emitted on-chain to log the movement.

4. 'approve(spender, amount)'

Authorizes a third-party address — typically a DeFi protocol or exchange contract — to spend up to a specified amount of tokens on your behalf. This is how token approvals work: before Uniswap can swap your tokens, you must first call 'approve()' to grant it that permission. The approval itself does not move any tokens; it only sets a limit.

5. 'allowance(owner, spender)'

A read function that returns the remaining amount a spender is still authorized to transfer on behalf of an owner. If you approved a DEX to spend 1,000 USDC and it has already used 300, 'allowance()' returns 700.

6. 'transferFrom(from, to, amount)'

Executes a token transfer on behalf of an approved spender. Once 'approve()' has been called, the authorized contract uses 'transferFrom()' to actually move the tokens. This two-step pattern — approve then transferFrom — is the engine that powers DEX swaps, lending protocols, and most DeFi interactions.

In addition to these six functions, the ERC-20 standard also defines two events that contracts must emit: 'Transfer' (fired whenever tokens move between addresses) and 'Approval' (fired whenever a new approval is set). These events are what let blockchain explorers and off-chain apps track token activity without reading raw contract state.

Optional but Ubiquitous: Name, Symbol, and Decimals

Three additional functions are technically optional in the ERC-20 specification but are implemented by virtually every real token:

• 'name()' — returns the token's full name, like "USD Coin"
• 'symbol()' — returns the ticker symbol, like "USDC"
• 'decimals()' — returns how many decimal places the token uses (almost always 18, matching ETH, though stablecoins like USDC use 6)

These are why tokens appear with human-readable names and tickers in your wallet rather than just a raw contract address. Without 'decimals()', it would be ambiguous whether a balance of 1000000 means one million tokens or one token with six decimal places.

Real ERC-20 Tokens You Already Know

The list of ERC-20 tokens is extraordinarily long, but the examples that illustrate the standard best are the largest and most widely used:

• USDC and USDT (on Ethereum) — the two dominant stablecoins, each pegged to the US dollar, both implemented as ERC-20 contracts
• LINK — Chainlink's oracle network token, used to pay node operators
• UNI — Uniswap's governance token
• AAVE — the governance and staking token of the Aave lending protocol
• SHIB — Shiba Inu, one of the most widely held meme tokens

Every one of these contracts implements the same six functions. Swap the contract address and you are interacting with a completely different asset, but the interface — the way you call it and the shape of the responses — is identical. That uniformity is the entire point.

How ERC-20 Enabled the ICO Boom

In 2017, the combination of ERC-20's simplicity and Ethereum's permissionless nature created an explosion of token launches known as Initial Coin Offerings (ICOs). Any team could write an ERC-20 contract, deploy it to Ethereum for a few dollars of gas, and begin selling tokens to a global audience within hours. No investment bank, no stock exchange listing, no regulatory gatekeeping.

The result was both remarkable and chaotic. Hundreds of projects raised billions of dollars. Some built meaningful infrastructure that still operates today. Many others were vaporware, failed launches, or outright fraud. The ICO era shaped crypto regulation debates worldwide and left lasting lessons about the double-edged nature of permissionless token creation.

The infrastructure that made it possible — ERC-20 — was neutral. It enabled both the legitimate projects and the scams equally, because a standard does not evaluate intent.

ERC-20 vs ERC-721 vs ERC-1155

ERC-20 is one of several token standards that have emerged on Ethereum, each designed for a different use case. Understanding how they compare clarifies a lot of the token landscape.

ERC-20 tokens are fungible — one USDC is worth exactly the same as any other USDC, just as one dollar bill is interchangeable with any other dollar bill. There is no such thing as a "rare" USDC.

ERC-721 tokens are non-fungible — each token has a unique ID and is distinct from every other token in the collection. This is the standard underlying NFTs: a Bored Ape NFT with ID #1234 is not interchangeable with #5678. The ERC-721 standard added the concept of ownership tracking at the individual token level.

ERC-1155 is a later standard that allows a single contract to manage multiple token types simultaneously — some fungible, some non-fungible. It is particularly efficient for blockchain games that need both in-game currency (fungible) and unique equipment items (non-fungible) within the same contract.

Security Risks Specific to ERC-20

The standard's design introduces a few security considerations that every user interacting with the DeFi ecosystem should understand.

The approve + transferFrom pattern. Because 'approve()' grants a third-party contract the ability to move your tokens, approving a malicious contract is dangerous. If you approve a fake or compromised DEX, that contract can drain up to your approved amount without further interaction from you.

Infinite approvals. Many DeFi interfaces, for convenience, ask you to approve the maximum possible token amount rather than just what is needed for a single transaction. This avoids needing a new approval transaction each time you use the protocol. The tradeoff is that if the protocol is later exploited or compromised, your entire token balance is at risk. Reviewing and revoking unnecessary approvals using tools like Revoke.cash is good security hygiene.

Early implementation vulnerabilities. In the first years of ERC-20 deployment, several implementations suffered from integer overflow bugs and reentrancy vulnerabilities — cases where an attacker could exploit the execution order of operations in the contract to drain funds. Modern Solidity compilers and well-audited libraries have largely mitigated these risks in new contracts, but older deployed tokens may still contain them.

None of these risks are unique to ERC-20 as a standard; they are characteristics of smart contract interaction more broadly. But because ERC-20 defines the approval mechanism explicitly, understanding how 'approve()' works is essential for anyone using Ethereum-based applications.

ERC-20 on Other Blockchains

Many blockchains beyond Ethereum use the Ethereum Virtual Machine (EVM) — the execution environment that runs Ethereum smart contracts. BNB Chain, Polygon, Avalanche, Arbitrum, Optimism, and Base are all EVM-compatible, meaning they can run Ethereum smart contracts with minimal or no modification.

Tokens on these chains are often described as "ERC-20 tokens" because they implement the same interface, but technically they are not on Ethereum mainnet. A USDC token on Polygon lives on Polygon's chain and requires MATIC for gas, not ETH. The token standard is identical; the underlying network is different.

This EVM compatibility is why the ERC-20 interface has effectively become the industry standard for fungible tokens across most of the major blockchain ecosystems, not just Ethereum itself.

How to Verify a Token Is ERC-20

If you want to confirm a specific token follows the ERC-20 standard, Etherscan is the most practical tool:

1. Find the token's contract address (from the project's official website or a known reputable source — never from links in messages or social media)
2. Open the contract on Etherscan and go to the "Contract" tab
3. Look for "Read Contract" — you should see the six required functions listed: 'totalSupply', 'balanceOf', 'transfer', 'approve', 'allowance', and 'transferFrom'
4. If the source code is verified (a green checkmark on Etherscan), you can read the actual Solidity code to confirm the implementation

You can also check current cryptocurrency prices for ERC-20 tokens on major price aggregators, which typically display contract addresses alongside price data.

Watch the live Ethereum price for context on gas costs — every ERC-20 transaction, including approvals and transfers, requires paying gas in ETH on Ethereum mainnet.

Bottom Line

ERC-20 is the foundation beneath most of what people call "crypto tokens." It is a six-function interface that turned Ethereum into a programmable token factory: any team can deploy a standards-compliant token that every wallet, exchange, and protocol in the ecosystem can immediately work with. The standard enabled the ICO era, powers DeFi, and underpins stablecoins that move billions of dollars daily.

Understanding ERC-20 means understanding why the token ecosystem works the way it does — why your MetaMask can hold hundreds of different tokens without special software for each, and why connecting a new DeFi app always starts with an approval step. The plumbing is unglamorous but the implications are significant.

---

This article is for educational purposes only and does not constitute financial, legal, or security advice. Smart contracts carry real risks including bugs, exploits, and loss of funds. Always verify contract addresses from official sources, review token approvals regularly, and do your own research before interacting with any protocol or holding any asset.