以太坊共识算法

├─ethash
│      algorithm.go       // Dagger-Hashimoto算法实现
│      api.go         // RPC方法
│      consensus.go      // 共识设计
│      difficulty.go        // 难度设计
│      ethash.go        // cache结构体和dataset结构体实现
│      sealer.go          // 共识接口Seal实现

// filedir:go-ethereum-1.10.2\consensus\ethash\consensus.go L40
// Ethash proof-of-work protocol constants.
var (
  FrontierBlockReward           = big.NewInt(5e+18) // Block reward in wei for successfully mining a block
  ByzantiumBlockReward          = big.NewInt(3e+18) // Block reward in wei for successfully mining a block upward from Byzantium
  ConstantinopleBlockReward     = big.NewInt(2e+18) // Block reward in wei for successfully mining a block upward from Constantinople
  maxUncles                     = 2                 // Maximum number of uncles allowed in a single block
  allowedFutureBlockTimeSeconds = int64(15)         // Max seconds from current time allowed for blocks, before they're considered future blocks

  // calcDifficultyEip2384 is the difficulty adjustment algorithm as specified by EIP 2384.
  // It offsets the bomb 4M blocks from Constantinople, so in total 9M blocks.
  // Specification EIP-2384: https://eips.ethereum.org/EIPS/eip-2384
  calcDifficultyEip2384 = makeDifficultyCalculator(big.NewInt(9000000))

  // calcDifficultyConstantinople is the difficulty adjustment algorithm for Constantinople.
  // It returns the difficulty that a new block should have when created at time given the
  // parent block's time and difficulty. The calculation uses the Byzantium rules, but with
  // bomb offset 5M.
  // Specification EIP-1234: https://eips.ethereum.org/EIPS/eip-1234
  calcDifficultyConstantinople = makeDifficultyCalculator(big.NewInt(5000000))

  // calcDifficultyByzantium is the difficulty adjustment algorithm. It returns
  // the difficulty that a new block should have when created at time given the
  // parent block's time and difficulty. The calculation uses the Byzantium rules.
  // Specification EIP-649: https://eips.ethereum.org/EIPS/eip-649
  calcDifficultyByzantium = makeDifficultyCalculator(big.NewInt(3000000))
)

// Various error messages to mark blocks invalid. These should be private to
// prevent engine specific errors from being referenced in the remainder of the
// codebase, inherently breaking if the engine is swapped out. Please put common
// error types into the consensus package.
var (
  errOlderBlockTime    = errors.New("timestamp older than parent")
  errTooManyUncles     = errors.New("too many uncles")
  errDuplicateUncle    = errors.New("duplicate uncle")
  errUncleIsAncestor   = errors.New("uncle is ancestor")
  errDanglingUncle     = errors.New("uncle's parent is not ancestor")
  errInvalidDifficulty = errors.New("non-positive difficulty")
  errInvalidMixDigest  = errors.New("invalid mix digest")
  errInvalidPoW        = errors.New("invalid proof-of-work")
)

// filedir:go-ethereum-1.10.2\consensus\ethash\consensus.go  L82
// Author implements consensus.Engine, returning the header's coinbase as the
// proof-of-work verified author of the block.
func (ethash *Ethash) Author(header *types.Header) (common.Address, error) {
  return header.Coinbase, nil
}

// filedir:go-ethereum-1.10.2\consensus\ethash\consensus.go L88
// VerifyHeader checks whether a header conforms to the consensus rules of the
// stock Ethereum ethash engine.
func (ethash *Ethash) VerifyHeader(chain consensus.ChainHeaderReader, header *types.Header, seal bool) error {
  // If we're running a full engine faking, accept any input as valid
  if ethash.config.PowMode == ModeFullFake {
    return nil
  }
  // Short circuit if the header is known, or its parent not
  number := header.Number.Uint64()
  if chain.GetHeader(header.Hash(), number) != nil {
    return nil
  }
  parent := chain.GetHeader(header.ParentHash, number-1)
  if parent == nil {
    return consensus.ErrUnknownAncestor
  }
  // Sanity checks passed, do a proper verification
  return ethash.verifyHeader(chain, header, parent, false, seal, time.Now().Unix())
}

// filedir:go-ethereum-1.10.2\consensus\ethash\consensus.go  L108
// VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers
// concurrently. The method returns a quit channel to abort the operations and
// a results channel to retrieve the async verifications.
func (ethash *Ethash) VerifyHeaders(chain consensus.ChainHeaderReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) {
  // If we're running a full engine faking, accept any input as valid
  if ethash.config.PowMode == ModeFullFake || len(headers) == 0 {
    abort, results := make(chan struct{}), make(chan error, len(headers))
    for i := 0; i < len(headers); i++ {
      results <- nil
    }
    return abort, results
  }

  // Spawn as many workers as allowed threads
  workers := runtime.GOMAXPROCS(0)
  if len(headers) < workers {
    workers = len(headers)
  }

  // Create a task channel and spawn the verifiers
  var (
    inputs  = make(chan int)
    done    = make(chan int, workers)
    errors  = make([]error, len(headers))
    abort   = make(chan struct{})
    unixNow = time.Now().Unix()
  )
  for i := 0; i < workers; i++ {
    go func() {
      for index := range inputs {
        errors[index] = ethash.verifyHeaderWorker(chain, headers, seals, index, unixNow)
        done <- index
      }
    }()
  }

  errorsOut := make(chan error, len(headers))
  go func() {
    defer close(inputs)
    var (
      in, out = 0, 0
      checked = make([]bool, len(headers))
      inputs  = inputs
    )
    for {
      select {
      case inputs <- in:
        if in++; in == len(headers) {
          // Reached end of headers. Stop sending to workers.
          inputs = nil
        }
      case index := <-done:
        for checked[index] = true; checked[out]; out++ {
          errorsOut <- errors[out]
          if out == len(headers)-1 {
            return
          }
        }
      case <-abort:
        return
      }
    }
  }()
  return abort, errorsOut
}

func (ethash *Ethash) verifyHeaderWorker(chain consensus.ChainHeaderReader, headers []*types.Header, seals []bool, index int, unixNow int64) error {
  var parent *types.Header
  if index == 0 {
    parent = chain.GetHeader(headers[0].ParentHash, headers[0].Number.Uint64()-1)
  } else if headers[index-1].Hash() == headers[index].ParentHash {
    parent = headers[index-1]
  }
  if parent == nil {
    return consensus.ErrUnknownAncestor
  }
  return ethash.verifyHeader(chain, headers[index], parent, false, seals[index], unixNow)
}

// fileidr:go-ethereum-1.10.2\consensus\ethash\consensus.go  L242
// verifyHeader checks whether a header conforms to the consensus rules of the
// stock Ethereum ethash engine.
// See YP section 4.3.4. "Block Header Validity"
func (ethash *Ethash) verifyHeader(chain consensus.ChainHeaderReader, header, parent *types.Header, uncle bool, seal bool, unixNow int64) error {
  // Ensure that the header's extra-data section is of a reasonable size
  if uint64(len(header.Extra)) > params.MaximumExtraDataSize {
    return fmt.Errorf("extra-data too long: %d > %d", len(header.Extra), params.MaximumExtraDataSize)
  }
  // Verify the header's timestamp
  if !uncle {
    if header.Time > uint64(unixNow+allowedFutureBlockTimeSeconds) {
      return consensus.ErrFutureBlock
    }
  }
  if header.Time <= parent.Time {
    return errOlderBlockTime
  }
  // Verify the block's difficulty based on its timestamp and parent's difficulty
  expected := ethash.CalcDifficulty(chain, header.Time, parent)

  if expected.Cmp(header.Difficulty) != 0 {
    return fmt.Errorf("invalid difficulty: have %v, want %v", header.Difficulty, expected)
  }
  // Verify that the gas limit is <= 2^63-1
  cap := uint64(0x7fffffffffffffff)
  if header.GasLimit > cap {
    return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimit, cap)
  }
  // Verify that the gasUsed is <= gasLimit
  if header.GasUsed > header.GasLimit {
    return fmt.Errorf("invalid gasUsed: have %d, gasLimit %d", header.GasUsed, header.GasLimit)
  }

  // Verify that the gas limit remains within allowed bounds
  diff := int64(parent.GasLimit) - int64(header.GasLimit)
  if diff < 0 {
    diff *= -1
  }
  limit := parent.GasLimit / params.GasLimitBoundDivisor

  if uint64(diff) >= limit || header.GasLimit < params.MinGasLimit {
    return fmt.Errorf("invalid gas limit: have %d, want %d += %d", header.GasLimit, parent.GasLimit, limit)
  }
  // Verify that the block number is parent's +1
  if diff := new(big.Int).Sub(header.Number, parent.Number); diff.Cmp(big.NewInt(1)) != 0 {
    return consensus.ErrInvalidNumber
  }
  // Verify the engine specific seal securing the block
  if seal {
    if err := ethash.verifySeal(chain, header, false); err != nil {
      return err
    }
  }
  // If all checks passed, validate any special fields for hard forks
  if err := misc.VerifyDAOHeaderExtraData(chain.Config(), header); err != nil {
    return err
  }
  if err := misc.VerifyForkHashes(chain.Config(), header, uncle); err != nil {
    return err
  }
  return nil
}

