Blockchain

Lập Trình Solidity Cơ Bản: Viết Smart Contract Đầu Tiên

Solidity là ngôn ngữ lập trình hợp đồng thông minh phổ biến nhất thế giới Web3, được thiết kế chuyên biệt để thực thi an toàn trên máy ảo EVM của Ethereum.

LẬP TRÌNH SOLIDITY NỀN TẢNG Đóng gói biến lưu trữ và thực thi hàm Khai Báo Kiểu Dữ Liệu uint256, address, mapping, struct Tối Ưu Đóng Gói Slot Gom biến nhỏ vào ô nhớ 32 byte Bảo Vệ Kiểm Soát Truy Cập Kiểm tra bằng modifier, require
LẬP TRÌNH SOLIDITY NỀN TẢNG Cú Pháp Cơ Bản Biến trạng thái và hàm Slot Storage Gom cụm tiết kiệm phí gas Modifier Bảo Vệ Kiểm tra quyền truy cập hàm
Hình 1. Cấu trúc lưu trữ dữ liệu dạng slot và mô hình kiểm soát truy cập trong ngôn ngữ Solidity.

Nếu như JavaScript là ngôn ngữ thống trị thế giới Web2 giúp các trang web tương tác linh hoạt thì Solidity chính là ngôn ngữ lập trình nền móng xây dựng nên toàn bộ hệ sinh thái Tài chính phi tập trung (DeFi), NFT và các tổ chức tự trị (DAO) của Web3. Được thiết kế chuyên biệt để biên dịch ra mã bytecode thực thi trên máy ảo EVM của Ethereum, Solidity đòi hỏi tư duy lập trình hoàn toàn khác biệt so với các ngôn ngữ truyền thống.

Trong lập trình phần mềm thông thường, một dòng code thừa có thể chỉ làm ứng dụng chạy chậm vài mili giây hoặc tốn thêm vài Megabyte RAM. Nhưng trong Solidity, một dòng code cẩu thả hoặc một biến khai báo sai thứ tự có thể tiêu tốn hàng triệu đồng tiền phí gas của người dùng, hoặc tệ hơn là mở toang cánh cửa cho hacker rút cạn toàn bộ quỹ dự trữ của hợp đồng.

Bài viết này sẽ hướng dẫn bạn từ những bước đi chập chững đầu tiên: cấu trúc chuẩn của một tệp Solidity, hệ thống kiểu dữ liệu, các từ khóa phạm vi truy cập (Visibility), bộ lọc điều kiện (Modifiers), cơ chế phát sự kiện (Events), cho đến kỹ thuật tối ưu hóa chi phí lưu trữ Storage Packing qua bộ mã mô phỏng bằng C++17 và Python 3.

Cấu trúc Chuẩn của một Tệp Hợp đồng Solidity

Một tệp mã nguồn Solidity (thường có phần mở rộng .sol) luôn tuân theo một khuôn mẫu cấu trúc chuẩn mực được quy định bởi cộng đồng Ethereum:

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

contract FirstSmartContract {
    // 1. Khai báo biến trạng thái (State Variables)
    address public owner;
    uint256 public counter;

    // 2. Định nghĩa sự kiện (Events)
    event CounterIncremented(address indexed caller, uint256 newCount);

    // 3. Bộ lọc điều kiện (Modifier)
    modifier onlyOwner() {
        require(msg.sender == owner, "Khong phai chu so huu");
        _;
    }

    // 4. Hàm khởi tạo (Constructor)
    constructor() {
        owner = msg.sender;
        counter = 0;
    }

    // 5. Các hàm chức năng (Functions)
    function increment() external {
        counter += 1;
        emit CounterIncremented(msg.sender, counter);
    }

    function reset() external onlyOwner {
        counter = 0;
    }
}

