ERC Token Standards: Your Simplified Guide

TL;DR

ERC token standards are technical blueprints defining how tokens operate on Ethereum. The seven key standards are:

ERC-20 – Fungible tokens like cryptocurrencies and stablecoins
ERC-721 – Unique NFTs and digital collectibles
ERC-1155 – Efficient multi-token management for gaming and complex projects
ERC-777 – Enhanced token operations with programmable hooks
ERC-4337 – Smart contract wallets with social recovery and gas abstraction
ERC-2981 – Standardized NFT creator royalties
ERC-3525 – Semi-fungible tokens for financial instruments

These standards enable seamless interoperability across wallets, exchanges, and dApps in the Ethereum ecosystem.

What Are ERC Token Standards?

ERC stands for Ethereum Request for Comments. Think of ERC standards as instruction manuals telling tokens how to behave on Ethereum. Without them, every token would work differently and wallets couldn’t handle them.

The Ethereum Improvement Proposal process lets developers propose new standards for community review and adoption. Once a proposal gains consensus, it becomes an official ERC standard. This collaborative approach creates a robust ecosystem where innovation happens through community consensus.

These standards specify functions tokens must support, like transferring ownership or checking balances. When developers follow these rules, their tokens work with existing wallets, exchanges, and applications automatically.

What are the Different Standards of ERC Tokens?

If you’ve ever wondered why your crypto wallet handles thousands of different tokens seamlessly, you have ERC standards to thank. These blueprints make the Ethereum ecosystem work smoothly, letting developers create interoperable tokens.

1. ERC-20: The Fungible Token Standard

What It Does: Creates interchangeable tokens where each unit is identical to every other unit.

When to Use: Cryptocurrencies, utility tokens, governance tokens, stablecoins, reward points.

ERC-20 launched in 2015 and became the gold standard for fungible tokens on Ethereum. Its simplicity defines just six mandatory functions and two optional ones, making implementation easy while ensuring universal compatibility.

The standard requires functions like transfer() for sending tokens, balanceOf() to check holdings, and approve() to authorize spending. These building blocks enable DeFi protocols to work with any ERC-20 token without custom integration.

Popular ERC-20 tokens include USDT, USDC, and thousands of project tokens. The standard’s success proves simple solutions often work best.

Key Features:

Total supply tracking
Balance checking for any address
Direct transfer between addresses
Approval system for third-party spending
Transfer-on-behalf functionality

Example Code:

pragma solidity ^0.8.0;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract MyToken is IERC20 {
    string public constant name = "MyToken";
    string public constant symbol = "MTK";
    uint8 public constant decimals = 18;
    
    uint256 private _totalSupply = 1000000 * 10 ** uint256(decimals);
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    constructor() {
        _balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }

    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

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

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

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

    function approve(address spender, uint256 amount) public override returns (bool) {
        require(spender != address(0), "Approve to zero address");
        
        _allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
        require(sender != address(0), "Transfer from zero address");
        require(recipient != address(0), "Transfer to zero address");
        require(_balances[sender] >= amount, "Insufficient balance");
        require(_allowances[sender][msg.sender] >= amount, "Insufficient allowance");
        
        _balances[sender] -= amount;
        _balances[recipient] += amount;
        _allowances[sender][msg.sender] -= amount;
        emit Transfer(sender, recipient, amount);
        return true;
    }
}

pragma solidity ^0.8.0;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract MyToken is IERC20 {
    string public constant name = "MyToken";
    string public constant symbol = "MTK";
    uint8 public constant decimals = 18;
    
    uint256 private _totalSupply = 1000000 * 10 ** uint256(decimals);
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    constructor() {
        _balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }

    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

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

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

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

    function approve(address spender, uint256 amount) public override returns (bool) {
        require(spender != address(0), "Approve to zero address");
        
        _allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
        require(sender != address(0), "Transfer from zero address");
        require(recipient != address(0), "Transfer to zero address");
        require(_balances[sender] >= amount, "Insufficient balance");
        require(_allowances[sender][msg.sender] >= amount, "Insufficient allowance");
        
        _balances[sender] -= amount;
        _balances[recipient] += amount;
        _allowances[sender][msg.sender] -= amount;
        emit Transfer(sender, recipient, amount);
        return true;
    }
}

2. ERC-721: The Non-Fungible Token Standard

What It Does: Creates unique, non-interchangeable tokens where each token has distinct properties.

When to Use: Digital art, collectibles, game items, real estate titles, identity tokens.

ERC-721 revolutionized digital ownership when it launched in 2018, sparking the NFT boom. Unlike ERC-20 tokens, each ERC-721 token is unique with its own metadata, perfect for representing one-of-a-kind assets.

The standard introduced token IDs – unique identifiers distinguishing each NFT. This innovation enabled creators to represent digital art, concert tickets, and more on the blockchain.

Projects like CryptoPunks and Bored Ape Yacht Club demonstrated ERC-721’s power for creating digital communities. The standard includes functions for ownership tracking, safe transfers, and marketplace approval.

Key Features:

Unique token identification system
Owner tracking for each token
Safe transfer mechanisms with callback validation
Metadata links for storing token information
Approval system for marketplace interactions

Example Code:

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

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract MyNFT is ERC721URIStorage, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor() ERC721("MyNFT", "MNFT") {}

    function mintNFT(address recipient, string memory tokenURI) 
        public 
        onlyOwner 
        returns (uint256) 
    {
        _tokenIds.increment();
        uint256 newItemId = _tokenIds.current();
        
        _mint(recipient, newItemId);
        _setTokenURI(newItemId, tokenURI);
        
        return newItemId;
    }
}

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

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract MyNFT is ERC721URIStorage, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor() ERC721("MyNFT", "MNFT") {}

    function mintNFT(address recipient, string memory tokenURI) 
        public 
        onlyOwner 
        returns (uint256) 
    {
        _tokenIds.increment();
        uint256 newItemId = _tokenIds.current();
        
        _mint(recipient, newItemId);
        _setTokenURI(newItemId, tokenURI);
        
        return newItemId;
    }
}

