ERC-20 fungible token standard in Blockchain / Solidity - Deep Dive

Overview - ERC-20 fungible token standard

What is it?

ERC-20 is a set of rules that define how tokens work on the Ethereum blockchain. These tokens are fungible, meaning each token is exactly the same as another. The standard makes it easy for different tokens to work with wallets, exchanges, and other smart contracts. It defines how tokens can be transferred, how to check balances, and how to approve spending.

Why it matters

Without ERC-20, every token would behave differently, making it hard to use or trade them. This standard creates a common language so wallets and exchanges can support many tokens easily. It helps build a large ecosystem of tokens that can work together smoothly, enabling things like decentralized finance and token sales.

Where it fits

Before learning ERC-20, you should understand basic blockchain concepts and Ethereum smart contracts. After ERC-20, you can explore more advanced token standards like ERC-721 for unique tokens or ERC-1155 for mixed tokens. You can also learn how to build decentralized applications that use these tokens.

Mental Model

Core Idea

ERC-20 is a shared rulebook that makes all fungible tokens on Ethereum behave the same way so they can be easily used and traded.

Think of it like...

Imagine a vending machine that accepts only standard coins. ERC-20 tokens are like those coins, all the same size and weight, so the machine knows how to accept and count them without confusion.

┌─────────────────────────────┐
│         ERC-20 Token        │
├─────────────┬───────────────┤
│ Functions   │ Description   │
├─────────────┼───────────────┤
│ totalSupply │ Total tokens  │
│ balanceOf   │ Check balance │
│ transfer    │ Send tokens   │
│ approve     │ Allow spending│
│ allowance   │ Check allowance│
│ transferFrom│ Transfer by   │
│             │ approved user │
└─────────────┴───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Fungible Tokens

Concept: Tokens that are identical and interchangeable are called fungible tokens.

Fungible tokens mean one token is exactly the same as another, like dollars or gold coins. This is different from unique tokens, which have distinct identities. ERC-20 tokens are fungible, so you can trade or use any token without caring which one it is.

Result

You know that ERC-20 tokens are all equal and can be swapped freely.

Understanding fungibility is key because it explains why ERC-20 tokens need a standard way to behave identically.

2

Foundation

Basics of Ethereum Smart Contracts

Concept: Smart contracts are programs on Ethereum that control token behavior.

Ethereum lets you write code called smart contracts that run on the blockchain. These contracts can hold tokens, send tokens, and keep track of balances. ERC-20 is a smart contract standard that defines how these programs should work for fungible tokens.

Result

You see that ERC-20 tokens are controlled by smart contracts following specific rules.

Knowing smart contracts lets you understand that ERC-20 is not just a concept but actual code running on Ethereum.

3

Intermediate

Core ERC-20 Functions Explained

🤔Before reading on: do you think ERC-20 tokens can be sent without checking balances first? Commit to your answer.

Concept: ERC-20 defines six main functions that every token contract must have.

The key functions are: - totalSupply(): shows how many tokens exist. - balanceOf(address): shows how many tokens an address owns. - transfer(address, amount): sends tokens from sender to another. - approve(spender, amount): lets another address spend tokens on your behalf. - allowance(owner, spender): shows how many tokens the spender can use. - transferFrom(from, to, amount): lets approved spender transfer tokens. These functions ensure tokens can be moved and tracked safely.

Result

You understand how tokens move and how spending permissions work.

Knowing these functions helps you predict how wallets and apps interact with tokens.

4

Intermediate

Events and Their Role in ERC-20

🤔Before reading on: do you think token transfers are automatically visible to apps without events? Commit to your answer.

Concept: ERC-20 uses events to notify the blockchain and apps about token transfers and approvals.

Events like Transfer and Approval are emitted during token operations. They act like signals that apps listen to, so wallets can update balances and exchanges can track trades. Without events, apps would have to scan the entire blockchain, which is slow and inefficient.

Result

You see how apps stay updated about token activity in real time.

Understanding events explains how the ecosystem stays synchronized without heavy computation.

5

Intermediate

Allowance and Spending Mechanism

🤔Before reading on: do you think anyone can spend your tokens if they know your address? Commit to your answer.

Concept: ERC-20 allows token owners to approve others to spend tokens on their behalf safely.