Hãy cùng bóc tách từng thành phần cốt lõi trong đoạn mã trên:

  1. SPDX-License-Identifier: Dòng chú thích nên đặt ở đầu mọi tệp để khai báo giấy phép mã nguồn (ví dụ MIT, GPL-3.0 hoặc UNLICENSED). Trình biên dịch không kiểm tra giấy phép này, chỉ ghi chuỗi đó vào metadata của bytecode, nhờ vậy người khác (ví dụ trên Etherscan) biết mã nguồn được phát hành theo giấy phép nào.
  2. pragma solidity: Khai báo phiên bản trình biên dịch tối thiểu mà mã nguồn yêu cầu. Ký hiệu ^0.8.20 thông báo rằng tệp mã nguồn có thể biên dịch bằng bất kỳ phiên bản nào từ 0.8.20 đến trước 0.9.0. Kể từ phiên bản 0.8.0, Solidity đã tích hợp sẵn cơ chế kiểm tra lỗi tràn số toán học (Arithmetic Overflow/Underflow), giúp bảo vệ hợp đồng mà không cần đến thư viện SafeMath bên ngoài.
  3. contract: Từ khóa định nghĩa hợp đồng, có cấu trúc tương đương với từ khóa class trong lập trình hướng đối tượng (C++, Java). Một hợp đồng có thể chứa các biến trạng thái, hàm, sự kiện, cấu trúc tự định nghĩa (struct) và kiểu liệt kê (enum).

Hệ thống Kiểu Dữ liệu Cốt lõi trong Solidity

Solidity là ngôn ngữ định kiểu tĩnh (Statically Typed Language), nghĩa là kiểu dữ liệu của mọi biến bắt buộc phải được xác định rõ ràng tại thời điểm biên dịch.

1. Kiểu số nguyên (Integers)

  • Số nguyên không dấu: uint8, uint16, uint32, ..., uint256 (bước nhảy 8 bit). Trong đó uint là từ khóa viết tắt mặc định của uint256 (tối đa \(2^{256} - 1\)).
  • Số nguyên có dấu: int8, int16, ..., int256.
  • Quy tắc tối ưu: Dù uint8 chỉ chiếm 1 byte dữ liệu nhưng trong các phép toán trên Stack của EVM, EVM vẫn phải đệm thêm các số 0 để đưa về từ 32 bytes (256 bit). Do đó, chỉ nên dùng các kiểu số nhỏ (uint8, uint64, uint128) khi bạn có ý định gom chúng vào chung một Slot lưu trữ trong Storage. Nếu là biến cục bộ trong hàm, hãy luôn ưu tiên sử dụng uint256.

2. Kiểu Boolean và Địa chỉ (Address)

  • bool: Lưu trữ hai giá trị true hoặc false (chiếm 1 byte).
  • address: Lưu trữ địa chỉ tài khoản trên Ethereum (dài đúng 20 bytes hay 160-bit hex).
  • address payable: Phiên bản đặc biệt của address có tích hợp sẵn hai phương thức chuyển tiền: .transfer(amount) và .send(amount). Từ Solidity 0.8.31 (12/2025), trình biên dịch cảnh báo hai phương thức này đã lỗi thời và sẽ bỏ chúng ở bản 0.9.0; cách gửi ETH được khuyến nghị là recipient.call{value: amount}("") (xem mục Các Sai lầm Thường gặp).

3. Bảng ánh xạ (Mapping)

  • Cú pháp: mapping(KeyType => ValueType) public balances;
  • Về bản chất, mapping là một bảng băm (Hash Table) ảo khổng lồ. Mọi khóa khả dĩ đều đã được khởi tạo sẵn với giá trị mặc định (như số 0, false hoặc địa chỉ rỗng 0x0).
  • Đặc điểm kỹ thuật: mapping không lưu trữ danh sách các khóa đã được thêm vào và không có thuộc tính đo độ dài .length. Bạn không thể duyệt qua một mapping bằng vòng lặp for trừ khi bạn tự duy trì một mảng phụ lưu danh sách các khóa.

4. Vị trí lưu trữ dữ liệu (Data Locations: Storage, Memory, Calldata)

Khi truyền các kiểu dữ liệu tham chiếu (như mảng uint[], chuỗi string, hoặc cấu trúc struct) vào hàm, bạn bắt buộc phải chỉ định rõ vị trí lưu trữ của nó:

  • storage: Biến trỏ thẳng tới vùng lưu trữ vĩnh viễn trên blockchain. Mọi sửa đổi thông qua biến này sẽ làm thay đổi trạng thái toàn cục của hợp đồng.
  • memory: Biến được sao chép vào bộ nhớ RAM tạm thời của node và bị xóa sạch khi hàm kết thúc. Thường dùng khi cần sửa đổi dữ liệu tạm thời trước khi tính toán.
  • calldata: Vùng nhớ chỉ đọc (Read-only), bất biến và không thể chỉnh sửa, chứa dữ liệu thô gửi kèm giao dịch. Dùng calldata cho tham số đầu vào của hàm external giúp tiết kiệm gas vượt trội so với memory vì nó không tốn chi phí sao chép dữ liệu.

Các Khái niệm Nâng cao: Modifier, Event và Visibility

