ERC-20 implementation in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - ERC-20 implementation

Start Contract

↓

Define State Variables

↓

Implement totalSupply()

↓

Implement balanceOf()

↓

Implement transfer()

↓

Implement approve()

↓

Implement allowance()

↓

Implement transferFrom()

↓

Emit Events

↓

End Contract

The ERC-20 contract starts by defining variables, then implements each required function step-by-step, emitting events as needed.

Execution Sample

Blockchain / Solidity

contract SimpleToken {
  mapping(address => uint) balances;
  event Transfer(address indexed from, address indexed to, uint value);
  function transfer(address to, uint amount) public returns (bool) {
    require(balances[msg.sender] >= amount);
    balances[msg.sender] -= amount;
    balances[to] += amount;
    emit Transfer(msg.sender, to, amount);
    return true;
  }
}

This code transfers tokens from the sender to another address if the sender has enough balance.

Execution Table

Step	Action	Condition/Check	State Change	Event Emitted	Result
1	Call transfer(to, amount)	balances[msg.sender] >= amount?	No change yet	No	Proceed if true
2	Check sender balance	100 >= 50?	No change	No	True, continue
3	Subtract amount from sender	N/A	balances[msg.sender] = 100 - 50 = 50	No	Updated balance
4	Add amount to receiver	N/A	balances[to] = 0 + 50 = 50	No	Updated balance
5	Emit Transfer event	N/A	No state change	Transfer(msg.sender, to, 50)	Event emitted
6	Return true	N/A	No state change	No	Success
7	End	N/A	Final balances updated	No	Transfer complete

💡 Execution stops after transfer completes successfully or fails if balance check fails.

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
balances[msg.sender]	100	50	50	50
balances[to]	0	0	50	50

Key Moments - 3 Insights

Why do we check if the sender has enough balance before subtracting?

Because if the sender doesn't have enough tokens, the transfer should fail to prevent negative balances. See execution_table step 2 where the condition is checked.

What happens if the balance check fails?

The function stops immediately and does not change any balances or emit events. This prevents invalid transfers. This is implied before step 3 in the execution_table.

Why do we emit a Transfer event after updating balances?

Events notify external apps about token movements. Emitting after balances update ensures the event matches the actual state. See execution_table step 5.

Visual Quiz - 3 Questions

Look at the execution_table, what is balances[msg.sender] after step 3?

A 0

B 100

C 50

D 150

💡 Hint

Check the 'State Change' column at step 3 in the execution_table.

At which step is the Transfer event emitted?

A Step 5

B Step 2

C Step 4

D Step 6

💡 Hint

Look at the 'Event Emitted' column in the execution_table.

If balances[msg.sender] was 30 and amount 50, what would happen?

A Transfer succeeds and balances update

B Transfer fails at balance check

C Transfer event emits but balances unchanged

D balances[to] increases but sender balance unchanged

💡 Hint

Refer to the condition check in step 2 of the execution_table.

Concept Snapshot

ERC-20 contract defines balances and allowances.
Functions: totalSupply(), balanceOf(), transfer(), approve(), allowance(), transferFrom().
transfer() moves tokens if sender has enough balance.
approve() sets allowance for others to spend.
Events (Transfer, Approval) notify token movements.
Checks prevent invalid transfers.

Full Transcript

This visual execution traces a simple ERC-20 token transfer. The contract starts by defining balances. When transfer is called, it first checks if the sender has enough tokens. If yes, it subtracts the amount from sender and adds to receiver. Then it emits a Transfer event to signal the change. Finally, it returns true to indicate success. If the sender lacks tokens, the transfer stops immediately without changing balances or emitting events. This ensures token safety and transparency.