3. ERC-1155: The Multi-Token Standard

What It Does: Manages multiple token types (both fungible and non-fungible) in a single contract.

When to Use: Gaming assets, complex NFT projects, supply chain tracking, fractional ownership.

ERC-1155 emerged in 2019 to solve gas efficiency when managing multiple token types. Before this, projects needed separate contracts per token type, causing expensive deployments. This standard changed that by allowing unlimited token types in one contract.

Gaming quickly adopted ERC-1155 because games need both fungible items and unique items. One contract manages all assets efficiently, reducing gas costs by up to 90% compared to multiple ERC-721 contracts.

Batch operations are another breakthrough feature. You can transfer 100 different tokens in one transaction instead of 100 separate ones.

Key Features:

Multiple token types in one contract
Batch transfer operations
Batch balance queries
Significant gas savings
Atomic swaps between token types

Example Code:

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

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyMultiToken is ERC1155, Ownable {
    uint256 public constant GOLD = 0;
    uint256 public constant SILVER = 1;
    uint256 public constant THORS_HAMMER = 2;

    constructor() 
        ERC1155("https://game.example/api/item/{id}.json") 
        Ownable(msg.sender) 
    {
        _mint(msg.sender, GOLD, 1000, "");
        _mint(msg.sender, SILVER, 1000, "");
        _mint(msg.sender, THORS_HAMMER, 1, "");
    }

    function mint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public onlyOwner {
        _mint(account, id, amount, data);
    }

    function mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public onlyOwner {
        _mintBatch(to, ids, amounts, data);
    }

    function setURI(string memory newuri) public onlyOwner {
        _setURI(newuri);
    }
}

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

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyMultiToken is ERC1155, Ownable {
    uint256 public constant GOLD = 0;
    uint256 public constant SILVER = 1;
    uint256 public constant THORS_HAMMER = 2;

    constructor() 
        ERC1155("https://game.example/api/item/{id}.json") 
        Ownable(msg.sender) 
    {
        _mint(msg.sender, GOLD, 1000, "");
        _mint(msg.sender, SILVER, 1000, "");
        _mint(msg.sender, THORS_HAMMER, 1, "");
    }

    function mint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public onlyOwner {
        _mint(account, id, amount, data);
    }

    function mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public onlyOwner {
        _mintBatch(to, ids, amounts, data);
    }

    function setURI(string memory newuri) public onlyOwner {
        _setURI(newuri);
    }
}

4. ERC-777: Enhanced Token Operations

What It Does: Improves upon ERC-20 with hooks, operators, and better transaction handling.

When to Use: Advanced DeFi protocols, subscription services, automated payment systems.

ERC-777 launched in 2017 as a backward-compatible upgrade to ERC-20. It introduces hooks – functions executing automatically when tokens are received. This enables smart contracts to react to incoming tokens without requiring second transactions.

The operator system is another innovation in ERC-777. Operators are authorized addresses managing tokens on your behalf. This is more flexible than ERC-20’s approval mechanism.

Key Features:

Send and receive hooks for automation
Operator system for delegated control
ERC-20 backward compatibility

Example Code:

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

import "@openzeppelin/contracts/token/ERC777/ERC777.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyERC777Token is ERC777, Ownable {
    constructor(
        address[] memory defaultOperators
    ) 
        ERC777("MyERC777Token", "M777", defaultOperators) 
        Ownable(msg.sender)
    {
        // Mint 1 million tokens to contract deployer
        _mint(msg.sender, 1000000 * 10 ** 18, "", "");
    }

    // Mint new tokens (only owner)
    function mint(
        address account,
        uint256 amount,
        bytes memory userData,
        bytes memory operatorData
    ) public onlyOwner {
        _mint(account, amount, userData, operatorData);
    }

    // Burn tokens
    function burn(uint256 amount, bytes memory data) public {
        _burn(msg.sender, amount, data);
    }
}

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

import "@openzeppelin/contracts/token/ERC777/ERC777.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyERC777Token is ERC777, Ownable {
    constructor(
        address[] memory defaultOperators
    ) 
        ERC777("MyERC777Token", "M777", defaultOperators) 
        Ownable(msg.sender)
    {
        // Mint 1 million tokens to contract deployer
        _mint(msg.sender, 1000000 * 10 ** 18, "", "");
    }

    // Mint new tokens (only owner)
    function mint(
        address account,
        uint256 amount,
        bytes memory userData,
        bytes memory operatorData
    ) public onlyOwner {
        _mint(account, amount, userData, operatorData);
    }

    // Burn tokens
    function burn(uint256 amount, bytes memory data) public {
        _burn(msg.sender, amount, data);
    }
}

5. ERC-4337: Account Abstraction Revolution

What It Does: Enables smart contract wallets with programmable features without protocol changes.

When to Use: User-friendly wallets, social recovery, gas abstraction, batch operations.

ERC-4337 represents Ethereum’s future, approved in 2023 and gaining adoption in 2026. The standard enables account abstraction, meaning wallets can be smart contracts with custom logic.

Social recovery is one game-changing feature. Instead of losing everything if you forget your seed phrase, trusted contacts can help recover access. This makes crypto accessible to mainstream users.

Gas abstraction is another killer feature. Projects can pay gas fees for users or let users pay in any token. This removes a major barrier to entry.

Key Features:

Smart contract wallet support
Social recovery mechanisms
Flexible gas payments
Batch transactions
Custom signature verification

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyNFTWithRoyalty is ERC721, ERC2981, Ownable {
    uint256 private _tokenIdCounter;
    
    // Default royalty info: 5% (500 basis points) to contract owner
    uint96 public constant DEFAULT_ROYALTY_FRACTION = 500; // 5%
    
    constructor() 
        ERC721("MyNFTWithRoyalty", "MNFTR") 
        Ownable(msg.sender)
    {
        // Set default royalty: 5% to contract owner
        _setDefaultRoyalty(msg.sender, DEFAULT_ROYALTY_FRACTION);
    }

    function mint(address to) public onlyOwner returns (uint256) {
        uint256 tokenId = _tokenIdCounter;
        _tokenIdCounter++;
        _mint(to, tokenId);
        return tokenId;
    }

    // Set royalty for a specific token
    function setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) public onlyOwner {
        _setTokenRoyalty(tokenId, receiver, feeNumerator);
    }

    // Update default royalty for all tokens
    function setDefaultRoyalty(
        address receiver,
        uint96 feeNumerator
    ) public onlyOwner {
        _setDefaultRoyalty(receiver, feeNumerator);
    }

    // Delete default royalty
    function deleteDefaultRoyalty() public onlyOwner {
        _deleteDefaultRoyalty();
    }

    // Reset royalty for a specific token to default
    function resetTokenRoyalty(uint256 tokenId) public onlyOwner {
        _resetTokenRoyalty(tokenId);
    }

    // Required override for ERC2981
    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC2981)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyNFTWithRoyalty is ERC721, ERC2981, Ownable {
    uint256 private _tokenIdCounter;
    
    // Default royalty info: 5% (500 basis points) to contract owner
    uint96 public constant DEFAULT_ROYALTY_FRACTION = 500; // 5%
    
    constructor() 
        ERC721("MyNFTWithRoyalty", "MNFTR") 
        Ownable(msg.sender)
    {
        // Set default royalty: 5% to contract owner
        _setDefaultRoyalty(msg.sender, DEFAULT_ROYALTY_FRACTION);
    }

    function mint(address to) public onlyOwner returns (uint256) {
        uint256 tokenId = _tokenIdCounter;
        _tokenIdCounter++;
        _mint(to, tokenId);
        return tokenId;
    }

    // Set royalty for a specific token
    function setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) public onlyOwner {
        _setTokenRoyalty(tokenId, receiver, feeNumerator);
    }

    // Update default royalty for all tokens
    function setDefaultRoyalty(
        address receiver,
        uint96 feeNumerator
    ) public onlyOwner {
        _setDefaultRoyalty(receiver, feeNumerator);
    }

    // Delete default royalty
    function deleteDefaultRoyalty() public onlyOwner {
        _deleteDefaultRoyalty();
    }

    // Reset royalty for a specific token to default
    function resetTokenRoyalty(uint256 tokenId) public onlyOwner {
        _resetTokenRoyalty(tokenId);
    }

    // Required override for ERC2981
    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC2981)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

6. ERC-2981: NFT Royalty Standard

What It Does: Implements standardized royalty payments for NFT creators on secondary sales.

When to Use: NFT marketplaces, digital art platforms, creator monetization.

ERC-2981 solved a crucial problem – consistent royalty payments for creators. Before this, each marketplace implemented royalties differently or not at all.

The standard provides a simple interface for marketplaces to query royalty information. When someone buys an NFT, the creator automatically receives their designated percentage.

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

// This is a simplified implementation for demonstration
// For production, use: https://github.com/solv-finance/erc-3525

