以太坊源码分析之九区块

以太坊源码分析之九区块
终于到了区块链中最和区块链搭界的部分，毕竟它们只差一个字。区块是区块链的基础，区块通过HASH链接在一起就成为了区块链。
一、区块的相关数据结构
不当嘴炮党，看源码：
链数据结构：
type BlockChain struct {
    chainConfig *params.ChainConfig // Chain & network configuration
    cacheConfig *CacheConfig        // Cache configuration for pruning

    db     ethdb.Database // Low level persistent database to store final content in
    triegc *prque.Prque   // Priority queue mapping block numbers to tries to gc
    gcproc time.Duration  // Accumulates canonical block processing for trie dumping

    hc            *HeaderChain  //只有头的链，用于验证和快速下载
    //其下为消息订阅的一系列事件
rmLogsFeed    event.Feed    //其下为消息订阅的一系列事件，删除日志
    chainFeed     event.Feed    //主链事件
    chainSideFeed event.Feed      //侧链事件
    chainHeadFeed event.Feed     // 主链头事件
    logsFeed      event.Feed
    scope         event.SubscriptionScope
    genesisBlock  *types.Block   //创世块

    mu      sync.RWMutex // global mutex for locking chain operations
    chainmu sync.RWMutex // blockchain insertion lock
    procmu  sync.RWMutex // block processor lock

    checkpoint       int          // checkpoint counts towards the new checkpoint
    currentBlock     *types.Block // Current head of the block chain
    currentFastBlock *types.Block // Current head of the fast-sync chain (may be above the block chain!)

    stateCache   state.Database // State database to reuse between imports (contains state cache)
    bodyCache    *lru.Cache     // Cache for the most recent block bodies
    bodyRLPCache *lru.Cache     // Cache for the most recent block bodies in RLP encoded format
    blockCache   *lru.Cache     // Cache for the most recent entire blocks
    futureBlocks *lru.Cache     // future blocks are blocks added for later processing

    quit    chan struct{} // blockchain quit channel
    running int32         // running must be called atomically
    // procInterrupt must be atomically called
    procInterrupt int32          // interrupt signaler for block processing
    wg            sync.WaitGroup // chain processing wait group for shutting down

    engine    consensus.Engine
    processor Processor // block processor interface
    validator Validator // block and state validator interface
    vmConfig  vm.Config

    badBlocks *lru.Cache // Bad block cache
}
块数据结构：
// Block represents an entire block in the Ethereum blockchain.
type Block struct {
    header       *Header
    uncles       []*Header  //叔块的头，叔块最多有两个
    transactions Transactions

    // caches
    hash atomic.Value
    size atomic.Value

    // Td is used by package core to store the total difficulty
    // of the chain up to and including the block.
    td *big.Int   //难度

    // These fields are used by package eth to track
    // inter-peer block relay.
    ReceivedAt   time.Time
    ReceivedFrom interface{}
}
区块头数据结构：
type Header struct {
//指向父区块(parentBlock)的hash。除了创世块(Genesis Block)没有父区块，每个区块有且//只有一个父区块。
    ParentHash  common.Hash    `json:"parentHash"       gencodec:"required"`
    //叔块地址。
UncleHash   common.Hash    `json:"sha3Uncles"       gencodec:"required"`
    //出块地址。挖矿和交易都发给这个地址。
Coinbase    common.Address `json:"miner"            gencodec:"required"`
//世界状态，状态树的根哈希值—三大树
    Root        common.Hash    `json:"stateRoot"        gencodec:"required"`
    //交易树根哈希值 
    TxHash      common.Hash    `json:"transactionsRoot" gencodec:"required"`
    //接收者树的的根哈希值
    ReceiptHash common.Hash    `json:"receiptsRoot"     gencodec:"required"`
    //交易收据日志组成的布隆过滤器
    Bloom       Bloom          `json:"logsBloom"        gencodec:"required"`
    //本块难度
    Difficulty  *big.Int       `json:"difficulty"       gencodec:"required"`
    //块号
    Number      *big.Int       `json:"number"           gencodec:"required"`
    //本块Gas上限
    GasLimit    uint64         `json:"gasLimit"         gencodec:"required"`
    //Gas使用量
    GasUsed     uint64         `json:"gasUsed"          gencodec:"required"`
    //本块的产生时间戳
    Time        *big.Int       `json:"timestamp"        gencodec:"required"`
    //附加数据
    Extra       []byte         `json:"extraData"        gencodec:"required"`
    //一个哈希值，用NONCE组合用于计算工作量
    MixDigest   common.Hash    `json:"mixHash"          gencodec:"required"`
    //区块产生的随机值，每个用户必须单调步长为1递增
    Nonce       BlockNonce     `json:"nonce"            gencodec:"required"`
}

