Blockchain

Solana Là Gì? Từ Proof Of History Đến Alpenglow Và Lập Trình Rust

Solana tạo một khối khoảng 200 mili giây một lần, và từ ngày 21/10/2026 bản nâng cấp Alpenglow thay đồng hồ Proof of History cùng Tower BFT bằng cơ chế bỏ phiếu Votor, nhắm tới chốt giao dịch trong khoảng 150 mili giây.

KIẾN TRÚC MẠNG SOLANA VÀ RUST Đồng hồ PoH (tới 10/2026), Sealevel và ký quỹ rent Proof of History Đồng hồ băm, dùng tới 10/2026 Động Cơ Sealevel Chạy song song nhiều giao dịch Tài Khoản Phí Thuê Ký quỹ, hoàn lại khi đóng
KIẾN TRÚC MẠNG SOLANA VÀ RUST Cơ Chế PoH Chuỗi băm SHA-256, dùng tới 10/2026 Chạy Song Song Chạy song song nhiều giao dịch Tài Khoản Solana Tách riêng mã lệnh và dữ liệu lưu trữ
Hình 1. Ba ý chính của bài: đồng hồ Proof of History (Solana dùng tới tháng 10/2026), thực thi song song Sealevel và ký quỹ rent của tài khoản.

Trong thế giới blockchain Layer 1, nếu Ethereum được ví như một chiếc máy tính lớn toàn cầu chọn cách đi chậm mà chắc (mỗi khối 12 giây, mở rộng chủ yếu nhờ Layer 2) thì Solana xuất hiện như một đường đua công thức 1 tốc độ cao ngay trên Layer 1. Được thiết kế bởi Anatoly Yakovenko - từng là kỹ sư của tập đoàn bán dẫn Qualcomm, Solana tiếp cận bài toán mở rộng quy mô (Scalability) dưới góc nhìn của kỹ thuật viễn thông và phần cứng máy tính: làm thế nào để tận dụng tối đa băng thông mạng gigabit, ổ cứng SSD NVMe và các bộ vi xử lý đồ họa GPU đa luồng.

Kết quả của triết lý thiết kế đó là một mạng lưới tạo một khối khoảng 200 mili giây một lần (từ ngày 9/10/2026; trước đó là 400 mili giây), với phí cơ bản 5.000 lamport cho mỗi chữ ký, tức khoảng 0,00035 USD khi giá SOL là 70,67 USD (ngày 22/11/2026). Con số 65.000 giao dịch mỗi giây (Transactions Per Second - TPS) hay được nhắc tới là mức lý thuyết; trên mạng chính ngày 22/11/2026, số giao dịch của người dùng đo được là khoảng 1.500 đến 2.300 giao dịch mỗi giây. Để đạt hiệu năng này mà không cần chia cắt thanh khoản qua Layer 2 hay Sharding, từ khi ra mắt năm 2020 Solana dựa trên hai trụ cột kỹ thuật: đồng hồ mật mã học Proof of History (PoH) và Mô hình Tài khoản (Account Model) tách rời trạng thái. Ngày 21/10/2026, bản nâng cấp Alpenglow đã thay trụ cột thứ nhất: các validator bỏ phiếu trực tiếp với nhau theo giao thức Votor thay cho Tower BFT, và PoH không còn điều nhịp tạo khối.

Bài viết này sẽ phân tích cơ chế hoạt động của Proof of History (để hiểu Solana đã chạy thế nào trong sáu năm đầu và vì sao Alpenglow thay nó), những gì Alpenglow thay đổi, mô hình tài khoản và động cơ Sealevel, cơ chế ký quỹ lưu trữ (Rent Exemption) với mức phí mới, cùng các lưu ý khi lập trình bằng ngôn ngữ Rust và framework Anchor, kèm bộ mô phỏng kỹ thuật bằng C++17 và Python 3.

Nút Thắt Thời Gian trong Hệ Thống Phân Tán

Để hiểu tại sao Proof of History lại là một cuộc cách mạng, trước hết chúng ta cần hiểu điểm nghẽn lớn nhất của các hệ thống phân tán truyền thống (Distributed Systems): Khái niệm Thời gian.