contract ERC3525SimplifiedExample {
    string public name = "Semi-Fungible Token";
    string public symbol = "SFT";
    uint8 public decimals = 18;
    
    uint256 private _tokenIdCounter;
    
    struct TokenData {
        uint256 slot;      // Category/type of token
        uint256 value;     // Fungible value within the slot
        address owner;
        address approved;
    }
    
    // tokenId => TokenData
    mapping(uint256 => TokenData) private _tokens;
    
    // owner => operator => approved
    mapping(address => mapping(address => bool)) private _operatorApprovals;
    
    // slot => totalValue
    mapping(uint256 => uint256) private _slotTotalValue;
    
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 indexed tokenId
    );
    
    event TransferValue(
        uint256 indexed fromTokenId,
        uint256 indexed toTokenId,
        uint256 value
    );
    
    event SlotChanged(
        uint256 indexed tokenId,
        uint256 indexed oldSlot,
        uint256 indexed newSlot
    );
    
    event ApprovalValue(
        uint256 indexed tokenId,
        address indexed operator,
        uint256 value
    );

    // Mint a new token with specific slot and value
    function mint(
        address to,
        uint256 slot,
        uint256 value
    ) public returns (uint256 tokenId) {
        require(to != address(0), "Mint to zero address");
        require(value > 0, "Value must be positive");
        
        tokenId = _tokenIdCounter++;
        
        _tokens[tokenId] = TokenData({
            slot: slot,
            value: value,
            owner: to,
            approved: address(0)
        });
        
        _slotTotalValue[slot] += value;
        
        emit Transfer(address(0), to, tokenId);
    }

    // Get token slot
    function slotOf(uint256 tokenId) public view returns (uint256) {
        require(_exists(tokenId), "Token does not exist");
        return _tokens[tokenId].slot;
    }

    // Get token value
    function balanceOf(uint256 tokenId) public view returns (uint256) {
        require(_exists(tokenId), "Token does not exist");
        return _tokens[tokenId].value;
    }

    // Get token owner
    function ownerOf(uint256 tokenId) public view returns (address) {
        require(_exists(tokenId), "Token does not exist");
        return _tokens[tokenId].owner;
    }

    // Transfer entire token (like ERC-721)
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public {
        require(_isApprovedOrOwner(msg.sender, tokenId), "Not approved");
        require(_tokens[tokenId].owner == from, "Not owner");
        require(to != address(0), "Transfer to zero address");
        
        _tokens[tokenId].owner = to;
        _tokens[tokenId].approved = address(0);
        
        emit Transfer(from, to, tokenId);
    }

    // Transfer value from one token to another (Semi-Fungible feature!)
    function transferValueFrom(
        uint256 fromTokenId,
        uint256 toTokenId,
        uint256 value
    ) public {
        require(_exists(fromTokenId), "From token does not exist");
        require(_exists(toTokenId), "To token does not exist");
        require(
            _tokens[fromTokenId].slot == _tokens[toTokenId].slot,
            "Slots must match"
        );
        require(
            _isApprovedOrOwner(msg.sender, fromTokenId),
            "Not approved"
        );
        require(_tokens[fromTokenId].value >= value, "Insufficient value");
        
        _tokens[fromTokenId].value -= value;
        _tokens[toTokenId].value += value;
        
        emit TransferValue(fromTokenId, toTokenId, value);
        
        // If source token has zero value, it can be burned
        if (_tokens[fromTokenId].value == 0) {
            address owner = _tokens[fromTokenId].owner;
            delete _tokens[fromTokenId];
            emit Transfer(owner, address(0), fromTokenId);
        }
    }

    // Transfer value to new token (mints new token with transferred value)
    function transferValueFrom(
        uint256 fromTokenId,
        address to,
        uint256 value
    ) public returns (uint256 newTokenId) {
        require(_exists(fromTokenId), "Token does not exist");
        require(to != address(0), "Transfer to zero address");
        require(
            _isApprovedOrOwner(msg.sender, fromTokenId),
            "Not approved"
        );
        require(_tokens[fromTokenId].value >= value, "Insufficient value");
        
        uint256 slot = _tokens[fromTokenId].slot;
        
        // Deduct value from source token
        _tokens[fromTokenId].value -= value;
        
        // Create new token with transferred value
        newTokenId = _tokenIdCounter++;
        _tokens[newTokenId] = TokenData({
            slot: slot,
            value: value,
            owner: to,
            approved: address(0)
        });
        
        emit TransferValue(fromTokenId, newTokenId, value);
        emit Transfer(address(0), to, newTokenId);
        
        // If source token has zero value, burn it
        if (_tokens[fromTokenId].value == 0) {
            address owner = _tokens[fromTokenId].owner;
            delete _tokens[fromTokenId];
            emit Transfer(owner, address(0), fromTokenId);
        }
    }

    // Approve operator for specific token
    function approve(address to, uint256 tokenId) public {
        address owner = _tokens[tokenId].owner;
        require(to != owner, "Approval to current owner");
        require(
            msg.sender == owner || isApprovedForAll(owner, msg.sender),
            "Not authorized"
        );
        
        _tokens[tokenId].approved = to;
    }

    // Approve operator for all tokens
    function setApprovalForAll(address operator, bool approved) public {
        require(operator != msg.sender, "Approve to caller");
        _operatorApprovals[msg.sender][operator] = approved;
    }

    // Check if operator is approved
    function isApprovedForAll(
        address owner,
        address operator
    ) public view returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    // Helper functions
    function _exists(uint256 tokenId) internal view returns (bool) {
        return _tokens[tokenId].owner != address(0);
    }

    function _isApprovedOrOwner(
        address spender,
        uint256 tokenId
    ) internal view returns (bool) {
        address owner = _tokens[tokenId].owner;
        return (
            spender == owner ||
            _tokens[tokenId].approved == spender ||
            isApprovedForAll(owner, spender)
        );
    }
}

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

// This is a simplified implementation for demonstration
// For production, use: https://github.com/solv-finance/erc-3525