// filedir: go-ethereum-1.10.2\consensus\ethash\consensus.go L186
// VerifyUncles verifies that the given block's uncles conform to the consensus
// rules of the stock Ethereum ethash engine.
func (ethash *Ethash) VerifyUncles(chain consensus.ChainReader, block *types.Block) error {
  // If we're running a full engine faking, accept any input as valid
  if ethash.config.PowMode == ModeFullFake {
    return nil
  }
  // Verify that there are at most 2 uncles included in this block
  if len(block.Uncles()) > maxUncles {
    return errTooManyUncles
  }
  if len(block.Uncles()) == 0 {
    return nil
  }
  // Gather the set of past uncles and ancestors
  uncles, ancestors := mapset.NewSet(), make(map[common.Hash]*types.Header)

  number, parent := block.NumberU64()-1, block.ParentHash()
  for i := 0; i < 7; i++ {
    ancestor := chain.GetBlock(parent, number)
    if ancestor == nil {
      break
    }
    ancestors[ancestor.Hash()] = ancestor.Header()
    for _, uncle := range ancestor.Uncles() {
      uncles.Add(uncle.Hash())
    }
    parent, number = ancestor.ParentHash(), number-1
  }
  ancestors[block.Hash()] = block.Header()
  uncles.Add(block.Hash())

  // Verify each of the uncles that it's recent, but not an ancestor
  for _, uncle := range block.Uncles() {
    // Make sure every uncle is rewarded only once
    hash := uncle.Hash()
    if uncles.Contains(hash) {
      return errDuplicateUncle
    }
    uncles.Add(hash)

    // Make sure the uncle has a valid ancestry
    if ancestors[hash] != nil {
      return errUncleIsAncestor
    }
    if ancestors[uncle.ParentHash] == nil || uncle.ParentHash == block.ParentHash() {
      return errDanglingUncle
    }
    if err := ethash.verifyHeader(chain, uncle, ancestors[uncle.ParentHash], true, true, time.Now().Unix()); err != nil {
      return err
    }
  }
  return nil
}

// filedir:go-ethereum-1.10.2\core\block_validator.go L48
// ValidateBody validates the given block's uncles and verifies the block
// header's transaction and uncle roots. The headers are assumed to be already
// validated at this point.
func (v *BlockValidator) ValidateBody(block *types.Block) error {
  // Check whether the block's known, and if not, that it's linkable
  if v.bc.HasBlockAndState(block.Hash(), block.NumberU64()) {
    return ErrKnownBlock
  }
  // Header validity is known at this point, check the uncles and transactions
  header := block.Header()
  if err := v.engine.VerifyUncles(v.bc, block); err != nil {
    return err
  }
  if hash := types.CalcUncleHash(block.Uncles()); hash != header.UncleHash {
    return fmt.Errorf("uncle root hash mismatch: have %x, want %x", hash, header.UncleHash)
  }
  if hash := types.DeriveSha(block.Transactions(), trie.NewStackTrie(nil)); hash != header.TxHash {
    return fmt.Errorf("transaction root hash mismatch: have %x, want %x", hash, header.TxHash)
  }
  if !v.bc.HasBlockAndState(block.ParentHash(), block.NumberU64()-1) {
    if !v.bc.HasBlock(block.ParentHash(), block.NumberU64()-1) {
      return consensus.ErrUnknownAncestor
    }
    return consensus.ErrPrunedAncestor
  }
  return nil
}

// Prepare implements consensus.Engine, initializing the difficulty field of a
// header to conform to the ethash protocol. The changes are done inline.
func (ethash *Ethash) Prepare(chain consensus.ChainHeaderReader, header *types.Header) error {
  parent := chain.GetHeader(header.ParentHash, header.Number.Uint64()-1)
  if parent == nil {
    return consensus.ErrUnknownAncestor
  }
  header.Difficulty = ethash.CalcDifficulty(chain, header.Time, parent)
  return nil
}

// fileidir:go-ethereum-1.10.2\consensus\ethash\consensus.go  L304
// CalcDifficulty is the difficulty adjustment algorithm. It returns
// the difficulty that a new block should have when created at time
// given the parent block's time and difficulty.
func (ethash *Ethash) CalcDifficulty(chain consensus.ChainHeaderReader, time uint64, parent *types.Header) *big.Int {
  return CalcDifficulty(chain.Config(), time, parent)
}

// filedir:go-ethereum-1.10.2\consensus\ethash\consensus.go  L312
// CalcDifficulty is the difficulty adjustment algorithm. It returns
// the difficulty that a new block should have when created at time
// given the parent block's time and difficulty.
func CalcDifficulty(config *params.ChainConfig, time uint64, parent *types.Header) *big.Int {
  next := new(big.Int).Add(parent.Number, big1)
  switch {
  case config.IsMuirGlacier(next):
    return calcDifficultyEip2384(time, parent)
  case config.IsConstantinople(next):
    return calcDifficultyConstantinople(time, parent)
  case config.IsByzantium(next):
    return calcDifficultyByzantium(time, parent)
  case config.IsHomestead(next):
    return calcDifficultyHomestead(time, parent)
  default:
    return calcDifficultyFrontier(time, parent)
  }
}

// filedir:go-ethereum-1.10.2\consensus\ethash\consensus.go  L404
// calcDifficultyHomestead is the difficulty adjustment algorithm. It returns
// the difficulty that a new block should have when created at time given the
// parent block's time and difficulty. The calculation uses the Homestead rules.
func calcDifficultyHomestead(time uint64, parent *types.Header) *big.Int {
  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2.md
  // algorithm:
  // diff = (parent_diff +
  //         (parent_diff / 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
  //        ) + 2^(periodCount - 2)

  bigTime := new(big.Int).SetUint64(time)
  bigParentTime := new(big.Int).SetUint64(parent.Time)

  // holds intermediate values to make the algo easier to read & audit
  x := new(big.Int)
  y := new(big.Int)

  // 1 - (block_timestamp - parent_timestamp) // 10
  x.Sub(bigTime, bigParentTime)
  x.Div(x, big10)
  x.Sub(big1, x)

  // max(1 - (block_timestamp - parent_timestamp) // 10, -99)
  if x.Cmp(bigMinus99) < 0 {
    x.Set(bigMinus99)
  }
  // (parent_diff + parent_diff // 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
  y.Div(parent.Difficulty, params.DifficultyBoundDivisor)
  x.Mul(y, x)
  x.Add(parent.Difficulty, x)

  // minimum difficulty can ever be (before exponential factor)
  if x.Cmp(params.MinimumDifficulty) < 0 {
    x.Set(params.MinimumDifficulty)
  }
  // for the exponential factor
  periodCount := new(big.Int).Add(parent.Number, big1)
  periodCount.Div(periodCount, expDiffPeriod)

  // the exponential factor, commonly referred to as "the bomb"
  // diff = diff + 2^(periodCount - 2)
  if periodCount.Cmp(big1) > 0 {
    y.Sub(periodCount, big2)
    y.Exp(big2, y, nil)
    x.Add(x, y)
  }
  return x
}

// filedir:go-ethereum-1.10.2\consensus\ethash\consensus.go  L490
// verifySeal checks whether a block satisfies the PoW difficulty requirements,
// either using the usual ethash cache for it, or alternatively using a full DAG
// to make remote mining fast.
func (ethash *Ethash) verifySeal(chain consensus.ChainHeaderReader, header *types.Header, fulldag bool) error {
  // If we're running a fake PoW, accept any seal as valid
  if ethash.config.PowMode == ModeFake || ethash.config.PowMode == ModeFullFake {
    time.Sleep(ethash.fakeDelay)
    if ethash.fakeFail == header.Number.Uint64() {
      return errInvalidPoW
    }
    return nil
  }
  // If we're running a shared PoW, delegate verification to it
  if ethash.shared != nil {
    return ethash.shared.verifySeal(chain, header, fulldag)
  }
  // Ensure that we have a valid difficulty for the block
  if header.Difficulty.Sign() <= 0 {
    return errInvalidDifficulty
  }
  // Recompute the digest and PoW values
  number := header.Number.Uint64()

  var (
    digest []byte
    result []byte
  )
  // If fast-but-heavy PoW verification was requested, use an ethash dataset
  if fulldag {
    dataset := ethash.dataset(number, true)
    if dataset.generated() {
      digest, result = hashimotoFull(dataset.dataset, ethash.SealHash(header).Bytes(), header.Nonce.Uint64())

      // Datasets are unmapped in a finalizer. Ensure that the dataset stays alive
      // until after the call to hashimotoFull so it's not unmapped while being used.
      runtime.KeepAlive(dataset)
    } else {
      // Dataset not yet generated, don't hang, use a cache instead
      fulldag = false
    }
  }
  // If slow-but-light PoW verification was requested (or DAG not yet ready), use an ethash cache
  if !fulldag {
    cache := ethash.cache(number)

    size := datasetSize(number)
    if ethash.config.PowMode == ModeTest {
      size = 32 * 1024
    }
    digest, result = hashimotoLight(size, cache.cache, ethash.SealHash(header).Bytes(), header.Nonce.Uint64())

    // Caches are unmapped in a finalizer. Ensure that the cache stays alive
    // until after the call to hashimotoLight so it's not unmapped while being used.
    runtime.KeepAlive(cache)
  }
  // Verify the calculated values against the ones provided in the header
  if !bytes.Equal(header.MixDigest[:], digest) {
    return errInvalidMixDigest
  }
  target := new(big.Int).Div(two256, header.Difficulty)
  if new(big.Int).SetBytes(result).Cmp(target) > 0 {
    return errInvalidPoW
  }
  return nil
}