Trong một hệ thống tập trung như ngân hàng thương mại, máy chủ trung tâm có một chiếc đồng hồ nguyên tử duy nhất. Khi bạn chuyển tiền, máy chủ ghi lại mốc thời gian (Timestamp) chính xác theo đồng hồ đó. Mọi tranh chấp được giải quyết dễ dàng vì có một nguồn chân lý thời gian duy nhất.

Tuy nhiên, trong một mạng lưới blockchain phi tập trung toàn cầu gồm hàng nghìn node độc lập:

  • Không có một chiếc đồng hồ trung tâm nào để tin tưởng.
  • Đồng hồ phần cứng nội bộ của từng máy tính có độ sai lệch (Clock Drift) lên tới vài giây.
  • Kẻ tấn công có thể cố tình gửi một khối với timestamp giả mạo nhằm chiếm lợi thế trong các giao dịch tài chính.
  • Do đó, trong các blockchain cổ điển như Bitcoin hay Ethereum, các node phải liên tục trao đổi các thông điệp mạng ngang hàng (P2P Message Passing) để bỏ phiếu và thống nhất xem giao dịch A xảy ra trước hay giao dịch B xảy ra trước. Quá trình trao đổi tin nhắn qua lại này tiêu tốn rất nhiều thời gian và băng thông, khiến tốc độ tạo khối bị ghìm lại ở mức 12 giây (Ethereum) hoặc 10 phút (Bitcoin).

Anatoly Yakovenko nhận ra rằng: Nếu có một cách nào đó để mã hóa dòng chảy thời gian trực tiếp vào dữ liệu của chuỗi khối trước khi các node tiến hành bỏ phiếu đồng thuận, chúng ta có thể loại bỏ hoàn toàn việc trao đổi tin nhắn xác thực thời gian, mở đường cho tốc độ tính toán song song cực đại.

Proof of History (PoH) Hoạt Động Như Thế Nào?

Phần này mô tả PoH như Solana đã dùng từ khi ra mắt năm 2020 tới ngày 21/10/2026; mục ngay sau nói Alpenglow đã thay nó ra sao.

Về bản chất toán học, Proof of History không phải là một thuật toán đồng thuận (Consensus Mechanism) độc lập như Proof of Work hay Proof of Stake. PoH là một Hàm trễ có thể kiểm chứng (Verifiable Delay Function - VDF) dựa trên việc lặp lại liên tục một hàm băm mật mã học một chiều (SHA-256).

1. Chuỗi băm thời gian tuần tự (Sequential Hashing)

Bộ tạo chuỗi PoH (thường là Leader Validator hiện tại) liên tục thực thi hàm băm SHA-256 trên một luồng CPU duy nhất: \[H_0 = \text{SHA-256}(\text{seed})\] \[H_1 = \text{SHA-256}(H_0)\] \[H_2 = \text{SHA-256}(H_1)\] \[\dots\] \[H_n = \text{SHA-256}(H_{n-1})\]

Đặc tính toán học của SHA-256 là không có bất kỳ phím tắt nào: bạn không thể dùng 1000 lõi CPU để tính toán trước giá trị \(H_{1.000.000}\) trong 1 giây, bởi vì muốn tính \(H_n\), bạn bắt buộc phải biết kết quả của \(H_{n-1}\). Do đó, việc sinh ra chuỗi băm này bắt buộc phải tiêu tốn một khoảng thời gian vật lý thực tế trên một lõi vi xử lý.

2. Gắn kết sự kiện vào dòng thời gian (Event Tagging)

Khi một người dùng gửi một giao dịch (ví dụ giao dịch chuyển 100 SOL có mã băm \(T_x\)) tới Leader Node tại mốc bước nhảy \(k\): Leader sẽ băm kết hợp giá trị băm hiện tại \(H_{k-1}\) với mã băm của giao dịch: \[H_k = \text{SHA-256}(H_{k-1} + T_x)\] Sau đó, Leader tiếp tục chu kỳ băm tự nhiên \(H_{k+1} = \text{SHA-256}(H_k)\).