三者的关系非常明晰，BlockChain 由Block组成，而Header是后者的重要组成部分。
在BlockChain的注释中指出：它是一个标准的以太坊的链数据结构，其内部包含了创世区块及相关数据库的配置,以太坊通过它管理链的插入,恢复,重组等操作.
通过由一系列规则组成的两阶段的验证器来插入一个区块。利用交易处理器对区块中的交易进行处理并利用验证器进行验证，一旦错误将导致上链的失败。
需要注意的是GetBlock函数可能得到任何当前链中的块,但是使用GetBlockByNumber函数却一直得到当前主链中的区块。

二、以太坊的存储模型
以太坊的存储分三层：
上层：业务数据
中层：MPT缓存
底层：LEVELDB
结合到实际的代码中：
type StateDB struct {
    db   Database 
    trie Trie   

    // This map holds 'live' objects, which will get modified while processing a state transition.
    stateObjects      map[common.Address]*stateObject   //顶层业务
    stateObjectsDirty map[common.Address]struct{}

……
}
type stateObject struct {
    address  common.Address
    addrHash common.Hash // hash of ethereum address of the account
    data     Account
    db       *StateDB

    // DB error.
    // State objects are used by the consensus core and VM which are
    // unable to deal with database-level errors. Any error that occurs
    // during a database read is memoized here and will eventually be returned
    // by StateDB.Commit.
    dbErr error

    // Write caches.缓存
    trie Trie // storage trie, which becomes non-nil on first access
    code Code // contract bytecode, which gets set when code is loaded

    cachedStorage Storage // Storage entry cache to avoid duplicate reads
    dirtyStorage  Storage // Storage entries that need to be flushed to disk

    // Cache flags.
    // When an object is marked suicided it will be delete from the trie
    // during the "update" phase of the state transition.
    dirtyCode bool // true if the code was updated
    suicided  bool
    touched   bool
    deleted   bool
    onDirty   func(addr common.Address) // Callback method to mark a state object newly dirty
}
最终在 CommitTire实现写入数据LEVELDB。

三、区块的存储
区块的存储在以太坊中是通过leveldb实现的，leveldb是一个kv型数据库，支持高速写入。
在存储区块信息时，会将区块头和区块体分开进行存储。因此在区块的结构体中，能够看到Header和Body两个结构体。
头（Header）的存储格式为：
    headerPrefix + num (uint64 big endian) + hash -> rlpEncode(header)
key是由header的前缀，Number和区块hash构成。value是header的RLP编码。
区块体（Body）的存储格式为：

    bodyPrefix + num (uint64 big endian) + hash -> rlpEncode(block body)
key是由body前缀，Number和区块hash构成。value是区块体的RLP编码。
看一下database_util.go中的定义的变量：
var (
    headHeaderKey = []byte("LastHeader")
    headBlockKey  = []byte("LastBlock")
    headFastKey   = []byte("LastFast")

    // Data item prefixes (use single byte to avoid mixing data types, avoid `i`).
    headerPrefix        = []byte("h") // headerPrefix + num (uint64 big endian) + hash -> header
    tdSuffix            = []byte("t") // headerPrefix + num (uint64 big endian) + hash + tdSuffix -> td
    numSuffix           = []byte("n") // headerPrefix + num (uint64 big endian) + numSuffix -> hash
    blockHashPrefix     = []byte("H") // blockHashPrefix + hash -> num (uint64 big endian)
    bodyPrefix          = []byte("b") // bodyPrefix + num (uint64 big endian) + hash -> block body
    blockReceiptsPrefix = []byte("r") // blockReceiptsPrefix + num (uint64 big endian) + hash -> block receipts
    lookupPrefix        = []byte("l") // lookupPrefix + hash -> transaction/receipt lookup metadata
    bloomBitsPrefix     = []byte("B") // bloomBitsPrefix + bit (uint16 big endian) + section (uint64 big endian) + hash -> bloom bits

    preimagePrefix = "secure-key-"              // preimagePrefix + hash -> preimage
    configPrefix   = []byte("ethereum-config-") // config prefix for the db

    // Chain index prefixes (use `i` + single byte to avoid mixing data types).
    BloomBitsIndexPrefix = []byte("iB") // BloomBitsIndexPrefix is the data table of a chain indexer to track its progress

    // used by old db, now only used for conversion
    oldReceiptsPrefix = []byte("receipts-")
    oldTxMetaSuffix   = []byte{0x01}

    ErrChainConfigNotFound = errors.New("ChainConfig not found") // general config not found error

    preimageCounter    = metrics.NewCounter("db/preimage/total")
    preimageHitCounter = metrics.NewCounter("db/preimage/hits")
)

这些前缀用来表明是什么样的数据类型。下面看一下具体的存储，在core/database_util.go中封装了区块存储和读取相关的代码。
// DatabaseReader wraps the Get method of a backing data store.
type DatabaseReader interface {
    Get(key []byte) (value []byte, err error)
}