// FinalizeAndAssemble implements consensus.Engine, accumulating the block and
// uncle rewards, setting the final state and assembling the block.
func (ethash *Ethash) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) {
  // Finalize block
  ethash.Finalize(chain, header, state, txs, uncles)

  // Header seems complete, assemble into a block and return
  return types.NewBlock(header, txs, uncles, receipts, trie.NewStackTrie(nil)), nil
}

// filedir：go-ethereum-1.10.2\consensus\ethash\consensus.go  L568
// Finalize implements consensus.Engine, accumulating the block and uncle rewards,
// setting the final state on the header
func (ethash *Ethash) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header) {
  // Accumulate any block and uncle rewards and commit the final state root
  accumulateRewards(chain.Config(), state, header, uncles)
  header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number))
}

// filedir:go-ethereum-1.10.2\consensus\ethash\consensus.go  L614
// AccumulateRewards credits the coinbase of the given block with the mining
// reward. The total reward consists of the static block reward and rewards for
// included uncles. The coinbase of each uncle block is also rewarded.
func accumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) {
  // Select the correct block reward based on chain progression
  blockReward := FrontierBlockReward
  if config.IsByzantium(header.Number) {
    blockReward = ByzantiumBlockReward
  }
  if config.IsConstantinople(header.Number) {
    blockReward = ConstantinopleBlockReward
  }
  // Accumulate the rewards for the miner and any included uncles
  reward := new(big.Int).Set(blockReward)
  r := new(big.Int)
  for _, uncle := range uncles {
    r.Add(uncle.Number, big8)
    r.Sub(r, header.Number)
    r.Mul(r, blockReward)
    r.Div(r, big8)
    state.AddBalance(uncle.Coinbase, r)

    r.Div(blockReward, big32)
    reward.Add(reward, r)
  }
  state.AddBalance(header.Coinbase, reward)
}

// filedir:go-ethereum-1.10.2\core\state\statedb.go  L834
// IntermediateRoot computes the current root hash of the state trie.
// It is called in between transactions to get the root hash that
// goes into transaction receipts.
func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
  // Finalise all the dirty storage states and write them into the tries
  s.Finalise(deleteEmptyObjects)

  // If there was a trie prefetcher operating, it gets aborted and irrevocably
  // modified after we start retrieving tries. Remove it from the statedb after
  // this round of use.
  //
  // This is weird pre-byzantium since the first tx runs with a prefetcher and
  // the remainder without, but pre-byzantium even the initial prefetcher is
  // useless, so no sleep lost.
  prefetcher := s.prefetcher
  if s.prefetcher != nil {
    defer func() {
      s.prefetcher.close()
      s.prefetcher = nil
    }()
  }
  // Although naively it makes sense to retrieve the account trie and then do
  // the contract storage and account updates sequentially, that short circuits
  // the account prefetcher. Instead, let's process all the storage updates
  // first, giving the account prefeches just a few more milliseconds of time
  // to pull useful data from disk.
  for addr := range s.stateObjectsPending {
    if obj := s.stateObjects[addr]; !obj.deleted {
      obj.updateRoot(s.db)
    }
  }
  // Now we're about to start to write changes to the trie. The trie is so far
  // _untouched_. We can check with the prefetcher, if it can give us a trie
  // which has the same root, but also has some content loaded into it.
  if prefetcher != nil {
    if trie := prefetcher.trie(s.originalRoot); trie != nil {
      s.trie = trie
    }
  }
  usedAddrs := make([][]byte, 0, len(s.stateObjectsPending))
  for addr := range s.stateObjectsPending {
    if obj := s.stateObjects[addr]; obj.deleted {
      s.deleteStateObject(obj)
    } else {
      s.updateStateObject(obj)
    }
    usedAddrs = append(usedAddrs, common.CopyBytes(addr[:])) // Copy needed for closure
  }
  if prefetcher != nil {
    prefetcher.used(s.originalRoot, usedAddrs)
  }
  if len(s.stateObjectsPending) > 0 {
    s.stateObjectsPending = make(map[common.Address]struct{})
  }
  // Track the amount of time wasted on hashing the account trie
  if metrics.EnabledExpensive {
    defer func(start time.Time) { s.AccountHashes += time.Since(start) }(time.Now())
  }
  return s.trie.Hash()
}

// filedir:go-ethereum-1.10.2\core\types\block.go L197
// NewBlock creates a new block. The input data is copied,
// changes to header and to the field values will not affect the
// block.
//
// The values of TxHash, UncleHash, ReceiptHash and Bloom in header
// are ignored and set to values derived from the given txs, uncles
// and receipts.
func NewBlock(header *Header, txs []*Transaction, uncles []*Header, receipts []*Receipt, hasher TrieHasher) *Block {
  b := &Block{header: CopyHeader(header), td: new(big.Int)}

  // TODO: panic if len(txs) != len(receipts)
  if len(txs) == 0 {
    b.header.TxHash = EmptyRootHash
  } else {
    b.header.TxHash = DeriveSha(Transactions(txs), hasher)
    b.transactions = make(Transactions, len(txs))
    copy(b.transactions, txs)
  }

  if len(receipts) == 0 {
    b.header.ReceiptHash = EmptyRootHash
  } else {
    b.header.ReceiptHash = DeriveSha(Receipts(receipts), hasher)
    b.header.Bloom = CreateBloom(receipts)
  }

  if len(uncles) == 0 {
    b.header.UncleHash = EmptyUncleHash
  } else {
    b.header.UncleHash = CalcUncleHash(uncles)
    b.uncles = make([]*Header, len(uncles))
    for i := range uncles {
      b.uncles[i] = CopyHeader(uncles[i])
    }
  }

  return b
}