Hành động này đóng đinh (anchor) giao dịch \(T_x\) vào dòng thời gian với hai chứng minh mật mã học không thể chối cãi:

  1. Chứng minh xảy ra sau (Created After): Giao dịch \(T_x\) chắc chắn phải được tạo ra sau mốc \(H_{k-1}\), vì nếu chưa có \(H_{k-1}\) thì không thể tính được \(H_k\).
  2. Chứng minh xảy ra trước (Created Before): Giao dịch \(T_x\) chắc chắn phải xảy ra trước mốc \(H_{k+1}\), vì kết quả của \(H_{k+1}\) phụ thuộc vào \(H_k\) (vốn chứa \(T_x\)).

3. Đột phá Xác minh Song song (Parallel Verification)

Điểm kỳ diệu của PoH nằm ở khâu xác minh: Trong khi quá trình tạo chuỗi băm bắt buộc phải chạy tuần tự trên 1 lõi, thì quá trình kiểm tra (Verification) lại có thể được chia nhỏ cho hàng trăm lõi CPU/GPU chạy song song cực nhanh! Ví dụ: Một khối gồm 4.000 bước băm có thể được chia đều cho 4 lõi GPU: Lõi 1 kiểm tra từ 0 đến 1000, Lõi 2 kiểm tra từ 1000 đến 2000... Toàn bộ chuỗi thời gian của một khối được xác minh chỉ trong vài phần nghìn giây.

Alpenglow: Solana Thay Tower BFT Và Bỏ PoH (21/10/2026)

Trong sáu năm đầu, Solana đạt đồng thuận bằng Tower BFT: các validator bỏ phiếu bằng chính các giao dịch trên chuỗi, xếp nhịp theo đồng hồ PoH, và một khối chỉ được coi là chốt hẳn (finalized) khi đã có đủ phiếu chồng lên qua 32 slot, mất khoảng 12,8 giây.

Alpenglow là giao thức đồng thuận mới do Anza (nhóm phát triển phần mềm validator Agave của Solana) thiết kế. Nó được kích hoạt trên mạng chính ở epoch 1064, bắt đầu ngày 21/10/2026, và chạy từ slot 459.653.000. Pha đầu tiên có tên Votor:

  • Phiếu bầu thành chứng chỉ: validator gửi phiếu trực tiếp cho nhau thay vì đưa giao dịch bỏ phiếu vào khối, rồi gộp phiếu thành chứng chỉ (certificate). Một khối được chốt sau một vòng bỏ phiếu nếu có ít nhất 80% lượng stake tham gia, hoặc sau hai vòng với ngưỡng 60%. Mục tiêu là chốt giao dịch trong khoảng 150 mili giây thay vì 12,8 giây.
  • Khối không còn giao dịch bỏ phiếu: trước đây phần lớn giao dịch trên Solana là phiếu bầu của validator; nay khối chỉ còn giao dịch của người dùng.
  • PoH không còn điều nhịp tạo khối: thời gian chờ (timeout) và chứng chỉ của Votor quyết định nhịp tạo khối, leader không phát các mục tick của PoH nữa.
  • Không đổi: máy ảo SVM, cách thực thi giao dịch, các chương trình (program) và phí giao dịch giữ nguyên. Pha thứ hai, Rotor (thay giao thức lan truyền khối Turbine), chưa có lịch.

Thời gian mỗi slot được rút ngắn riêng, theo đề xuất SIMD-0525, từ 400 xuống 200 mili giây qua bốn bước; bước cuối kích hoạt ngày 9/10/2026. Đo bằng phương thức RPC getRecentPerformanceSamples trên mạng chính ngày 22/11/2026, mạng tiến khoảng 280 slot mỗi phút, tức khoảng 215 mili giây mỗi slot.

Vì vậy, phần mô phỏng PoH trong bài giúp hiểu cơ chế mà Solana đã dùng và ý tưởng hàm trễ kiểm chứng được (VDF); mạng chính hiện nay không còn chạy PoH.

Mô Hình Tài Khoản Tách Rời (Account Model) và Động Cơ Sealevel

Nếu EVM gom cả mã thực thi (bytecode) và dữ liệu trạng thái (storage) vào chung một tài khoản hợp đồng thông minh, thì Solana lựa chọn kiến trúc hoàn toàn trái ngược: Tách rời mã lệnh khỏi dữ liệu.