contract ERC3525SimplifiedExample {
    string public name = "Semi-Fungible Token";
    string public symbol = "SFT";
    uint8 public decimals = 18;
    
    uint256 private _tokenIdCounter;
    
    struct TokenData {
        uint256 slot;      // Category/type of token
        uint256 value;     // Fungible value within the slot
        address owner;
        address approved;
    }
    
    // tokenId => TokenData
    mapping(uint256 => TokenData) private _tokens;
    
    // owner => operator => approved
    mapping(address => mapping(address => bool)) private _operatorApprovals;
    
    // slot => totalValue
    mapping(uint256 => uint256) private _slotTotalValue;
    
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 indexed tokenId
    );
    
    event TransferValue(
        uint256 indexed fromTokenId,
        uint256 indexed toTokenId,
        uint256 value
    );
    
    event SlotChanged(
        uint256 indexed tokenId,
        uint256 indexed oldSlot,
        uint256 indexed newSlot
    );
    
    event ApprovalValue(
        uint256 indexed tokenId,
        address indexed operator,
        uint256 value
    );

    // Mint a new token with specific slot and value
    function mint(
        address to,
        uint256 slot,
        uint256 value
    ) public returns (uint256 tokenId) {
        require(to != address(0), "Mint to zero address");
        require(value > 0, "Value must be positive");
        
        tokenId = _tokenIdCounter++;
        
        _tokens[tokenId] = TokenData({
            slot: slot,
            value: value,
            owner: to,
            approved: address(0)
        });
        
        _slotTotalValue[slot] += value;
        
        emit Transfer(address(0), to, tokenId);
    }

    // Get token slot
    function slotOf(uint256 tokenId) public view returns (uint256) {
        require(_exists(tokenId), "Token does not exist");
        return _tokens[tokenId].slot;
    }

    // Get token value
    function balanceOf(uint256 tokenId) public view returns (uint256) {
        require(_exists(tokenId), "Token does not exist");
        return _tokens[tokenId].value;
    }

    // Get token owner
    function ownerOf(uint256 tokenId) public view returns (address) {
        require(_exists(tokenId), "Token does not exist");
        return _tokens[tokenId].owner;
    }

    // Transfer entire token (like ERC-721)
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public {
        require(_isApprovedOrOwner(msg.sender, tokenId), "Not approved");
        require(_tokens[tokenId].owner == from, "Not owner");
        require(to != address(0), "Transfer to zero address");
        
        _tokens[tokenId].owner = to;
        _tokens[tokenId].approved = address(0);
        
        emit Transfer(from, to, tokenId);
    }

    // Transfer value from one token to another (Semi-Fungible feature!)
    function transferValueFrom(
        uint256 fromTokenId,
        uint256 toTokenId,
        uint256 value
    ) public {
        require(_exists(fromTokenId), "From token does not exist");
        require(_exists(toTokenId), "To token does not exist");
        require(
            _tokens[fromTokenId].slot == _tokens[toTokenId].slot,
            "Slots must match"
        );
        require(
            _isApprovedOrOwner(msg.sender, fromTokenId),
            "Not approved"
        );
        require(_tokens[fromTokenId].value >= value, "Insufficient value");
        
        _tokens[fromTokenId].value -= value;
        _tokens[toTokenId].value += value;
        
        emit TransferValue(fromTokenId, toTokenId, value);
        
        // If source token has zero value, it can be burned
        if (_tokens[fromTokenId].value == 0) {
            address owner = _tokens[fromTokenId].owner;
            delete _tokens[fromTokenId];
            emit Transfer(owner, address(0), fromTokenId);
        }
    }

    // Transfer value to new token (mints new token with transferred value)
    function transferValueFrom(
        uint256 fromTokenId,
        address to,
        uint256 value
    ) public returns (uint256 newTokenId) {
        require(_exists(fromTokenId), "Token does not exist");
        require(to != address(0), "Transfer to zero address");
        require(
            _isApprovedOrOwner(msg.sender, fromTokenId),
            "Not approved"
        );
        require(_tokens[fromTokenId].value >= value, "Insufficient value");
        
        uint256 slot = _tokens[fromTokenId].slot;
        
        // Deduct value from source token
        _tokens[fromTokenId].value -= value;
        
        // Create new token with transferred value
        newTokenId = _tokenIdCounter++;
        _tokens[newTokenId] = TokenData({
            slot: slot,
            value: value,
            owner: to,
            approved: address(0)
        });
        
        emit TransferValue(fromTokenId, newTokenId, value);
        emit Transfer(address(0), to, newTokenId);
        
        // If source token has zero value, burn it
        if (_tokens[fromTokenId].value == 0) {
            address owner = _tokens[fromTokenId].owner;
            delete _tokens[fromTokenId];
            emit Transfer(owner, address(0), fromTokenId);
        }
    }

    // Approve operator for specific token
    function approve(address to, uint256 tokenId) public {
        address owner = _tokens[tokenId].owner;
        require(to != owner, "Approval to current owner");
        require(
            msg.sender == owner || isApprovedForAll(owner, msg.sender),
            "Not authorized"
        );
        
        _tokens[tokenId].approved = to;
    }

    // Approve operator for all tokens
    function setApprovalForAll(address operator, bool approved) public {
        require(operator != msg.sender, "Approve to caller");
        _operatorApprovals[msg.sender][operator] = approved;
    }

    // Check if operator is approved
    function isApprovedForAll(
        address owner,
        address operator
    ) public view returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    // Helper functions
    function _exists(uint256 tokenId) internal view returns (bool) {
        return _tokens[tokenId].owner != address(0);
    }

    function _isApprovedOrOwner(
        address spender,
        uint256 tokenId
    ) internal view returns (bool) {
        address owner = _tokens[tokenId].owner;
        return (
            spender == owner ||
            _tokens[tokenId].approved == spender ||
            isApprovedForAll(owner, spender)
        );
    }
}

7. ERC-3525: Semi-Fungible Token Standard

What It Does: Creates tokens that are fungible within categories but unique across categories.

When to Use: Financial instruments, bond tokens, fractionalized assets.

ERC-3525 fills a gap between fully fungible and unique tokens. Each token has a unique ID but also units interchangeable within the same category.

Think of concert tickets – Section A tickets are fungible with each other but not with Section B. ERC-3525 handles this elegantly.

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

// This is a simplified implementation for demonstration
// For production, use: https://github.com/solv-finance/erc-3525

