Trong thế giới khoa học máy tính truyền thống, một chương trình phần mềm được biên dịch thành mã máy nhị phân chạy trực tiếp trên kiến trúc phần cứng của vi xử lý cụ thể như x86-64 của Intel/AMD hoặc ARM của Apple Silicon. Tuy nhiên, trong một mạng lưới phi tập trung toàn cầu như Ethereum, nơi có hàng vạn máy tính độc lập (nodes) tham gia xác thực với đủ loại phần cứng và hệ điều hành khác nhau, làm thế nào để đảm bảo một đoạn mã smart contract luôn cho ra kết quả tính toán chính xác tuyệt đối như nhau trên mọi máy?
Câu trả lời nằm ở Ethereum Virtual Machine (EVM) - một máy ảo phần mềm trừu tượng hóa toàn bộ phần cứng vật lý, tạo ra một môi trường thực thi tất định (deterministic execution environment). Đồng thời, để bảo vệ cỗ máy tính toán dùng chung này khỏi các cuộc tấn công treo máy vô tận hoặc cạn kiệt tài nguyên bộ nhớ, Ethereum xây dựng một nền kinh tế năng lượng mang tên Phí Gas, được cách mạng hóa qua đề xuất EIP-1559.
Bài viết này sẽ đi sâu vào chi tiết vi kiến trúc của máy ảo EVM, cấu trúc ba vùng dữ liệu Stack - Memory - Storage, chu trình thực thi opcode, bản chất kinh tế học của phí Gas và cách mô phỏng máy ảo bằng mã nguồn C++17 và Python 3.
EVM là gì? Bản chất của Máy tính Toàn cầu
Về mặt lý thuyết tính toán, EVM là một máy Turing-complete phân tán. Thuật ngữ "Turing-complete" đồng nghĩa với việc EVM có khả năng thực hiện bất kỳ phép toán nào có thể tính toán được, bao gồm các phép rẽ nhánh có điều kiện, các vòng lặp và lời gọi hàm đệ quy phức tạp (khác biệt cơ bản so với ngôn ngữ Script có chủ đích giới hạn của Bitcoin).
Tuy nhiên, tính năng Turing-complete mang lại một lỗ hổng lý thuyết kinh điển trong khoa học máy tính: Bài toán dừng (The Halting Problem) được chứng minh bởi Alan Turing năm 1936. Không có một thuật toán nào có thể nhìn vào một đoạn mã bất kỳ và dự đoán chắc chắn rằng đoạn mã đó sẽ kết thúc hay sẽ chạy mãi mãi trong một vòng lặp vô hạn while(true). Nếu một lập trình viên vô tình hay cố ý triển khai một smart contract chứa vòng lặp vô hạn lên Ethereum, mọi node trong mạng khi cố gắng xác thực giao dịch sẽ bị treo vĩnh viễn, dẫn tới sụp đổ toàn bộ chuỗi khối.
Để giải quyết triệt để vấn đề này, kiến trúc sư trưởng của Ethereum - Vitalik Buterin cùng tiến sĩ Gavin Wood (tác giả của cuốn Ethereum Yellow Paper) đã đưa ra giải pháp Phí Gas: mỗi chỉ thị tính toán đều phải trả giá bằng một lượng nhiên liệu xác định. Người gửi giao dịch bắt buộc phải cung cấp một mức giới hạn nhiên liệu (gasLimit). Mỗi khi EVM thực thi một lệnh, lượng gas tương ứng bị trừ dần. Nếu gas về 0 trước khi chương trình kết thúc, EVM lập tức ngắt lệnh, kích hoạt lỗi Out of Gas, hủy bỏ mọi thay đổi trạng thái nhưng vẫn tịch thu toàn bộ phí gas của người gửi nhằm phạt hành vi làm lãng phí tài nguyên mạng lưới.
Kiến trúc Ba Vùng Dữ liệu của EVM
Khác với các kiến trúc máy tính thanh ghi (Register-based Virtual Machine) như Lua VM hay Dalvik VM của Android, EVM được thiết kế theo mô hình Máy ảo dựa trên Ngăn xếp (Stack-based Virtual Machine) với độ rộng từ chuẩn (Word Size) là 256-bit (tương đương 32 bytes). Sự lựa chọn kích thước 256-bit là có chủ đích kỹ thuật sâu sắc: nó giúp xử lý tự nhiên và hiệu quả các hàm băm mật mã học độ dài 256-bit như Keccak-256 hay đường cong elliptic secp256k1 mà không cần chia nhỏ dữ liệu.
EVM phân tách rạch ròi ba vùng không gian dữ liệu phục vụ các mục đích tính toán khác nhau:
1. Stack (Ngăn xếp thao tác)
- Hoạt động theo cơ chế LIFO (Vào sau Ra trước).
- Độ sâu tối đa được giới hạn nghiêm ngặt ở mức 1024 phần tử. Mỗi phần tử là một từ 256-bit.
- Mọi phép toán số học (
ADD,SUB,MUL,DIV), phép toán logic (AND,OR,XOR,NOT) và điều khiển luồng (JUMP,JUMPI) đều lấy toán hạng trực tiếp từ đỉnh Stack và đẩy kết quả trở lại đỉnh Stack. - Chi phí gas: Rất rẻ, chỉ khoảng 3 gas cho các phép toán thông thường (
PUSH,POP,ADD). - Giới hạn kỹ thuật: EVM chỉ có thể truy cập trực tiếp tối đa 16 phần tử trên đỉnh ngăn xếp thông qua các lệnh
DUP1–DUP16hoặcSWAP1–SWAP16. Nếu một hàm trong Solidity khai báo quá nhiều biến cục bộ vượt quá phạm vi này, trình biên dịch sẽ báo lỗi kinh điển:Stack Too Deep.
2. Memory (Bộ nhớ tạm thời)
- Là một mảng byte tuyến tính (Byte-addressable linear memory) được cấp phát tự động trong quá trình thực thi hàm.
- Có tính chất tạm thời (Volatile): Toàn bộ nội dung trong Memory sẽ bị xóa sạch hoàn toàn ngay khi lệnh gọi hàm hoặc giao dịch kết thúc.
- Được dùng để lưu trữ các cấu trúc dữ liệu tạm thời như chuỗi ký tự (
string), mảng byte (bytes), hoặc chuẩn bị tham số calldata trước khi gọi sang một hợp đồng khác. - Chi phí gas: Tăng theo hàm bậc hai (Quadratic Memory Expansion Cost). Khi mở rộng kích thước bộ nhớ lên
wtừ (mỗi từ 32 bytes), chi phí gas được tính bằng công thức: \[\text{Cost}(w) = 3 \times w + \left\lfloor \frac{w^2}{512} \right\rfloor\] Quy tắc tính phí này nhằm ngăn chặn một giao dịch cấp phát hàng trăm Megabyte RAM trên máy chủ của các validator, khiến hệ thống cạn kiệt bộ nhớ.
3. Storage (Vùng lưu trữ trạng thái vĩnh viễn)
- Là vùng nhớ đại diện cho trạng thái của hợp đồng, tồn tại vĩnh viễn trên ổ cứng của toàn bộ các node thông qua cấu trúc cây Merkle Patricia Trie.
- Về bản chất, Storage là một bảng băm ánh xạ khổng lồ chứa \(2^{256}\) vị trí (slots), mỗi slot có kích thước 32 bytes (256-bit key mapped to 256-bit value).
- Chi phí gas: Cực kỳ đắt đỏ vì nó đòi hỏi các node phải ghi dữ liệu xuống đĩa cứng (Disk I/O) và duy trì vĩnh viễn trong trạng thái toàn cục của blockchain:
SSTORE(ghi mới từ giá trị 0 lên một giá trị khác): Tiêu tốn tới 20.000 gas.SSTORE(ghi đè một giá trị đã tồn tại): Tiêu tốn 2.900 gas (hoặc 5.000 gas tùy thuộc trạng thái warm/cold).SLOAD(đọc dữ liệu từ storage): Tiêu tốn 2.100 gas cho lần đọc đầu tiên (Cold Access) và giảm xuống 100 gas cho các lần đọc kế tiếp trong cùng giao dịch (Warm Access theo EIP-2929).
Bảng so sánh 3 vùng nhớ trong EVM
| Tiêu chí | Stack | Memory | Storage |
|---|---|---|---|
| Vòng đời tồn tại | Tồn tại trong phạm vi thực thi lệnh hiện tại | Tồn tại trong suốt một lời gọi hàm (Message Call) | Tồn tại vĩnh viễn cùng vòng đời của hợp đồng |
| Độ rộng truy xuất | 256-bit (từng từ 32 bytes) | Đánh địa chỉ theo từng byte đơn lẻ | Đánh địa chỉ theo từng slot 256-bit |
| Dung lượng tối đa | 1024 phần tử (tương đương 32 KB) | Không giới hạn cứng, nhưng bị chặn bởi phí gas bậc hai | \(2^{256}\) slots (về mặt lý thuyết là vô hạn) |
| Mức độ tốn Gas | Rất thấp (~3 gas/lệnh) | Trung bình (tăng tuyến tính rồi nhảy vọt bậc hai) | Rất cao (lên tới 20.000 gas cho mỗi thao tác ghi mới) |
| Vị trí lưu trữ | Thanh ghi hoặc RAM máy ảo | RAM của node thực thi | Cơ sở dữ liệu trạng thái (LevelDB/RocksDB) trên ổ cứng |
Cơ chế Phí Gas EIP-1559: Cách mạng Kinh tế học Ethereum
Trước bản nâng cấp London Hard Fork (tháng 8/2021), Ethereum sử dụng cơ chế đấu giá giá đầu tiên (First-Price Auction). Người dùng tự đặt mức giá gas (gasPrice) mà họ sẵn sàng trả. Thợ đào sẽ ưu tiên chọn các giao dịch trả giá cao nhất xếp vào khối. Cơ chế này bộc lộ những nhược điểm nghiêm trọng: người dùng liên tục phải trả hớ giá (overpaying), phí giao dịch biến động thất thường và thiếu khả năng dự báo.
Đề xuất EIP-1559 do Vitalik Buterin khởi xướng đã tái thiết kế hoàn toàn mô hình kinh tế này với 3 thành phần cốt lõi:
1. Phí cơ sở (Base Fee)
- Là mức giá tối thiểu bắt buộc trên mỗi đơn vị gas để giao dịch được đưa vào khối.
- Base Fee không do thợ đào hay người dùng tự ý quyết định, mà được thuật toán của mạng lưới tự động tính toán dựa trên mức độ nghẽn của khối trước đó.
- Mỗi khối Ethereum có mục tiêu kích thước (Target Gas) bằng một nửa giới hạn gas của khối (Gas Limit). Giới hạn này do các validator điều chỉnh dần: tháng 11/2026 là 60 triệu gas, tức mục tiêu 30 triệu gas:
- Nếu khối trước sử dụng đúng 30 triệu gas: Base Fee giữ nguyên.
- Nếu khối trước sử dụng nhiều hơn 30 triệu gas: Base Fee của khối tiếp theo sẽ tăng, tối đa 12.5%.
- Nếu khối trước sử dụng ít hơn 30 triệu gas: Base Fee của khối tiếp theo sẽ giảm, tối đa 12.5%.
- Cơ chế đốt phí (Burn Mechanism): Toàn bộ lượng ETH thu được từ Base Fee bị loại bỏ vĩnh viễn khỏi lưu thông (Burned). Cơ chế này biến Ethereum thành một tài sản giảm phát (Ultrasound Money) khi nhu cầu sử dụng mạng lưới tăng cao.
2. Phí ưu tiên (Priority Fee hay Miner Tip)
- Là khoản tiền thưởng tùy chọn mà người dùng trả trực tiếp cho validator để khuyến khích họ đưa giao dịch vào block nhanh hơn trong những lúc cao điểm.
3. Mức phí tối đa người dùng chấp nhận (Max Fee)
- Người dùng chỉ định mức phí trần
maxFeePerGasmà họ sẵn sàng chi trả. - Công thức tính giá gas thực tế (Effective Gas Price) tuân theo công thức: \[P_{\text{eff}} = \text{BaseFee} + \min(\text{PriorityFee}, \text{MaxFee} - \text{BaseFee})\]
- Nếu
MaxFee < BaseFeecủa khối, giao dịch không được đưa vào khối đó; nó nằm chờ trong mempool cho tới khi Base Fee giảm xuống dướiMaxFee(hoặc bị loại khỏi hàng đợi).
Chủ đề này nằm trong Lecture 01 - Tổng quan về Blockchain của Khóa Blockchain. Xem đề cương
Thuật toán Mô phỏng EVM & Phí Gas EIP-1559
Để làm chủ kiến trúc EVM dưới góc độ kỹ thuật, chúng ta xây dựng một bộ mô phỏng máy ảo stack thu gọn có khả năng:
- Kiểm tra tính hợp lệ của tham số phí EIP-1559 và tính toán
effective_gas_price. - Khởi tạo chi phí cơ bản cho một giao dịch chuẩn (Standard Base Cost = 21.000 gas).
- Thực thi ngăn xếp 256-bit cho các opcode số học (
PUSH,ADD,SUB,MUL) kèm kiểm tra lỗi tràn/thiếu ngăn xếp (STACK_UNDERFLOW). - Quản lý vùng lưu trữ
Storagevới chi phíSLOAD(100 gas) vàSSTORE(20.000 gas cho ô nhớ mới, 2.900 gas cho ô nhớ sửa đổi). Bảng phí này đã giản lược: trên mạng thật, lần đầu chạm một ô nhớ trong giao dịch tốn thêm 2.100 gas (truy cập lạnh), và ghi lại một ô đã ghi trong cùng giao dịch chỉ tốn 100 gas. - Theo dõi tổng lượng gas tiêu thụ và phát hiện lỗi cạn kiệt nhiên liệu (
OUT_OF_GAS). - Tính toán rạch ròi tổng tiền phí, lượng ETH bị đốt (Burned) và lượng ETH thưởng cho validator.
// solution.cpp - EVM Stack and EIP-1559 Gas Simulator in C++17
#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <cstdint>
#include <cassert>
struct BigInt256 {
uint64_t limb[4] = {0, 0, 0, 0};
BigInt256() = default;
BigInt256(uint64_t v) { limb[0] = v; }
static BigInt256 from_string(const std::string& s) {
BigInt256 res;
for (char c : s) {
uint64_t carry = c - '0';
for (int i = 0; i < 4; ++i) {
__uint128_t prod = (__uint128_t)res.limb[i] * 10 + carry;
res.limb[i] = (uint64_t)prod;
carry = (uint64_t)(prod >> 64);
}
}
return res;
}
BigInt256 operator+(const BigInt256& o) const {
BigInt256 res;
uint64_t carry = 0;
for (int i = 0; i < 4; ++i) {
__uint128_t sum = (__uint128_t)limb[i] + o.limb[i] + carry;
res.limb[i] = (uint64_t)sum;
carry = (uint64_t)(sum >> 64);
}
return res;
}
BigInt256 operator-(const BigInt256& o) const {
BigInt256 res;
uint64_t borrow = 0;
for (int i = 0; i < 4; ++i) {
__int128_t diff = (__int128_t)limb[i] - o.limb[i] - borrow;
if (diff < 0) {
diff += ((__int128_t)1 << 64);
borrow = 1;
} else {
borrow = 0;
}
res.limb[i] = (uint64_t)diff;
}
return res;
}
BigInt256 operator*(const BigInt256& o) const {
BigInt256 res;
for (int i = 0; i < 4; ++i) {
uint64_t carry = 0;
for (int j = 0; i + j < 4; ++j) {
__uint128_t prod = (__uint128_t)res.limb[i+j] + (__uint128_t)limb[i] * o.limb[j] + carry;
res.limb[i+j] = (uint64_t)prod;
carry = (uint64_t)(prod >> 64);
}
}
return res;
}
std::string to_string() const {
if (limb[0] == 0 && limb[1] == 0 && limb[2] == 0 && limb[3] == 0) return "0";
BigInt256 copy = *this;
std::string s;
while (!(copy.limb[0] == 0 && copy.limb[1] == 0 && copy.limb[2] == 0 && copy.limb[3] == 0)) {
uint64_t rem = 0;
for (int i = 3; i >= 0; --i) {
__uint128_t cur = ((__uint128_t)rem << 64) | copy.limb[i];
copy.limb[i] = (uint64_t)(cur / 10);
rem = (uint64_t)(cur % 10);
}
s += (char)('0' + rem);
}
std::reverse(s.begin(), s.end());
return s;
}
};
struct Op {
std::string code;
uint64_t val1 = 0;
uint64_t val2 = 0;
};
struct EvmResult {
std::string status;
long long gas_used;
long long total_fee_gwei;
long long burned_gwei;
std::string top_stack;
};
EvmResult simulate_evm(long long base_fee,
long long max_fee,
long long max_priority,
long long gas_limit,
const std::vector<Op>& opcodes) {
if (max_fee < base_fee) {
return {"INVALID_FEE", 0, 0, 0, "0"};
}
long long priority_fee = std::min(max_priority, max_fee - base_fee);
long long effective_gas_price = base_fee + priority_fee;
long long gas_used = 21000;
std::vector<BigInt256> stack;
std::map<uint64_t, uint64_t> storage;
for (const auto& op : opcodes) {
if (op.code == "PUSH") {
gas_used += 3;
stack.push_back(BigInt256(op.val1));
} else if (op.code == "ADD") {
if (stack.size() < 2) {
// Thieu toan hang la dung bat thuong: mat toan bo gas_limit, giong OUT_OF_GAS
return {"STACK_UNDERFLOW", gas_limit, gas_limit * effective_gas_price, gas_limit * base_fee, "0"};
}
BigInt256 a = stack.back(); stack.pop_back();
BigInt256 b = stack.back(); stack.pop_back();
gas_used += 3;
stack.push_back(a + b);
} else if (op.code == "SUB") {
if (stack.size() < 2) {
// Thieu toan hang la dung bat thuong: mat toan bo gas_limit, giong OUT_OF_GAS
return {"STACK_UNDERFLOW", gas_limit, gas_limit * effective_gas_price, gas_limit * base_fee, "0"};
}
BigInt256 a = stack.back(); stack.pop_back();
BigInt256 b = stack.back(); stack.pop_back();
gas_used += 3;
stack.push_back(a - b);
} else if (op.code == "MUL") {
if (stack.size() < 2) {
// Thieu toan hang la dung bat thuong: mat toan bo gas_limit, giong OUT_OF_GAS
return {"STACK_UNDERFLOW", gas_limit, gas_limit * effective_gas_price, gas_limit * base_fee, "0"};
}
BigInt256 a = stack.back(); stack.pop_back();
BigInt256 b = stack.back(); stack.pop_back();
gas_used += 5;
stack.push_back(a * b);
} else if (op.code == "SLOAD") {
uint64_t key = op.val1;
gas_used += 100;
uint64_t val = storage.count(key) ? storage[key] : 0;
stack.push_back(BigInt256(val));
} else if (op.code == "SSTORE") {
uint64_t key = op.val1;
uint64_t val = op.val2;
uint64_t old_val = storage.count(key) ? storage[key] : 0;
if (old_val == 0 && val != 0) {
gas_used += 20000;
} else {
gas_used += 2900;
}
storage[key] = val;
}
if (gas_used > gas_limit) {
return {"OUT_OF_GAS", gas_limit, gas_limit * effective_gas_price, gas_limit * base_fee, "0"};
}
}
long long total_fee = gas_used * effective_gas_price;
long long burned = gas_used * base_fee;
std::string top_stack = stack.empty() ? "0" : stack.back().to_string();
return {"SUCCESS", gas_used, total_fee, burned, top_stack};
}
int main() {
std::vector<Op> ops = {{"PUSH", 10, 0}, {"PUSH", 25, 0}, {"ADD", 0, 0}};
EvmResult r = simulate_evm(30, 50, 2, 50000, ops);
assert(r.status == "SUCCESS");
assert(r.gas_used == 21009);
assert(r.total_fee_gwei == 672288);
assert(r.burned_gwei == 630270);
assert(r.top_stack == "35");
std::cout << "C++17 EVM checks PASSED!\n";
return 0;
}
# solution.py - EVM Stack and EIP-1559 Gas Simulator
def simulate_evm(base_fee, max_fee, max_priority, gas_limit, opcodes):
if max_fee < base_fee:
return ("INVALID_FEE", 0, 0, 0, 0)
priority_fee = min(max_priority, max_fee - base_fee)
effective_gas_price = base_fee + priority_fee
gas_used = 21000 # Base transaction cost
stack = []
storage = {}
for op in opcodes:
code = op[0]
if code == "PUSH":
val = op[1]
gas_used += 3
stack.append(val % (2**256))
elif code == "ADD":
if len(stack) < 2:
# Thiếu toán hạng là dừng bất thường: mất toàn bộ gas_limit, giống OUT_OF_GAS
return ("STACK_UNDERFLOW", gas_limit, gas_limit * effective_gas_price, gas_limit * base_fee, 0)
a = stack.pop()
b = stack.pop()
gas_used += 3
stack.append((a + b) % (2**256))
elif code == "SUB":
if len(stack) < 2:
# Thiếu toán hạng là dừng bất thường: mất toàn bộ gas_limit, giống OUT_OF_GAS
return ("STACK_UNDERFLOW", gas_limit, gas_limit * effective_gas_price, gas_limit * base_fee, 0)
a = stack.pop()
b = stack.pop()
gas_used += 3
stack.append((a - b) % (2**256))
elif code == "MUL":
if len(stack) < 2:
# Thiếu toán hạng là dừng bất thường: mất toàn bộ gas_limit, giống OUT_OF_GAS
return ("STACK_UNDERFLOW", gas_limit, gas_limit * effective_gas_price, gas_limit * base_fee, 0)
a = stack.pop()
b = stack.pop()
gas_used += 5
stack.append((a * b) % (2**256))
elif code == "SLOAD":
key = op[1]
gas_used += 100
stack.append(storage.get(key, 0))
elif code == "SSTORE":
key = op[1]
val = op[2]
old_val = storage.get(key, 0)
if old_val == 0 and val != 0:
gas_used += 20000
else:
gas_used += 2900
storage[key] = val
if gas_used > gas_limit:
return ("OUT_OF_GAS", gas_limit, gas_limit * effective_gas_price, gas_limit * base_fee, 0)
total_fee = gas_used * effective_gas_price
burned = gas_used * base_fee
top_stack = stack[-1] if stack else 0
return ("SUCCESS", gas_used, total_fee, burned, top_stack)
if __name__ == "__main__":
from cases import TEST_CASES
for idx, tc in enumerate(TEST_CASES, 1):
res = simulate_evm(*tc["input"])
assert res == tc["expected"], f"Case {idx} failed: got {res}, expected {tc['expected']}"
print("All Python test cases PASSED!")
Phân tích Chi tiết Thuật toán và Mã nguồn
1. Xử lý số học 256-bit trong C++17 và Python
Trong Python, số nguyên hỗ trợ độ dài tùy ý (arbitrary precision integers), do đó các phép toán modulo \(2^{256}\) được thực hiện tự nhiên qua toán tử % (2**256). Ngược lại, trong C++17 tiêu chuẩn, kiểu dữ liệu lớn nhất là uint64_t (hoặc phần mở rộng __uint128_t của GCC/Clang). Để mô phỏng chính xác hành vi của máy ảo EVM, mã nguồn C++ xây dựng cấu trúc BigInt256 với 4 phần tử uint64_t (mỗi limb 64-bit). Các toán tử cộng, trừ, nhân đều xử lý số dư (carry/borrow) qua kiểu __uint128_t, đảm bảo tính toán chính xác tuyệt đối trên không gian 256-bit và xuất ra chuỗi thập phân chuẩn mực.
2. Thực thi Opcode và Theo dõi Khấu trừ Gas
- Giao dịch luôn bắt đầu với
gas_used = 21000. Đây là chi phí tối thiểu để mạng lưới xác thực chữ ký ECDSA và tạo cấu trúc giao dịch trên chuỗi. - Mỗi lệnh
PUSHđẩy giá trị vào Stack và tốn 3 gas. Các lệnh tính toánADD,SUB,MULtiêu thụ tương ứng 3 đến 5 gas và rút 2 toán hạng trên đỉnh ngăn xếp. - Khi ghi dữ liệu bằng
SSTORE: Hàm kiểm tra xem khóa mục tiêu trong bảngstoragetrước đó bằng 0 hay đã có giá trị. Nếu ghi từ 0 thành giá trị khác 0, phí gas tính 20.000; nếu ghi đè lên giá trị đã có sẵn, phí giảm còn 2.900 gas. - Tại mỗi bước lệnh, nếu
gas_used > gas_limit, máy ảo lập tức dừng lại, trả về mã trạng tháiOUT_OF_GASvà trừ toàn bộgas_limitcủa người dùng. Lỗi thiếu toán hạng trên ngăn xếp (STACK_UNDERFLOW) cũng là một kiểu dừng bất thường, nên mô phỏng cũng tính phí trên toàn bộgas_limit, giống EVM thật.
Các lỗi thường gặp khi làm việc với EVM và Gas
- Lỗi Stack Too Deep: Khai báo hàm trong Solidity có nhiều hơn 16 biến cục bộ hoặc tham số truyền vào. Trình biên dịch không thể thực thi các lệnh
DUPhoặcSWAPvượt quá độ sâu 16 của Stack. Khắc phục bằng cách gom các biến liên quan vào mộtstructhoặc chia nhỏ hàm logic. - Không dự trù trượt Base Fee: Trong các ứng dụng Web3 bot hoặc backend gửi giao dịch, đặt
maxFeePerGasbằng đúngbaseFeehiện tại. Khi có nhiều giao dịch ùa vào mempool khiến khối kế tiếp tăng 12.5% Base Fee, giao dịch của bạn sẽ bị kẹt vĩnh viễn trong hàng đợi vì không đủ chi phí cơ sở. - Lạm dụng Storage thay vì Memory: Lưu trữ các mảng dữ liệu tạm thời vào biến trạng thái (Storage) thay vì vùng nhớ
memory. Điều này khiến chi phí gas của hàm tăng vọt hàng trăm lần do các lệnhSSTOREliên tiếp. - Không giới hạn độ dài mảng khi duyệt: Đọc toàn bộ danh sách người dùng lưu trong storage bằng vòng lặp
for. Khi danh sách đạt hàng nghìn phần tử, lượng gas cần thiết để đọc vượt quá lượng gas tối đa của một giao dịch (16.777.216 gas từ bản nâng cấp Fusaka tháng 12/2025; giới hạn của cả khối tháng 11/2026 là 60 triệu gas), khiến hợp đồng rơi vào trạng thái tê liệt vĩnh viễn.
Tại sao EVM lại dùng số nguyên 256-bit thay vì 64-bit như CPU thông thường?
Mục tiêu cốt lõi của Ethereum là xử lý các thuật toán mật mã học và bảo mật tài chính. Hầu hết các thuật toán chữ ký số (như ECDSA trên secp256k1) và hàm băm mật mã (như Keccak-256, SHA-256) đều tạo ra kết quả đầu ra dài đúng 256 bit. Nếu dùng kiến trúc 64-bit, EVM sẽ phải liên tục chia nhỏ và ghép nối 4 thanh ghi 64-bit cho mỗi phép toán băm hay xác thực chữ ký, làm tăng đáng kể độ phức tạp của mã máy và tiêu tốn nhiều opcode hơn.
Khối lượng Gas không dùng hết có được hoàn trả không?
Có. Khi bạn gửi một giao dịch với gasLimit = 100.000 nhưng hợp đồng chỉ thực thi hết 35.000 gas, thì 65.000 gas còn thừa sẽ được nhân với giá gas thực tế và hoàn trả lại tài khoản ví của bạn ngay sau khi giao dịch hoàn tất. Bạn chỉ bị mất toàn bộ gas limit khi giao dịch dừng bất thường, ví dụ hết gas (Out of Gas) hoặc thiếu toán hạng trên ngăn xếp. Còn revert(), require() và cả assert() (từ Solidity 0.8.0, lỗi Panic của assert() dùng lệnh REVERT) đều hoàn lại phần gas chưa dùng.
EIP-1559 có giúp làm giảm phí gas trên Ethereum không?
EIP-1559 không được thiết kế để làm giảm phí gas tổng thể, vì phí gas phụ thuộc hoàn toàn vào quy luật cung cầu về không gian khối (Block Space). Khi mạng lưới có 100.000 người cùng muốn gửi giao dịch vào một khối chỉ chứa được 300 giao dịch, phí gas vẫn sẽ tăng cao. Mục đích thực sự của EIP-1559 là làm cho phí gas trở nên dễ dự đoán hơn (người dùng không cần đoán mò giá để khỏi bị trả hớ) và đốt bỏ Base Fee để giảm phát nguồn cung ETH.
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í.