1. Program Account (Hợp đồng thông minh)

  • Là tài khoản chứa mã thực thi: chương trình viết bằng Rust/C được biên dịch qua LLVM sang bytecode sBPF (Solana Bytecode Format), một biến thể của eBPF - extended Berkeley Packet Filter.
  • Tài khoản này có cờ executable = true.
  • Hoàn toàn không chứa dữ liệu trạng thái (Stateless): Program trên Solana giống như một hàm thuần túy (pure function) hoặc một thư viện mã dùng chung, chỉ đọc dữ liệu đầu vào và tính toán kết quả mà không lưu giữ số dư hay thông tin người dùng trong mã của nó.

2. Data Account (Tài khoản lưu dữ liệu)

  • Là các tài khoản độc lập chứa dữ liệu trạng thái thực tế của người dùng hoặc ứng dụng DApp (như số dư token, thông tin NFT, lệnh giao dịch).
  • Mỗi Data Account có một trường dữ liệu owner trỏ về địa chỉ của Program được phép sửa đổi dữ liệu bên trong nó. Một Program khác chỉ có quyền đọc chứ không thể tự ý ghi đè dữ liệu của Data Account này.
  • Program Derived Address (PDA): Là địa chỉ tài khoản đặc biệt được sinh ra từ mã băm của địa chỉ Program kết hợp với các chuỗi seed (không có khóa bí mật Private Key). Chỉ duy nhất Program sở hữu mới có quyền ký giao dịch và sửa đổi dữ liệu trên PDA này.

3. Động cơ Thực thi Song song Sealevel

Vì mọi giao dịch trên Solana đều bắt buộc phải khai báo trước toàn bộ danh sách các Data Account mà nó dự định đọc (read-only) hoặc ghi (read-write), động cơ Sealevel có thể phân tích đồ thị phụ thuộc của hàng nghìn giao dịch trong nháy mắt:

  • Nếu Giao dịch 1 ghi vào Tài khoản A và Giao dịch 2 ghi vào Tài khoản B: Hai giao dịch này hoàn toàn độc lập và được phân bổ cho hai lõi CPU khác nhau chạy đồng thời.
  • Nếu hai giao dịch cùng ghi vào Tài khoản A: Chúng sẽ được xếp hàng xử lý tuần tự.

Nhờ Sealevel, Solana tận dụng được 100% sức mạnh của các máy chủ phần cứng hiện đại với CPU 32 đến 64 lõi, giải quyết triệt để nút thắt cổ chai đơn luồng của EVM.

Cơ Chế Phí Thuê Kho Lưu Trữ (Rent Exemption)

Mọi validator phải lưu toàn bộ các tài khoản đang tồn tại và đọc ghi chúng thật nhanh. Nếu người dùng tạo ra hàng triệu tài khoản rác chứa dữ liệu rồi bỏ quên vĩnh viễn, dung lượng lưu trữ và bộ nhớ của các node sẽ phình lên không kiểm soát được.

Để giải quyết vấn đề này, Solana áp dụng cơ chế Phí thuê kho lưu trữ (Rent):

  • Mỗi tài khoản gồm 128 bytes phần đầu cố định (Metadata: địa chỉ sở hữu, số dư lamports, cờ executable...) cộng với số bytes dữ liệu thực tế data_len.
  • Solana quy định một mức ký quỹ tối thiểu (tên trong RPC là rent-exempt minimum): số dư tối thiểu = (128 + data_len) × số lamport mỗi byte. Tài khoản phải giữ đủ số dư này mới được tồn tại trên chuỗi. Việc thu tiền thuê định kỳ đã bị tắt, nên đây là khoản ký quỹ được hoàn lại đủ khi đóng tài khoản, không phải phí mất đi.
  • Mức lamport mỗi byte đang được hạ dần theo đề xuất SIMD-0437, từ 6.960 xuống 696 qua năm bước. Ngày 22/11/2026, phương thức RPC getMinimumBalanceForRentExemption của mạng chính trả về 650.240 lamport cho tài khoản 0 byte, tức 128 × 5.080: mức hiện hành là 5.080 lamport mỗi byte (với \(1 \text{ SOL} = 10^9 \text{ Lamports}\)). Vì mức này còn giảm tiếp, chương trình nên đọc số tối thiểu qua RPC (hoặc sysvar Rent trong chương trình on-chain) thay vì viết cứng một con số.
  • Khi người dùng không còn nhu cầu sử dụng DApp, lệnh đóng tài khoản (close_account) sẽ giải phóng vùng nhớ và hoàn trả 100% số tiền Lamports ký quỹ về lại ví của người dùng.

