以太坊狀態 Trie 與狀態管理原始碼深度分析：Merkle Patricia Tree 的工程實踐

摘要

以太坊的狀態管理是其區塊鏈架構的核心支柱，而 Merkle Patricia Trie（MPT）則是實現這種狀態管理的關鍵資料結構。本文從原始碼層級深入分析以太坊中各類 Trie（狀態 Trie、儲存 Trie、交易 Trie、收據 Trie）的實現機制，涵蓋 Go Ethereum（Geth）客戶端的完整實作邏輯。我們將詳細解析 MPT 的節點結構、Insert/Delete/Get 操作的具體流程、並探討 Verkle Tree 等未來升級方案如何進一步優化以太坊的狀態管理效率。

1. 以太坊狀態模型的理論基礎

1.1 區塊鏈狀態的定義

在以太坊中，「狀態」是指區塊鏈在任意時間點的完整快照，包含：

• 所有帳戶的餘額
• 所有智能合約的程式碼和儲存
• 所有合約儲存的鍵值對
• Nonce（交易序號）

這種「帳戶模型」與比特幣的「UTXO 模型」形成根本性的架構差異。

1.2 狀態爆炸問題

以太坊面臨的「狀態爆炸」問題是區塊鏈領域的核心挑戰之一：

問題描述：

• 每個區塊處理後，狀態需要更新
• 狀態持續增長，完整節點的儲存需求不斷增加
• 截至 2026 年第一季度，以太坊狀態已超過 200GB

歷史數據：

1.3 為什麼需要 Merkle Trie

Merkle Trie 解決了三個關鍵問題：

1. 密碼學承諾：任何狀態根哈希都綁定了完整狀態，任何篡改都可被檢測
2. 輕客戶端驗證：無需下載完整狀態即可驗證特定帳戶的存在性
3. 狀態分裂攻擊防禦：即使某些狀態不可用，仍可驗證其他狀態的有效性

2. Merkle Patricia Trie 的數學基礎

2.1 密碼學哈希函數

以太坊使用 Keccak-256（SHA-3 的變體）作為其哈希函數：

H(x) = Keccak-256(x)

特性：
- 確定性：相同輸入總是產生相同輸出
- 不可逆：無法從輸出反推輸入
- 抗碰撞：極難找到 x ≠ y 使得 H(x) = H(y)
- 雪崩效應：輸入微小變化導致輸出巨大變化

以太坊中的典型哈希值：

• 空白輸入：0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
• 帳戶狀態根：32 bytes 的任意值

2.2 Merkle Tree 的基本原理

Merkle Tree 是一種二叉哈希樹，葉節點是數據塊的哈希，非葉節點是其子節點哈希的組合：

          Root Hash
         /        \
    Hash(AB)    Hash(CD)
    /    \       /    \
  Hash(A) Hash(B) Hash(C) Hash(D)
    |       |       |       |
    A       B       C       D

驗證證明的數學表述：

給定葉節點 A 及其 Merkle Path，要驗證 A 存在於樹中，只需：

root = Hash(Hash(Hash(A) + Hash(B)) + Hash(Hash(C) + Hash(D)))

計算複雜度：

• 時間：O(log n)
• 空間：O(log n) 個哈希值

2.3 Patricia Trie 的前綴匹配

Patricia Trie（Radix Tree）使用前綴壓縮優化記憶體：

原始字串集合：
- "apple"
- "application"
- "banana"
- "band"

未壓縮 Trie：
                    (root)
                   /   |   \
                 'a'  'b'  ...
                /      \
              ...     'an'
                    /     \
                  ...    'ana'
                        /     \
                      ...    'na'

壓縮 Patricia Trie（共用前綴）：
                    (root)
                 /         \
              "ap"        "ban"
              /   \          \
          "ple" "plication" "ana"
                               \
                             "na"

2.4 Merkle Patricia Trie 的節點類型

以太坊的 MPT 定義了四種節點類型：

Nibble 的定義：

• 每個 nibble = 4 bits = 半個 byte
• 路徑由 nibble 序列表示
• 十六進位前綴區分葉子/擴展：0x10 = 葉子，0x20 = 擴展

3. Go Ethereum 客戶端的 Trie 實作分析

3.1 核心資料結構

以下為 Geth 中 Trie 節點的原始碼結構（基於 go-ethereum v1.12）：

// core/types/const.go
const (
    HashLen   = 32 // Keccak-256 哈希長度
    BranchLen = 17 // 分支節點長度（16 個子節點 + 1 個值）
)

