Blockchain

Chuẩn Token ERC-20 Và NFT ERC-721: Bản Chất Kỹ Thuật

Các tiêu chuẩn token trên Ethereum như ERC-20 và ERC-721 đóng vai trò như các bản thiết kế chung, tạo nên tính tương tác liền mạch cho toàn bộ nền kinh tế Web3.

TIÊU CHUẨN TOKEN ERC-20 VÀ ERC-721 Phân biệt token có thể thay thế và token độc bản Chuẩn ERC-20 Token thay thế được: transfer Chuẩn ERC-721 Mỗi NFT có một tokenId riêng Sổ Cái Ánh Xạ Balances Số dư và hạn mức ủy quyền
TIÊU CHUẨN TOKEN ERC-20 VÀ ERC-721 Token ERC-20 Các đơn vị giống hệt nhau như tiền tệ NFT ERC-721 Mỗi token có định danh độc nhất Quyền Sở Hữu Theo dõi minh bạch trên blockchain
Hình 1. Mô hình kiến trúc phân biệt token có thể thay thế ERC-20 và tài sản độc bản NFT ERC-721.

Hãy thử tưởng tượng một thế giới nơi mỗi hãng sản xuất xe hơi tự thiết kế một loại súng bơm xăng có kích thước và hình dạng khác nhau: bạn lái xe Toyota đến cây xăng chỉ dùng được vòi bơm Toyota, còn xe Honda phải chạy sang cây xăng khác. Hệ quả là chi phí xây dựng cơ sở hạ tầng sẽ đội lên khổng lồ và người dùng gặp vô vàn phiền toái.

Trước khi ERC-20 ra đời (cuối năm 2015), các token trên Ethereum cũng rơi vào tình trạng hỗn loạn tương tự. Mỗi dự án phát hành token tự nghĩ ra một tập hợp tên hàm và cấu trúc dữ liệu riêng: có dự án đặt tên hàm chuyển tiền là transfer(), dự án khác đặt là send(), dự án thứ ba lại viết là pay(). Kết quả là các sàn giao dịch và ví điện tử phải tốn hàng tháng trời viết code tùy biến riêng cho từng token một.

Để chấm dứt sự phân mảnh này, cộng đồng Ethereum đã phát minh ra các Tiêu chuẩn Yêu cầu Nhận xét (Ethereum Request for Comments - ERC). Nổi bật và quan trọng nhất trong số đó là ERC-20 (tiêu chuẩn cho tài sản có thể thay thế) và ERC-721 (tiêu chuẩn cho tài sản không thể thay thế - NFT).

Bài viết này sẽ phân tích tường tận bản chất kỹ thuật của hai tiêu chuẩn này: cấu trúc dữ liệu lưu trữ, giao diện lập trình bắt buộc, cơ chế ủy quyền hai bước (Approve - TransferFrom), đặc tả siêu dữ liệu (Metadata JSON trên IPFS), cùng mã nguồn mô phỏng sổ cái kép bằng C++17 và Python 3.

ERC-20 Là Gì? Bản Chất Của Tài Sản Có Thể Thay Thế (Fungible Token)

Khái niệm "có thể thay thế" (Fungibility) là một thuật ngữ kinh tế học cốt lõi mô tả một loại tài sản mà các đơn vị của nó hoàn toàn giống hệt nhau về bản chất, chất lượng và giá trị:

  • Một tờ tiền 100.000 đồng của bạn có giá trị hoàn toàn tương đương với một tờ tiền 100.000 đồng của người khác. Bạn có thể đổi tờ tiền của mình lấy tờ tiền của họ mà không bên nào cảm thấy bị thiệt thòi.
  • Tương tự, 1 token USDT hay 1 token UNI trong ví của bạn hoàn toàn đồng nhất với 1 token USDT/UNI của bất kỳ ai trên thế giới.

Được đề xuất vào tháng 11/2015 bởi Fabian Vogelsteller và Vitalik Buterin, chuẩn ERC-20 biến một smart contract thành một cuốn sổ cái tài chính số (Ledger).

