go-ethereum源码分析 PartII 共识算法

首先从共识引擎-Engine开始记录

Engine是一个独立于具体算法的共识引擎接口

Author(header) (common.Address, error) 返回打包header对应的区块的矿工地址

VerifyHeader(chain ChainReader, header, seal bool) 验证header是否遵循当前Engine的共识原则。seal代表是否要顺便把VerifySeal做了

VerifyHeaders

VerifyUncles(chain ChainReader, block) error

VerifySeal(chain ChainReader, header) error

Prepare(chain, header) error 为header的共识fields的初始化做准备, The changes are executed incline.

Finalize 

(chain ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction,

        uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error)

会话结束后状态的修改

Seal（chain, block,results chan<- *types.Block, stop <-chan struct{}） 生成sealing request并且把结果加入channel中。注意，异步(the method returns immediately and will send the result async)，根据共识算法不同，可能获得复数个blocks

SealHash(header) common.Hash 在sealed之前的块的Hash值

CalcDifficulty(chain, time uint64, parent *types.Header) *bigInt 难度调节算法，返回新块的难度 

APIs(chain ChainReader)[]rpc.API 返回该共识引擎所提供的RPC APIs

// PoW is a consensus engine based on proof-of-work.

type PoW interface {

    Engine

    // Hashrate returns the current mining hashrate of a PoW consensus engine.

    Hashrate() float64

}

 

引擎的实现是Ethhash算法，Ethash算法是Ethereum1.0提出的PoW算法，也是Dagger-Hashimoto方法用在Ether上的最后一版改编版。（之后可能用PoS代替）

Ethash的设计目的是：

1. IO饱和，以便抵抗ASIC类似机器的挖掘。尽量消耗IO带宽

2. GPU friendliness

3. light client容易验证，能够在0.01s（c语言)内验证一回合的挖矿验证，只占1MB以内的内存

4. light client更慢: light client的速度更慢，就算用特制硬件也要比full node 更慢-对应hashimotolight和hashimotofull，目前看来前者要比后者用到的memory少但是可能需要频繁调用

5. light client fast startup: 在js中用40s以内的时间

基本流程

1. 首先根据当前epoch生成一个seed

2. 通过seed，计算一块伪cache，大小16MB

3. 通过16MBcache，可以生成约1G大小的dataset（或者说DAG）（DAG每30000个blocks完全更新一次）

4. 随机抽取dataset的一部分（2块cache），与当前header的RLP的keccak256hash值做hash。

5. 验证者可以生成那一块cache来验证，耗CPU较少

 6. 不忘记删掉旧的epoch

 

基本参数

 

WORD_BYTES = 4                    # bytes in word
DATASET_BYTES_INIT = 2**30        # bytes in dataset at genesis
DATASET_BYTES_GROWTH = 2**23      # dataset growth per epoch
CACHE_BYTES_INIT = 2**24          # bytes in cache at genesis
CACHE_BYTES_GROWTH = 2**17        # cache growth per epoch
CACHE_MULTIPLIER=1024             # Size of the DAG relative to the cache
EPOCH_LENGTH = 30000              # blocks per epoch
MIX_BYTES = 128                   # width of mix
HASH_BYTES = 64                   # hash length in bytes
DATASET_PARENTS = 256             # number of parents of each dataset element
CACHE_ROUNDS = 3                  # number of rounds in cache production
ACCESSES = 64                     # number of accesses in hashimoto loop