// trie/trie.go
type (
    // 節點介面
    Node interface {
        cache() (uint16, bool)
        hash() (Node, bool)
        rlp() []byte
    }

    // 空白節點
    fullNode struct {
        Children [BranchLen]Node // 16 個子節點 + 1 個 value
        flags   nodeFlag
    }

    // 葉子節點或擴展節點
    shortNode struct {
        Key     []byte
        Val     Node
        flags   nodeFlag
    }

    // 哈希節點（懶惰載入）
    hashNode []byte
    valueNode []byte
)

type nodeFlag struct {
    hash  hashNode  // 節點的緩存哈希
    gen   uint16   // 回收時代
    dirty bool      // 是否有未提交的修改
}

3.2 節點編碼：Compact Encoding

以太坊使用「緊湊編碼」（Compact Encoding）來序列化路徑 nibble：

// trie/encoding.go

// 將 nibble 序列轉換為 compact encoding
func hexToCompact(in []byte) []byte {
    // 確定前綴：
    // - 葉子節點: 0x20 + 偶數 nibble
    // - 擴展節點: 0x00 + 偶數 nibble
    // - 葉子節點: 0x30 + 奇數 nibble
    // - 擴展節點: 0x10 + 奇數 nibble
    
    var (
        base      byte = 0
        oddLen    byte = 0
        firstByte byte = 0
    )
    
    if len(in)%2 == 1 {
        // 奇數長度：加 2（前綴 + 第一個 nibble）
        base = 2
        oddLen = 1
        firstByte = in[0]
    } else {
        // 偶數長度：加 1（前綴 + 前兩個 nibble）
        base = 1
        firstByte = nibbleToHex(in[0], in[1])
    }
    
    out := make([]byte, base+len(in)/2)
    out[0] = base | firstByte
    
    // 將 nibble 配對為 bytes
    for i := 0; i < len(in)/2; i++ {
        out[base+i] = nibbleToHex(in[2*i+1], in[2*i+2])
    }
    
    return out
}

// 從 compact encoding 恢復 nibble 序列
func compactToHex(in []byte) []byte {
    base := in[0] & 0x03 // 提取前綴
    flag := in[0] & 0x30 // 0x10=擴展, 0x20=葉子
    
    var out []byte
    
    switch base {
    case 0:
        // 偶數長度：前兩個 nibble 在第一個 byte
        out = []byte{nibbleFromHex(in[0])}
        for i := 1; i < len(in); i++ {
            out = append(out, nibbleFromHex(in[i]>>4), nibbleFromHex(in[i]&0x0f))
        }
    case 2:
        // 奇數長度：只有第一個 nibble
        out = []byte{nibbleFromHex(in[0] & 0x0f)}
        for i := 1; i < len(in); i++ {
            out = append(out, nibbleFromHex(in[i]>>4), nibbleFromHex(in[i]&0x0f))
        }
    }
    
    return out
}

3.3 Get 操作的原始碼解析

// trie/trie.go

// Trie 結構定義
type Trie struct {
    root  Node
    db   *Database
    lock  sync.RWMutex
}

// Get 操作的公開介面
func (t *Trie) Get(key []byte) []byte {
    return t.GetKey(hexToKeybytes(key))
}

// 內部 GetKey 實現
func (t *Trie) GetKey(key []byte) []byte {
    if len(key) == 0 {
        // 嘗試從根節點直接獲取值
        if v, ok := t.root.(valueNode); ok {
            return v
        }
        return nil
    }
    
    // 遞迴查找
    return t.doGet(t.root, key)
}

func (t *Trie) doGet(n Node, key []byte) []byte {
    for {
        // 根據節點類型處理
        switch n := n.(type) {
        case *shortNode:
            // 葉子/擴展節點
            if len(key) < len(n.Key) {
                return nil
            }
            // 檢查 key 前綴是否匹配
            if !bytes.HasPrefix(key, n.Key) {
                return nil
            }
            // 前綴匹配，繼續向下一層
            key = key[len(n.Key):]
            
            // 如果是葉子節點，返回值
            if len(key) == 0 {
                return t.resolveNode(n.Val, nil)
            }
            
            // 否則，這個 shortNode 只能是擴展節點，繼續查找
            n = t.resolveNode(n.Val, nil)
            continue
            
        case *fullNode:
            // 分支節點
            if len(key) == 0 {
                // 最後的分支節點持有值
                return t.resolveNode(n.Children[16], nil)
            }
            // 根據 key 的第一個 nibble 選擇子節點
            n = t.resolveNode(n.Children[key[0]], key[1:])
            if n == nil {
                return nil
            }
            key = key[1:]
            continue
            
        case hashNode:
            // 哈希節點：從資料庫載入
            n = t.resolveNode(n, key)
            if n == nil {
                return nil
            }
            continue
            
        case valueNode:
            // 值節點：搜索終止
            return n
            
        default:
            panic("invalid node type")
        }
    }
}

