type Block struct {
  header       *Header       //区块头
  uncles       []*Header     //当前块所包含的叔块
  transactions Transactions  //当前块所包含的所有交易

  ......
}

//下面的字段解释以ethash共识为准。在clique共识中字段的意义不尽相同，这里不作讨论。
//感兴趣的读者可以参看对clique的介绍：https://yangzhe.me/2019/02/01/ethereum-clique/
type Header struct {
  ParentHash  common.Hash    //父区块的哈希
  UncleHash   common.Hash    //所有叔块的哈希（Block.uncles）
  Coinbase    common.Address //接受出块奖励的地址。矿工出块时在这个字段填入自己的地址。
  Root        common.Hash    //此区块包含的所有交易完成后，state对象的哈希值
  TxHash      common.Hash    //此区块包含的所有交易的哈希(Block.transactions)
  ReceiptHash common.Hash    //此区块所有交易完成后所产生的所有收据的哈希
  Bloom       Bloom          //布隆过滤对象，用来查找交易产生的Log
  Difficulty  *big.Int       //此区块的难度值
  Number      *big.Int       //此区块的高度
  GasLimit    uint64         //此区块所有交易消耗的gas值的上限
  GasUsed     uint64         //此区块所有交易消耗的gas的实际值
  Time        *big.Int       //区块时间戳
  Extra       []byte         //区块的额外数据
  MixDigest   common.Hash    //以太坊hashimoto算法产生的哈希。详细可参看对ethash的介绍：https://yangzhe.me/2019/02/14/ethereum-ethash-theory/
  Nonce       BlockNonce     //PoW共识挖矿时通过随意此字段，使区块哈希发生变化从而产生符合Difficulty值要求的区块哈希
}

func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.Receipt, state *state.StateDB) (status WriteStatus, err error) {
  ptd := bc.GetTd(block.ParentHash(), block.NumberU64()-1)

  currentBlock := bc.CurrentBlock()
  //localTd是主链上最新的一个区块的累计Difficulty值（Total Difficulty）
  localTd := bc.GetTd(currentBlock.Hash(), currentBlock.NumberU64())
  externTd := new(big.Int).Add(block.Difficulty(), ptd)
  ......

  reorg := externTd.Cmp(localTd) > 0
  currentBlock = bc.CurrentBlock()
  if !reorg && externTd.Cmp(localTd) == 0 {
    //处理新加入的区块的TotalDifficulty与主链的TotalDifficulty相等的情况
    if block.NumberU64() < currentBlock.NumberU64() {
      //如果新加入的区块的高度较小，则调整主链
      reorg = true
    } else if block.NumberU64() == currentBlock.NumberU64() {
      //如果高度相同，则求助于shouldPreserve函数。这个函数虽然是外部传入的，但整个以太坊代码中
      //只有Ethereum.shouldPreserve这一个定义。其基本想法是如果是矿工自己产生的块则返回true，
      //否则返回false。
      var currentPreserve, blockPreserve bool
      if bc.shouldPreserve != nil {
        currentPreserve, blockPreserve = bc.shouldPreserve(currentBlock), bc.shouldPreserve(block)
      }
      //如果不保留currentBlock且保留新加入的block，则进行调整
      //如果不保留currentBlock也不保留新加入的block，通过使用随机数仍有一半的机会调整
      reorg = !currentPreserve && (blockPreserve || mrand.Float64() < 0.5)
    }
  }
  if reorg {
    // Reorganise the chain if the parent is not the head block
    //如果决定调整，还要看新加入的区块的父区块是否就是主链上的最新区块。如果是就不必调整了。
    if block.ParentHash() != currentBlock.Hash() {
      if err := bc.reorg(currentBlock, block); err != nil {
        return NonStatTy, err
      }
      ......

      status = CanonStatTy
    }
  }

  ......

  // Set new head.
  if status == CanonStatTy {
    bc.insert(block)  //BlockChain.insert会将block作为主链上的区块写入相关数据
  }
}