Bảng So Sánh Kiến Trúc: Solana vs Ethereum

Tiêu chí Ethereum (EVM) Solana (SVM / Sealevel)
Đồng thuận và nhịp thời gian Proof of Stake, mỗi slot 12 giây Tower BFT kèm đồng hồ PoH tới 21/10/2026; nay là Alpenglow (Votor), không còn PoH
Mô hình Hợp đồng Gom chung Code và Storage vào Contract Account Tách rời: Program (Stateless) và Data Account
Cơ chế thực thi Đơn luồng tuần tự (Single-threaded) Đa luồng song song thực thụ (Parallel Multi-threading)
Ngôn ngữ lập trình chính Solidity, Vyper (biên dịch ra EVM bytecode) Rust, C/C++ (biên dịch ra bytecode sBPF)
Thông lượng thực tế 15 – 30 TPS trên Layer 1 Khoảng 1.500 – 2.300 giao dịch người dùng mỗi giây (đo ngày 22/11/2026)
Thời gian tạo khối (Block Time) 12 giây Khoảng 200 mili giây mỗi slot (từ 9/10/2026)
Thời gian chốt giao dịch (Finality) Khoảng 13 phút (2 epoch) Mục tiêu khoảng 150 mili giây với Alpenglow (trước đó khoảng 12,8 giây)
Chi phí giao dịch trung bình Khoảng 0,01 – 0,05 USD lúc bình thường (tháng 11/2026), tăng mạnh khi nghẽn mạng Phí cơ bản 5.000 lamport mỗi chữ ký (khoảng 0,00035 USD), cộng phí ưu tiên tùy chọn
Quản lý bộ nhớ trạng thái Trả phí SSTORE một lần, lưu vĩnh viễn trên ổ cứng Cơ chế ký quỹ Rent-Exemption (hoàn trả khi đóng tài khoản)
Học cùng giảng viên

Chủ đề này nằm trong Lecture 03 - Solana là gì? của Khóa Blockchain. Xem đề cương

Thuật toán Mô phỏng PoH và Tính Phí Rent

Để làm chủ cơ chế PoH và Rent Exemption của Solana dưới góc nhìn kỹ thuật lập trình, chúng ta xây dựng bộ công cụ mô phỏng bằng C++17 và Python 3 thực hiện hai nhiệm vụ cốt lõi:

  1. Mô phỏng chuỗi PoH (cơ chế Solana dùng tới ngày 21/10/2026): Nhận một chuỗi hạt giống (seed), liên tục băm tuần tự SHA-256 qua num_hashes bước. Tại các bước chỉ định sẵn, chèn dữ liệu giao dịch bên ngoài vào hàm băm để kiểm chứng tính toàn vẹn thời gian.
  2. Bộ tính toán ký quỹ Rent-Exempt: Nhận kích thước dữ liệu data_len, cộng thêm 128 bytes metadata của tài khoản Solana, nhân với số lamport mỗi byte lamports_per_byte (tham số truyền vào, ví dụ 5.080 là mức trên mạng chính ngày 22/11/2026) để tính số Lamports và số SOL cần ký quỹ.
// solution.cpp - Solana Proof of History (co che cu, dung toi 21/10/2026) & Rent-Exempt Minimum in C++17
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <iomanip>
#include <map>
#include <cstdint>
#include <cstring>
#include <cassert>

// Standard self-contained SHA-256 implementation
class SHA256 {
private:
    uint32_t state[8];
    uint64_t bitlen;
    uint8_t data[64];
    uint32_t datalen;