contract ERC3525SimplifiedExample {
    string public name = "Semi-Fungible Token";
    string public symbol = "SFT";
    uint8 public decimals = 18;
    
    uint256 private _tokenIdCounter;
    
    struct TokenData {
        uint256 slot;      // Category/type of token
        uint256 value;     // Fungible value within the slot
        address owner;
        address approved;
    }
    
    // tokenId => TokenData
    mapping(uint256 => TokenData) private _tokens;
    
    // owner => operator => approved
    mapping(address => mapping(address => bool)) private _operatorApprovals;
    
    // slot => totalValue
    mapping(uint256 => uint256) private _slotTotalValue;
    
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 indexed tokenId
    );
    
    event TransferValue(
        uint256 indexed fromTokenId,
        uint256 indexed toTokenId,
        uint256 value
    );
    
    event SlotChanged(
        uint256 indexed tokenId,
        uint256 indexed oldSlot,
        uint256 indexed newSlot
    );
    
    event ApprovalValue(
        uint256 indexed tokenId,
        address indexed operator,
        uint256 value
    );

    // Mint a new token with specific slot and value
    function mint(
        address to,
        uint256 slot,
        uint256 value
    ) public returns (uint256 tokenId) {
        require(to != address(0), "Mint to zero address");
        require(value > 0, "Value must be positive");
        
        tokenId = _tokenIdCounter++;
        
        _tokens[tokenId] = TokenData({
            slot: slot,
            value: value,
            owner: to,
            approved: address(0)
        });
        
        _slotTotalValue[slot] += value;
        
        emit Transfer(address(0), to, tokenId);
    }

    // Get token slot
    function slotOf(uint256 tokenId) public view returns (uint256) {
        require(_exists(tokenId), "Token does not exist");
        return _tokens[tokenId].slot;
    }

    // Get token value
    function balanceOf(uint256 tokenId) public view returns (uint256) {
        require(_exists(tokenId), "Token does not exist");
        return _tokens[tokenId].value;
    }

    // Get token owner
    function ownerOf(uint256 tokenId) public view returns (address) {
        require(_exists(tokenId), "Token does not exist");
        return _tokens[tokenId].owner;
    }

    // Transfer entire token (like ERC-721)
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public {
        require(_isApprovedOrOwner(msg.sender, tokenId), "Not approved");
        require(_tokens[tokenId].owner == from, "Not owner");
        require(to != address(0), "Transfer to zero address");
        
        _tokens[tokenId].owner = to;
        _tokens[tokenId].approved = address(0);
        
        emit Transfer(from, to, tokenId);
    }

    // Transfer value from one token to another (Semi-Fungible feature!)
    function transferValueFrom(
        uint256 fromTokenId,
        uint256 toTokenId,
        uint256 value
    ) public {
        require(_exists(fromTokenId), "From token does not exist");
        require(_exists(toTokenId), "To token does not exist");
        require(
            _tokens[fromTokenId].slot == _tokens[toTokenId].slot,
            "Slots must match"
        );
        require(
            _isApprovedOrOwner(msg.sender, fromTokenId),
            "Not approved"
        );
        require(_tokens[fromTokenId].value >= value, "Insufficient value");
        
        _tokens[fromTokenId].value -= value;
        _tokens[toTokenId].value += value;
        
        emit TransferValue(fromTokenId, toTokenId, value);
        
        // If source token has zero value, it can be burned
        if (_tokens[fromTokenId].value == 0) {
            address owner = _tokens[fromTokenId].owner;
            delete _tokens[fromTokenId];
            emit Transfer(owner, address(0), fromTokenId);
        }
    }

    // Transfer value to new token (mints new token with transferred value)
    function transferValueFrom(
        uint256 fromTokenId,
        address to,
        uint256 value
    ) public returns (uint256 newTokenId) {
        require(_exists(fromTokenId), "Token does not exist");
        require(to != address(0), "Transfer to zero address");
        require(
            _isApprovedOrOwner(msg.sender, fromTokenId),
            "Not approved"
        );
        require(_tokens[fromTokenId].value >= value, "Insufficient value");
        
        uint256 slot = _tokens[fromTokenId].slot;
        
        // Deduct value from source token
        _tokens[fromTokenId].value -= value;
        
        // Create new token with transferred value
        newTokenId = _tokenIdCounter++;
        _tokens[newTokenId] = TokenData({
            slot: slot,
            value: value,
            owner: to,
            approved: address(0)
        });
        
        emit TransferValue(fromTokenId, newTokenId, value);
        emit Transfer(address(0), to, newTokenId);
        
        // If source token has zero value, burn it
        if (_tokens[fromTokenId].value == 0) {
            address owner = _tokens[fromTokenId].owner;
            delete _tokens[fromTokenId];
            emit Transfer(owner, address(0), fromTokenId);
        }
    }

    // Approve operator for specific token
    function approve(address to, uint256 tokenId) public {
        address owner = _tokens[tokenId].owner;
        require(to != owner, "Approval to current owner");
        require(
            msg.sender == owner || isApprovedForAll(owner, msg.sender),
            "Not authorized"
        );
        
        _tokens[tokenId].approved = to;
    }

    // Approve operator for all tokens
    function setApprovalForAll(address operator, bool approved) public {
        require(operator != msg.sender, "Approve to caller");
        _operatorApprovals[msg.sender][operator] = approved;
    }

    // Check if operator is approved
    function isApprovedForAll(
        address owner,
        address operator
    ) public view returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    // Helper functions
    function _exists(uint256 tokenId) internal view returns (bool) {
        return _tokens[tokenId].owner != address(0);
    }

    function _isApprovedOrOwner(
        address spender,
        uint256 tokenId
    ) internal view returns (bool) {
        address owner = _tokens[tokenId].owner;
        return (
            spender == owner ||
            _tokens[tokenId].approved == spender ||
            isApprovedForAll(owner, spender)
        );
    }
}

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

// This is a simplified implementation for demonstration
// For production, use: https://github.com/solv-finance/erc-3525