Giao Diện Lập Trình Chuẩn ERC-20 (IERC20 Interface)

Một hợp đồng thông minh muốn được công nhận là chuẩn ERC-20 bắt buộc phải triển khai đầy đủ 6 hàm và 2 sự kiện theo đặc tả:

interface IERC20 {
    // 3 Hàm truy vấn dữ liệu (View Functions)
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);

    // 3 Hàm biến đổi trạng thái (State-changing Functions)
    function transfer(address recipient, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    // 2 Sự kiện bắt buộc (Events)
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

Cơ Chế Ủy Quyền Hai Bước: Approve và TransferFrom

Nếu như hàm transfer cho phép người dùng chuyển token trực tiếp từ ví mình sang ví người khác, thì hàm approve kết hợp transferFrom là phát minh quan trọng nhất làm bùng nổ toàn bộ hệ sinh thái Tài chính phi tập trung (DeFi):

  1. Vấn đề thực tế: Giả sử bạn muốn dùng 1.000 token USDT để mua ETH trên sàn phi tập trung Uniswap. Smart contract của Uniswap không thể tự ý thò tay vào ví của bạn để rút 1.000 USDT ra được (vì điều đó sẽ vi phạm nghiêm trọng tính bảo mật của tài sản).
  2. Bước 1 - Phê duyệt (approve): Bạn gửi một giao dịch gọi hàm approve(uniswapRouterAddress, 1000). Giao dịch này ghi nhận vào biến trạng thái allowance[msg.sender][uniswapRouterAddress] = 1000, cấp phép cho hợp đồng Uniswap được quyền rút tối đa 1.000 USDT từ ví của bạn.
  3. Bước 2 - Thực thi rút tiền (transferFrom): Khi bạn bấm nút Swap, hợp đồng Uniswap sẽ gọi hàm transferFrom(yourAddress, poolAddress, 1000). Hàm này kiểm tra xem số tiền có vượt quá hạn mức allowance bạn đã cấp hay không. Nếu hợp lệ, nó sẽ trừ số dư của bạn, trừ hạn mức ủy quyền và chuyển token vào kho thanh khoản của sàn.

ERC-721 Là Gì? Kỷ Nguyên Quyền Sở Hữu Kỹ Thuật Số (NFT)

Trái ngược hoàn toàn với ERC-20, tiêu chuẩn ERC-721 ra đời vào tháng 1/2018 bởi William Entriken, Dieter Shirley, Jacob Evans và Nastassia Sachs để đại diện cho các tài sản Không thể thay thế (Non-Fungible Tokens - NFT).

Một tài sản là "không thể thay thế" khi mỗi đơn vị của nó mang các thuộc tính đặc trưng độc nhất vô nhị:

  • Một bức tranh Mona Lisa nguyên bản của Leonardo da Vinci là độc nhất. Bạn không thể đổi nó lấy một bức tranh khác rồi bảo rằng hai bức tranh có giá trị giống hệt nhau.
  • Một cuốn sổ đỏ nhà đất, một tấm vé xem trận chung kết World Cup có in rõ số ghế và hàng ghế, hay một thanh kiếm thần thoại trong trò chơi trực tuyến đều là các tài sản độc bản.

Cấu Trúc Dữ Liệu Cốt Lõi của ERC-721

Trong khi ERC-20 theo dõi số lượng token qua một mapping số dư, thì ERC-721 theo dõi quyền sở hữu của từng mã định danh số nguyên không âm (tokenId kiểu uint256):

// Theo doi chu so huu cua tung TokenId cu the
mapping(uint256 => address) private _owners;

// Theo doi tong so luong NFT ma mot dia chi vi dang nam giu
mapping(address => uint256) private _balances;

// Theo doi dia chi duoc uy quyen quan ly cho mot TokenId cu the
mapping(uint256 => address) private _tokenApprovals;

Hàm safeTransferFrom và Cơ Chế Phòng Chống Thất Lạc

Một trong những cải tiến an toàn xuất sắc của ERC-721 so với ERC-20 là hàm safeTransferFrom. Trong ERC-20, nếu bạn vô tình gửi token vào một địa chỉ smart contract mà hợp đồng đó không được lập trình để xử lý token, số token đó sẽ bị kẹt vĩnh viễn trong hợp đồng và không ai có thể rút ra được (Black Hole).

Để ngăn ngừa thảm họa này, hàm safeTransferFrom của ERC-721 kiểm tra xem địa chỉ người nhận có phải là một smart contract hay không (thông qua opcode EXTCODESIZE). Nếu là contract, nó bắt buộc phải gọi hàm kiểm tra:

IERC721Receiver(to).onERC721Received(operator, from, tokenId, data)

Nếu hợp đồng nhận không trả về đúng giá trị chữ ký 0x150b7a02, toàn bộ giao dịch sẽ lập tức bị REVERT, bảo vệ chiếc NFT không bị gửi nhầm vào các hợp đồng vô chủ.

Siêu Dữ Liệu NFT (Metadata) và Cơ Chế Lưu Trữ IPFS

Blockchain được thiết kế để duy trì tính đồng thuận của các phép tính tài chính chứ không phải là nơi lưu trữ các tệp ảnh PNG hay video MP4 dung lượng lớn. Nếu lưu trực tiếp một bức ảnh 10 MB lên storage của Ethereum, chi phí gas sẽ lên tới hàng chục nghìn USD.

Do đó, tiêu chuẩn ERC-721 giải quyết bài toán này thông qua phần mở rộng Siêu dữ liệu (Metadata Extension) với hàm:

function tokenURI(uint256 tokenId) external view returns (string memory);

Hàm này trả về một đường link URI (thường bắt đầu bằng giao thức lưu trữ phân tán ipfs:// hoặc ar://) dẫn tới một tệp JSON có cấu trúc chuẩn mực:

{
  "name": "Bored Ape #1234",
  "description": "Mot thanh vien trong bo suu tap 10,000 chu khi doc ban tren blockchain.",
  "image": "ipfs://QmXoypizjW3WknFiJnKLwHCnL72vedxjQkDDP1mXWo6uco/1234.png",
  "attributes": [
    { "trait_type": "Background", "value": "Aquamarine" },
    { "trait_type": "Eyes", "value": "Laser Eyes" },
    { "trait_type": "Mouth", "value": "Grin Gold" }
  ]
}

Bằng cách tách rời dữ liệu nặng (hình ảnh, video) lưu trên mạng ngang hàng IPFS và chỉ ghi nhận mã băm định danh tokenURI trên chuỗi khối, ERC-721 vừa đảm bảo tính bất biến của tác phẩm nghệ thuật, vừa giữ cho chuỗi khối gọn nhẹ và tiết kiệm gas.

Bảng So Sánh Kỹ Thuật: ERC-20 vs ERC-721

Đặc tính kỹ thuật Tiêu chuẩn ERC-20 Tiêu chuẩn ERC-721
Bản chất tài sản Có thể thay thế (Fungible) Không thể thay thế (Non-Fungible)
Đơn vị định danh Không có (chỉ phân biệt bằng số lượng token) Định danh duy nhất bằng tokenId (uint256)
Khả năng chia nhỏ Có thể chia nhỏ tới 18 chữ số thập phân (decimals) Không thể chia nhỏ (nguyên khối, 1 đơn vị)
Cấu trúc dữ liệu chính mapping(address => uint256) mapping(uint256 => address)
Cơ chế chuyển an toàn Không có (chỉ có transfer cơ bản) Có hàm safeTransferFrom kiểm tra IERC721Receiver
Quản lý siêu dữ liệu Thuộc tính đơn giản: name, symbol, decimals Tệp JSON ngoài chuỗi phong phú qua tokenURI
Lĩnh vực ứng dụng Tiền tệ, Thanh toán, Stablecoin, Quản trị DAO Nghệ thuật số, Chứng chỉ học vấn, Vé sự kiện, Bất động sản ảo
Học cùng giảng viên

Chủ đề này nằm trong Lecture 02 - Ứng dụng của Blockchain trong thực tế của Khóa Blockchain. Xem đề cương

Thiết Kế Thuật Toán Mô Phỏng Sổ Cái Kép

Để kiểm chứng tính toàn vẹn của logic điều khiển quyền sở hữu và hạn mức ủy quyền theo đúng chuẩn OpenZeppelin, chúng ta thiết kế một bộ mô phỏng sổ cái kép kết hợp cả hai chuẩn ERC-20 và ERC-721 bằng C++17 và Python 3.

Thuật toán hỗ trợ các hành động:

  • ERC20_MINT: Đúc thêm token và tăng tổng cung.
  • ERC20_TRANSFER: Chuyển tiền trực tiếp, kiểm tra số dư người gửi.
  • ERC20_APPROVE: Thiết lập hạn mức ủy quyền chi tiêu cho bên thứ ba.
  • ERC20_TRANSFER_FROM: Rút tiền ủy quyền, đối chiếu cả số dư ví và hạn mức allowance.
  • ERC721_MINT: Đúc NFT mới, kiểm tra trùng lặp tokenId.
  • ERC721_APPROVE: Chủ sở hữu ủy quyền quản lý chiếc NFT cho một địa chỉ.
  • ERC721_TRANSFER_FROM: Chuyển giao quyền sở hữu NFT, kiểm tra quyền hạn hợp lệ và tự động xóa bỏ quyền ủy quyền cũ sau khi đổi chủ.
// solution.cpp - ERC-20 & ERC-721 Token Ledger Simulator in C++17
#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <cassert>

struct TokenAction {
    std::string op;
    std::string p1;
    std::string p2;
    std::string p3;
    long long num = 0;
};

struct LedgerReport {
    long long erc20_supply;
    int erc721_minted_count;
    int success_ops;
    int failed_ops;
};

LedgerReport simulate_token_ledger(const std::vector<TokenAction>& actions) {
    std::map<std::string, long long> erc20_bal;
    std::map<std::string, std::map<std::string, long long>> erc20_allow;
    long long erc20_supply = 0;
    std::map<long long, std::string> erc721_owner;
    std::map<long long, std::string> erc721_app;
    int success = 0;
    int failed = 0;

    for (const auto& act : actions) {
        if (act.op == "ERC20_MINT") {
            std::string to = act.p1;
            long long amt = act.num;
            erc20_bal[to] += amt;
            erc20_supply += amt;
            success++;
        } else if (act.op == "ERC20_TRANSFER") {
            std::string frm = act.p1;
            std::string to = act.p2;
            long long amt = act.num;
            if (erc20_bal[frm] >= amt) {
                erc20_bal[frm] -= amt;
                erc20_bal[to] += amt;
                success++;
            } else {
                failed++;
            }
        } else if (act.op == "ERC20_APPROVE") {
            std::string owner = act.p1;
            std::string spender = act.p2;
            long long amt = act.num;
            erc20_allow[owner][spender] = amt;
            success++;
        } else if (act.op == "ERC20_TRANSFER_FROM") {
            std::string caller = act.p1;
            std::string frm = act.p2;
            std::string to = act.p3;
            long long amt = act.num;
            long long allow = erc20_allow[frm][caller];
            long long bal = erc20_bal[frm];
            if (bal >= amt && allow >= amt) {
                erc20_bal[frm] -= amt;
                erc20_bal[to] += amt;
                erc20_allow[frm][caller] -= amt;
                success++;
            } else {
                failed++;
            }
        } else if (act.op == "ERC721_MINT") {
            std::string to = act.p1;
            long long tid = act.num;
            if (erc721_owner.find(tid) == erc721_owner.end()) {
                erc721_owner[tid] = to;
                success++;
            } else {
                failed++;
            }
        } else if (act.op == "ERC721_APPROVE") {
            std::string caller = act.p1;
            std::string app_to = act.p2;
            long long tid = act.num;
            if (erc721_owner.count(tid) && erc721_owner[tid] == caller) {
                erc721_app[tid] = app_to;
                success++;
            } else {
                failed++;
            }
        } else if (act.op == "ERC721_TRANSFER_FROM") {
            std::string caller = act.p1;
            std::string frm = act.p2;
            std::string to = act.p3;
            long long tid = act.num;
            bool exists = (erc721_owner.find(tid) != erc721_owner.end());
            if (exists && erc721_owner[tid] == frm) {
                std::string app = erc721_app.count(tid) ? erc721_app[tid] : "";
                if (caller == frm || caller == app) {
                    erc721_owner[tid] = to;
                    erc721_app[tid] = "";
                    success++;
                } else {
                    failed++;
                }
            } else {
                failed++;
            }
        } else {
            failed++;
        }
    }

    return {erc20_supply, (int)erc721_owner.size(), success, failed};
}

int main() {
    std::vector<TokenAction> actions = {
        {"ERC20_MINT", "alice", "", "", 1000},
        {"ERC20_TRANSFER", "alice", "bob", "", 200},
        {"ERC721_MINT", "alice", "", "", 1},
        {"ERC721_TRANSFER_FROM", "alice", "alice", "bob", 1}
    };
    LedgerReport rep = simulate_token_ledger(actions);
    assert(rep.erc20_supply == 1000);
    assert(rep.erc721_minted_count == 1);
    assert(rep.success_ops == 4);
    assert(rep.failed_ops == 0);
    std::cout << "C++17 basic check PASSED!\n";
    return 0;
}

Phân tích Chi tiết Thuật toán và Mã nguồn

1. Quản lý Sổ cái ERC-20

Trong cả hai bản triển khai:

  • Biến erc20_supply theo dõi tổng lượng cung đang lưu hành.
  • Bảng ánh xạ lồng nhau erc20_allow[owner][spender] lưu trữ số dư ủy quyền.
  • Khi hàm ERC20_TRANSFER_FROM được kích hoạt bởi người gọi caller: Thuật toán kiểm tra đồng thời hai điều kiện: bal >= amt và allow >= amt. Nếu cả hai đều thỏa mãn, số dư của frm bị trừ đi, số dư của to tăng lên, và điều quan trọng nhất: hạn mức ủy quyền allowance[frm][caller] bị khấu trừ tương ứng với số tiền đã rút.

2. Quản lý Quyền sở hữu và Xóa Ủy quyền ERC-721

  • Bảng ánh xạ erc721_owner[tid] liên kết mỗi tokenId với một địa chỉ chủ nhân duy nhất. Lệnh đúc mới sẽ lập tức từ chối nếu tid đã tồn tại.
  • Khi thực hiện ERC721_TRANSFER_FROM: Người gọi caller bắt buộc phải là chính chủ sở hữu frm hoặc địa chỉ đã được phê duyệt erc721_app[tid].
  • Sau khi quyền sở hữu được chuyển giao thành công cho chủ nhân mới to, thuật toán tiến hành xóa trắng biến ủy quyền: erc721_app[tid] = "". Đây là quy tắc bảo mật bắt buộc trong chuẩn ERC-721 của OpenZeppelin nhằm ngăn chặn người được ủy quyền cũ tiếp tục can thiệp vào tài sản sau khi tài sản đã đổi chủ.

Các Lỗ Hổng Bảo Mật Thường Gặp với Token Standards

  1. Hiểm họa Cấp quyền Vô hạn (Unlimited Approval): Nhiều ứng dụng DApp khuyến khích người dùng phê duyệt hạn mức tối đa \(2^{256} - 1\) để không phải ký lại nhiều lần. Nếu smart contract của DApp đó bị khai thác bảo mật, hacker có thể dùng quyền transferFrom để quét sạch toàn bộ token có trong ví của mọi người dùng đã từng cấp quyền. Hãy thường xuyên sử dụng các công cụ như Revoke.cash để hủy bỏ các quyền ủy quyền không còn sử dụng.
  2. Kẹt NFT do dùng transferFrom thay vì safeTransferFrom: Khi xây dựng các chức năng chuyển NFT trong DApp, nhiều lập trình viên sử dụng hàm transferFrom thông thường. Nếu người nhận là một hợp đồng ví đa chữ ký hoặc hợp đồng game chưa hỗ trợ giao diện ERC-721, NFT sẽ bị khóa chết vĩnh viễn.
  3. Lỗ hổng Front-Running trong hàm Approve: Nếu Alice muốn giảm hạn mức ủy quyền cho Bob từ 100 xuống 50 token, cô gửi giao dịch approve(Bob, 50). Bob quan sát thấy giao dịch này trong mempool, liền gửi giao dịch transferFrom(Alice, 100) với giá gas cao hơn để được khai thác trước. Sau khi rút xong 100 token, giao dịch của Alice mới được thực thi và cấp thêm 50 token nữa cho Bob, giúp Bob rút tổng cộng 150 token. Để khắc phục, đặc tả ERC-20 khuyên giao diện ví đặt hạn mức về 0 trước rồi mới đặt giá trị mới. Lưu ý: increaseAllowance / decreaseAllowance không thuộc chuẩn ERC-20, và thư viện OpenZeppelin đã bỏ hai hàm này từ phiên bản 5.0 (10/2023).
  4. Lưu trữ Metadata tập trung trên máy chủ web thông thường: Sử dụng đường link HTTP (như https://api.mygame.com/nft/1.json) làm tokenURI. Khi công ty phát triển game đóng cửa máy chủ web hoặc đổi tên miền, toàn bộ hình ảnh và thuộc tính của các NFT sẽ biến thành liên kết hỏng (Dead Link), khiến tài sản số của người dùng mất trắng giá trị thẩm mỹ. Hãy luôn lưu trữ metadata trên các mạng lưu trữ phi tập trung vĩnh viễn như IPFS hoặc Arweave.
Tiêu chuẩn ERC-1155 có gì khác biệt so với ERC-20 và ERC-721?

ERC-1155 (Multi-Token Standard) được phát triển bởi Enjin, cho phép một smart contract duy nhất có thể quản lý đồng thời cả hai loại tài sản: token có thể thay thế (như tiền tệ, vàng trong game) và token không thể thay thế (như vũ khí, trang bị độc bản). Điểm vượt trội của ERC-1155 là tính năng chuyển hàng loạt (Batch Transfers), cho phép chuyển hàng chục loại vật phẩm khác nhau chỉ trong một giao dịch duy nhất, giúp tiết kiệm tới 80% phí gas so với việc gọi nhiều lệnh ERC-721 riêng lẻ.

Token Wrapped (như WETH) là gì và tại sao cần đến nó?

Đồng tiền bản địa Ether (ETH) ra đời trước khi tiêu chuẩn ERC-20 được phát minh, do đó bản thân ETH không tuân theo các giao diện của ERC-20 (nó không có các hàm approve hay transferFrom). Để sử dụng ETH trên các sàn giao dịch phi tập trung như Uniswap, các nhà phát triển tạo ra hợp đồng Wrapped Ether (WETH). Người dùng nạp ETH vào hợp đồng và nhận lại WETH theo tỷ lệ 1:1. WETH là một token chuẩn ERC-20 hoàn chỉnh, cho phép tương tác mượt mà với mọi giao thức DeFi.

Làm sao để biết một hợp đồng thông minh có hỗ trợ chuẩn ERC-721 hay không?

Các nhà phát triển sử dụng tiêu chuẩn ERC-165 (Standard Interface Detection). Hợp đồng triển khai hàm supportsInterface(bytes4 interfaceId) trả về giá trị true nếu nó hỗ trợ giao diện ERC-721 (với interfaceId = 0x80ac58cd). Nhờ vậy, các sàn thương mại điện tử như OpenSea có thể tự động nhận diện và hiển thị các bộ sưu tập NFT ngay khi hợp đồng vừa được deploy lên blockchain.

Muốn học bài bản cùng giảng viên?

Nhập môn Blockchain và Solana: hiểu Web3, lập trình Smart Contract, tự xây dApps bằng Rust/TypeScript. 16 buổi online, học thử buổi 1 miễn phí.

Xem Khóa Blockchain

Nguồn tham khảo

Chia sẻ: Facebook LinkedIn
Nhắn Zalo tư vấnZalo Gọi 0937 401 483