// resolveNode 從資料庫載入節點
func (t *Trie) resolveNode(n hashNode, prefix []byte) Node {
    if len(n) == 0 {
        return nil
    }
    // 嘗試從本地快取獲取
    if cached, ok := t.db.nodeCache.Get(string(n)); ok {
        return cached.(Node)
    }
    // 從持久化資料庫載入
    node, err := t.db.Node(n)
    if err != nil {
        return nil
    }
    return node
}

3.4 Insert 操作的原始碼解析

// trie/trie.go

// Insert 操作的公開介面
func (t *Trie) Insert(key, value []byte) {
    t.insert(trieAndFlag{trie: t}, hexToKeybytes(key), value)
}

// 內部 insert 實現（遞迴）
func (t *Trie) insert(tn trieAndFlag, key []byte, value []byte) (Node, *trieAndFlag) {
    // 遞迴終止條件
    if len(key) == 0 {
        // 轉換為值節點
        return valueNode(value), tn.r()
    }
    
    // 確保 key 不為空
    if len(tn.trie.root) == 0 {
        tn.trie.root = hashNode{}
    }
    
    // 根據節點類型處理
    switch n := tn.trie.root.(type) {
    case *shortNode:
        // 葉子或擴展節點
        return t.insertShortNode(tn, n, key, value)
        
    case *fullNode:
        // 分支節點
        return t.insertFullNode(tn, n, key, value)
        
    case hashNode:
        // 哈希節點：先載入完整節點
        newNode, newTrieAndFlag, _, err := tn.trie.update(n, key)
        if err != nil {
            return nil, nil
        }
        return t.insert(newTrieAndFlag, key, value)
        
    case nil:
        // 空樹：創建新葉子節點
        return &shortNode{
            Key: key,
            Val: valueNode(value),
        }, tn.r()
        
    default:
        panic("invalid node type")
    }
}

// 處理短節點（葉子/擴展）
func (t *Trie) insertShortNode(tn trieAndFlag, sn *shortNode, key []byte, value []byte) (Node, *trieAndFlag) {
    // 計算與現有 key 的共同前綴
    commonLen := len(sn.Key)
    for i := 0; i < len(sn.Key) && i < len(key); i++ {
        if sn.Key[i] != key[i] {
            commonLen = i
            break
        }
    }
    
    if commonLen == len(sn.Key) {
        // 完整前綴匹配
        if len(key) == len(sn.Key) {
            // 完全相同：替換值
            if reflect.DeepEqual(sn.Val, valueNode(value)) {
                return sn, tn.r()
            }
            return &shortNode{
                Key: sn.Key,
                Val: valueNode(value),
            }, tn.r()
        }
        
        // 新 key 更長：需要向下插入
        // 這個短節點是擴展節點
        newBranch, _ := t.insert(tn, key[commonLen:], value)
        return &shortNode{
            Key: sn.Key,
            Val: newBranch,
        }, tn.r()
    }
    
    // 需要分裂：創建分支節點
    // 1. 現有 key 分叉
    // 2. 新 key 分叉
    
    // 構建分支節點
    branch := &fullNode{}
    
    // 新 key 的分支
    newBranch, tn := t.insert(tn, key[commonLen+1:], value)
    branch.Children[key[commonLen]] = newBranch
    
    // 現有 key 的分支
    remainingKey := sn.Key[commonLen+1:]
    if len(remainingKey) == 0 {
        branch.Children[16] = sn.Val
    } else {
        branch.Children[sn.Key[commonLen]] = &shortNode{
            Key: remainingKey,
            Val: sn.Val,
        }
    }
    
    // 如果共同前綴長度 > 0，創建上層擴展節點
    if commonLen > 0 {
        return &shortNode{
            Key: sn.Key[:commonLen],
            Val: branch,
        }, tn.r()
    }
    
    return branch, tn.r()
}