// filedir:go-ethereum-1.10.2\consensus\ethash\sealer.go L48
// Seal implements consensus.Engine, attempting to find a nonce that satisfies
// the block's difficulty requirements.
func (ethash *Ethash) Seal(chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error {
  // If we're running a fake PoW, simply return a 0 nonce immediately
  if ethash.config.PowMode == ModeFake || ethash.config.PowMode == ModeFullFake {
    header := block.Header()
    header.Nonce, header.MixDigest = types.BlockNonce{}, common.Hash{}
    select {
    case results <- block.WithSeal(header):
    default:
      ethash.config.Log.Warn("Sealing result is not read by miner", "mode", "fake", "sealhash", ethash.SealHash(block.Header()))
    }
    return nil
  }
  // If we're running a shared PoW, delegate sealing to it
  if ethash.shared != nil {
    return ethash.shared.Seal(chain, block, results, stop)
  }
  // Create a runner and the multiple search threads it directs
  abort := make(chan struct{})

  ethash.lock.Lock()
  threads := ethash.threads
  if ethash.rand == nil {
    seed, err := crand.Int(crand.Reader, big.NewInt(math.MaxInt64))
    if err != nil {
      ethash.lock.Unlock()
      return err
    }
    ethash.rand = rand.New(rand.NewSource(seed.Int64()))
  }
  ethash.lock.Unlock()
  if threads == 0 {
    threads = runtime.NumCPU()
  }
  if threads < 0 {
    threads = 0 // Allows disabling local mining without extra logic around local/remote
  }
  // Push new work to remote sealer
  if ethash.remote != nil {
    ethash.remote.workCh <- &sealTask{block: block, results: results}
  }
  var (
    pend   sync.WaitGroup
    locals = make(chan *types.Block)
  )
  for i := 0; i < threads; i++ {
    pend.Add(1)
    go func(id int, nonce uint64) {
      defer pend.Done()
      ethash.mine(block, id, nonce, abort, locals)    // 调用mine函数
    }(i, uint64(ethash.rand.Int63()))
  }
  // Wait until sealing is terminated or a nonce is found
  go func() {
    var result *types.Block
    select {
    case <-stop:
      // Outside abort, stop all miner threads
      close(abort)
    case result = <-locals:
      // One of the threads found a block, abort all others
      select {
      case results <- result:
      default:
        ethash.config.Log.Warn("Sealing result is not read by miner", "mode", "local", "sealhash", ethash.SealHash(block.Header()))
      }
      close(abort)
    case <-ethash.update:
      // Thread count was changed on user request, restart
      close(abort)
      if err := ethash.Seal(chain, block, results, stop); err != nil {
        ethash.config.Log.Error("Failed to restart sealing after update", "err", err)
      }
    }
    // Wait for all miners to terminate and return the block
    pend.Wait()
  }()
  return nil
}

// filedir:go-ethereum-1.10.2\consensus\ethash\sealer.go  L30
// mine is the actual proof-of-work miner that searches for a nonce starting from
// seed that results in correct final block difficulty.
func (ethash *Ethash) mine(block *types.Block, id int, seed uint64, abort chan struct{}, found chan *types.Block) {
  // Extract some data from the header 从区块头中提取出一些数据
  var (
    header  = block.Header()
    hash    = ethash.SealHash(header).Bytes()
    target  = new(big.Int).Div(two256, header.Difficulty)
    number  = header.Number.Uint64()
    dataset = ethash.dataset(number, false)
  )
  // Start generating random nonces until we abort or find a good one  
  var (
    attempts = int64(0)
    nonce    = seed
  )
  logger := ethash.config.Log.New("miner", id)
  logger.Trace("Started ethash search for new nonces", "seed", seed)
search:
  for {
    select {
    case <-abort:    // 挖矿中止，更新状态，中止当前操作
      // Mining terminated, update stats and abort
      logger.Trace("Ethash nonce search aborted", "attempts", nonce-seed)
      ethash.hashrate.Mark(attempts)
      break search

    default:      // 默认执行逻辑
      // We don't have to update hash rate on every nonce, so update after after 2^X nonces
      attempts++
      if (attempts % (1 << 15)) == 0 {
        ethash.hashrate.Mark(attempts)
        attempts = 0
      }
      // Compute the PoW value of this nonce   // 计算nonce的pow值
      digest, result := hashimotoFull(dataset.dataset, hash, nonce)
      if new(big.Int).SetBytes(result).Cmp(target) <= 0 {
        // Correct nonce found, create a new header with it  找到正确nonce值，创建一个基于它的新的区块头
        header = types.CopyHeader(header)
        header.Nonce = types.EncodeNonce(nonce)
        header.MixDigest = common.BytesToHash(digest)

        // Seal and return a block (if still needed)   封装并返回一个区块
        select {
        case found <- block.WithSeal(header):
          logger.Trace("Ethash nonce found and reported", "attempts", nonce-seed, "nonce", nonce)
        case <-abort:
          logger.Trace("Ethash nonce found but discarded", "attempts", nonce-seed, "nonce", nonce)
        }
        break search
      }
      nonce++
    }
  }
  // Datasets are unmapped in a finalizer. Ensure that the dataset stays live
  // during sealing so it's not unmapped while being read.
  runtime.KeepAlive(dataset)
}

func startRemoteSealer(ethash *Ethash, urls []string, noverify bool) *remoteSealer {
  ctx, cancel := context.WithCancel(context.Background())
  s := &remoteSealer{
    ethash:       ethash,
    noverify:     noverify,
    notifyURLs:   urls,
    notifyCtx:    ctx,
    cancelNotify: cancel,
    works:        make(map[common.Hash]*types.Block),
    rates:        make(map[common.Hash]hashrate),
    workCh:       make(chan *sealTask),
    fetchWorkCh:  make(chan *sealWork),
    submitWorkCh: make(chan *mineResult),
    fetchRateCh:  make(chan chan uint64),
    submitRateCh: make(chan *hashrate),
    requestExit:  make(chan struct{}),
    exitCh:       make(chan struct{}),
  }
  go s.loop()
  return s
}

func (s *remoteSealer) loop() {
  defer func() {
    s.ethash.config.Log.Trace("Ethash remote sealer is exiting")
    s.cancelNotify()
    s.reqWG.Wait()
    close(s.exitCh)
  }()

  ticker := time.NewTicker(5 * time.Second)
  defer ticker.Stop()

  for {
    select {
    case work := <-s.workCh:      
      // Update current work with new received block.    
      // Note same work can be past twice, happens when changing CPU threads.
      s.results = work.results
      s.makeWork(work.block)
      s.notifyWork()

    case work := <-s.fetchWorkCh:
      // Return current mining work to remote miner.
      if s.currentBlock == nil {
        work.errc <- errNoMiningWork
      } else {
        work.res <- s.currentWork
      }

    case result := <-s.submitWorkCh:
      // Verify submitted PoW solution based on maintained mining blocks.
      if s.submitWork(result.nonce, result.mixDigest, result.hash) {
        result.errc <- nil
      } else {
        result.errc <- errInvalidSealResult
      }

    case result := <-s.submitRateCh:
      // Trace remote sealer's hash rate by submitted value.
      s.rates[result.id] = hashrate{rate: result.rate, ping: time.Now()}
      close(result.done)

    case req := <-s.fetchRateCh:
      // Gather all hash rate submitted by remote sealer.
      var total uint64
      for _, rate := range s.rates {
        // this could overflow
        total += rate.rate
      }
      req <- total

    case <-ticker.C:
      // Clear stale submitted hash rate.
      for id, rate := range s.rates {
        if time.Since(rate.ping) > 10*time.Second {
          delete(s.rates, id)
        }
      }
      // Clear stale pending blocks
      if s.currentBlock != nil {
        for hash, block := range s.works {
          if block.NumberU64()+staleThreshold <= s.currentBlock.NumberU64() {
            delete(s.works, hash)
          }
        }
      }

    case <-s.requestExit:
      return
    }
  }
}

// filedir:go-ethereum-1.10.2\consensus\ethash\sealer.go  L338
// makeWork creates a work package for external miner.
//
// The work package consists of 3 strings:
//   result[0], 32 bytes hex encoded current block header pow-hash
//   result[1], 32 bytes hex encoded seed hash used for DAG
//   result[2], 32 bytes hex encoded boundary condition ("target"), 2^256/difficulty
//   result[3], hex encoded block number
func (s *remoteSealer) makeWork(block *types.Block) {
  hash := s.ethash.SealHash(block.Header())
  s.currentWork[0] = hash.Hex()
  s.currentWork[1] = common.BytesToHash(SeedHash(block.NumberU64())).Hex()
  s.currentWork[2] = common.BytesToHash(new(big.Int).Div(two256, block.Difficulty()).Bytes()).Hex()
  s.currentWork[3] = hexutil.EncodeBig(block.Number())

  // Trace the seal work fetched by remote sealer.
  s.currentBlock = block
  s.works[hash] = block
}

// filedir:go-ethereum-1.10.2\consensus\ethash\sealer.go  L356
// notifyWork notifies all the specified mining endpoints of the availability of
// new work to be processed.
func (s *remoteSealer) notifyWork() {
  work := s.currentWork

  // Encode the JSON payload of the notification. When NotifyFull is set,
  // this is the complete block header, otherwise it is a JSON array.
  var blob []byte
  if s.ethash.config.NotifyFull {
    blob, _ = json.Marshal(s.currentBlock.Header())
  } else {
    blob, _ = json.Marshal(work)
  }

  s.reqWG.Add(len(s.notifyURLs))
  for _, url := range s.notifyURLs {
    go s.sendNotification(s.notifyCtx, url, blob, work)
  }
}

func (s *remoteSealer) sendNotification(ctx context.Context, url string, json []byte, work [4]string) {
  defer s.reqWG.Done()

  req, err := http.NewRequest("POST", url, bytes.NewReader(json))
  if err != nil {
    s.ethash.config.Log.Warn("Can't create remote miner notification", "err", err)
    return
  }
  ctx, cancel := context.WithTimeout(ctx, remoteSealerTimeout)
  defer cancel()
  req = req.WithContext(ctx)
  req.Header.Set("Content-Type", "application/json")

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    s.ethash.config.Log.Warn("Failed to notify remote miner", "err", err)
  } else {
    s.ethash.config.Log.Trace("Notified remote miner", "miner", url, "hash", work[0], "target", work[2])
    resp.Body.Close()
  }
}

    case work := <-s.fetchWorkCh:
      // Return current mining work to remote miner.
      if s.currentBlock == nil {
        work.errc <- errNoMiningWork
      } else {
        work.res <- s.currentWork
      }

    case result := <-s.submitWorkCh:
      // Verify submitted PoW solution based on maintained mining blocks.
      if s.submitWork(result.nonce, result.mixDigest, result.hash) {
        result.errc <- nil
      } else {
        result.errc <- errInvalidSealResult
      }

