Fungible Tokens

🪙 Token Standards: Your Guide to Fungible Tokens

The Cookie Factory Analogy 🍪

Imagine you own a cookie factory. Every cookie you make is exactly the same—same size, same taste, same value. If someone has 10 cookies, they can trade them with anyone else’s 10 cookies because they’re all identical and interchangeable.

That’s exactly what fungible tokens are in the blockchain world. They’re like digital cookies where every single token is worth exactly the same as any other token of the same type.

🎯 What is ERC-20?

ERC stands for “Ethereum Request for Comment.” It’s like a recipe book that tells everyone how to bake the same kind of cookie.

ERC-20 is the most popular recipe (standard) for creating fungible tokens on Ethereum. It’s a set of rules that all tokens must follow so they can work together smoothly.

Why Do We Need a Standard?

Think about it this way:

• 🔌 All phone chargers used to be different
• 📱 Now USB-C works everywhere
• ✅ Standards make everything compatible!

Without ERC-20, every token would speak a different language. Wallets wouldn’t know how to hold them. Exchanges couldn’t trade them. Chaos!

graph TD
    A["🍪 Token Creator"] --> B["📜 ERC-20 Standard"]
    B --> C["💼 Any Wallet"]
    B --> D["🏪 Any Exchange"]
    B --> E["📱 Any DApp"]
    style B fill:#667eea,stroke:#333,color:#fff

🔧 ERC-20 Core Functions

Every ERC-20 token must have these 6 essential functions. Think of them as the basic skills every token must know:

1. totalSupply() 📊

What it does: Tells you how many tokens exist in total.

function totalSupply()
  returns (uint256)

Example: “There are 1,000,000 CookieCoins in existence.”

2. balanceOf(address) 💰

What it does: Checks how many tokens a specific person owns.

function balanceOf(address owner)
  returns (uint256)

Example: “Alice has 500 CookieCoins in her wallet.”

3. transfer(to, amount) 📤

What it does: Sends tokens from YOUR wallet to someone else.

function transfer(
  address to,
  uint256 amount
) returns (bool)

Example: “I’m sending 50 CookieCoins to Bob.”

4. approve(spender, amount) ✅

What it does: Gives permission for someone else to spend YOUR tokens.

function approve(
  address spender,
  uint256 amount
) returns (bool)

Example: “I allow the CookieShop to take up to 100 of my CookieCoins.”

5. allowance(owner, spender) 🔍

What it does: Checks how many tokens someone is allowed to spend on your behalf.

function allowance(
  address owner,
  address spender
) returns (uint256)

Example: “CookieShop can still spend 75 of Alice’s CookieCoins.”

6. transferFrom(from, to, amount) 🔄

What it does: Moves tokens from one person to another (using your allowance).

function transferFrom(
  address from,
  address to,
  uint256 amount
) returns (bool)

Example: “CookieShop takes 25 CookieCoins from Alice and gives them to Charlie.”

🎫 Token Allowance Mechanism

Here’s a story that explains it perfectly:

The Cookie Shop Story 🏪

Scene 1: Alice has 1000 CookieCoins.

Scene 2: Alice wants to buy things from CookieShop, but she doesn’t want to sit at her computer every time.

Scene 3: Alice says: “CookieShop, you can take UP TO 200 CookieCoins from my wallet whenever I buy something.”

Scene 4: Now CookieShop can automatically deduct cookies when Alice shops—but NEVER more than 200!

graph TD
    A["👩 Alice"] -->|"approve#40;Shop, 200#41;"| B["📜 Token Contract"]
    B -->|Stores Allowance| C["✅ Shop can spend 200"]
    D["🏪 CookieShop"] -->|"transferFrom#40;Alice, Shop, 50#41;"| B
    B -->|Checks Allowance| E["💸 Transfer Success!"]
    E -->|Updates| F["Remaining: 150"]

Why Is This Useful?

• 🤖 DeFi protocols can swap tokens for you
• 🛒 NFT marketplaces can take payment automatically
• 🔄 DEXs can execute trades without your signature every time

⚠️ Safety Tip!

Only approve what you need. Approving unlimited tokens (like type(uint256).max) can be dangerous if the contract is malicious!

🏭 Token Minting

Minting = Creating new tokens out of thin air (like printing new money).