// 處理分支節點
func (t *Trie) insertFullNode(tn trieAndFlag, fn *fullNode, key []byte, value []byte) (Node, *trieAndFlag) {
    // 根據 key 的第一個 nibble 遞迴插入
    branch, tn := t.insert(tn, key[1:], value)
    
    // 更新分支節點
    newFn := *fn
    newFn.Children[key[0]] = branch
    
    return &newFn, tn.r()
}

3.5 Delete 操作的原始碼解析

// trie/trie.go

// Delete 操作的公開介面
func (t *Trie) Delete(key []byte) {
    t.delete(trieAndFlag{trie: t}, hexToKeybytes(key))
}

// 內部 delete 實現（遞迴）
func (t *Trie) delete(tn trieAndFlag, key []byte) (Node, *trieAndFlag) {
    switch n := tn.trie.root.(type) {
    case *shortNode:
        return t.deleteShortNode(tn, n, key)
    case *fullNode:
        return t.deleteFullNode(tn, n, key)
    case hashNode:
        // 載入節點後刪除
        newNode, newTn, _, _ := tn.trie.update(n, key)
        return t.delete(newTn, key)
    case nil:
        // 空樹：無需刪除
        return nil, tn.r()
    default:
        panic("invalid node type")
    }
}

// 刪除短節點
func (t *Trie) deleteShortNode(tn trieAndFlag, sn *shortNode, key []byte) (Node, *trieAndFlag) {
    if !bytes.HasPrefix(key, sn.Key) {
        // Key 不匹配：無需刪除
        return tn.trie.root, tn.r()
    }
    
    if len(key) == len(sn.Key) {
        // 完全匹配：刪除這個鍵值對
        return nil, tn.r()
    }
    
    // Key 更長但前綴匹配：需要遞迴刪除
    newVal, tn := t.delete(tn, key[len(sn.Key):])
    
    if newVal == nil {
        // 子節點被刪除，需要合併
        return nil, tn.r()
    }
    
    // 替換為新的值節點
    newSn := *sn
    newSn.Val = newVal
    return &newSn, tn.r()
}

// 刪除分支節點
func (t *Trie) deleteFullNode(tn trieAndFlag, fn *fullNode, key []byte) (Node, *trieAndFlag) {
    // 遞迴刪除子節點
    newChild, tn := t.delete(tn, key[1:])
    
    // 統計非空子節點數量
    nonEmptyCount := 0
    nonEmptyIndex := 0
    for i, child := range fn.Children {
        if child != nil {
            nonEmptyCount++
            nonEmptyIndex = i
        }
    }
    
    if newChild != nil {
        // 更新分支節點
        newFn := *fn
        newFn.Children[key[0]] = newChild
        
        // 檢查是否可以合併
        if nonEmptyCount == 1 && newFn.Children[16] == nil {
            // 只有一個非空子節點，可以合併
            return t.mergeShortNode(newFn, nonEmptyIndex), tn.r()
        }
        
        return &newFn, tn.r()
    }
    
    if nonEmptyCount == 0 {
        // 所有子節點都為空
        return nil, tn.r()
    }
    
    if nonEmptyCount == 1 {
        // 只有一個非空子節點：檢查是否可以合併
        if nonEmptyIndex == 16 {
            // 分支節點的值位置有值
            // 需要轉換為短節點
            if child := fn.Children[16]; child != nil {
                return &shortNode{
                    Key: []byte{byte(key[0])}, // nibble
                    Val: child,
                }, tn.r()
            }
        } else {
            // 分支節點的一個子節點有值
            child := fn.Children[nonEmptyIndex]
            if short, ok := child.(*shortNode); ok {
                // 擴展節點可以合併
                newKey := append([]byte{byte(nonEmptyIndex)}, short.Key...)
                return &shortNode{
                    Key: append([]byte{byte(key[0])}, newKey...),
                    Val: short.Val,
                }, tn.r()
            }
        }
    }
    
    return fn, tn.r()
}

// 合併短節點（輔助函數）
func (t *Trie) mergeShortNode(fn *fullNode, index int) Node {
    child := fn.Children[index]
    
    if short, ok := child.(*shortNode); ok {
        // 合併前綴
        newKey := append([]byte{byte(index)}, short.Key...)
        return &shortNode{
            Key: newKey,
            Val: short.Val,
        }
    }
    
    return fn
}

4. 以太坊四種 Trie 的比較分析

4.1 四種 Trie 的定義

以太坊區塊頭包含四個哈希根：

4.2 狀態 Trie 的特殊設計

帳戶表示：

// core/types/state_account.go