contract ERC3525SimplifiedExample {
    string public name = "Semi-Fungible Token";
    string public symbol = "SFT";
    uint8 public decimals = 18;
    
    uint256 private _tokenIdCounter;
    
    struct TokenData {
        uint256 slot;      // Category/type of token
        uint256 value;     // Fungible value within the slot
        address owner;
        address approved;
    }
    
    // tokenId => TokenData
    mapping(uint256 => TokenData) private _tokens;
    
    // owner => operator => approved
    mapping(address => mapping(address => bool)) private _operatorApprovals;
    
    // slot => totalValue
    mapping(uint256 => uint256) private _slotTotalValue;
    
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 indexed tokenId
    );
    
    event TransferValue(
        uint256 indexed fromTokenId,
        uint256 indexed toTokenId,
        uint256 value
    );
    
    event SlotChanged(
        uint256 indexed tokenId,
        uint256 indexed oldSlot,
        uint256 indexed newSlot
    );
    
    event ApprovalValue(
        uint256 indexed tokenId,
        address indexed operator,
        uint256 value
    );

    // Mint a new token with specific slot and value
    function mint(
        address to,
        uint256 slot,
        uint256 value
    ) public returns (uint256 tokenId) {
        require(to != address(0), "Mint to zero address");
        require(value > 0, "Value must be positive");
        
        tokenId = _tokenIdCounter++;
        
        _tokens[tokenId] = TokenData({
            slot: slot,
            value: value,
            owner: to,
            approved: address(0)
        });
        
        _slotTotalValue[slot] += value;
        
        emit Transfer(address(0), to, tokenId);
    }

    // Get token slot
    function slotOf(uint256 tokenId) public view returns (uint256) {
        require(_exists(tokenId), "Token does not exist");
        return _tokens[tokenId].slot;
    }

    // Get token value
    function balanceOf(uint256 tokenId) public view returns (uint256) {
        require(_exists(tokenId), "Token does not exist");
        return _tokens[tokenId].value;
    }

    // Get token owner
    function ownerOf(uint256 tokenId) public view returns (address) {
        require(_exists(tokenId), "Token does not exist");
        return _tokens[tokenId].owner;
    }

    // Transfer entire token (like ERC-721)
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public {
        require(_isApprovedOrOwner(msg.sender, tokenId), "Not approved");
        require(_tokens[tokenId].owner == from, "Not owner");
        require(to != address(0), "Transfer to zero address");
        
        _tokens[tokenId].owner = to;
        _tokens[tokenId].approved = address(0);
        
        emit Transfer(from, to, tokenId);
    }

    // Transfer value from one token to another (Semi-Fungible feature!)
    function transferValueFrom(
        uint256 fromTokenId,
        uint256 toTokenId,
        uint256 value
    ) public {
        require(_exists(fromTokenId), "From token does not exist");
        require(_exists(toTokenId), "To token does not exist");
        require(
            _tokens[fromTokenId].slot == _tokens[toTokenId].slot,
            "Slots must match"
        );
        require(
            _isApprovedOrOwner(msg.sender, fromTokenId),
            "Not approved"
        );
        require(_tokens[fromTokenId].value >= value, "Insufficient value");
        
        _tokens[fromTokenId].value -= value;
        _tokens[toTokenId].value += value;
        
        emit TransferValue(fromTokenId, toTokenId, value);
        
        // If source token has zero value, it can be burned
        if (_tokens[fromTokenId].value == 0) {
            address owner = _tokens[fromTokenId].owner;
            delete _tokens[fromTokenId];
            emit Transfer(owner, address(0), fromTokenId);
        }
    }

    // Transfer value to new token (mints new token with transferred value)
    function transferValueFrom(
        uint256 fromTokenId,
        address to,
        uint256 value
    ) public returns (uint256 newTokenId) {
        require(_exists(fromTokenId), "Token does not exist");
        require(to != address(0), "Transfer to zero address");
        require(
            _isApprovedOrOwner(msg.sender, fromTokenId),
            "Not approved"
        );
        require(_tokens[fromTokenId].value >= value, "Insufficient value");
        
        uint256 slot = _tokens[fromTokenId].slot;
        
        // Deduct value from source token
        _tokens[fromTokenId].value -= value;
        
        // Create new token with transferred value
        newTokenId = _tokenIdCounter++;
        _tokens[newTokenId] = TokenData({
            slot: slot,
            value: value,
            owner: to,
            approved: address(0)
        });
        
        emit TransferValue(fromTokenId, newTokenId, value);
        emit Transfer(address(0), to, newTokenId);
        
        // If source token has zero value, burn it
        if (_tokens[fromTokenId].value == 0) {
            address owner = _tokens[fromTokenId].owner;
            delete _tokens[fromTokenId];
            emit Transfer(owner, address(0), fromTokenId);
        }
    }

    // Approve operator for specific token
    function approve(address to, uint256 tokenId) public {
        address owner = _tokens[tokenId].owner;
        require(to != owner, "Approval to current owner");
        require(
            msg.sender == owner || isApprovedForAll(owner, msg.sender),
            "Not authorized"
        );
        
        _tokens[tokenId].approved = to;
    }

    // Approve operator for all tokens
    function setApprovalForAll(address operator, bool approved) public {
        require(operator != msg.sender, "Approve to caller");
        _operatorApprovals[msg.sender][operator] = approved;
    }

    // Check if operator is approved
    function isApprovedForAll(
        address owner,
        address operator
    ) public view returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    // Helper functions
    function _exists(uint256 tokenId) internal view returns (bool) {
        return _tokens[tokenId].owner != address(0);
    }

    function _isApprovedOrOwner(
        address spender,
        uint256 tokenId
    ) internal view returns (bool) {
        address owner = _tokens[tokenId].owner;
        return (
            spender == owner ||
            _tokens[tokenId].approved == spender ||
            isApprovedForAll(owner, spender)
        );
    }
}

ERC Token Standards Comparison Table

Standard	Type	Primary Use Case	Launched	Key Advantage	Gas Efficiency
ERC-20	Fungible	Cryptocurrencies, utility tokens	2015	Universal compatibility	High
ERC-721	Non-Fungible	NFTs, unique assets	2018	Proven uniqueness	Medium
ERC-1155	Multi-Token	Gaming, complex projects	2019	Batch operations	Very High
ERC-777	Enhanced Fungible	Advanced DeFi	2017	Programmable hooks	Medium
ERC-4337	Account Abstraction	User-friendly wallets	2023	Social recovery	Variable
ERC-2981	Royalty Info	Creator monetization	2020	Standardized royalties	Minimal
ERC-3525	Semi-Fungible	Financial instruments	2022	Flexible categorization	Medium-High

Conclusion

ERC token standards transformed Ethereum from an experimental platform into the backbone of decentralized finance. These standards enable interoperability, reduce development complexity, and create consistent user experiences. While ERC-20 remains the most popular standard for fungible tokens, developers should be aware of its limitations and consider alternative standards like ERC-721 for NFTs and ERC-1155 for multi-token use cases.

Understanding these standards empowers better decisions whether you’re investing, building, or using blockchain applications. As technology matures, new standards will emerge to solve future problems.