// filedir:go-ethereum-1.10.2\consensus\ethash\sealer.go  L398
// submitWork verifies the submitted pow solution, returning
// whether the solution was accepted or not (not can be both a bad pow as well as
// any other error, like no pending work or stale mining result).
func (s *remoteSealer) submitWork(nonce types.BlockNonce, mixDigest common.Hash, sealhash common.Hash) bool {
  if s.currentBlock == nil {
    s.ethash.config.Log.Error("Pending work without block", "sealhash", sealhash)
    return false
  }
  // Make sure the work submitted is present
  block := s.works[sealhash]
  if block == nil {
    s.ethash.config.Log.Warn("Work submitted but none pending", "sealhash", sealhash, "curnumber", s.currentBlock.NumberU64())
    return false
  }
  // Verify the correctness of submitted result.
  header := block.Header()
  header.Nonce = nonce
  header.MixDigest = mixDigest

  start := time.Now()
  if !s.noverify {
    if err := s.ethash.verifySeal(nil, header, true); err != nil {
      s.ethash.config.Log.Warn("Invalid proof-of-work submitted", "sealhash", sealhash, "elapsed", common.PrettyDuration(time.Since(start)), "err", err)
      return false
    }
  }
  // Make sure the result channel is assigned.
  if s.results == nil {
    s.ethash.config.Log.Warn("Ethash result channel is empty, submitted mining result is rejected")
    return false
  }
  s.ethash.config.Log.Trace("Verified correct proof-of-work", "sealhash", sealhash, "elapsed", common.PrettyDuration(time.Since(start)))

  // Solutions seems to be valid, return to the miner and notify acceptance.
  solution := block.WithSeal(header)

  // The submitted solution is within the scope of acceptance.
  if solution.NumberU64()+staleThreshold > s.currentBlock.NumberU64() {
    select {
    case s.results <- solution:
      s.ethash.config.Log.Debug("Work submitted is acceptable", "number", solution.NumberU64(), "sealhash", sealhash, "hash", solution.Hash())
      return true
    default:
      s.ethash.config.Log.Warn("Sealing result is not read by miner", "mode", "remote", "sealhash", sealhash)
      return false
    }
  }
  // The submitted block is too old to accept, drop it.
  s.ethash.config.Log.Warn("Work submitted is too old", "number", solution.NumberU64(), "sealhash", sealhash, "hash", solution.Hash())
  return false
}

    case result := <-s.submitRateCh:
      // Trace remote sealer's hash rate by submitted value.
      s.rates[result.id] = hashrate{rate: result.rate, ping: time.Now()}
      close(result.done)

    case req := <-s.fetchRateCh:
      // Gather all hash rate submitted by remote sealer.
      var total uint64
      for _, rate := range s.rates {
        // this could overflow
        total += rate.rate
      }
      req <- total

    case <-ticker.C:
      // Clear stale submitted hash rate.
      for id, rate := range s.rates {
        if time.Since(rate.ping) > 10*time.Second {
          delete(s.rates, id)
        }
      }
      // Clear stale pending blocks
      if s.currentBlock != nil {
        for hash, block := range s.works {
          if block.NumberU64()+staleThreshold <= s.currentBlock.NumberU64() {
            delete(s.works, hash)
          }
        }
      }

    case <-s.requestExit:
      return
    }

├─clique
│      api.go               // RPC方法
│      clique.go      // 共识设计
│      snapshot.go      // 快照处理

const (
  checkpointInterval = 1024 // Number of blocks after which to save the vote snapshot to the database
  inmemorySnapshots  = 128  // Number of recent vote snapshots to keep in memory
  inmemorySignatures = 4096 // Number of recent block signatures to keep in memory

  wiggleTime = 500 * time.Millisecond // Random delay (per signer) to allow concurrent signers
)

const (
  checkpointInterval = 1024 // Number of blocks after which to save the vote snapshot to the database
  inmemorySnapshots  = 128  // Number of recent vote snapshots to keep in memory
  inmemorySignatures = 4096 // Number of recent block signatures to keep in memory

  wiggleTime = 500 * time.Millisecond // Random delay (per signer) to allow concurrent signers
)

// Clique proof-of-authority protocol constants.
var (
  epochLength = uint64(30000) // Default number of blocks after which to checkpoint and reset the pending votes

  extraVanity = 32                     // Fixed number of extra-data prefix bytes reserved for signer vanity
  extraSeal   = crypto.SignatureLength // Fixed number of extra-data suffix bytes reserved for signer seal

  nonceAuthVote = hexutil.MustDecode("0xffffffffffffffff") // Magic nonce number to vote on adding a new signer
  nonceDropVote = hexutil.MustDecode("0x0000000000000000") // Magic nonce number to vote on removing a signer.

  uncleHash = types.CalcUncleHash(nil) // Always Keccak256(RLP([])) as uncles are meaningless outside of PoW.

  diffInTurn = big.NewInt(2) // Block difficulty for in-turn signatures
  diffNoTurn = big.NewInt(1) // Block difficulty for out-of-turn signatures
)

// Various error messages to mark blocks invalid. These should be private to
// prevent engine specific errors from being referenced in the remainder of the
// codebase, inherently breaking if the engine is swapped out. Please put common
// error types into the consensus package.
var (
  // errUnknownBlock is returned when the list of signers is requested for a block
  // that is not part of the local blockchain.
  errUnknownBlock = errors.New("unknown block")

  // errInvalidCheckpointBeneficiary is returned if a checkpoint/epoch transition
  // block has a beneficiary set to non-zeroes.
  errInvalidCheckpointBeneficiary = errors.New("beneficiary in checkpoint block non-zero")

  // errInvalidVote is returned if a nonce value is something else that the two
  // allowed constants of 0x00..0 or 0xff..f.
  errInvalidVote = errors.New("vote nonce not 0x00..0 or 0xff..f")

  // errInvalidCheckpointVote is returned if a checkpoint/epoch transition block
  // has a vote nonce set to non-zeroes.
  errInvalidCheckpointVote = errors.New("vote nonce in checkpoint block non-zero")

  // errMissingVanity is returned if a block's extra-data section is shorter than
  // 32 bytes, which is required to store the signer vanity.
  errMissingVanity = errors.New("extra-data 32 byte vanity prefix missing")

  // errMissingSignature is returned if a block's extra-data section doesn't seem
  // to contain a 65 byte secp256k1 signature.
  errMissingSignature = errors.New("extra-data 65 byte signature suffix missing")

  // errExtraSigners is returned if non-checkpoint block contain signer data in
  // their extra-data fields.
  errExtraSigners = errors.New("non-checkpoint block contains extra signer list")

  // errInvalidCheckpointSigners is returned if a checkpoint block contains an
  // invalid list of signers (i.e. non divisible by 20 bytes).
  errInvalidCheckpointSigners = errors.New("invalid signer list on checkpoint block")

  // errMismatchingCheckpointSigners is returned if a checkpoint block contains a
  // list of signers different than the one the local node calculated.
  errMismatchingCheckpointSigners = errors.New("mismatching signer list on checkpoint block")

  // errInvalidMixDigest is returned if a block's mix digest is non-zero.
  errInvalidMixDigest = errors.New("non-zero mix digest")

  // errInvalidUncleHash is returned if a block contains an non-empty uncle list.
  errInvalidUncleHash = errors.New("non empty uncle hash")

  // errInvalidDifficulty is returned if the difficulty of a block neither 1 or 2.
  errInvalidDifficulty = errors.New("invalid difficulty")

  // errWrongDifficulty is returned if the difficulty of a block doesn't match the
  // turn of the signer.
  errWrongDifficulty = errors.New("wrong difficulty")

  // errInvalidTimestamp is returned if the timestamp of a block is lower than
  // the previous block's timestamp + the minimum block period.
  errInvalidTimestamp = errors.New("invalid timestamp")

  // errInvalidVotingChain is returned if an authorization list is attempted to
  // be modified via out-of-range or non-contiguous headers.
  errInvalidVotingChain = errors.New("invalid voting chain")

  // errUnauthorizedSigner is returned if a header is signed by a non-authorized entity.
  errUnauthorizedSigner = errors.New("unauthorized signer")

  // errRecentlySigned is returned if a header is signed by an authorized entity
  // that already signed a header recently, thus is temporarily not allowed to.
  errRecentlySigned = errors.New("recently signed")
)

// ecrecover extracts the Ethereum account address from a signed header.
func ecrecover(header *types.Header, sigcache *lru.ARCCache) (common.Address, error) {
  // If the signature's already cached, return that
  hash := header.Hash()
  if address, known := sigcache.Get(hash); known {
    return address.(common.Address), nil
  }
  // Retrieve the signature from the header extra-data
  if len(header.Extra) < extraSeal {
    return common.Address{}, errMissingSignature
  }
  signature := header.Extra[len(header.Extra)-extraSeal:]

  // Recover the public key and the Ethereum address
  pubkey, err := crypto.Ecrecover(SealHash(header).Bytes(), signature)
  if err != nil {
    return common.Address{}, err
  }
  var signer common.Address
  copy(signer[:], crypto.Keccak256(pubkey[1:])[12:])

  sigcache.Add(hash, signer)
  return signer, nil
}

// New creates a Clique proof-of-authority consensus engine with the initial
// signers set to the ones provided by the user.
func New(config *params.CliqueConfig, db ethdb.Database) *Clique {
  // Set any missing consensus parameters to their defaults
  conf := *config
  if conf.Epoch == 0 {
    conf.Epoch = epochLength
  }
  // Allocate the snapshot caches and create the engine
  recents, _ := lru.NewARC(inmemorySnapshots)
  signatures, _ := lru.NewARC(inmemorySignatures)

  return &Clique{
    config:     &conf,
    db:         db,
    recents:    recents,
    signatures: signatures,
    proposals:  make(map[common.Address]bool),
  }
}

// Author implements consensus.Engine, returning the Ethereum address recovered
// from the signature in the header's extra-data section.
func (c *Clique) Author(header *types.Header) (common.Address, error) {
  return ecrecover(header, c.signatures)
}