How Minting Works

function mint(
  address to,
  uint256 amount
) {
  totalSupply += amount;
  balances[to] += amount;
}

Real-World Examples:

Who Can Mint?

Not everyone! Usually only:

• 👑 The contract owner
• 🤖 Automated systems (like bridges)
• 🗳️ Governance votes

graph TD
    A["🔑 Authorized Minter"] -->|"mint#40;#41;"| B["📜 Token Contract"]
    B --> C["✨ New Tokens Created"]
    C --> D["📈 Total Supply Increases"]
    C --> E["💰 Recipient Balance Increases"]

🔥 Token Burning

Burning = Destroying tokens forever (like shredding money).

How Burning Works

function burn(uint256 amount) {
  balances[msg.sender] -= amount;
  totalSupply -= amount;
}

The tokens are sent to address 0x0000...dead (the “burn address”)—a wallet nobody can access.

Why Burn Tokens?

Famous Burns:

• 🔥 ETH burns a portion of every transaction fee
• 🔥 BNB does quarterly burns
• 🔥 SHIB burned trillions of tokens

graph TD
    A["👤 Token Holder"] -->|"burn#40;100#41;"| B["📜 Token Contract"]
    B --> C["🔥 Tokens Destroyed"]
    C --> D["📉 Total Supply Decreases"]
    C --> E["💀 Tokens Gone Forever"]

👥 Token Approval Operators

Sometimes you want someone to manage ALL your tokens of a certain type—not just a fixed amount.

The Difference:

When Do We Use Operators?

• 🏦 Vaults that manage your investments
• 🎨 NFT platforms (though ERC-721 uses this more)
• 🔄 DEX routers for complex swaps

Example Pattern:

// Give operator full control
function setOperator(
  address operator,
  bool approved
)

// Check if someone is operator
function isOperator(
  address owner,
  address operator
) returns (bool)

🛡️ OpenZeppelin Contracts

OpenZeppelin is like a trusted cookbook of pre-written, security-audited smart contract code.

Why Use OpenZeppelin?

Instead of writing token code from scratch (risky!), you import battle-tested code:

import "@openzeppelin/contracts/
  token/ERC20/ERC20.sol";

contract MyCookie is ERC20 {
  constructor() ERC20("Cookie", "COOK") {
    _mint(msg.sender, 1000000);
  }
}

That’s it! You now have a fully functional ERC-20 token.

What OpenZeppelin Provides:

The Safety Shield 🛡️

• ✅ Audited by security experts
• ✅ Battle-tested in production
• ✅ Open source and transparent
• ✅ Upgradeable patterns available

graph TD
    A["👨‍💻 Developer"] --> B["📦 OpenZeppelin"]
    B --> C["🔒 Audited Code"]
    C --> D["🚀 Deploy Token"]
    D --> E["✨ Safe & Secure!"]
    style B fill:#48bb78,stroke:#333,color:#fff

🎁 Putting It All Together

Here’s a complete ERC-20 token using OpenZeppelin:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/
  token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/
  token/ERC20/extensions/
  ERC20Burnable.sol";
import "@openzeppelin/contracts/
  access/Ownable.sol";

contract CookieCoin is
  ERC20,
  ERC20Burnable,
  Ownable
{
  constructor()
    ERC20("CookieCoin", "COOKIE")
    Ownable(msg.sender)
  {
    _mint(msg.sender, 1000000 * 10**18);
  }

  function mint(
    address to,
    uint256 amount
  ) public onlyOwner {
    _mint(to, amount);
  }
}

What This Token Can Do:

• ✅ Transfer between wallets
• ✅ Check balances
• ✅ Approve spending
• ✅ Burn tokens (anyone can burn their own)
• ✅ Mint new tokens (only owner)

🚀 Key Takeaways

1. ERC-20 is the universal standard for fungible tokens
2. 6 core functions make tokens work everywhere
3. Allowances let apps spend tokens on your behalf
4. Minting creates new tokens; Burning destroys them
5. OpenZeppelin provides safe, audited code to build on

Remember: Every token you see on Uniswap, every stablecoin you use, every reward token you earn—they all follow these same rules. Now you understand the magic behind the curtain! ✨

You’ve just learned how billions of dollars worth of tokens work. That’s pretty amazing! 🎉