type Account struct {
    Nonce    uint64
    Balance  *big.Int
    Root     common.Hash // 合約的儲存 Trie 根哈希
    CodeHash []byte      // 合約程式碼哈希
}

狀態 Trie 的鍵：

• 鍵 = keccak256(address) 的前 16 nibbles（hex 字串）
• 這確保了鍵的均勻分佈，避免衝突

鍵編碼示例：

# 地址
address = "0x1234567890123456789012345678901234567890"

# 轉換為 hex nibble
address_hex = "1234567890123456789012345678901234567890"

# 取得 keccak256 哈希
import hashlib
h = hashlib.new('keccak256')
h.update(address_hex.encode())
hash_hex = h.hexdigest()  # 64 個 hex 字元 = 32 bytes

# 狀態 Trie 鍵（取前 32 個 nibble，即 16 bytes）
trie_key = hash_hex[:32]  # "a1b2c3d4e5f678901234567890123456"

4.3 儲存 Trie 的層級結構

每個合約帳戶擁有自己的儲存 Trie：

世界狀態 Trie
│
└── [0xa1b2...] → Account {
    Root: 0x1234... // 合約 A 的儲存 Trie 根
    ...
}
└── [0xc3d4...] → Account {
    Root: 0x5678... // 合約 B 的儲存 Trie 根
    ...
}

合約 A 的儲存 Trie
│
├── [slot_0] → value_0
├── [slot_1] → value_1
└── [slot_2] → value_2

插槽編碼：

// Solidity 原始碼
mapping(address => uint256) public balances;

// 編譯後 slot = keccak256(abi.encode(address, uint256(0)))
// 其中 uint256(0) 是 mapping 的第一個 slot 位置

// 查詢某地址的餘額：
address user = 0x1234...;
uint256 slot = uint256(keccak256(abi.encode(user, uint256(0))));

4.4 交易 Trie 的特殊性

交易 Trie 是區塊內交易的 Merkle Tree（非 Patricia），因為：

• 交易按順序執行，順序固定
• 交易內容是確定的，不支持 Update/Delete
• 只需簡單的 Merkle 證明，無需 Patricia 的路徑壓縮

// core/types/block.go

// 交易 Trie 的構建
func (trie *StateDb) BuildReceiptTrie(receipts types.Receipts) (*trie.Trie, error) {
    trie := trie.NewTrie()
    
    for i, receipt := range receipts {
        key := encodeIndex(i) // 簡單的索引編碼
        value, _ := rlp.EncodeToBytes(receipt)
        trie.Insert(key, value)
    }
    
    return trie, nil
}

5. 狀態管理效率優化：EIP-4444 與快照機制

5.1 歷史狀態的 Pruning

EIP-4444 提議停止在客戶端傳播超過一年的歷史區塊：

核心內容：

• 客戶端不再需要存储完整的區塊歷史
• 歷史狀態可以被「修剪」
• 減少節點存儲需求

5.2 Geth 的快照機制（Snapshot）

Geth 實現了「快照」（Snapshot）機制來加速狀態訪問：

// core/state/snapshot/
type snapshot struct {
    // 快照根
    root common.Hash
    
    // 完整狀態的記憶體副本（惰性構建）
    complete  map[common.Hash][]byte
    
    // 磁碟快照（每 16384 個區塊快照一次）
    diskdb   ethdb.Database
    
    // 堆疊式快照（日誌覆蓋）
    diffing   []map[common.Hash][]byte
}

// GetOrNewStateObject 演示快照的使用
func (s *StateDB) GetOrNewStateObject(addr common.Address) *StateObject {
    // 1. 首先檢查記憶體快照
    if obj := s.stateObjects[addr]; obj != nil {
        return obj
    }
    
    // 2. 從磁碟快照讀取
    enc, err := s.snaps.Get(keccak256(addr))
    if err == nil {
        obj := &StateObject{}
        rlp.DecodeBytes(enc, obj)
        return obj
    }
    
    // 3. 從完整狀態 Trie 讀取
    obj := s.getStateObjectFromTrie(addr)
    return obj
}

5.3 狀態增長控制策略

6. Verkle Tree：未來狀態管理升級

6.1 Verkle Tree 簡介

Verkle Tree 是一種新的密碼學證明結構，結合了：

• Vector Commitment 的可擴展性
• Merkle Tree 的簡單性
• 更短的證明長度

6.2 與 MPT 的比較

6.3 以太坊的 Verkle Tree 遷移

EIP-2935 已經引入了 Verkle Tree 友好的歷史訪問：