The approve() function lets you set a limit for another address to spend your tokens. Then that address can use transferFrom() to move tokens up to that limit. This is useful for things like decentralized exchanges or subscriptions where you want to allow spending without giving full control.

Result

You understand how token spending can be delegated securely.

Knowing this prevents security mistakes and enables complex token use cases.

6

Advanced

Common ERC-20 Implementation Pitfalls

🤔Before reading on: do you think failing to check for zero addresses in transfers is safe? Commit to your answer.

Concept: Implementing ERC-20 requires careful checks to avoid bugs and security issues.

Common mistakes include not checking for zero addresses (which can burn tokens unintentionally), not handling integer overflows (which can cause wrong balances), and not emitting events properly. Modern Solidity versions and libraries help prevent these issues, but understanding them is crucial for secure tokens.

Result

You recognize the importance of safe coding practices in token contracts.

Knowing these pitfalls helps you avoid costly bugs and security flaws in production.

7

Expert

ERC-20 Extensions and Limitations

🤔Before reading on: do you think ERC-20 can represent unique assets like collectibles? Commit to your answer.

Concept: ERC-20 is designed for fungible tokens but has limits that led to new standards and extensions.

ERC-20 cannot represent unique or semi-fungible tokens well, which led to standards like ERC-721 and ERC-1155. Also, ERC-20 lacks built-in support for metadata or token snapshots. Extensions like ERC-20 Permit add features like gasless approvals. Understanding these helps you choose the right token standard for your project.

Result

You see where ERC-20 fits and when to use other standards.

Knowing ERC-20's limits prevents misuse and guides better token design choices.

Under the Hood

ERC-20 tokens are smart contracts written in Solidity that store balances in a mapping from addresses to numbers. When a transfer happens, the contract updates these balances and emits events. The blockchain records every transaction, ensuring transparency and immutability. The allowance system uses a nested mapping to track approved spenders and their limits. The Ethereum Virtual Machine executes these contracts deterministically, so everyone agrees on token states.

Why designed this way?

ERC-20 was created to unify token behavior on Ethereum, avoiding fragmentation. Before ERC-20, tokens had different interfaces, making integration hard. The design balances simplicity and functionality, focusing on fungible tokens. It avoids complex features to keep contracts small and gas-efficient. Alternatives existed but were less compatible or more complex, so ERC-20 became the widely accepted standard.

┌───────────────┐        ┌───────────────┐
│   User A      │        │   User B      │
└──────┬────────┘        └──────┬────────┘
       │                        │
       │ transfer(amount)        │
       │──────────────────────▶ │
       │                        │
┌──────▼────────┐        ┌──────▼────────┐
│ ERC-20 Token  │        │  Blockchain   │
│ Smart Contract│        │  Ledger      │
└──────┬────────┘        └──────┬────────┘
       │ update balances           │ record transaction
       │ emit Transfer event       │
       │─────────────────────────▶│
       │                          │
       ▼                          ▼

Myth Busters - 4 Common Misconceptions

Quick: do you think ERC-20 tokens can represent unique collectibles? Commit to yes or no.

Common Belief: ERC-20 tokens can represent any kind of asset, including unique collectibles.

Reality: ERC-20 tokens are fungible and identical; unique collectibles require different standards like ERC-721.

Why it matters: Using ERC-20 for unique items causes confusion and breaks wallet or marketplace support.

Quick: do you think anyone can spend your tokens if they know your address? Commit to yes or no.

Common Belief: If someone knows your Ethereum address, they can spend your ERC-20 tokens.

Reality: Only addresses you approve via the allowance system can spend tokens on your behalf.

Why it matters: Misunderstanding this leads to unnecessary fear or insecure sharing of private keys.

Quick: do you think ERC-20 transfer always succeeds if you call it? Commit to yes or no.

Common Belief: Calling transfer() always moves tokens successfully.

Reality: Transfers can fail if the sender lacks enough balance or if the recipient is the zero address.

Why it matters: Ignoring failure cases can cause lost tokens or broken applications.

Quick: do you think events are optional in ERC-20? Commit to yes or no.

Common Belief: Emitting Transfer and Approval events is optional and only for convenience.

Reality: Events are required by the standard to allow external apps to track token activity.