1. Phạm vi hiển thị của Hàm và Biến (Visibility)

  • public: Có thể được gọi từ cả bên ngoài (qua giao dịch của người dùng) và bên trong nội bộ hợp đồng. Trình biên dịch sẽ tự động tạo một hàm đọc (getter function) cho các biến trạng thái khai báo public.
  • external: Chỉ có thể được gọi từ bên ngoài thông qua giao dịch hoặc từ một hợp đồng khác. Hàm external nhận tham số dạng calldata giúp tối ưu hóa chi phí gas.
  • internal: Chỉ có thể được gọi từ bên trong hợp đồng hiện tại hoặc từ các hợp đồng con kế thừa từ nó (tương tự protected trong C++).
  • private: Chỉ có thể được gọi duy nhất từ bên trong chính hợp đồng khai báo nó. Lưu ý quan trọng: từ khóa private chỉ ngăn chặn hợp đồng khác gọi hàm, chứ hoàn toàn không làm bí mật dữ liệu đối với người ngoài, vì mọi dữ liệu trên blockchain đều công khai đọc được qua bộ nhớ storage của node.

2. Bộ lọc điều kiện (Modifiers)

Modifier là cơ chế tái sử dụng mã lệnh kiểm tra điều kiện trước và sau khi hàm chạy. Ký hiệu dấu gạch dưới _; (merge point) đánh dấu vị trí mà thân hàm chính sẽ được chèn vào:

modifier onlyAdmin() {
    require(msg.sender == admin, "Chi danh cho quan tri vien");
    _; // Than ham duoc thuc thi tai day neu dieu kien dung
}

3. Sự kiện (Events) và Cơ chế Ghi Log

Smart contract không thể in dữ liệu ra màn hình console như hàm print() trong Python hay std::cout trong C++. Để thông báo cho các ứng dụng giao diện (Frontend) biết một hành động đã diễn ra thành công, hợp đồng sử dụng lệnh emit EventName(...). Dữ liệu sự kiện được lưu trữ trong biên lai giao dịch (Transaction Receipt) trên chuỗi khối với chi phí gas cực rẻ (375 gas cho mỗi sự kiện, cộng 375 gas cho mỗi topic và 8 gas cho mỗi byte dữ liệu, rẻ hơn nhiều so với ghi vào Storage). Bằng cách gắn từ khóa indexed (tối đa 3 tham số indexed trong một event), các tham số này trở thành các chủ đề (Topics) giúp frontend lọc và tìm kiếm lịch sử giao dịch tức thì.

Học cùng giảng viên

Chủ đề này nằm trong Lecture 05 - Cài đặt môi trường & Triển khai smart contract đầu tiên của Khóa Blockchain. Xem đề cương

Bí quyết Tối ưu Gas: Kỹ thuật Gom Biến (Storage Packing)

Trong kiến trúc máy ảo EVM, vùng lưu trữ Storage được chia thành các khe cắm (slots) liên tiếp, mỗi slot rộng đúng 32 bytes (256 bits). Phép toán ghi mới một slot (SSTORE) tiêu tốn tới 20.000 gas.

Trình biên dịch Solidity thực hiện một quy tắc gom biến tuần tự (Sequential Variable Packing):

  • Nếu biến tiếp theo có kích thước đủ nhỏ để nhét vừa vào phần dung lượng còn trống của slot hiện tại, trình biên dịch sẽ nén nó vào chung slot đó.
  • Nếu biến tiếp theo có kích thước lớn hơn dung lượng còn lại, slot hiện tại sẽ bị đóng lại (để trống phần thừa), và biến mới sẽ chiếm một slot hoàn toàn mới!

Phân tích Ví dụ Thực tế:

Giả sử hợp đồng của bạn cần lưu 3 biến: uint128 a, uint256 b, và uint128 c.

  • Khai báo cẩu thả (Không tối ưu):
    uint128 a; // Slot 0: dung 16 bytes, trong 16 bytes
    uint256 b; // Slot 1: khong vua slot 0 (can 32 bytes), nhay sang slot 1 chiem tron 32 bytes
    uint128 c; // Slot 2: khong vua slot 1, nhay sang slot 2 dung 16 bytes
    // Tong cong ton: 3 SLOTS (Chi phi khoi tao ghi moi: 60.000 gas)
    
  • Khai báo tối ưu (Đã gom biến):
    uint128 a; // Slot 0: dung 16 bytes
    uint128 c; // Slot 0: vua van nhet tiep 16 bytes con lai -> Slot 0 day tron ven 32 bytes!
    uint256 b; // Slot 1: dung tron 32 bytes
    // Tong cong ton: 2 SLOTS (Chi phi khoi tao ghi moi: 40.000 gas -> Tiet kiem ngay 20.000 gas!)
    

