ERC-20 Tokens

// Inside ERC-20 contract
mapping(address => uint256) private _balances;

// Example:
// _balances[0x1234...] = 1,000  ← Alice owns 1,000 tokens
// _balances[0x5678...] = 500    ← Bob owns 500 tokens

What the wallet service does:
1. My address: 0x1234...
2. Query USDT contract: balanceOf(0x1234...)
   → Response: 1,000 USDT
3. Query UNI contract: balanceOf(0x1234...)
   → Response: 50 UNI
4. Query LINK contract: balanceOf(0x1234...)
   → Response: 200 LINK
5. Display on screen: "USDT: 1,000 | UNI: 50 | LINK: 200"

// Returns total token supply
// Sum of all tokens owned by all addresses
function totalSupply() public view returns (uint256)

// Returns token balance of a specific address
// Wallets call this function to display tokens
function balanceOf(address account) public view returns (uint256)

// Returns amount of tokens owner approved for spender
// Check the limit that spender can transfer on behalf
function allowance(address owner, address spender) public view returns (uint256)

// Caller transfers amount tokens to recipient
// The most basic transfer method
function transfer(address recipient, uint256 amount) public returns (bool)

// Approves spender to transfer amount tokens on caller's behalf
// Essential function in DeFi
function approve(address spender, uint256 amount) public returns (bool)

// Transfers tokens from sender to recipient within approved amount
// Used together with approve
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool)

// Emitted whenever tokens are transferred
// Emitted on transfer() and transferFrom() calls
event Transfer(address indexed from, address indexed to, uint256 value)

// Emitted when token spending is approved
// Emitted on approve() call
event Approval(address indexed owner, address indexed spender, uint256 value)

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

contract SimpleERC20 {
    // Token information
    string public name = "My Token";
    string public symbol = "MTK";
    uint8 public decimals = 18;

    // Total supply
    uint256 private _totalSupply;

    // Mapping to store each address's balance (this is the ledger!)
    mapping(address => uint256) private _balances;

    // Mapping to store approval records
    mapping(address => mapping(address => uint256)) private _allowances;

    // Events
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    // Constructor: mint initial tokens
    constructor(uint256 initialSupply) {
        _totalSupply = initialSupply * 10**decimals;
        _balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }

    // Query total supply
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    // Query balance
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    // Transfer tokens
    function transfer(address recipient, uint256 amount) public returns (bool) {
        require(recipient != address(0), "Invalid recipient");
        require(_balances[msg.sender] >= amount, "Insufficient balance");

        _balances[msg.sender] -= amount;
        _balances[recipient] += amount;

        emit Transfer(msg.sender, recipient, amount);
        return true;
    }

    // Approve
    function approve(address spender, uint256 amount) public returns (bool) {
        require(spender != address(0), "Invalid spender");

        _allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    // Query allowance
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    // Delegated transfer
    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        require(sender != address(0), "Invalid sender");
        require(recipient != address(0), "Invalid recipient");
        require(_balances[sender] >= amount, "Insufficient balance");
        require(_allowances[sender][msg.sender] >= amount, "Allowance exceeded");

        _balances[sender] -= amount;
        _balances[recipient] += amount;
        _allowances[sender][msg.sender] -= amount;

        emit Transfer(sender, recipient, amount);
        return true;
    }
}

// Alice transfers 100 tokens to Bob
token.transfer(bobAddress, 100);

// What happens inside the contract:
require(_balances[alice] >= 100, "Insufficient balance");
_balances[alice] -= 100;  // Alice: 1000 → 900
_balances[bob] += 100;    // Bob: 500 → 600
emit Transfer(alice, bob, 100);

// Step 1: Alice approves Uniswap contract to use 1000 tokens
token.approve(uniswapAddress, 1000);

// Inside the contract:
_allowances[alice][uniswap] = 1000;  // Record approval
emit Approval(alice, uniswap, 1000);

// Step 2: Uniswap contract moves Alice's tokens to the pool
token.transferFrom(alice, uniswapPoolAddress, 100);

// Inside the contract:
require(_allowances[alice][uniswap] >= 100, "Allowance exceeded");
require(_balances[alice] >= 100, "Insufficient balance");
_balances[alice] -= 100;
_balances[uniswapPool] += 100;
_allowances[alice][uniswap] -= 100;  // Deduct from allowance
emit Transfer(alice, uniswapPool, 100);

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

contract MyToken is ERC20 {
    constructor() ERC20("MyToken", "MTK") {
        // OpenZeppelin ERC20 uses decimals = 18 by default
        // To mint 1,000,000 tokens, pass 1000000 * 10^18
        _mint(msg.sender, 1000000 * 10**18);
    }

    // decimals() is already implemented in ERC20 (default: 18)
    // To use a different value, override it:
    // function decimals() public view virtual override returns (uint8) {
    //     return 6;  // Change to 6 like USDT, USDC
    // }
}