    static uint32_t rotr(uint32_t a, uint32_t b) { return (a >> b) | (a << (32 - b)); }
    static uint32_t ch(uint32_t x, uint32_t y, uint32_t z) { return (x & y) ^ (~x & z); }
    static uint32_t maj(uint32_t x, uint32_t y, uint32_t z) { return (x & y) ^ (x & z) ^ (y & z); }
    static uint32_t sig0(uint32_t x) { return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22); }
    static uint32_t sig1(uint32_t x) { return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25); }
    static uint32_t theta0(uint32_t x) { return rotr(x, 7) ^ rotr(x, 18) ^ (x >> 3); }
    static uint32_t theta1(uint32_t x) { return rotr(x, 17) ^ rotr(x, 19) ^ (x >> 10); }

    static const uint32_t K[64];

    void transform(const uint8_t chunk[]) {
        uint32_t m[64];
        for (int i = 0, j = 0; i < 16; ++i, j += 4)
            m[i] = (chunk[j] << 24) | (chunk[j + 1] << 16) | (chunk[j + 2] << 8) | (chunk[j + 3]);
        for (int i = 16; i < 64; ++i)
            m[i] = theta1(m[i - 2]) + m[i - 7] + theta0(m[i - 15]) + m[i - 16];

        uint32_t a = state[0], b = state[1], c = state[2], d = state[3];
        uint32_t e = state[4], f = state[5], g = state[6], h = state[7];

        for (int i = 0; i < 64; ++i) {
            uint32_t t1 = h + sig1(e) + ch(e, f, g) + K[i] + m[i];
            uint32_t t2 = sig0(a) + maj(a, b, c);
            h = g; g = f; f = e; e = d + t1;
            d = c; c = b; b = a; a = t1 + t2;
        }

        state[0] += a; state[1] += b; state[2] += c; state[3] += d;
        state[4] += e; state[5] += f; state[6] += g; state[7] += h;
    }

public:
    SHA256() { reset(); }

    void reset() {
        datalen = 0;
        bitlen = 0;
        state[0] = 0x6a09e667; state[1] = 0xbb67ae85; state[2] = 0x3c6ef372; state[3] = 0xa54ff53a;
        state[4] = 0x510e527f; state[5] = 0x9b05688c; state[6] = 0x1f83d9ab; state[7] = 0x5be0cd19;
    }

    void update(const uint8_t* p, size_t len) {
        for (size_t i = 0; i < len; ++i) {
            data[datalen] = p[i];
            datalen++;
            if (datalen == 64) {
                transform(data);
                bitlen += 512;
                datalen = 0;
            }
        }
    }

    std::string finalize() {
        uint32_t i = datalen;
        if (datalen < 56) {
            data[i++] = 0x80;
            while (i < 56) data[i++] = 0x00;
        } else {
            data[i++] = 0x80;
            while (i < 64) data[i++] = 0x00;
            transform(data);
            memset(data, 0, 56);
        }

        bitlen += datalen * 8;
        data[63] = bitlen;
        data[62] = bitlen >> 8;
        data[61] = bitlen >> 16;
        data[60] = bitlen >> 24;
        data[59] = bitlen >> 32;
        data[58] = bitlen >> 40;
        data[57] = bitlen >> 48;
        data[56] = bitlen >> 56;
        transform(data);

        std::ostringstream ss;
        for (int j = 0; j < 8; ++j) {
            ss << std::hex << std::setw(8) << std::setfill('0') << state[j];
        }
        return ss.str();
    }

    static std::string hash_string(const std::string& input) {
        SHA256 ctx;
        ctx.update(reinterpret_cast<const uint8_t*>(input.data()), input.size());
        return ctx.finalize();
    }
};

const uint32_t SHA256::K[64] = {
    0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
    0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
    0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
    0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
    0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
    0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
    0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
    0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
};

struct SolanaReport {
    std::string final_poh_prefix;
    int total_steps;
    long long rent_lamports;
    std::string rent_sol_str;
};

// So byte phan dau co dinh Solana tinh cho moi tai khoan khi tinh ky quy
const long long ACCOUNT_STORAGE_OVERHEAD = 128;