Để tự động hóa việc phân tích và tối ưu hóa cấu trúc này, chúng ta xây dựng thuật toán phân tích bố cục bộ nhớ và đóng gói thùng tối ưu (Bin Packing Heuristic) bằng C++17 và Python 3.

// solution.cpp - Solidity Storage Layout & Packing Optimizer in C++17
#include <iostream>
#include <vector>
#include <string>
#include <tuple>
#include <algorithm>
#include <map>
#include <cassert>

int get_type_size(const std::string& type_name) {
    if (type_name == "bool" || type_name == "uint8") return 1;
    if (type_name == "uint16") return 2;
    if (type_name == "uint32") return 4;
    if (type_name == "uint64") return 8;
    if (type_name == "uint128") return 16;
    if (type_name == "address") return 20;
    if (type_name == "uint256" || type_name == "bytes32" || type_name == "mapping") return 32;
    return 32;
}

struct StorageReport {
    int total_slots;
    int optimal_slots;
    int saved_slots;
};

StorageReport analyze_storage_layout(const std::vector<std::pair<std::string, std::string>>& var_list) {
    int current_slot = 0;
    int current_offset = 0;

    std::vector<int> sizes;
    for (const auto& item : var_list) {
        int sz = get_type_size(item.second);
        sizes.push_back(sz);
        if (current_offset + sz > 32) {
            current_slot++;
            current_offset = 0;
        }
        current_offset += sz;
        if (current_offset == 32) {
            current_slot++;
            current_offset = 0;
        }
    }

    int total_slots = current_slot + (current_offset > 0 ? 1 : 0);

    // First-Fit Decreasing bin packing
    std::sort(sizes.begin(), sizes.end(), std::greater<int>());
    std::vector<int> bins;
    for (int s : sizes) {
        bool placed = false;
        for (size_t i = 0; i < bins.size(); ++i) {
            if (bins[i] + s <= 32) {
                bins[i] += s;
                placed = true;
                break;
            }
        }
        if (!placed) {
            bins.push_back(s);
        }
    }

    int optimal_slots = (int)bins.size();
    int saved = total_slots - optimal_slots;
    return {total_slots, optimal_slots, saved};
}