cache size和dataset size因为要随着时间增长，所以是CACHE_BYTES_INIT + CACHE_BYTES_GROWTH * (block_number // EPOCH_LENGTH)之下的最大质数

生成mkcache的seed

 def get_seedhash(block):
     s = 'x00' * 32
     for i in range(block.number // EPOCH_LENGTH):
         s = serialize_hash(sha3_256(s))
     return s

　　

 生成cache的方法

注意ETH用的hash是sha3的变体，更接近keccak算法

def mkcache(cache_size, seed):
    n = cache_size // HASH_BYTES

    # Sequentially produce the initial dataset
    o = [sha3_512(seed)]
    for i in range(1, n):
        o.append(sha3_512(o[-1]))

    # Use a low-round version of randmemohash
    for _ in range(CACHE_ROUNDS):
        for i in range(n):
            v = o[i][0] % n
            o[i] = sha3_512(map(xor, o[(i-1+n) % n], o[v]))

    return o

生成dataset的方法

FNV_PRIME = 0x01000193

def fnv(v1, v2):
    return ((v1 * FNV_PRIME) ^ v2) % 2**32

def calc_dataset_item(cache, i):
    n = len(cache)
    r = HASH_BYTES // WORD_BYTES
    # initialize the mix
    mix = copy.copy(cache[i % n])
    mix[0] ^= i
    mix = sha3_512(mix)
    # fnv it with a lot of random cache nodes based on i
    for j in range(DATASET_PARENTS):
        cache_index = fnv(i ^ j, mix[j % r])
        mix = map(fnv, mix, cache[cache_index % n])
    return sha3_512(mix)

def calc_dataset(full_size, cache):
    return [calc_dataset_item(cache, i) for i in range(full_size // HASH_BYTES)]

算法主体

注意这里的s与seed不要混淆

def hashimoto(header, nonce, full_size, dataset_lookup):
    n = full_size / HASH_BYTES
    w = MIX_BYTES // WORD_BYTES
    mixhashes = MIX_BYTES / HASH_BYTES
    # combine header+nonce into a 64 byte seed
    s = sha3_512(header + nonce[::-1])
    # start the mix with replicated s
    mix = []
    for _ in range(MIX_BYTES / HASH_BYTES):
        mix.extend(s)
    # mix in random dataset nodes
    for i in range(ACCESSES):
        p = fnv(i ^ s[0], mix[i % w]) % (n // mixhashes) * mixhashes
        newdata = []
        for j in range(MIX_BYTES / HASH_BYTES):
            newdata.extend(dataset_lookup(p + j))
        mix = map(fnv, mix, newdata)
    # compress mix
    cmix = []
    for i in range(0, len(mix), 4):
        cmix.append(fnv(fnv(fnv(mix[i], mix[i+1]), mix[i+2]), mix[i+3]))
    return {
        "mix digest": serialize_hash(cmix),
        "result": serialize_hash(sha3_256(s+cmix))
    }

def hashimoto_light(full_size, cache, header, nonce):
    return hashimoto(header, nonce, full_size, lambda x: calc_dataset_item(cache, x))

def hashimoto_full(full_size, dataset, header, nonce):
    return hashimoto(header, nonce, full_size, lambda x: dataset[x])

def mine(full_size, dataset, header, difficulty):
    # zero-pad target to compare with hash on the same digit when reversed
    target = zpad(encode_int(2**256 // difficulty), 64)[::-1]
    from random import randint
    nonce = randint(0, 2**64)
    while hashimoto_full(full_size, dataset, header, nonce) > target:
        nonce = (nonce + 1) % 2**64
    return nonce

结构定义

// Ethash is a consensus engine based on proof-of-work implementing the ethash
// algorithm.
type Ethash struct {
    config Config

    caches   *lru // In memory caches to avoid regenerating too often
    datasets *lru // In memory datasets to avoid regenerating too often

    // Mining related fields
    rand     *rand.Rand    // Properly seeded random source for nonces
    threads  int           // Number of threads to mine on if mining
    update   chan struct{} // Notification channel to update mining parameters
    hashrate metrics.Meter // Meter tracking the average hashrate

    // Remote sealer related fields
    workCh       chan *sealTask   // Notification channel to push new work and relative result channel to remote sealer
    fetchWorkCh  chan *sealWork   // Channel used for remote sealer to fetch mining work
    submitWorkCh chan *mineResult // Channel used for remote sealer to submit their mining result
    fetchRateCh  chan chan uint64 // Channel used to gather submitted hash rate for local or remote sealer.
    submitRateCh chan *hashrate   // Channel used for remote sealer to submit their mining hashrate

    // The fields below are hooks for testing
    shared    *Ethash       // Shared PoW verifier to avoid cache regeneration
    fakeFail  uint64        // Block number which fails PoW check even in fake mode
    fakeDelay time.Duration // Time delay to sleep for before returning from verify

    lock      sync.Mutex      // Ensures thread safety for the in-memory caches and mining fields
    closeOnce sync.Once       // Ensures exit channel will not be closed twice.
    exitCh    chan chan error // Notification channel to exiting backend threads
}

Ethash在ethash.go中有以下一些方法：

1. cache

2. dataset

这两个方法先在内存中找，接着去磁盘的DAG中找，最后创建对应数据结构

3. Hashrate

收集本机和网络peer的过去一分钟内search invocation的速率（单位每秒）

SUGAR:

Go non-blocking channel op

如果通道恰好能够收发，那么就对通道做对应操作

    select {
    case msg := <-messages:
        fmt.Println("received message", msg)
    case sig := <-signals:
        fmt.Println("received signal", sig)
    default:
        fmt.Println("no activity")
    }