// lamports_per_byte: muc ky quy moi byte, dang giam dan theo SIMD-0437. Doc muc hien hanh qua RPC
// getMinimumBalanceForRentExemption (ngay 22/11/2026 tren mang chinh la 5080 lamport moi byte).
SolanaReport simulate_solana(const std::string& seed,
                             int num_hashes,
                             const std::vector<std::pair<int, std::string>>& events,
                             int data_len,
                             long long lamports_per_byte) {
    std::map<int, std::string> ev_map;
    for (const auto& ev : events) {
        ev_map[ev.first] = ev.second;
    }

    std::string cur = SHA256::hash_string(seed);
    for (int i = 1; i <= num_hashes; ++i) {
        if (ev_map.count(i)) {
            cur = SHA256::hash_string(cur + ev_map[i]);
        } else {
            cur = SHA256::hash_string(cur);
        }
    }

    long long total_bytes = data_len + ACCOUNT_STORAGE_OVERHEAD;
    long long rent_lamports = total_bytes * lamports_per_byte;

    // 1 SOL = 10^9 lamport: in du 9 chu so thap phan bang phep chia nguyen, khong lam tron so thuc
    std::ostringstream ss;
    ss << rent_lamports / 1000000000LL << '.' << std::setw(9) << std::setfill('0') << rent_lamports % 1000000000LL;

    return {cur.substr(0, 16), num_hashes, rent_lamports, ss.str()};
}

int main() {
    SolanaReport r = simulate_solana("genesis", 5, {}, 0, 5080);
    assert(r.final_poh_prefix == "fa921638a80a3f61");
    assert(r.rent_lamports == 650240);  // = 128 * 5080, dung so RPC mang chinh tra ve ngay 22/11/2026
    assert(r.rent_sol_str == "0.000650240");
    std::cout << "C++17 Solana PoH & Rent check PASSED!\n";
    return 0;
}

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

1. Thuật toán Hashing Tuần tự Proof of History

Trong cả hai phiên bản:

  • Bước khởi tạo tính mã băm đầu tiên \(H_0 = \text{SHA256}(\text{seed})\).
  • Một vòng lặp chạy từ bước 1 đến num_hashes. Tại mỗi bước i, hàm kiểm tra xem có sự kiện giao dịch nào diễn ra tại thời điểm đó không (thông qua bảng ánh xạ ev_map).
  • Nếu có sự kiện tại bước i, hàm băm nối chuỗi giá trị băm của bước trước đó với chuỗi dữ liệu giao dịch: \(\text{SHA256}(H_{i-1} + \text{data})\). Ngược lại, nếu là bước trôi qua bình thường của đồng hồ, hàm chỉ băm lại giá trị cũ: \(\text{SHA256}(H_{i-1})\).
  • Kết quả đầu ra trả về 16 ký tự hexa đầu tiên của mã băm sau cùng, đóng vai trò như một mốc thời gian mật mã học (Tick Hash Checkpoint).

2. Thuật toán Tính toán Ký quỹ Rent Exemption

  • Kích thước dùng để tính ký quỹ là total_bytes = data_len + 128. Con số 128 bytes này là phần lưu trữ cố định Solana tính thêm cho mỗi tài khoản (ứng với phần đầu như khóa công khai Pubkey của chủ sở hữu, số dư Lamports, độ dài dữ liệu, cờ executable...).
  • Số Lamports ký quỹ bắt buộc: rent_lamports = total_bytes * lamports_per_byte. Với 5.080 lamport mỗi byte, tài khoản 0 byte cần 128 × 5.080 = 650.240 lamport và tài khoản token 165 byte cần 293 × 5.080 = 1.488.440 lamport, đúng bằng các số mà RPC getMinimumBalanceForRentExemption của mạng chính trả về ngày 22/11/2026.
  • Số SOL tương ứng được in đủ 9 chữ số thập phân (\(1 \text{ SOL} = 10^9\) lamport) bằng phép chia nguyên, nên không có sai số làm tròn của số thực.