func (bc *BlockChain) reorg(oldBlock, newBlock *types.Block) error {
  var (
    newChain    types.Blocks
    oldChain    types.Blocks
    commonBlock *types.Block
    deletedTxs  types.Transactions
  )

  //这里if/else和紧跟着的for的功能是查找oldBlock和newBlock两个分支的共同祖先commonBlock，
  //并将达到共同祖先的路径上所有区块各自记录在newChain和oldChain中。同时将oldBlock的分支
  //上的所有transaction放到deletedTxs中。
  if oldBlock.NumberU64() > newBlock.NumberU64() {
    ......
  } else {
    ......
  }
  for {
    ......
  }

  //调用BlockChain.insert将newBlock分支上所有区块作为主链区块写入数据库中
  //同时删掉只在旧链上的交易的索引信息（并不删除交易本身，只是删除 txLookupEntry）
  var addedTxs types.Transactions
  for i := len(newChain) - 1; i >= 0; i-- {
    bc.insert(newChain[i])
    rawdb.WriteTxLookupEntries(bc.db, newChain[i])
    addedTxs = append(addedTxs, newChain[i].Transactions()...)
  }
  diff := types.TxDifference(deletedTxs, addedTxs)
  for _, tx := range diff {
    rawdb.DeleteTxLookupEntry(batch, tx.Hash())
  }
}

func (bc *BlockChain) insert(block *types.Block) {
  // If the block is on a side chain or an unknown one, force other heads onto it too
  updateHeads := rawdb.ReadCanonicalHash(bc.db, block.NumberU64()) != block.Hash()

  // Add the block to the canonical chain number scheme and mark as the head
  rawdb.WriteCanonicalHash(bc.db, block.Hash(), block.NumberU64())
  rawdb.WriteHeadBlockHash(bc.db, block.Hash())

  bc.currentBlock.Store(block)

  // If the block is better than our head or is on a different chain, force update heads
  if updateHeads {
    bc.hc.SetCurrentHeader(block.Header())
    rawdb.WriteHeadFastBlockHash(bc.db, block.Hash())

    bc.currentFastBlock.Store(block)
  }
}

func DefaultGenesisBlock() *Genesis {
  return &Genesis{
    Config:     params.MainnetChainConfig,
    Nonce:      66,
    ExtraData:  hexutil.MustDecode("0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa"),
    GasLimit:   5000,
    Difficulty: big.NewInt(17179869184),
    Alloc:      decodePrealloc(mainnetAllocData),
  }
}

func SetupGenesisBlockWithOverride(db ethdb.Database, genesis *Genesis, constantinopleOverride *big.Int) (*params.ChainConfig, common.Hash, error) {
  ......

  stored := rawdb.ReadCanonicalHash(db, 0)
  if (stored == common.Hash{}) {
    if genesis == nil {
      log.Info("Writing default main-net genesis block")
      genesis = DefaultGenesisBlock()
    } else {
      log.Info("Writing custom genesis block")
    }
    block, err := genesis.Commit(db)
    return genesis.Config, block.Hash(), err
  }

  ......
}

func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.Receipt, state *state.StateDB) (status WriteStatus, err error) {
  ......

  root, err := state.Commit(bc.chainConfig.IsEIP158(block.Number()))
  if err != nil {
    return NonStatTy, err
  }
  triedb := bc.stateCache.TrieDB()

  // If we're running an archive node, always flush
  if bc.cacheConfig.Disabled {
    if err := triedb.Commit(root, false); err != nil {
      return NonStatTy, err
    }
  } else {
    ......
  }

  ......
}

func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.Receipt, state *state.StateDB) (status WriteStatus, err error) {
  if bc.cacheConfig.Disabled {
    ......
  } else {
    // Full but not archive node, do proper garbage collection
    triedb.Reference(root, common.Hash{}) // metadata reference to keep trie alive
    bc.triegc.Push(root, -int64(block.NumberU64()))
    if current := block.NumberU64(); current > triesInMemory {
      ......

      // Find the next state trie we need to commit
      header := bc.GetHeaderByNumber(current - triesInMemory)
      chosen := header.Number.Uint64()

      ......

      // Garbage collect anything below our required write retention
      for !bc.triegc.Empty() {
        root, number := bc.triegc.Pop()
        if uint64(-number) > chosen {
          bc.triegc.Push(root, number)
          break
        }
        triedb.Dereference(root.(common.Hash))
      }
    }
  }
}

