以太坊 Trie树
Trie树
Trie树，又称字典树，是一种用于快速检索的多叉树结构。
Trie树可以利用字符串的公共前缀来节约存储空间，如果系统中存在大量字符串且这些字符串基本没有公共前缀，则相应的trie树将非常消耗内存，这也是trie树的一个缺点。
Trie树的基本性质可以归纳为：
根节点不包含字符，除根节点以外每个节点只包含一个字符。
从根节点到某一个节点，路径上经过的字符连接起来，为该节点对应的字符串。
每个节点的所有子节点包含的字符串不相同。
如英文字母的字典树是一个26叉树，数字的字典树是一个10叉树。
如下图所示，该trie树用10个节点保存了6个字符串：tea，ten，to，in，inn，int：
Patricia Tries 前缀树
前缀树跟Trie树的不同之处在于Trie树是为每一个字符串分配一个节点，
而前缀树是将那些很长但又没有公共节点的字符串的Trie树退化成数组。
在以太坊里面会由黑客构造很多这种节点造成拒绝服务攻击。
前缀树的不同之处在于如果节点有公共前缀，那么就使用公共前缀，否则就把剩下的所有节点插入同一个节点。
如：
Merkle树
Merkle Tree，通常也被称作Hash Tree，顾名思义，就是存储hash值的一棵树。
Merkle树的叶子是数据块(例如，文件或者文件的集合)的hash值。
非叶节点是其对应子节点串联字符串的hash。
Merkle Tree的主要作用是当我拿到Top Hash的时候，这个hash值代表了整颗树的信息摘要，当树里面任何一个数据发生了变动，都会导致Top Hash的值发生变化。
而Top Hash的值是会存储到区块链的区块头里面去的， 区块头是必须经过工作量证明。
这也就是说我只要拿到一个区块头，就可以对区块信息进行验证。
MPT 以太坊Tries树
Merkle Patricia Trie(MPT) 是 EThereum 中一种非常重要的数据结构，用来存储用户账户的状态及其变更、交易信息、交易的收据信息。
每一个以太坊的区块头包含三颗MPT树,分别是：
1、交易树
2、收据树(交易执行过程中的一些数据)
3、状态树(账号信息，合约账户和用户账户)
MPT树有以下几个作用：
存储任意长度的key-value键值对数据；
提供了一种快速计算所维护数据集哈希标识的机制；
提供了快速状态回滚的机制；
提供了一种称为默克尔证明的证明方法，进行轻节点的扩展，实现简单支付验证；
下图中是两个区块头，
其中state root，tx root，receipt root分别存储了这三棵树的树根，
第二个区块显示了当账号 175的数据变更(27 -> 45)的时候，只需要存储跟这个账号相关的部分数据，而且老的区块中的数据还是可以正常访问。
key value
a711355 45.0 ETH
a77d337 1.00 WEI|
a7f9365 1.1 ETH
a77d397 0.12 ETH
prefix 前缀:
0 - 扩展节点，偶数个半字节
1 - 扩展节点，奇数个半字节
2 - 叶子节点，偶数个半字节
3 - 叶子节点，奇数个半字节
MPT 中对 key 的编码
trie/encoding.go 主要处理trie树中的三种编码格式的相互转换的工作。
三种编码格式分别为：
KEYBYTES 编码: 这种编码格式是原生的key字节数组
HEX 编码: 这种编码格式是把一字节拆分成两字节，尾部加一字节编码标记(0x10)，
COMPACT 编码: 这种编码格式是把Hex的两字节合并为一字节，在头部加一字节奇偶数据位(0x20或0x30)
将 keybytes 编码为 Hex:
编码前: 0x12 0x34 0x56
编码后: 0x01 0x02 0x03 0x04 0x03 0x04 0x05 0x06 0x10
0x10 为标记为 表示是Hex编码
package main
import (
"fmt"
)
// 将 keybytes 转化成 Hex
// 1. 将 keybytes 中的1byte信息，高4bit和低4bit分别放在2个byte里。
// 2. 最后在尾部加1字节标记当前属于Hex格式。
func keybytesToHex(str []byte) []byte {
l := len(str)*2 + 1
var nibbles = make([]byte, l)
for i, b := range str {
nibbles[i*2] = b / 16 // 取 keybytes 高 4bit
nibbles[i*2+1] = b % 16 // 取 keybytes 低 4bit
}
nibbles[l-1] = 16 // 标记是Hex格式
return nibbles
}
func main() {
key := []byte{0x12,0x34,0x56}
h := keybytesToHex(key)
fmt.Printf("keybytesToHex(%x) -> %x\n", key, h, )
}运行结果:
keybytesToHex(123456) -> 01020304050610
将 Hex 编码为 keybytes :
将0x01 0x02 0x03 0x04 0x10 合并 1234
注：0x10 为标记符，表示Hex编码
package main
import (
"fmt"
)
// hex 参数必须是偶数长度（不包括终结符16）
func hexToKeybytes(hex []byte) []byte {
if hasTerm(hex) {
hex = hex[:len(hex)-1] // 去除终结符 16
}
if len(hex)&1 != 0 { // 判断 hex长度是否为偶数(hex不包含终结符16)
panic("can't convert hex key of odd length")
}
key := make([]byte, len(hex)/2)
decodeNibbles(hex, key)
return key
}
// 将 nibbles 的每2个字节的低4位合并为一个字节
func decodeNibbles(nibbles []byte, bytes []byte) {
for bi, ni := 0, 0; ni < len(nibbles); bi, ni = bi+1, ni+2 {
bytes[bi] = nibbles[ni]<<4 | nibbles[ni+1] // 将2个字节的 各自低4位合并为1个字节
}
}
// 判断是否有终结符 16, 有终结符16 表明是Hex编码
func hasTerm(s []byte) bool {
return len(s) > 0 && s[len(s)-1] == 16
}
func main() {
hex := []byte{0x01,0x02,0x03,0x04,0x10}
h := hexToKeybytes(hex)
fmt.Printf("keybytesToHex(%x) -> %x\n", hex, h, )
}运行结果:
hexToKeybytes(0102030410) -> 1234
将 Hex 压缩 Compact：
0x01 0x02 0x03 0x04 0x10 压缩后 201234
其中 20 为奇偶标记位
package main
import (
"fmt"
)
// 将 Hex 压缩
func hexToCompact(hex []byte) []byte {
terminator := byte(0) // 设置终结符为 0 （1字节）
if hasTerm(hex) {
terminator = 1 // 如果为 Hex 编码， 设置终结符为1
hex = hex[:len(hex)-1] // 去除编码标记位
}
buf := make([]byte, len(hex)/2+1) // buf 长度为 hex去除编码标记位后除2,加上1字节的终结符标记
buf[0] = terminator << 5 // 偶数设置终结符标记位为 0x20
if len(hex)&1 == 1 { // 判断长度为奇数还是偶数，如果是奇数做如下处理
buf[0] |= 1 << 4 // 奇数设置终结符标记位为 0x30
buf[0] |= hex[0] // 将 hex[0] 的低四位包含到 buf[0] 的低四位，因为高四位是奇数/偶数位
hex = hex[1:] // 截取掉hex的第1字节
}
decodeNibbles(hex, buf[1:])
return buf
}
// 将 nibbles 的每2个字节的低4位合并为一个字节
func decodeNibbles(nibbles []byte, bytes []byte) {
for bi, ni := 0, 0; ni < len(nibbles); bi, ni = bi+1, ni+2 {
bytes[bi] = nibbles[ni]<<4 | nibbles[ni+1] // 将2个字节的 各自低4位合并为1个字节
}
}
// 判断是否有终结符 16, 有终结符16 表明是Hex编码
func hasTerm(s []byte) bool {
return len(s) > 0 && s[len(s)-1] == 16
}
func main() {
hex := []byte{0x01,0x02,0x03,0x04,0x10}
h := hexToCompact(hex)
fmt.Printf("hexToCompact(%x) -> %x\n", hex, h, )
}运行结果:
hexToCompact(0102030410) -> 201234
将 compact 解压为 Hex 或 keybytes：
package main
import (
"fmt"
)
// 将Hex的压缩码 解压为Hex
func compactToHex(compact []byte) []byte {
base := keybytesToHex(compact) // 先将 compact 转换为Hex编码
// delete terminator flag
if base[0] < 2 { // 如果不为Hex 压缩编码， 去除 Hex 编码标记
base = base[:len(base)-1] // 去除 Hex 编码标记
}
// apply odd flag
chop := 2 - base[0]&1 // 0 是偶数（从索引2开始，去除头部）， 1是奇数 （从索引1开始，去除头部）
return base[chop:]
}
func keybytesToHex(str []byte) []byte {
l := len(str)*2 + 1
var nibbles = make([]byte, l)
for i, b := range str {
nibbles[i*2] = b / 16
nibbles[i*2+1] = b % 16
}
nibbles[l-1] = 16
return nibbles
}
func main() {
compact := []byte{0x20,0x13,0x34}
h := compactToHex(compact)
fmt.Printf("compactToHex(%x) -> %x\n", compact, h, )
}运行结果:
compactToHex(201334) -> 0103030410
Node 节点
node接口及node接口分四种实现：
fullNode 对应于分支节点，可以有多个子节点
shortNode 对应于扩展节点，只有一个子节点
valueNode 对应于叶子节点，没有子节点
hashNode 比较特殊，是fullNode和shortNode对象的RLP哈希值。没有子节点。
type node interface {
fstring(string) string
cache() (hashNode, bool)
canUnload(cachegen, cachelimit uint16) bool
}
type (
fullNode struct {
Children [17]node // Actual trie node data to encode/decode (needs custom encoder)
flags nodeFlag
}
shortNode struct {
Key []byte
Val node
flags nodeFlag
}
hashNode []byte
valueNode []byte
)- fullNode : 有一个node数组成员Children，该数组中保存的值为16进制的 0 ~ 9 和 a ~ f。
对于每个子节点，根据key值的第一位，就可挂载到Children数组的某个位置。
每个父节点最多有16个分支。
Children的第17位，用来保存fullNode的数据部分。
fullNode本身不再需要额外key变量。 - shortNode：成员Val指向一个子节点。
成员Key是一个字节数组。
shortNode 通过合并只有一个子节点的父节点和其子节点来缩短trie的深度。 - valueNode：保存了MPT结构中真正的数据部分的节点。
valueNode值为RLP哈希值，长度32byte。 - hashNode：是fullNode或者shortNode对象的RLP哈希值。
hashNode不会单独存在，而是以nodeFlag.hsah的形式存在，被fullNode和shortNode间接持有。
一旦fullNode或shortNode的成员变量发生任何变化，nodeFlag.hsah就一定会更新。
trie.insert(...) 和 trie.delete(...) 实现中除了新创建的fullNode、shortNode
Trie
trie的结构
db是后端的KV存储，trie的结构最终都是需要通过KV的形式存储到数据库里面去，然后启动的时候是需要从数据库里面加载的。root作为整个MPT的根节点。originalRoot 在创建trie对象时承接入参hashNode，通过这个hash值可以在数据库里面恢复出整颗的trie树。
cachegen字段指示了当前Trie树的cache时代，每次调用Commit操作的时候，会增加Trie树的cache时代，即cahegen自增1。
Trie每次Commit时node会被更新，默认是node.nodeFlag.gen = cachegen，如果node的gen会小于cachegen，当前的cachegen - cachelimit 大于node的gen，说明trie commit之后，node一直没有更新，那么node会从cache里面卸载，以便节约内存。 其实这就是缓存更新的LRU算法， 如果一个缓存在多久没有被使用，那么就从缓存里面移除，以节约内存空间。
// Trie is a Merkle Patricia Trie.
// The zero value is an empty trie with no database.
// Use New to create a trie that sits on top of a database.
//
// Trie is not safe for concurrent use.
type Trie struct {
db *Database
root node
// Cache generation values.
// cachegen increases by one with each commit operation.
// new nodes are tagged with the current generation and unloaded
// when their generation is older than than cachegen-cachelimit.
cachegen, cachelimit uint16
}Trie树的初始化
Trie树的初始化调用New函数，函数接受一个hash值和一个Database参数，
如果hash值不是空值的化，就说明是从数据库加载一个已经存在的Trie树， 就调用trei.resolveHash方法来加载整颗Trie树，
如果root是空，那么就新建一颗Trie树返回。
// New creates a trie with an existing root node from db.
//
// If root is the zero hash or the sha3 hash of an empty string, the
// trie is initially empty and does not require a database. Otherwise,
// New will panic if db is nil and returns a MissingNodeError if root does
// not exist in the database. Accessing the trie loads nodes from db on demand.
func New(root common.Hash, db *Database) (*Trie, error) {
if db == nil {
panic("trie.New called without a database")
}
trie := &Trie{
db: db,
}
if root != (common.Hash{}) && root != emptyRoot {
rootnode, err := trie.resolveHash(root[:], nil)
if err != nil {
return nil, err
}
trie.root = rootnode
}
return trie, nil
}Trie结构提供插入、删除、更新，所有节点改动的提交，以及返回整个MPT的哈希值。
- node 接口担当整个MPT中的各个节点。
- 任何一个k,v类型数据被插入，会以k字符串为路径沿着root向下延伸，在此次插入结束时首先会成为一个shortNode。
- k以自顶点root起到该节点此的 key路径形式存在。
MPT结构是不断变化的，原有节点可能会变化成其他node类型的节点，同时MPT中也会不断裂变或者合并出新的节点。
如：
// Update associates key with value in the trie. Subsequent calls to
// Get will return value. If value has length zero, any existing value
// is deleted from the trie and calls to Get will return nil.
//
// The value bytes must not be modified by the caller while they are
// stored in the trie.
func (t *Trie) Update(key, value []byte) {
if err := t.TryUpdate(key, value); err != nil {
log.Error(fmt.Sprintf("Unhandled trie error: %v", err))
}
}
// TryUpdate associates key with value in the trie. Subsequent calls to
// Get will return value. If value has length zero, any existing value
// is deleted from the trie and calls to Get will return nil.
//
// The value bytes must not be modified by the caller while they are
// stored in the trie.
//
// If a node was not found in the database, a MissingNodeError is returned.
func (t *Trie) TryUpdate(key, value []byte) error {
k := keybytesToHex(key)
if len(value) != 0 { // 插入节点
_, n, err := t.insert(t.root, nil, k, valueNode(value))
if err != nil {
return err
}
t.root = n
} else { // 如果 value 长度为0，删除节点
_, n, err := t.delete(t.root, nil, k)
if err != nil {
return err
}
t.root = n
}
return nil
}
例程：
第一次insert：
第二次insert：
第三次insert：
trie commit：
// Commit writes all nodes to the trie's memory database, tracking the internal
// and external (for account tries) references.
func (t *Trie) Commit(onleaf LeafCallback) (root common.Hash, err error) {
if t.db == nil {
panic("commit called on trie with nil database")
}
hash, cached, err := t.hashRoot(t.db, onleaf)
if err != nil {
return common.Hash{}, err
}
t.root = cached
t.cachegen++
return common.BytesToHash(hash.(hashNode)), nil
}func (t *Trie) hashRoot(db *Database, onleaf LeafCallback) (node, node, error) {
if t.root == nil {
return hashNode(emptyRoot.Bytes()), nil, nil
}
h := newHasher(t.cachegen, t.cachelimit, onleaf)
defer returnHasherToPool(h)
return h.hash(t.root, db, true)
}// hash collapses a node down into a hash node, also returning a copy of the
// original node initialized with the computed hash to replace the original one.
func (h *hasher) hash(n node, db *Database, force bool) (node, node, error) {
// If we're not storing the node, just hashing, use available cached data
if hash, dirty := n.cache(); hash != nil {
if db == nil {
return hash, n, nil
}
if n.canUnload(h.cachegen, h.cachelimit) {
// Unload the node from cache. All of its subnodes will have a lower or equal
// cache generation number.
cacheUnloadCounter.Inc(1)
return hash, hash, nil
}
if !dirty {
return hash, n, nil
}
}
// Trie not processed yet or needs storage, walk the children
collapsed, cached, err := h.hashChildren(n, db)
if err != nil {
return hashNode{}, n, err
}
hashed, err := h.store(collapsed, db, force)
if err != nil {
return hashNode{}, n, err
}
// Cache the hash of the node for later reuse and remove
// the dirty flag in commit mode. It's fine to assign these values directly
// without copying the node first because hashChildren copies it.
cachedHash, _ := hashed.(hashNode)
switch cn := cached.(type) {
case *shortNode:
cn.flags.hash = cachedHash
if db != nil {
cn.flags.dirty = false
}
case *fullNode:
cn.flags.hash = cachedHash
if db != nil {
cn.flags.dirty = false
}
}
return hashed, cached, nil
}// hashChildren replaces the children of a node with their hashes if the encoded
// size of the child is larger than a hash, returning the collapsed node as well
// as a replacement for the original node with the child hashes cached in.
// 把所有的子节点替换成它们的hash
func (h *hasher) hashChildren(original node, db *Database) (node, node, error) {
var err error
switch n := original.(type) {
case *shortNode:
// Hash the short node's child, caching the newly hashed subtree
// cached 接管了原来的Trie树的完整结构
// collapsed 把子节点替换成子节点的hash值
collapsed, cached := n.copy(), n.copy()
// collapsed.Key 从Hex编码 替换成 Compact编码
collapsed.Key = hexToCompact(n.Key)
// cached.Key 保留 n.Key 的拷贝
cached.Key = common.CopyBytes(n.Key)
// 递归调用 hash 方法，计算子节点的hash和cache，把子节点替换成子节点的hash值
if _, ok := n.Val.(valueNode); !ok {
collapsed.Val, cached.Val, err = h.hash(n.Val, db, false)
if err != nil {
return original, original, err
}
}
return collapsed, cached, nil
case *fullNode:
// Hash the full node's children, caching the newly hashed subtrees
// cached 接管了原来的Trie树的完整结构
// collapsed 把子节点替换成子节点的hash值
collapsed, cached := n.copy(), n.copy()
// 遍历每个字节点，把子节点替换成子节点的hash值
for i := 0; i < 16; i++ {
if n.Children[i] != nil {
collapsed.Children[i], cached.Children[i], err = h.hash(n.Children[i], db, false)
if err != nil {
return original, original, err
}
}
}
cached.Children[16] = n.Children[16]
return collapsed, cached, nil
default:
// Value and hash nodes don't have children so they're left as were
return n, original, nil
}
}
trie store:
rlp.Encode(&h.tmp, n) 对节点n进行编码，编码信息保存到h.tmp中。
hash = h.makeHashNode(h.tmp) 对RPL进行hash计算。
db.insert(hash, h.tmp, n) 将节点hash值，RLP编码，节点插入数据库
// store hashes the node n and if we have a storage layer specified, it writes
// the key/value pair to it and tracks any node->child references as well as any
// node->external trie references.
func (h *hasher) store(n node, db *Database, force bool) (node, error) {
// Don't store hashes or empty nodes.
if _, isHash := n.(hashNode); n == nil || isHash {
return n, nil
}
// Generate the RLP encoding of the node
h.tmp.Reset() // tmp 赋值为空
// 对 node进行RLP编码保存到h.tmp中
if err := rlp.Encode(&h.tmp, n); err != nil {
panic("encode error: " + err.Error())
}
if len(h.tmp) < 32 && !force {
// 小于32字节的节点存储在其父节点内
return n, nil // Nodes smaller than 32 bytes are stored inside their parent
}
// Larger nodes are replaced by their hash and stored in the database.
// RLP 做 sha hash
hash, _ := n.cache()
if hash == nil {
hash = h.makeHashNode(h.tmp)
}
if db != nil {
// We are pooling the trie nodes into an intermediate memory cache
// 字节数组转换成hash
hash := common.BytesToHash(hash)
// 插入数据库, key是node的RLP之后的hash值(即hashNode)
db.lock.Lock()
db.insert(hash, h.tmp, n)
db.lock.Unlock()
// Track external references from account->storage trie
if h.onleaf != nil {
switch n := n.(type) {
case *shortNode:
if child, ok := n.Val.(valueNode); ok {
h.onleaf(child, hash)
}
case *fullNode:
for i := 0; i < 16; i++ {
if child, ok := n.Children[i].(valueNode); ok {
h.onleaf(child, hash)
}
}
}
}
}
return hash, nil
}
https://www.jianshu.com/p/1e7455d00065
https://github.com/ZtesoftCS/go-ethereum-code-analysis/blob/master/trie%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md