Các Lỗi Thường Gặp khi Lập Trình Solana với Rust/Anchor

  1. Quên kiểm tra chủ quyền tài khoản (Missing Account Owner Check): Trong các chương trình Solana viết bằng Rust thuần túy, nếu lập trình viên quên kiểm tra điều kiện account.owner == expected_program_id, kẻ tấn công có thể tự tạo một tài khoản giả mạo có cùng cấu trúc dữ liệu nhưng do chính hacker làm chủ để đánh lừa logic xử lý tiền của chương trình. Khi sử dụng framework Anchor, lỗi này được tự động hóa triệt tiêu nhờ macro #[account(mut)] và các ràng buộc kiểu định sẵn.
  2. Không nạp đủ hoặc viết cứng số Rent-Exempt Lamports khi khởi tạo tài khoản: Mọi tài khoản phải giữ đủ số dư tối thiểu theo kích thước dữ liệu. Nếu chương trình tạo một Data Account mới với số dư nhỏ hơn ngưỡng này, giao dịch bị từ chối (lỗi InsufficientFundsForRent) và tài khoản không được tạo. Cơ chế cũ trừ dần tiền thuê qua từng kỷ nguyên (Epoch) đã bị tắt. Lỗi hay gặp hơn bây giờ là viết cứng con số ký quỹ theo mức cũ (ví dụ 2.039.280 lamport cho tài khoản token theo mức 6.960): hãy đọc mức hiện hành qua RPC getMinimumBalanceForRentExemption hoặc sysvar Rent.
  3. Trùng lặp Seed trong khởi tạo PDA: Khởi tạo tài khoản Program Derived Address (PDA) với các chuỗi seed quá chung chung (ví dụ chỉ dùng một chuỗi hằng số "user_data" mà không ghép thêm user_pubkey). Hậu quả là người dùng sau sẽ ghi đè lên tài khoản PDA của người dùng trước, gây xung đột trạng thái nghiêm trọng.
  4. Vượt quá giới hạn Compute Budget: Mặc định mỗi lệnh (instruction) không phải lệnh dựng sẵn được cấp 200.000 Compute Units (CU); một giao dịch có thể xin tối đa 1.400.000 CU bằng lệnh SetComputeUnitLimit. Nếu logic hàm Rust của bạn chứa các vòng lặp tính toán quá nặng hoặc giải mã các chuỗi dữ liệu lồng nhau phức tạp vượt quá mức này, giao dịch sẽ lập tức bị hủy bỏ với mã lỗi ComputationalBudgetExceeded.
Tại sao Solana chọn ngôn ngữ Rust thay vì Solidity?

Solidity được thiết kế cho môi trường máy ảo EVM thông dịch (interpreted virtual machine), vốn có tốc độ thực thi tương đối chậm và tốn nhiều tài nguyên. Ngược lại, Rust là ngôn ngữ lập trình hệ thống cấp thấp không sử dụng bộ thu gom rác (Garbage Collector), kiểm soát bộ nhớ nghiêm ngặt thông qua cơ chế Ownership và Borrowing. Mã nguồn Rust được biên dịch ra bytecode sBPF; validator dịch tiếp bytecode này sang mã máy (JIT) nên chương trình chạy gần với tốc độ của CPU, đáp ứng yêu cầu xử lý hàng nghìn giao dịch mỗi giây của Solana.

Framework Anchor trong hệ sinh thái Solana tương đương với công cụ nào của Ethereum?

Anchor trong lập trình Solana đóng vai trò tương tự như bộ đôi Hardhat/Foundry kết hợp với thư viện OpenZeppelin của Ethereum. Anchor tự động hóa việc tạo bản đặc tả giao tiếp IDL (tương đương với ABI trong Ethereum), tự động sinh mã kiểm tra bảo mật tài khoản (Account Validation), xử lý việc đóng gói và giải nén dữ liệu qua thư viện Borsh, giúp lập trình viên giảm bớt tới 70% các dòng mã lặp lại (boilerplate code) dễ gây lỗi trong Rust thuần.

Sự cố mạng ngừng hoạt động (Network Outage) của Solana xuất phát từ đâu?

Trong quá khứ, các đợt gián đoạn hoạt động của mạng lưới Solana chủ yếu xuất phát từ việc các bot giao dịch tự động bắn hàng triệu giao dịch rác (spam transactions) mỗi giây vào một đợt phát hành NFT hoặc sàn giao dịch DEX. Vì chi phí giao dịch trên Solana quá rẻ, các bot có thể spam với chi phí gần như bằng 0, khiến bộ đệm mạng của các node xác thực bị tràn bộ nhớ. Solana đã giảm mạnh vấn đề này nhờ triển khai giao thức mạng QUIC, cơ chế thị trường phí cục bộ (Local Fee Markets) và thuật toán phân bổ quyền ưu tiên dựa trên lượng SOL đặt cọc (Stake-weighted QoS).

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