// VerifyHeader checks whether a header conforms to the consensus rules.
func (c *Clique) VerifyHeader(chain consensus.ChainHeaderReader, header *types.Header, seal bool) error {
  return c.verifyHeader(chain, header, nil)
}

// VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers. The
// method returns a quit channel to abort the operations and a results channel to
// retrieve the async verifications (the order is that of the input slice).
func (c *Clique) VerifyHeaders(chain consensus.ChainHeaderReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) {
  abort := make(chan struct{})
  results := make(chan error, len(headers))

  go func() {
    for i, header := range headers {
      err := c.verifyHeader(chain, header, headers[:i])

      select {
      case <-abort:
        return
      case results <- err:
      }
    }
  }()
  return abort, results
}

// verifyHeader checks whether a header conforms to the consensus rules.The
// caller may optionally pass in a batch of parents (ascending order) to avoid
// looking those up from the database. This is useful for concurrently verifying
// a batch of new headers.
func (c *Clique) verifyHeader(chain consensus.ChainHeaderReader, header *types.Header, parents []*types.Header) error {
  if header.Number == nil {
    return errUnknownBlock
  }
  number := header.Number.Uint64()

  // Don't waste time checking blocks from the future
  if header.Time > uint64(time.Now().Unix()) {
    return consensus.ErrFutureBlock
  }
  // Checkpoint blocks need to enforce zero beneficiary
  checkpoint := (number % c.config.Epoch) == 0
  if checkpoint && header.Coinbase != (common.Address{}) {
    return errInvalidCheckpointBeneficiary
  }
  // Nonces must be 0x00..0 or 0xff..f, zeroes enforced on checkpoints
  if !bytes.Equal(header.Nonce[:], nonceAuthVote) && !bytes.Equal(header.Nonce[:], nonceDropVote) {
    return errInvalidVote
  }
  if checkpoint && !bytes.Equal(header.Nonce[:], nonceDropVote) {
    return errInvalidCheckpointVote
  }
  // Check that the extra-data contains both the vanity and signature
  if len(header.Extra) < extraVanity {
    return errMissingVanity
  }
  if len(header.Extra) < extraVanity+extraSeal {
    return errMissingSignature
  }
  // Ensure that the extra-data contains a signer list on checkpoint, but none otherwise
  signersBytes := len(header.Extra) - extraVanity - extraSeal
  if !checkpoint && signersBytes != 0 {
    return errExtraSigners
  }
  if checkpoint && signersBytes%common.AddressLength != 0 {
    return errInvalidCheckpointSigners
  }
  // Ensure that the mix digest is zero as we don't have fork protection currently
  if header.MixDigest != (common.Hash{}) {
    return errInvalidMixDigest
  }
  // Ensure that the block doesn't contain any uncles which are meaningless in PoA
  if header.UncleHash != uncleHash {
    return errInvalidUncleHash
  }
  // Ensure that the block's difficulty is meaningful (may not be correct at this point)
  if number > 0 {
    if header.Difficulty == nil || (header.Difficulty.Cmp(diffInTurn) != 0 && header.Difficulty.Cmp(diffNoTurn) != 0) {
      return errInvalidDifficulty
    }
  }
  // If all checks passed, validate any special fields for hard forks
  if err := misc.VerifyForkHashes(chain.Config(), header, false); err != nil {
    return err
  }
  // All basic checks passed, verify cascading fields
  return c.verifyCascadingFields(chain, header, parents)
}

// filedir:go-ethereum-1.10.2\consensus\clique\clique.go  L304
// verifyCascadingFields verifies all the header fields that are not standalone,
// rather depend on a batch of previous headers. The caller may optionally pass
// in a batch of parents (ascending order) to avoid looking those up from the
// database. This is useful for concurrently verifying a batch of new headers.
func (c *Clique) verifyCascadingFields(chain consensus.ChainHeaderReader, header *types.Header, parents []*types.Header) error {
  // The genesis block is the always valid dead-end
  number := header.Number.Uint64()
  if number == 0 {
    return nil
  }
  // Ensure that the block's timestamp isn't too close to its parent
  var parent *types.Header
  if len(parents) > 0 {
    parent = parents[len(parents)-1]
  } else {
    parent = chain.GetHeader(header.ParentHash, number-1)
  }
  if parent == nil || parent.Number.Uint64() != number-1 || parent.Hash() != header.ParentHash {
    return consensus.ErrUnknownAncestor
  }
  if parent.Time+c.config.Period > header.Time {
    return errInvalidTimestamp
  }
  // Retrieve the snapshot needed to verify this header and cache it
  snap, err := c.snapshot(chain, number-1, header.ParentHash, parents)
  if err != nil {
    return err
  }
  // If the block is a checkpoint block, verify the signer list
  if number%c.config.Epoch == 0 {
    signers := make([]byte, len(snap.Signers)*common.AddressLength)
    for i, signer := range snap.signers() {
      copy(signers[i*common.AddressLength:], signer[:])
    }
    extraSuffix := len(header.Extra) - extraSeal
    if !bytes.Equal(header.Extra[extraVanity:extraSuffix], signers) {
      return errMismatchingCheckpointSigners
    }
  }
  // All basic checks passed, verify the seal and return
  return c.verifySeal(chain, header, parents)
}

// Vote represents a single vote that an authorized signer made to modify the
// list of authorizations.
type Vote struct {
  Signer    common.Address `json:"signer"`    // Authorized signer that cast this vote
  Block     uint64         `json:"block"`     // Block number the vote was cast in (expire old votes)
  Address   common.Address `json:"address"`   // Account being voted on to change its authorization
  Authorize bool           `json:"authorize"` // Whether to authorize or deauthorize the voted account
}

// Tally is a simple vote tally to keep the current score of votes. Votes that
// go against the proposal aren't counted since it's equivalent to not voting.
type Tally struct {
  Authorize bool `json:"authorize"` // Whether the vote is about authorizing or kicking someone
  Votes     int  `json:"votes"`     // Number of votes until now wanting to pass the proposal
}

// Snapshot is the state of the authorization voting at a given point in time.
type Snapshot struct {
  config   *params.CliqueConfig // Consensus engine parameters to fine tune behavior
  sigcache *lru.ARCCache        // Cache of recent block signatures to speed up ecrecover

  Number  uint64                      `json:"number"`  // Block number where the snapshot was created
  Hash    common.Hash                 `json:"hash"`    // Block hash where the snapshot was created
  Signers map[common.Address]struct{} `json:"signers"` // Set of authorized signers at this moment
  Recents map[uint64]common.Address   `json:"recents"` // Set of recent signers for spam protections
  Votes   []*Vote                     `json:"votes"`   // List of votes cast in chronological order
  Tally   map[common.Address]Tally    `json:"tally"`   // Current vote tally to avoid recalculating
}

// snapshot retrieves the authorization snapshot at a given point in time.
func (c *Clique) snapshot(chain consensus.ChainHeaderReader, number uint64, hash common.Hash, parents []*types.Header) (*Snapshot, error) {
  // Search for a snapshot in memory or on disk for checkpoints
  var (
    headers []*types.Header
    snap    *Snapshot
  )
  for snap == nil {
    // If an in-memory snapshot was found, use that    // 如果在内存中找到可用快照则加载
    if s, ok := c.recents.Get(hash); ok {
      snap = s.(*Snapshot)
      break
    }
    // If an on-disk checkpoint snapshot can be found, use that   // 如果可以找到磁盘上的检查点快照则使用该快照
    if number%checkpointInterval == 0 {
      if s, err := loadSnapshot(c.config, c.signatures, c.db, hash); err == nil {
        log.Trace("Loaded voting snapshot from disk", "number", number, "hash", hash)
        snap = s
        break
      }
    }  // 如果是创世区块则创建初始快照
    // If we're at the genesis, snapshot the initial state. Alternatively if we're
    // at a checkpoint block without a parent (light client CHT), or we have piled
    // up more headers than allowed to be reorged (chain reinit from a freezer),
    // consider the checkpoint trusted and snapshot it.
    if number == 0 || (number%c.config.Epoch == 0 && (len(headers) > params.FullImmutabilityThreshold || chain.GetHeaderByNumber(number-1) == nil)) {
      checkpoint := chain.GetHeaderByNumber(number)
      if checkpoint != nil {
        hash := checkpoint.Hash()

        signers := make([]common.Address, (len(checkpoint.Extra)-extraVanity-extraSeal)/common.AddressLength)
        for i := 0; i < len(signers); i++ {
          copy(signers[i][:], checkpoint.Extra[extraVanity+i*common.AddressLength:])
        }
        snap = newSnapshot(c.config, c.signatures, number, hash, signers)   // 新建快照
        if err := snap.store(c.db); err != nil {    // 存储快照
          return nil, err
        }
        log.Info("Stored checkpoint snapshot to disk", "number", number, "hash", hash)
        break
      }
    }
    // No snapshot for this header, gather the header and move backward // 如果当前区块头没有快照则收集区块头信息同时先后移动
    var header *types.Header
    if len(parents) > 0 {
      // If we have explicit parents, pick from there (enforced)
      header = parents[len(parents)-1]
      if header.Hash() != hash || header.Number.Uint64() != number {
        return nil, consensus.ErrUnknownAncestor
      }
      parents = parents[:len(parents)-1]
    } else {
      // No explicit parents (or no more left), reach out to the database  // 如果没有父区块则从数据库中查询
      header = chain.GetHeader(hash, number)
      if header == nil {
        return nil, consensus.ErrUnknownAncestor
      }
    }
    headers = append(headers, header)
    number, hash = number-1, header.ParentHash
  }
  // Previous snapshot found, apply any pending headers on top of it
  for i := 0; i < len(headers)/2; i++ {
    headers[i], headers[len(headers)-1-i] = headers[len(headers)-1-i], headers[i]
  }
  snap, err := snap.apply(headers)    // 避免没有尽头的投票窗口，周期性的清除除旧的投票提案  
  if err != nil {
    return nil, err
  }
  c.recents.Add(snap.Hash, snap)

  // If we've generated a new checkpoint snapshot, save to disk
  if snap.Number%checkpointInterval == 0 && len(headers) > 0 {
    if err = snap.store(c.db); err != nil {
      return nil, err
    }
    log.Trace("Stored voting snapshot to disk", "number", snap.Number, "hash", snap.Hash)
  }
  return snap, err
}