int main() {
    std::vector<std::pair<std::string, std::string>> sample = {
        {"owner", "address"},
        {"isActive", "bool"},
        {"count", "uint32"},
        {"balance", "uint256"}
    };
    StorageReport rep = analyze_storage_layout(sample);
    assert(rep.total_slots == 2);
    assert(rep.optimal_slots == 2);
    assert(rep.saved_slots == 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. Bảng quy đổi kích thước kiểu dữ liệu trong Solidity

Trong cả hai mã nguồn, từ điển kích thước định nghĩa chuẩn xác số byte của từng kiểu dữ liệu cơ bản: bool và uint8 chiếm 1 byte, uint16 chiếm 2 bytes, uint32 chiếm 4 bytes, uint64 chiếm 8 bytes, uint128 chiếm 16 bytes, address chiếm 20 bytes, và uint256, bytes32, mapping chiếm trọn vẹn 32 bytes.

2. Thuật toán Mô phỏng Thứ tự Gốc và Đóng gói Thùng Tối ưu

  • Tính toán thứ tự gốc (Original Layout): Duyệt tuần tự danh sách các biến được khai báo. Biến current_offset theo dõi số byte đã dùng trong current_slot. Nếu current_offset + size > 32, vị trí hiện tại không đủ sức chứa, ta tăng current_slot lên 1 và đặt lại offset về 0. Tổng số slot tiêu tốn của thứ tự ban đầu phản ánh chính xác cách trình biên dịch solc bố trí bộ nhớ trên EVM.
  • Thuật toán Đóng gói Thùng Tối ưu (First-Fit Decreasing Bin Packing): Sắp xếp các biến theo kích thước giảm dần. Lần lượt nhét từng biến vào chiếc thùng (slot 32 bytes) đầu tiên còn đủ dung lượng. Nếu không có thùng nào vừa, tạo một thùng mới. Số lượng thùng tối thiểu thu được chính là số slot tối ưu nhất mà hợp đồng có thể đạt được. Thuật toán trả về số slot ban đầu, số slot tối ưu và số lượng slot tiết kiệm được (mỗi slot tiết kiệm tương đương giảm 20.000 gas cho người triển khai hợp đồng).

Các Sai lầm Thường gặp khi Lập trình Solidity

  1. Khái niệm sai lầm về tính riêng tư của biến private: Nghĩ rằng biến đặt nhãn private sẽ giúp che giấu mật khẩu, seed phrase hoặc khóa bí mật. Cần ghi nhớ rằng toàn bộ bộ nhớ Storage của hợp đồng đều được lưu trên ổ cứng của hàng nghìn node công khai. Bất kỳ ai cũng có thể gọi hàm RPC eth_getStorageAt(contractAddress, slotIndex) để đọc sạch giá trị của các biến private.
  2. Quên cập nhật biến trạng thái trước khi gửi ETH: Đây là sai lầm kinh điển dẫn tới vụ hack The DAO. Hãy luôn luôn ghi nhớ quy tắc: Kiểm tra điều kiện (require) \(\to\) Trừ số dư trong biến trạng thái (balance -= amount) \(\to\) Sau cùng mới chuyển tiền (call{value: amount}("")).
  3. Sử dụng lệnh transfer() hoặc send() với lượng gas cố định 2300: Trước đây, các tài liệu cũ khuyên dùng addr.transfer(amount). Tuy nhiên, kể từ khi biểu phí gas của các opcode thay đổi qua các đợt Hard Fork, lệnh transfer chỉ cấp cứng 2300 gas khiến giao dịch gửi tiền tới các ví hợp đồng thông minh (như ví đa chữ ký Gnosis Safe hoặc ví Account Abstraction) bị lỗi thất bại. Phương pháp chuẩn mực hiện nay là sử dụng:
    (bool success, ) = recipient.call{value: amount}("");
    require(success, "Chuyen tien that bai");
    
  4. Khai báo mảng biến trạng thái trong vòng lặp: Đẩy các phần tử mới vào mảng storage liên tục bên trong vòng lặp for. Mỗi thao tác push() vào mảng storage là một lệnh SSTORE đắt đỏ. Thay vào đó, hãy gom dữ liệu và tính toán trong biến tạm trên memory, sau đó chỉ ghi một lần duy nhất vào storage khi kết thúc vòng lặp.
Làm thế nào để triển khai hợp đồng Solidity lên mạng thật?

Sau khi viết mã nguồn và kiểm thử cẩn thận trên Remix IDE hoặc các framework chuyên nghiệp như Hardhat hoặc Foundry, bạn cần chuẩn bị một ví tiền mã hóa (như MetaMask) có sẵn một lượng nhỏ ETH để trả phí gas triển khai. Bạn kết nối Remix với mạng thử nghiệm (Testnet như Sepolia) bằng môi trường Browser Extension (ví MetaMask), nhấn nút Deploy và xác nhận giao dịch trên ví. Sau khi giao dịch được đưa vào khối, hợp đồng của bạn sẽ có một địa chỉ chính thức trên mạng.

Tại sao không nên lưu trữ các tệp lớn (như ảnh, video) trực tiếp trong Solidity?

Bởi vì chi phí lưu trữ Storage trên blockchain là đắt nhất trong toàn bộ hệ sinh thái điện toán. Để lưu trữ 1 Megabyte dữ liệu vĩnh viễn trên mạng chính Ethereum có thể tiêu tốn hàng nghìn USD tiền phí gas. Do đó, các ứng dụng Web3 chỉ lưu trữ mã băm định danh (Content Identifier - CID) hoặc địa chỉ URI dẫn tới các hệ thống lưu trữ phân tán chuyên dụng như IPFS hoặc Arweave.

Thư viện OpenZeppelin là gì và tại sao nên sử dụng?

OpenZeppelin là bộ thư viện mã nguồn mở tiêu chuẩn vàng của ngành công nghiệp blockchain, cung cấp các mẫu hợp đồng thông minh đã được kiểm toán bảo mật khắt khe nhất thế giới (như chuẩn ERC-20, ERC-721, quản trị quyền hạn Ownable, kiểm soát truy cập phân quyền AccessControl, và chống tái nhập ReentrancyGuard). Thay vì tự viết lại từ đầu các logic bảo mật phức tạp, các lập trình viên chuyên nghiệp luôn kế thừa trực tiếp từ OpenZeppelin để triệt tiêu các lỗi bảo mật ngớ ngẩn.

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