// DatabaseDeleter wraps the Delete method of a backing data store.
type DatabaseDeleter interface {
    Delete(key []byte) error
}
写入区块：
// WriteBlock serializes a block into the database, header and body separately.
func WriteBlock(db ethdb.Putter, block *types.Block) error {
    // Store the body first to retain database consistency
    if err := WriteBody(db, block.Hash(), block.NumberU64(), block.Body()); err != nil {
        return err
    }
    // Store the header too, signaling full block ownership
    if err := WriteHeader(db, block.Header()); err != nil {
        return err
    }
    return nil
}
下面是写区块调用的两个函数：
// WriteHeader serializes a block header into the database.
func WriteHeader(db ethdb.Putter, header *types.Header) error {
    data, err := rlp.EncodeToBytes(header)
    if err != nil {
        return err
    }
    hash := header.Hash().Bytes()
    num := header.Number.Uint64()
    encNum := encodeBlockNumber(num)
    key := append(blockHashPrefix, hash...)
    if err := db.Put(key, encNum); err != nil {
        log.Crit("Failed to store hash to number mapping", "err", err)
    }
    key = append(append(headerPrefix, encNum...), hash...)
    if err := db.Put(key, data); err != nil {
        log.Crit("Failed to store header", "err", err)
    }
    return nil
}

// WriteBody serializes the body of a block into the database.
func WriteBody(db ethdb.Putter, hash common.Hash, number uint64, body *types.Body) error {
    data, err := rlp.EncodeToBytes(body)
    if err != nil {
        return err
    }
    return WriteBodyRLP(db, hash, number, data)
}
分为了写头和写区块体两部分。首先对区块头进行了RLP编码，然后将Number转换成为byte格式，然后拼装key。
这个过程中要先存储了hash->Number的值，然后才将区块头的数据写入数据库。
区块体类似，RLP编码，拼装KEY。
再分析一下交易的存储：
目前的以太坊交易在数据库中仅存储交易的元数据：
// TxLookupEntry is a positional metadata to help looking up the data content of
// a transaction or receipt given only its hash.
type TxLookupEntry struct {
    BlockHash  common.Hash
    BlockIndex uint64
    Index      uint64
}
存储的KV对应为：
txHash(交易哈希)+txMetaSuffix(前缀)->rlpEncode(txMeta)(元数据编码)
写入函数：
// WriteTxLookupEntries stores a positional metadata for every transaction from
// a block, enabling hash based transaction and receipt lookups.
func WriteTxLookupEntries(db ethdb.Putter, block *types.Block) error {
    // Iterate over each transaction and encode its metadata
    for i, tx := range block.Transactions() {
        entry := TxLookupEntry{
            BlockHash:  block.Hash(),
            BlockIndex: block.NumberU64(),
            Index:      uint64(i),
        }
        data, err := rlp.EncodeToBytes(entry)
        if err != nil {
            return err
        }
        if err := db.Put(append(lookupPrefix, tx.Hash().Bytes()...), data); err != nil {
            return err
        }
    }
    return nil
}
遍历交易，构造元数据，RLP编码，然后就可以入库了。
读取代码如下：
// GetTransaction retrieves a specific transaction from the database, along with
// its added positional metadata.
func GetTransaction(db DatabaseReader, hash common.Hash) (*types.Transaction, common.Hash, uint64, uint64) {
    // Retrieve the lookup metadata and resolve the transaction from the body
    blockHash, blockNumber, txIndex := GetTxLookupEntry(db, hash)

    if blockHash != (common.Hash{}) {
        body := GetBody(db, blockHash, blockNumber)
        if body == nil || len(body.Transactions) <= int(txIndex) {
            log.Error("Transaction referenced missing", "number", blockNumber, "hash", blockHash, "index", txIndex)
            return nil, common.Hash{}, 0, 0
        }
        return body.Transactions[txIndex], blockHash, blockNumber, txIndex
    }
    // Old transaction representation, load the transaction and it's metadata separately
    data, _ := db.Get(hash.Bytes())
    if len(data) == 0 {
        return nil, common.Hash{}, 0, 0
    }
    var tx types.Transaction
    if err := rlp.DecodeBytes(data, &tx); err != nil {
        return nil, common.Hash{}, 0, 0
    }
    // Retrieve the blockchain positional metadata
    data, _ = db.Get(append(hash.Bytes(), oldTxMetaSuffix...))
    if len(data) == 0 {
        return nil, common.Hash{}, 0, 0
    }
    var entry TxLookupEntry
    if err := rlp.DecodeBytes(data, &entry); err != nil {
        return nil, common.Hash{}, 0, 0
    }
    return &tx, entry.BlockHash, entry.BlockIndex, entry.Index
}
先通过交易哈希得到元数据入口，再查找块哈希，然后从块上找到交易的具体信息返回，或者如果是老的版本，则处理一下再返回。
也就是说，这个函数支持新旧两个版本的交易查询。
这样区块也就基本分析完成了。
如果对区块链和c++感兴趣，欢迎关注：