func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.Receipt, state *state.StateDB) (status WriteStatus, err error) {
  ......

    if current := block.NumberU64(); current > triesInMemory {
      // If we exceeded our memory allowance, flush matured singleton nodes to disk
      var (
        nodes, imgs = triedb.Size()
        limit       = common.StorageSize(bc.cacheConfig.TrieDirtyLimit) * 1024 * 1024
      )
      if nodes > limit || imgs > 4*1024*1024 {
        triedb.Cap(limit - ethdb.IdealBatchSize)
      }
      // Find the next state trie we need to commit
      header := bc.GetHeaderByNumber(current - triesInMemory)
      chosen := header.Number.Uint64()

      // If we exceeded out time allowance, flush an entire trie to disk
      if bc.gcproc > bc.cacheConfig.TrieTimeLimit {
        ......
      }

      ......
    }

  ......
}

func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.Receipt, state *state.StateDB) (status WriteStatus, err error) {
  ......

    if bc.gcproc > bc.cacheConfig.TrieTimeLimit {
      // If we're exceeding limits but haven't reached a large enough memory gap,
      // warn the user that the system is becoming unstable.
      if chosen < lastWrite+triesInMemory && bc.gcproc >= 2*bc.cacheConfig.TrieTimeLimit {
        log.Info("State in memory for too long, committing", ......)
      }
      // Flush an entire trie and restart the counters
      triedb.Commit(header.Root, true)
      lastWrite = chosen
      bc.gcproc = 0
    }
  ......
}

func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool) (int, []interface{}, []*types.Log, error) {
  ......

  for ; block != nil && err == nil; block, err = it.next() {
    ......
    start := time.Now()

    state, err := state.New(parent.Root(), bc.stateCache)
    receipts, logs, usedGas, err := bc.processor.Process(block, state, bc.vmConfig)
    bc.Validator().ValidateState(block, parent, state, receipts, usedGas)

    proctime := time.Since(start)

    status, err := bc.writeBlockWithState(block, receipts, state)
    switch status {
    case CanonStatTy:  
      // 如果区块被加入到了主链中，则将计算state的时候累加到bc.gcproc中
      bc.gcproc += proctime

    ......
    }
  }
  ......
}

func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool) (int, []interface{}, []*types.Log, error) {
  ......

  //参数chain[0]在被验证的时候返回ErrFutureBlock，或都chain[0]被验的时候返回ErrUnknownAncestor（找不到父区块）但父区块其实在futureBlocks中
  case err == consensus.ErrFutureBlock || (err == consensus.ErrUnknownAncestor && bc.futureBlocks.Contains(it.first().ParentHash())):
    //block变量的初始值其实就是chain[0]。for的判断逻辑是：第一个区块（即chain[0]）上面的case已经判断过了，因此可以直接加入futureBlocks中；由于前面的区块被加入到了futureBlocks而不是数据库中，因而后面的区块在验的时候应该是找不着父区块的，所以也当作futureBlocks处理。
    for block != nil && (it.index == 0 || err == consensus.ErrUnknownAncestor) {
    if err := bc.addFutureBlock(block); err != nil {
    return it.index, events, coalescedLogs, err
    }
    block, err = it.next()
    }

  //将验证正常区块加入到数据库中
  ......

  //上面验证后可能还有一些未能加入的区块，这里再次判断是否是将其加入futureBlocks。
  //判断逻辑与上面相同
  if block != nil && err == consensus.ErrFutureBlock {
    if err := bc.addFutureBlock(block); err != nil {
      return it.index, events, coalescedLogs, err
    }
    block, err = it.next()

    for ; block != nil && err == consensus.ErrUnknownAncestor; block, err = it.next() {
      if err := bc.addFutureBlock(block); err != nil {
        return it.index, events, coalescedLogs, err
      }
      stats.queued++
    }
  }
}

func (c *Clique) verifyHeader(chain consensus.ChainReader, header *types.Header, parents []*types.Header) error {
  ......

  if header.Time.Cmp(big.NewInt(time.Now().Unix())) > 0 {
    return consensus.ErrFutureBlock
  }

  ......
}