The key takeaway is simple; standards enable innovation by providing common ground. As you explore Ethereum in 2026, you’ll encounter these standards everywhere. Now you know what makes them tick.

Ready to build with ERC standards? Start with ERC-20 or ERC-721 to learn the basics. These proven standards offer excellent documentation and community support.

Frequently Asked Questions About ERC Token Standards

ERC token standards are predefined rules that Ethereum-based tokens follow to ensure compatibility and functionality within the Ethereum ecosystem.

The ERC-20 token standard is a set of guidelines for creating fungible tokens that can be exchanged or traded on the Ethereum blockchain.

Unlike ERC-20, which is for fungible tokens, ERC-721 is used for non-fungible tokens (NFTs), representing unique assets.

ERC-1155 is a multi-token standard allowing the creation of both fungible and non-fungible tokens within a single contract.

ERC token standards ensure interoperability, security, and ease of development, making it simpler to create and manage tokens on the Ethereum blockchain.

ERC tokens enhance the functionality and versatility of the Ethereum network by enabling a wide range of applications, from decentralized finance (DeFi) to gaming.

ERC-20 tokens are commonly used for Initial Coin Offerings (ICOs), DeFi applications, and as a means of transferring value on the Ethereum network.

Yes, ERC-721 tokens are popular in gaming for representing unique in-game items, characters, and collectibles.

ERC-1155 offers developers flexibility and efficiency by allowing multiple token types in a single contract, reducing transaction costs and complexity.

Tokenization is the process of converting assets into digital tokens on a blockchain. ERC tokens provide the framework for securely creating and managing these digital assets.

Yes, both token types can be integrated into a single project, allowing for a mix of fungible and non-fungible assets.

Popular ERC-20 tokens include USDT (Tether), LINK (Chainlink), and DAI (Dai Stablecoin).

Well-known ERC-721 tokens include CryptoKitties, Decentraland (MANA), and Axie Infinity (AXS).

Smart contracts automate the creation, transfer, and management of tokens according to the rules defined by their respective standards.

Token standards enable the creation of interoperable financial products, fostering innovation and growth in the DeFi space.

Yes, there are several other standards like ERC-1155 for multi-token types and ERC-777 for advanced token functionality.

Metana Editorial

Powered by Metana Editorial Team, our content explores technology, education and innovation. As a team, we strive to provide everything from step-by-step guides to thought provoking insights, so that our readers can gain impeccable knowledge on emerging trends and new skills to confidently build their career. While our articles cover a variety of topics, we are highly focused on Web3, Blockchain, Solidity, Full stack, AI and Cybersecurity. These articles are written, reviewed and thoroughly vetted by our team of subject matter experts, instructors and career coaches.

Metana Guarantees a Job 💼

Plus Risk Free 2-Week Refund Policy ✨

You’re guaranteed a new job in web3—or you’ll get a full tuition refund. We also offer a hassle-free two-week refund policy. If you’re not satisfied with your purchase for any reason, you can request a refund, no questions asked.

Web3 Solidity Bootcamp

The most advanced Solidity curriculum on the internet!

View Program

Full Stack Web3 Beginner Bootcamp

Learn foundational principles while gaining hands-on experience with Ethereum, DeFi, and Solidity.

7 Months
Beginner - Zero to Hero
25h/ Week
Your very own personal support tutor
1-on-1 mentorship
Expert code reviews
Coaching & career services

View Program

Bootcamps

Resources

Table of Contents

ERC Token Standards: Your Simplified Guide

TL;DR

What Are ERC Token Standards?

What are the Different Standards of ERC Tokens?

1. ERC-20: The Fungible Token Standard

2. ERC-721: The Non-Fungible Token Standard

3. ERC-1155: The Multi-Token Standard

4. ERC-777: Enhanced Token Operations

5. ERC-4337: Account Abstraction Revolution

6. ERC-2981: NFT Royalty Standard

7. ERC-3525: Semi-Fungible Token Standard

ERC Token Standards Comparison Table

Conclusion

Frequently Asked Questions About ERC Token Standards

Metana Guarantees a Job 💼

Plus Risk Free 2-Week Refund Policy ✨

Web3 Solidity Bootcamp

Full Stack Web3 Beginner Bootcamp

You may also like

Metana Guarantees a Job 💼

Plus Risk Free 2-Week Refund Policy

Web3 Solidity Bootcamp

Full Stack Web3 Beginner Bootcamp

Events by Metana

Join 600+ Builders, Engineers, and Career Switchers

Subscribe to Lettercamp

Start your new career today. Talk to an advisor.

Guarantee: Job or 100% money back

Expert-curated curriculum

On-demand mentor support

[Prod] Start Applying form

Company

Bootcamp

For businesses

Legal

Get a detailed look at our Cyber Security Bootcamp

Understand the goal of the bootcamp

Find out more about the course

Explore our methodology & what technologies we teach

You are downloading 2026 updated Cyber Security Bootcamp syllabus!

Cyber Security Bootcamp Syllabus Download

Get a detailed look at our AI Automations Bootcamp

Understand the goal of the bootcamp

Find out more about the course

Explore our methodology & what technologies we teach

You are downloading 2026 updated AI Automations Bootcamp syllabus!

AI Automations Bootcamp Syllabus Download

Get a detailed look at our Software Engineering Bootcamp

Understand the goal of the bootcamp

Find out more about the course

Explore our methodology & what technologies we teach

You are downloading 2026 updated Software Engineering Bootcamp syllabus!

Software Engineering Bootcamp Syllabus Download

New Application Alert!

Get a detailed look at our Full Stack Bootcamp

Understand the goal of the bootcamp

Find out more about the course

Explore our methodology & what technologies we teach

You are downloading 2026 updated Full stack Bootcamp syllabus!

Software Engineering Syllabus Download