Why it matters: Skipping events breaks wallet updates and exchange listings.

Expert Zone

1

Some ERC-20 tokens implement additional safety checks like pausing transfers during emergencies, which is not part of the standard but common in practice.

2

The approve() function has a known race condition if not handled carefully; experts use patterns like setting allowance to zero before changing it to prevent double spending.

3

Gas optimization in ERC-20 contracts can significantly reduce transaction costs, but requires deep understanding of Solidity and EVM internals.

When NOT to use

ERC-20 is not suitable for non-fungible tokens or tokens requiring complex metadata or batch operations. Use ERC-721 for unique assets or ERC-1155 for mixed fungible and non-fungible tokens instead.

Production Patterns

In production, ERC-20 tokens often include extensions like minting and burning functions, pausable transfers, and permit signatures for gasless approvals. They are integrated with wallets, decentralized exchanges, and DeFi protocols following the standard strictly to ensure compatibility.

Connections

Banking Systems

Both manage fungible units of value with rules for transfer and balance tracking.

Understanding ERC-20 tokens is like understanding how banks keep track of money and allow transfers securely and transparently.

Software APIs

ERC-20 defines a standard interface like an API that different programs agree to use.

Knowing how APIs work helps grasp why a token standard is needed for interoperability in blockchain.

Supply Chain Management

Both use unique identifiers and tracking, but ERC-20 focuses on identical units, unlike unique items in supply chains.

Comparing ERC-20 to supply chain concepts clarifies the difference between fungible and non-fungible assets.

Common Pitfalls

#1 Sending tokens to the zero address burns them unintentionally.

Wrong approach:

function transfer(address to, uint256 amount) public returns (bool) {
balances[msg.sender] -= amount;
balances[to] += amount;
emit Transfer(msg.sender, to, amount);
return true;
}

Correct approach:

function transfer(address to, uint256 amount) public returns (bool) {
require(to != address(0), "Cannot transfer to zero address");
balances[msg.sender] -= amount;
balances[to] += amount;
emit Transfer(msg.sender, to, amount);
return true;
}

Root cause:

Not validating the recipient address allows tokens to be sent to an unusable address, effectively destroying them.

#2 Changing allowance directly without resetting to zero causes race conditions.

Wrong approach:

function approve(address spender, uint256 amount) public returns (bool) {
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}

Correct approach:

function approve(address spender, uint256 amount) public returns (bool) {
require(amount == 0 || allowances[msg.sender][spender] == 0, "Must reset to zero first");
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}

Root cause:

Directly changing allowance can allow double spending if a spender uses old and new allowances simultaneously.

#3 Not emitting Transfer event after token transfer.

Wrong approach:

function transfer(address to, uint256 amount) public returns (bool) {
balances[msg.sender] -= amount;
balances[to] += amount;
return true;
}

Correct approach:

function transfer(address to, uint256 amount) public returns (bool) {
balances[msg.sender] -= amount;
balances[to] += amount;
emit Transfer(msg.sender, to, amount);
return true;
}

Root cause:

Skipping events breaks external tracking by wallets and exchanges, causing user interfaces to show wrong balances.

Key Takeaways

ERC-20 is a standard that makes all fungible tokens on Ethereum behave the same way, enabling easy use and trading.

It defines key functions and events that smart contracts must implement to track balances and allow transfers safely.

The allowance system lets token owners delegate spending rights securely, enabling complex applications.

Understanding ERC-20's design and limitations helps you build better tokens and choose the right standard for your needs.

Avoiding common pitfalls like zero address transfers and allowance race conditions is essential for secure token contracts.

Practice

1. What is the main purpose of the ERC-20 standard in Ethereum?

easy

A. To ensure tokens have a common set of functions for compatibility

B. To create unique non-fungible tokens

C. To define the Ethereum network consensus rules

D. To manage smart contract deployment costs

Solution

1. Step 1: Understand ERC-20 purpose

   ERC-20 defines a common interface for fungible tokens to work uniformly.

2. Step 2: Identify the correct purpose

   This standard allows wallets and apps to interact with tokens easily by using the same functions.

3. Final Answer:

   To ensure tokens have a common set of functions for compatibility -> Option A

4. Quick Check:

   ERC-20 = Common token interface [OK]