func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent *types.Header, uncle bool, seal bool) error {
  ......

  if uncle {
    ......
  } else {
    if header.Time.Cmp(big.NewInt(time.Now().Add(allowedFutureBlockTime).Unix())) > 0 {
      return consensus.ErrFutureBlock
    }
  }

  ......
}

func (bc *BlockChain) addFutureBlock(block *types.Block) error {
  max := big.NewInt(time.Now().Unix() + maxTimeFutureBlocks)
  if block.Time().Cmp(max) > 0 {
    return fmt.Errorf("future block timestamp %v > allowed %v", block.Time(), max)
  }
  bc.futureBlocks.Add(block.Hash(), block)
  return nil
}

func (bc *BlockChain) InsertChain(chain types.Blocks) (int, error) {
  // Sanity check that we have something meaningful to import
  if len(chain) == 0 {
    return 0, nil
  }
  // Do a sanity check that the provided chain is actually ordered and linked
  for i := 1; i < len(chain); i++ {
    if chain[i].NumberU64() != chain[i-1].NumberU64()+1 || chain[i].ParentHash() != chain[i-1].Hash() {
      // Chain broke ancestry, log a message (programming error) and skip insertion
      log.Error("Non contiguous block insert", "number", ......)
      return 0, fmt.Errorf("non contiguous insert: ......", ......)
    }
  }
  // Pre-checks passed, start the full block imports
  bc.wg.Add(1)
  bc.chainmu.Lock()
  n, events, logs, err := bc.insertChain(chain, true)
  bc.chainmu.Unlock()
  bc.wg.Done()

  bc.PostChainEvents(events, logs)
  return n, err
}

func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool) (int, []interface{}, []*types.Log, error) {
  ......
  for i, block := range chain {
    headers[i] = block.Header()
    seals[i] = verifySeals
  }
  abort, results := bc.engine.VerifyHeaders(bc, headers, seals)
  defer close(abort)

  // Peek the error for the first block to decide the directing import logic
  it := newInsertIterator(chain, results, bc.Validator())

  ......
}

func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool) (int, []interface{}, []*types.Log, error) {
  ......
  block, err := it.next()
  switch {
  // First block is pruned, insert as sidechain and reorg only if TD grows enough
  case err == consensus.ErrPrunedAncestor:
    return bc.insertSidechain(it)

  // First block is future, shove it (and all children) to the future queue (unknown ancestor)
  case err == consensus.ErrFutureBlock || (err == consensus.ErrUnknownAncestor && bc.futureBlocks.Contains(it.first().ParentHash())):
    for block != nil && (it.index == 0 || err == consensus.ErrUnknownAncestor) {
      if err := bc.addFutureBlock(block); err != nil {
        return it.index, events, coalescedLogs, err
      }
      block, err = it.next()
    }
    // If there are any still remaining, mark as ignored
    return it.index, events, coalescedLogs, err

  case err == ErrKnownBlock:
    // Skip all known blocks that behind us
    current := bc.CurrentBlock().NumberU64()
    for block != nil && err == ErrKnownBlock && current >= block.NumberU64() {
      stats.ignored++
      block, err = it.next()
    }

  case err != nil:
    stats.ignored += len(it.chain)
    bc.reportBlock(block, nil, err)
    return it.index, events, coalescedLogs, err
  }
  ......
}

func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool) (int, []interface{}, []*types.Log, error) {
  ......
  //for循环太长，这里只保留了重要代码，并去掉了一些错误处理代码
  for ; block != nil && err == nil; block, err = it.next() {
    parent := it.previous()
    if parent == nil {
      parent = bc.GetBlock(block.ParentHash(), block.NumberU64()-1)
    }

    state, err := state.New(parent.Root(), bc.stateCache)
    // Process block using the parent state as reference point.
    receipts, logs, usedGas, err := bc.processor.Process(block, state, bc.vmConfig)
    // Validate the state using the default validator
    bc.Validator().ValidateState(block, parent, state, receipts, usedGas)
    // Write the block to the chain and get the status.
    status, err := bc.writeBlockWithState(block, receipts, state)

    switch status {
    case CanonStatTy:
      coalescedLogs = append(coalescedLogs, logs...)
      events = append(events, ChainEvent{block, block.Hash(), logs})
      lastCanon = block
      // Only count canonical blocks for GC processing time
      bc.gcproc += proctime

    case SideStatTy:
      events = a  ppend(events, ChainSideEvent{block})
    }
  }
  ......
}