// Verkle Tree 的結構示例
type VerkleNode struct {
    Stem     [31]byte    // 31 bytes 的莖
    C1       []byte      // 第一組 128 個子節點的承諾
    C2       []byte      // 第二組 128 個子節點的承諾
}

遷移策略：

1. 階段一：添加 Verkle 狀態
2. 階段二：並行運行 MPT 和 Verkle
3. 階段三：棄用 MPT，僅使用 Verkle

7. 實例計算：狀態證明的驗證流程

7.1 驗證流程

假設我們要驗證地址 0xABCD... 的餘額為 100 ETH：

步驟 1：構建驗證路徑

狀態根哈希：0x1234...
│
├── 路徑：keccak256(0xABCD...)[:31]
│   └── 假設為 "0xab" + "12345678901234567890123456789012"
│
└── 完整路徑：
    [ab] → branch_node
        [12] → extension_node
            [3456...] → leaf_node
                key: "3456..."
                value: RLP([nonce, balance, storageRoot, codeHash])

步驟 2：驗證計算

# Python 模擬驗證過程

def verify_state_proof(state_root, address, proof):
    # 1. 計算地址哈希
    address_hash = keccak256(address)
    
    # 2. 遍歷 proof 中的每個節點
    current_hash = state_root
    path = address_hash[:32]  # 轉換為 nibble path
    
    for node in proof:
        # 3. 驗證節點哈希
        computed_hash = keccak256(node.encoded)
        assert computed_hash == node.hash, "Hash mismatch"
        
        # 4. 根據節點類型處理
        if node.type == "leaf":
            # 葉子節點：驗證 key 前綴匹配
            assert path.startswith(node.path_prefix)
            # 找到目標值
            return decode_account(node.value)
        elif node.type == "extension":
            # 擴展節點：跳過共同前綴
            path = path[len(node.common_prefix):]
        elif node.type == "branch":
            # 分支節點：根據下一個 nibble 選擇
            next_nibble = int(path[0])
            path = path[1:]
            assert node.children[next_nibble] is not None
            # 繼續驗證子節點
            current_hash = node.children[next_nibble]
    
    return None

7.2 計算複雜度分析

MPT 驗證：

Verkle Tree 驗證：

8. 結論與工程啟示

8.1 核心發現

1. MPT 是狀態管理的基石：Merkle Patricia Trie 為以太坊提供了密碼學承諾、輕客戶端驗證和狀態分裂攻擊防禦三大核心能力。

1. Go Ethereum 的實現精妙：Geth 的 Trie 實作通過巧妙的節點編碼、惰性載入和快取機制，在保證正確性的同時實現了高效的性能。

1. 狀態爆炸是根本挑戰：隨著以太坊生態的增長，狀態管理的挑戰日益嚴峻，需要多層次的解決方案（快照、Pruning、Verkle Tree）。

1. Verkle Tree 是未來方向：通過 Vector Commitment 替代哈希，Verkle Tree 可將狀態證明大小減少 100 倍，為 stateless Ethereum 奠定基礎。

8.2 對開發者的啟示

1. 理解狀態組織：智能合約開發者應理解合約儲存的組織方式，以便優化儲存使用。

1. 批量操作的效率：在 Layer 2 或批量交易中，理解狀態讀寫的成本對於優化 gas 消耗至關重要。

1. 未來相容性：設計合約時應考慮未來狀態結構的變化（如 Verkle Tree），避免依賴特定的實現細節。

8.3 研究前沿

1. stateless Ethereum：完全移除對狀態存儲的需求
2. State Expiry：定期過期不活躍狀態
3. EIP-4444：停止歷史區塊傳播
4. Verkle Tree 遷移：從 MPT 到 Verkle Tree 的平滑過渡

參考文獻

以太坊改進提案

1. EIP-98: Canonical Trie Format
2. EIP-609: Custom Chain Hashes for蜜ES
3. EIP-2935: Serve historical block headers via state
4. EIP-4444: History expiry

原始碼參考

1. go-ethereum: core/state/trie.go
2. go-ethereum: trie/encoding.go
3. go-ethereum: trie/trie.go
4. go-ethereum: core/state/snapshot/

學術論文

1. Merkle, R. (1988). A Digital Signature Based on a Conventional Encryption Function.
2. Danezis, G., et al. (2022). Verkle Trees for Statelessness and Accumulator Summaries.

本文為工程技術文章，聚焦於以太坊狀態管理機制的原始碼層級分析。所有代碼示例基於 go-ethereum v1.12，具體實現可能因版本而異。