Hint: ERC-20 standardizes token functions for easy use [OK]

Common Mistakes:

• Confusing ERC-20 with NFT standards
• Thinking ERC-20 controls Ethereum network rules
• Assuming ERC-20 manages deployment costs

2. Which of the following is the correct function signature to check a token balance in ERC-20?

easy

A. function balanceOf(address owner) external view returns (uint256);

B. function getBalance(address owner) public returns (uint256);

C. function balance(address owner) external returns (bool);

D. function checkBalance(address owner) public view returns (bool);

Solution

1. Step 1: Recall ERC-20 balance function

   The standard defines balanceOf as a view function returning a uint256 balance.

2. Step 2: Match function signature

   function balanceOf(address owner) external view returns (uint256); matches the exact signature: external view returns (uint256).

3. Final Answer:

   function balanceOf(address owner) external view returns (uint256); -> Option A

4. Quick Check:

   balanceOf = correct signature [OK]

Hint: balanceOf returns uint256 and is a view function [OK]

Common Mistakes:

• Using wrong function name like getBalance
• Missing view keyword for read-only function
• Returning bool instead of uint256

3. Given this Solidity snippet from an ERC-20 token contract:

function transfer(address to, uint256 amount) public returns (bool) {
    if (balances[msg.sender] < amount) {
        return false;
    }
    balances[msg.sender] -= amount;
    balances[to] += amount;
    emit Transfer(msg.sender, to, amount);
    return true;
}

What will transfer return if the sender has 50 tokens and tries to send 60 tokens?

medium

A. true

B. false

C. It will throw an error

D. It will return zero

Solution

1. Step 1: Check sender balance condition

   The function checks if sender's balance is less than amount; if yes, returns false.

2. Step 2: Apply given values

   Sender has 50 tokens but tries to send 60, so condition is true and function returns false.

3. Final Answer:

   false -> Option B

4. Quick Check:

   Insufficient balance returns false [OK]

Hint: Transfer returns false if balance is insufficient [OK]

Common Mistakes:

• Assuming it throws error instead of returning false
• Thinking it returns true regardless
• Confusing return value with event emission

4. Identify the error in this ERC-20 approve function snippet:

function approve(address spender, uint256 amount) public returns (bool) {
    allowances[msg.sender][spender] = amount;
    emit Approval(msg.sender, spender, amount);
    return true;
}

What is the common security issue with this implementation?

medium

A. It does not emit the Approval event

B. It does not check if spender is zero address

C. It allows race condition by directly setting allowance

D. It returns false instead of true

Solution

1. Step 1: Understand approve race condition

   Directly setting allowance can cause race conditions if spender uses old and new allowance simultaneously.

2. Step 2: Identify missing mitigation

   Safe implementations require resetting allowance to zero before changing it to new value to avoid this issue.

3. Final Answer:

   It allows race condition by directly setting allowance -> Option C

4. Quick Check:

   approve race condition = direct allowance set [OK]

Hint: Always reset allowance to zero before changing it [OK]

Common Mistakes:

• Thinking missing zero address check is main issue
• Assuming Approval event is missing
• Believing return value is incorrect

5. You want to create an ERC-20 token that charges a 1% fee on every transfer and sends it to a fee collector address. Which modification to the transfer function correctly implements this?

hard

A. Send full amount to recipient, then send 1% from sender to collector

B. Add 1% to amount, send full amount to recipient, send fee separately

C. Send full amount to recipient and fee collector equally

D. Deduct 1% from amount, send fee to collector, send rest to recipient

Solution

1. Step 1: Calculate fee and net transfer

   Calculate 1% fee from amount, subtract it to get net amount to recipient.

2. Step 2: Transfer fee and net amount correctly

   Send fee to fee collector address and net amount to recipient to implement fee deduction.

3. Final Answer:

   Deduct 1% from amount, send fee to collector, send rest to recipient -> Option D

4. Quick Check:

   Fee deducted and sent correctly = Deduct 1% from amount, send fee to collector, send rest to recipient [OK]

Hint: Subtract fee from amount before sending tokens [OK]

Common Mistakes:

• Adding fee on top of amount instead of deducting
• Sending full amount to recipient and fee separately from sender
• Splitting amount equally between recipient and fee collector