func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool) (int, []interface{}, []*types.Log, error) {
  ......
  if block != nil && err == consensus.ErrFutureBlock {
    if err := bc.addFutureBlock(block); err != nil {
      return it.index, events, coalescedLogs, err
    }
    block, err = it.next()

    for ; block != nil && err == consensus.ErrUnknownAncestor; block, err = it.next() {
      if err := bc.addFutureBlock(block); err != nil {
        return it.index, events, coalescedLogs, err
      }
    }
  }

  // Append a single chain head event if we've progressed the chain
  if lastCanon != nil && bc.CurrentBlock().Hash() == lastCanon.Hash() {
    events = append(events, ChainHeadEvent{lastCanon})
  }
  return it.index, events, coalescedLogs, err
}

func (bc *BlockChain) insertSidechain(it *insertIterator) (int, []interface{}, []*types.Log, error) {
  var (
    externTd *big.Int
    current  = bc.CurrentBlock()
  )

  block, err := it.current(), consensus.ErrPrunedAncestor
  for ; block != nil && (err == consensus.ErrPrunedAncestor); block, err = it.next() {
    // Check the canonical state root for that number
    if number := block.NumberU64(); current.NumberU64() >= number {
      if canonical := bc.GetBlockByNumber(number); canonical != nil && canonical.Root() == block.Root() {
        // 处理 shadow-state attack
        log.Warn("Sidechain ghost-state attack detected", ......)
      }
    }

    if externTd == nil {
      externTd = bc.GetTd(block.ParentHash(), block.NumberU64()-1)
    }
    externTd = new(big.Int).Add(externTd, block.Difficulty())

    if !bc.HasBlock(block.Hash(), block.NumberU64()) {
      if err := bc.WriteBlockWithoutState(block, externTd); err != nil {
        return it.index, nil, nil, err
      }
    }
  }
  ......
}

func (bc *BlockChain) insertSidechain(it *insertIterator) (int, []interface{}, []*types.Log, error) {
  ......

  //判断当前的侧链是否有资格成为主链
  localTd := bc.GetTd(current.Hash(), current.NumberU64())
  if localTd.Cmp(externTd) > 0 {
    return it.index, nil, nil, err
  }

  //可以成为主链。
  //收集当前分支上最新区块和其state对象不存在的祖先区块
  var (
    hashes  []common.Hash
    numbers []uint64
  )
  parent := bc.GetHeader(it.previous().Hash(), it.previous().NumberU64())
  for parent != nil && !bc.HasState(parent.Root) {
    hashes = append(hashes, parent.Hash())
    numbers = append(numbers, parent.Number.Uint64())

    parent = bc.GetHeader(parent.ParentHash, parent.Number.Uint64()-1)
  }
  if parent == nil {
    return it.index, nil, nil, errors.New("missing parent")
  }
  //将这些收集到的区块重新调用insertChain，以将其加入到主链中
  //这里为了防止内存占用过多，会记录内存使用的情况，如果超过一定限制就先调用一下insertChain。
  var (
    blocks []*types.Block
    memory common.StorageSize
  )
  for i := len(hashes) - 1; i >= 0; i-- {
  // Append the next block to our batch
  block := bc.GetBlock(hashes[i], numbers[i])

  blocks = append(blocks, block)
  memory += block.Size()

  if len(blocks) >= 2048 || memory > 64*1024*1024 {
    if _, _, _, err := bc.insertChain(blocks, false); err != nil {
      return 0, nil, nil, err
    }
    blocks, memory = blocks[:0], 0
    }
  }
  if len(blocks) > 0 {
    return bc.insertChain(blocks, false)
  }
  return 0, nil, nil, nil
}