ERC-20 fungible token standard in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - ERC-20 fungible token standard

Contract Deployment

↓

Initialize totalSupply

↓

Balances mapping setup

↓

User calls transfer

↓

Check sender balance >= amount?

No→Fail transaction

Yes↓

Subtract amount from sender

↓

Add amount to receiver

↓

Emit Transfer event

↓

Return success

↓

Other functions: approve, transferFrom, allowance

↓

Update allowances and balances accordingly

↓

Emit Approval event

↓

Return success

↓

End

This flow shows how an ERC-20 token contract is deployed, manages balances, and processes transfers and approvals step-by-step.

Execution Sample

Blockchain / Solidity

contract SimpleToken {
    mapping(address => uint) balances;
    uint totalSupply = 1000;

    constructor() {
        balances[msg.sender] = totalSupply;
    }

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

This code defines a simple ERC-20 token transfer function that moves tokens if the sender has enough balance.

Execution Table

Step	Action	Sender balance	Amount	Receiver balance	Condition (sender balance >= amount)	Result	Return value
1	Initial balances set: sender=1000, receiver=0	1000	N/A	0	N/A	Setup complete	N/A
2	Call transfer(to=receiver, amount=200)	1000	200	0	1000 >= 200 is True	Balances updated	true
3	Subtract 200 from sender	800	200	0	N/A	Sender balance updated	N/A
4	Add 200 to receiver	800	200	200	N/A	Receiver balance updated	N/A
5	Return true to caller	800	200	200	N/A	Transfer successful	true
6	Call transfer(to=receiver, amount=900)	800	900	200	800 >= 900 is False	Transfer failed	false
7	Return false to caller	800	900	200	N/A	Transfer unsuccessful	false

💡 Execution stops when transfer returns false due to insufficient sender balance.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7
balances[sender]	1000	1000	800	800	800	800	800
balances[receiver]	0	0	0	200	200	200	200
amount	N/A	200	200	200	200	900	900
return value	N/A	N/A	N/A	N/A	true	N/A	false

Key Moments - 3 Insights

Why does the transfer fail when the amount is 900 but the sender balance is 800?

Because the condition 'sender balance >= amount' is false (800 >= 900 is false), so the transfer does not proceed and returns false, as shown in step 6 of the execution_table.

What happens to the balances if the transfer amount is exactly equal to the sender's balance?

The transfer succeeds because the condition 'sender balance >= amount' is true when equal. The sender's balance becomes zero, and the receiver's balance increases by that amount, similar to step 2-5 but with amount equal to sender balance.

Why do we emit events like Transfer or Approval in ERC-20?

Events notify external apps about token movements or approvals. Though not shown in the simple code, emitting events after balance changes helps wallets and explorers track token activity.

Visual Quiz - 3 Questions

Look at the execution_table, what is the sender's balance after step 4?

A 1000

B 200

C 800

D 0

💡 Hint

Check the 'balances[sender]' row in variable_tracker after step 4.

At which step does the transfer function return false?

A Step 5

B Step 7

C Step 3

D Step 2

💡 Hint

Look at the 'Return value' column in execution_table for the false return.

If the sender's initial balance was 500 instead of 1000, what would happen at step 2 when transferring 200?

A Transfer would succeed and sender balance becomes 300

B Transfer would succeed and sender balance becomes 700

C Transfer would fail because 500 < 200

D Transfer would fail because 200 > 500

💡 Hint

Compare the condition 'sender balance >= amount' with new balance 500 and amount 200.

Concept Snapshot

ERC-20 is a standard for fungible tokens on Ethereum.
It defines functions like transfer, approve, transferFrom, and events.
Balances are tracked in a mapping from address to uint.
Transfers check sender balance before moving tokens.
Approvals allow others to spend tokens on your behalf.
Events notify external apps of token changes.

Full Transcript

This visual execution trace shows how an ERC-20 token contract works step-by-step. First, the contract is deployed with a total supply and balances are set. When a user calls transfer, the contract checks if the sender has enough tokens. If yes, it subtracts the amount from the sender and adds it to the receiver, then returns true. If not, it returns false and the transfer fails. The variable tracker shows how balances change after each step. Key moments clarify why transfers fail or succeed and the role of events. The quiz tests understanding of balances and return values during execution.