// newSnapshot creates a new snapshot with the specified startup parameters. This
// method does not initialize the set of recent signers, so only ever use if for
// the genesis block.
func newSnapshot(config *params.CliqueConfig, sigcache *lru.ARCCache, number uint64, hash common.Hash, signers []common.Address) *Snapshot {
  snap := &Snapshot{
    config:   config,
    sigcache: sigcache,
    Number:   number,
    Hash:     hash,
    Signers:  make(map[common.Address]struct{}),
    Recents:  make(map[uint64]common.Address),
    Tally:    make(map[common.Address]Tally),
  }
  for _, signer := range signers {
    snap.Signers[signer] = struct{}{}
  }
  return snap
}

// loadSnapshot loads an existing snapshot from the database.
func loadSnapshot(config *params.CliqueConfig, sigcache *lru.ARCCache, db ethdb.Database, hash common.Hash) (*Snapshot, error) {
  blob, err := db.Get(append([]byte("clique-"), hash[:]...))
  if err != nil {
    return nil, err
  }
  snap := new(Snapshot)
  if err := json.Unmarshal(blob, snap); err != nil {
    return nil, err
  }
  snap.config = config
  snap.sigcache = sigcache

  return snap, nil
}

// store inserts the snapshot into the database.
func (s *Snapshot) store(db ethdb.Database) error {
  blob, err := json.Marshal(s)
  if err != nil {
    return err
  }
  return db.Put(append([]byte("clique-"), s.Hash[:]...), blob)
}

// copy creates a deep copy of the snapshot, though not the individual votes.
func (s *Snapshot) copy() *Snapshot {
  cpy := &Snapshot{
    config:   s.config,
    sigcache: s.sigcache,
    Number:   s.Number,
    Hash:     s.Hash,
    Signers:  make(map[common.Address]struct{}),
    Recents:  make(map[uint64]common.Address),
    Votes:    make([]*Vote, len(s.Votes)),
    Tally:    make(map[common.Address]Tally),
  }
  for signer := range s.Signers {
    cpy.Signers[signer] = struct{}{}
  }
  for block, signer := range s.Recents {
    cpy.Recents[block] = signer
  }
  for address, tally := range s.Tally {
    cpy.Tally[address] = tally
  }
  copy(cpy.Votes, s.Votes)

  return cpy
}

// validVote returns whether it makes sense to cast the specified vote in the
// given snapshot context (e.g. don't try to add an already authorized signer).
func (s *Snapshot) validVote(address common.Address, authorize bool) bool {
  _, signer := s.Signers[address]
  return (signer && !authorize) || (!signer && authorize)
}

// cast adds a new vote into the tally.
func (s *Snapshot) cast(address common.Address, authorize bool) bool {
  // Ensure the vote is meaningful
  if !s.validVote(address, authorize) {
    return false
  }
  // Cast the vote into an existing or new tally
  if old, ok := s.Tally[address]; ok {
    old.Votes++
    s.Tally[address] = old
  } else {
    s.Tally[address] = Tally{Authorize: authorize, Votes: 1}
  }
  return true
}

// uncast removes a previously cast vote from the tally.
func (s *Snapshot) uncast(address common.Address, authorize bool) bool {
  // If there's no tally, it's a dangling vote, just drop
  tally, ok := s.Tally[address]
  if !ok {
    return false
  }
  // Ensure we only revert counted votes
  if tally.Authorize != authorize {
    return false
  }
  // Otherwise revert the vote
  if tally.Votes > 1 {
    tally.Votes--
    s.Tally[address] = tally
  } else {
    delete(s.Tally, address)
  }
  return true
}

// filedir:go-ethereum-1.10.2\consensus\clique\snapshot.go  L182
// apply creates a new authorization snapshot by applying the given headers to
// the original one.
func (s *Snapshot) apply(headers []*types.Header) (*Snapshot, error) {
  // Allow passing in no headers for cleaner code
  if len(headers) == 0 {
    return s, nil
  }
  // Sanity check that the headers can be applied
  for i := 0; i < len(headers)-1; i++ {
    if headers[i+1].Number.Uint64() != headers[i].Number.Uint64()+1 {
      return nil, errInvalidVotingChain
    }
  }
  if headers[0].Number.Uint64() != s.Number+1 {
    return nil, errInvalidVotingChain
  }
  // Iterate through the headers and create a new snapshot
  snap := s.copy()

  var (
    start  = time.Now()
    logged = time.Now()
  )
  for i, header := range headers {                
    // Remove any votes on checkpoint blocks
    number := header.Number.Uint64()
    if number%s.config.Epoch == 0 {     // 如果区块高度正好在Epoch结束，则清空投票和计分器
      snap.Votes = nil
      snap.Tally = make(map[common.Address]Tally)
    }
    // Delete the oldest signer from the recent list to allow it signing again
    if limit := uint64(len(snap.Signers)/2 + 1); number >= limit {
      delete(snap.Recents, number-limit)
    }
    // Resolve the authorization key and check against signers
    signer, err := ecrecover(header, s.sigcache)    // 从区块头中解密出来签名者地址
    if err != nil {
      return nil, err
    }
    if _, ok := snap.Signers[signer]; !ok {
      return nil, errUnauthorizedSigner
    }
    for _, recent := range snap.Recents {
      if recent == signer {
        return nil, errRecentlySigned
      }
    }
    snap.Recents[number] = signer

    // Header authorized, discard any previous votes from the signer   区块头认证，不管该签名者之前的任何投票
    for i, vote := range snap.Votes {    
      if vote.Signer == signer && vote.Address == header.Coinbase {
        // Uncast the vote from the cached tally
        snap.uncast(vote.Address, vote.Authorize)                 // 从缓存计数器中移除该投票

        // Uncast the vote from the chronological list
        snap.Votes = append(snap.Votes[:i], snap.Votes[i+1:]...)   // 从按时间排序的列表中移除投票
        break // only one vote allowed
      }
    }
    // Tally up the new vote from the signer   从签名者中计数新的投票
    var authorize bool
    switch {
    case bytes.Equal(header.Nonce[:], nonceAuthVote):
      authorize = true
    case bytes.Equal(header.Nonce[:], nonceDropVote):
      authorize = false
    default:
      return nil, errInvalidVote
    }
    if snap.cast(header.Coinbase, authorize) {
      snap.Votes = append(snap.Votes, &Vote{
        Signer:    signer,
        Block:     number,
        Address:   header.Coinbase,
        Authorize: authorize,
      })
    }
    // If the vote passed, update the list of signers   判断票数是否超过一半的投票者，如果投票通过，更新签名者列表
    if tally := snap.Tally[header.Coinbase]; tally.Votes > len(snap.Signers)/2 {
      if tally.Authorize {
        snap.Signers[header.Coinbase] = struct{}{}
      } else {
        delete(snap.Signers, header.Coinbase)

        // Signer list shrunk, delete any leftover recent caches
        if limit := uint64(len(snap.Signers)/2 + 1); number >= limit {
          delete(snap.Recents, number-limit)
        }
        // Discard any previous votes the deauthorized signer cast
        for i := 0; i < len(snap.Votes); i++ {
          if snap.Votes[i].Signer == header.Coinbase {
            // Uncast the vote from the cached tally
            snap.uncast(snap.Votes[i].Address, snap.Votes[i].Authorize)

            // Uncast the vote from the chronological list
            snap.Votes = append(snap.Votes[:i], snap.Votes[i+1:]...)

            i--
          }
        }
      }
      // Discard any previous votes around the just changed account   不管之前的任何投票，直接改变账户
      for i := 0; i < len(snap.Votes); i++ {
        if snap.Votes[i].Address == header.Coinbase {
          snap.Votes = append(snap.Votes[:i], snap.Votes[i+1:]...)
          i--
        }
      }
      delete(snap.Tally, header.Coinbase)
    }
    // If we're taking too much time (ecrecover), notify the user once a while
    if time.Since(logged) > 8*time.Second {
      log.Info("Reconstructing voting history", "processed", i, "total", len(headers), "elapsed", common.PrettyDuration(time.Since(start)))
      logged = time.Now()
    }
  }
  if time.Since(start) > 8*time.Second {
    log.Info("Reconstructed voting history", "processed", len(headers), "elapsed", common.PrettyDuration(time.Since(start)))
  }
  snap.Number += uint64(len(headers))
  snap.Hash = headers[len(headers)-1].Hash()

  return snap, nil
}

// inturn returns if a signer at a given block height is in-turn or not.
func (s *Snapshot) inturn(number uint64, signer common.Address) bool {
  signers, offset := s.signers(), 0
  for offset < len(signers) && signers[offset] != signer {
    offset++
  }
  return (number % uint64(len(signers))) == uint64(offset)
}

// signers retrieves the list of authorized signers in ascending order.
func (s *Snapshot) signers() []common.Address {
  sigs := make([]common.Address, 0, len(s.Signers))
  for sig := range s.Signers {
    sigs = append(sigs, sig)
  }
  sort.Sort(signersAscending(sigs))
  return sigs
}

// VerifyUncles implements consensus.Engine, always returning an error for any
// uncles as this consensus mechanism doesn't permit uncles.
func (c *Clique) VerifyUncles(chain consensus.ChainReader, block *types.Block) error {
  if len(block.Uncles()) > 0 {
    return errors.New("uncles not allowed")
  }
  return nil
}

// filedir: go-ethereum-1.10.2\consensus\clique\clique.go L436
// verifySeal checks whether the signature contained in the header satisfies the
// consensus protocol requirements. The method accepts an optional list of parent
// headers that aren't yet part of the local blockchain to generate the snapshots
// from.
func (c *Clique) verifySeal(chain consensus.ChainHeaderReader, header *types.Header, parents []*types.Header) error {
  // Verifying the genesis block is not supported   不支持创世区块
  number := header.Number.Uint64()
  if number == 0 {
    return errUnknownBlock
  }
  // Retrieve the snapshot needed to verify this header and cache it  检索验证该区块的快照并缓存它
  snap, err := c.snapshot(chain, number-1, header.ParentHash, parents)
  if err != nil {
    return err
  }

  // Resolve the authorization key and check against signers
  signer, err := ecrecover(header, c.signatures)
  if err != nil {
    return err
  }
  if _, ok := snap.Signers[signer]; !ok {
    return errUnauthorizedSigner
  }
  for seen, recent := range snap.Recents {
    if recent == signer {
      // Signer is among recents, only fail if the current block doesn't shift it out
      if limit := uint64(len(snap.Signers)/2 + 1); seen > number-limit {  
        return errRecentlySigned
      }
    }
  }
  // Ensure that the difficulty corresponds to the turn-ness of the signer
  if !c.fakeDiff {
    inturn := snap.inturn(header.Number.Uint64(), signer)
    if inturn && header.Difficulty.Cmp(diffInTurn) != 0 {
      return errWrongDifficulty
    }
    if !inturn && header.Difficulty.Cmp(diffNoTurn) != 0 {
      return errWrongDifficulty
    }
  }
  return nil
}

// Prepare implements consensus.Engine, preparing all the consensus fields of the
// header for running the transactions on top.
func (c *Clique) Prepare(chain consensus.ChainHeaderReader, header *types.Header) error {
  // If the block isn't a checkpoint, cast a random vote (good enough for now)
  header.Coinbase = common.Address{}
  header.Nonce = types.BlockNonce{}

  number := header.Number.Uint64()
  // Assemble the voting snapshot to check which votes make sense
  snap, err := c.snapshot(chain, number-1, header.ParentHash, nil)
  if err != nil {
    return err
  }
    if number%c.config.Epoch != 0 { //如果number不是epoch的整数倍(不是checkpoint)，则进行投票信息的填充
    c.lock.RLock()

    // Gather all the proposals that make sense voting on
    addresses := make([]common.Address, 0, len(c.proposals))
    for address, authorize := range c.proposals {
      if snap.validVote(address, authorize) {
        addresses = append(addresses, address)
      }
    }
        // If there's pending proposals, cast a vote on them  填写投票信息(投票信息存储在Coinbase和Nonce字段中)
    if len(addresses) > 0 {
      header.Coinbase = addresses[rand.Intn(len(addresses))]
      if c.proposals[header.Coinbase] {
        copy(header.Nonce[:], nonceAuthVote)
      } else {
        copy(header.Nonce[:], nonceDropVote)
      }
    }
    c.lock.RUnlock()
  }
  // Set the correct difficulty
  header.Difficulty = calcDifficulty(snap, c.signer)

  // Ensure the extra data has all its components
  if len(header.Extra) < extraVanity {
    header.Extra = append(header.Extra, bytes.Repeat([]byte{0x00}, extraVanity-len(header.Extra))...)
  }
  header.Extra = header.Extra[:extraVanity]

  if number%c.config.Epoch == 0 {   // 如果number是epoch的整数倍（将要生成一个checkpoint），则填充签名者列表
    for _, signer := range snap.signers() {
      header.Extra = append(header.Extra, signer[:]...)
    }
  }
  header.Extra = append(header.Extra, make([]byte, extraSeal)...)

  // Mix digest is reserved for now, set to empty
  header.MixDigest = common.Hash{}

  // Ensure the timestamp has the correct delay
  parent := chain.GetHeader(header.ParentHash, number-1)
  if parent == nil {
    return consensus.ErrUnknownAncestor
  }
  header.Time = parent.Time + c.config.Period
  if header.Time < uint64(time.Now().Unix()) {
    header.Time = uint64(time.Now().Unix())
  }
  return nil
}

// FinalizeAndAssemble implements consensus.Engine, ensuring no uncles are set,
// nor block rewards given, and returns the final block.
func (c *Clique) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) {
  // Finalize block
  c.Finalize(chain, header, state, txs, uncles)

  // Assemble and return the final block for sealing
  return types.NewBlock(header, txs, nil, receipts, trie.NewStackTrie(nil)), nil
}

// Finalize implements consensus.Engine, ensuring no uncles are set, nor block
// rewards given.
func (c *Clique) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header) {
  // No block rewards in PoA, so the state remains as is and uncles are dropped
  header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number))
  header.UncleHash = types.CalcUncleHash(nil)
}

// Authorize injects a private key into the consensus engine to mint new blocks
// with.
func (c *Clique) Authorize(signer common.Address, signFn SignerFn) {
  c.lock.Lock()
  defer c.lock.Unlock()

  c.signer = signer
  c.signFn = signFn
}

// filedir：go-ethereum-1.10.2\consensus\clique\clique.go  L574
// Seal implements consensus.Engine, attempting to create a sealed block using
// the local signing credentials.
func (c *Clique) Seal(chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error {
  header := block.Header()

  // Sealing the genesis block is not supported
  number := header.Number.Uint64()
  if number == 0 {
    return errUnknownBlock
  }
  // For 0-period chains, refuse to seal empty blocks (no reward but would spin sealing)
  if c.config.Period == 0 && len(block.Transactions()) == 0 {
    log.Info("Sealing paused, waiting for transactions")
    return nil
  }
  // Don't hold the signer fields for the entire sealing procedure
  c.lock.RLock()
  signer, signFn := c.signer, c.signFn
  c.lock.RUnlock()

  // Bail out if we're unauthorized to sign a block
  snap, err := c.snapshot(chain, number-1, header.ParentHash, nil)
  if err != nil {
    return err
  }
  if _, authorized := snap.Signers[signer]; !authorized {
    return errUnauthorizedSigner
  }
  // If we're amongst the recent signers, wait for the next block
  for seen, recent := range snap.Recents {
    if recent == signer {
      // Signer is among recents, only wait if the current block doesn't shift it out
      if limit := uint64(len(snap.Signers)/2 + 1); number < limit || seen > number-limit {
        log.Info("Signed recently, must wait for others")
        return nil
      }
    }
  }
  // Sweet, the protocol permits us to sign the block, wait for our time   
  delay := time.Unix(int64(header.Time), 0).Sub(time.Now()) // nolint: gosimple
  if header.Difficulty.Cmp(diffNoTurn) == 0 {
    // It's not our turn explicitly to sign, delay it a bit
    wiggle := time.Duration(len(snap.Signers)/2+1) * wiggleTime
    delay += time.Duration(rand.Int63n(int64(wiggle)))

    log.Trace("Out-of-turn signing requested", "wiggle", common.PrettyDuration(wiggle))
  }
  // Sign all the things!
  sighash, err := signFn(accounts.Account{Address: signer}, accounts.MimetypeClique, CliqueRLP(header))
  if err != nil {
    return err
  }
  copy(header.Extra[len(header.Extra)-extraSeal:], sighash)
  // Wait until sealing is terminated or delay timeout.
  log.Trace("Waiting for slot to sign and propagate", "delay", common.PrettyDuration(delay))
  go func() {
    select {
    case <-stop:
      return
    case <-time.After(delay):
    }

    select {
    case results <- block.WithSeal(header):
    default:
      log.Warn("Sealing result is not read by miner", "sealhash", SealHash(header))
    }
  }()

  return nil
}