func (bc *BlockChain) insertChain(chain types.Blocks) (int, []interface{}, []*types.Log, error) {//如果传入的区块切片上长度为空，直接返回
if len(chain) == 0 {return 0, nil, nil, nil
}
//1确保这组区块的是首尾相接的，并且区块号连续递增，如果不是则直接返回
// 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 insertionlog.Error("Non contiguous block insert", "number", chain[i].Number(), "hash", chain[i].Hash(),"parent", chain[i].ParentHash(), "prevnumber", chain[i-1].Number(), "prevhash", chain[i-1].Hash())return 0, nil, nil, fmt.Errorf("non contiguous insert: item %d is #%d [%x…], item %d is #%d [%x…] (parent [%x…])", i-1, chain[i-1].NumberU64(),chain[i-1].Hash().Bytes()[:4], i, chain[i].NumberU64(), chain[i].Hash().Bytes()[:4], chain[i].ParentHash().Bytes()[:4])}
}
// Pre-checks passed, start the full block imports
bc.wg.Add(1)
defer bc.wg.Done()bc.chainmu.Lock()
defer bc.chainmu.Unlock()// A queued approach to delivering events. This is generally
// faster than direct delivery and requires much less mutex
// acquiring.
var (stats         = insertStats{startTime: mclock.Now()}events        = make([]interface{}, 0, len(chain))lastCanon     *types.BlockcoalescedLogs []*types.Log
)
// Start the parallel header verifier
headers := make([]*types.Header, len(chain))
seals := make([]bool, len(chain))
//2并行验证这组区块的区块头
for i, block := range chain {headers[i] = block.Header()seals[i] = true
}
abort, results := bc.engine.VerifyHeaders(bc, headers, seals)
defer close(abort)// Start a parallel signature recovery (signer will fluke on fork transition, minimal perf loss)senderCacher.recoverFromBlocks(types.MakeSigner(bc.chainConfig, chain[0].Number
()), chain)// Iterate over the blocks and insert when the verifier permits
//3验证这组区块的区块体
for i, block := range chain {// If the chain is terminating, stop processing blocks//如果有人打断验证直接返回if atomic.LoadInt32(&bc.procInterrupt) == 1 {log.Debug("Premature abort during blocks processing")break}
//如果这个区块在bad区块列表里，说明这个区块不能插入区块链，直接返回// If the header is a banned one, straight out abortif BadHashes[block.Hash()] {bc.reportBlock(block, nil, ErrBlacklistedHash)return i, events, coalescedLogs, ErrBlacklistedHash}// Wait for the block's verification to completebstart := time.Now()//4接收区块头的验证结果 err := <-resultsif err == nil {//如果区块头没有问题，则验证区块体err = bc.Validator().ValidateBody(block)}//5 处理区块头或区块体的验证错误switch {case err == ErrKnownBlock:// Block and state both already known. However if the current block is below// this number we did a rollback and we should reimport it nonetheless.//6 待插入的区块在数据库中已经存在，如果当前的区块链的头区块高度比待插入的区块大，则直接忽略这个区块，否则继续向下执行插入流程if bc.CurrentBlock().NumberU64() >= block.NumberU64() {stats.ignored++continue}case err == consensus.ErrFutureBlock://7如果待插入区块是一个未来区块（大于当前时间15秒），则判断是否是小于30s，如果是则将区块放入futureBlocks列表// Allow up to MaxFuture second in the future blocks. If this limit is exceeded// the chain is discarded and processed at a later time if given.max := big.NewInt(time.Now().Unix() + maxTimeFutureBlocks)if block.Time().Cmp(max) > 0 {return i, events, coalescedLogs, fmt.Errorf("future block: %v > %v", block.Time(), max)}bc.futureBlocks.Add(block.Hash(), block)stats.queued++continuecase err == consensus.ErrUnknownAncestor && bc.futureBlocks.Contains(block.ParentHash())://8数据库里面找不到这个区块的父亲区块， 并且未来待处理区块缓冲里面有它的父区块， 就将它放入到futureBlocks列表中bc.futureBlocks.Add(block.Hash(), block)stats.queued++continuecase err == consensus.ErrPrunedAncestor://9如果待插入区块的祖先是一个精简分支（所谓精简分支就是一条分叉，只有区块头和区块体，但是没有状态），看这个区块的总难度是否大于本地规范链头区块的总难度，如果大于，则将这条精简分支上的所有没有状态的区块重新做一次插入，插入的过程会产生状态，并将这条精简分支升级为规范链，否则如果不大于则将这个区块不带状态的情况下插入这条精简分支。// Block competing with the canonical chain, store in the db, but don't process// until the competitor TD goes above the canonical TDcurrentBlock := bc.CurrentBlock()localTd := bc.GetTd(currentBlock.Hash(), currentBlock.NumberU64())externTd := new(big.Int).Add(bc.GetTd(block.ParentHash(), block.NumberU64
()-1), block.Difficulty())if localTd.Cmp(externTd) > 0 {if err = bc.WriteBlockWithoutState(block, externTd); err != nil {return i, events, coalescedLogs, err}continue}// Competitor chain beat canonical, gather all blocks from the common ancestorvar winner []*types.Blockparent := bc.GetBlock(block.ParentHash(), block.NumberU64()-1)for !bc.HasState(parent.Root()) {winner = append(winner, parent)parent = bc.GetBlock(parent.ParentHash(), parent.NumberU64()-1)}//将精简分支上的区块收集好后，做一个倒序，因为插入的时候要安从小到大的顺序插入for j := 0; j < len(winner)/2; j++ {winner[j], winner[len(winner)-1-j] = winner[len(winner)-1-j], winner[j]}// Import all the pruned blocks to make the state availablebc.chainmu.Unlock()_, evs, logs, err := bc.insertChain(winner)bc.chainmu.Lock()events, coalescedLogs = evs, logsif err != nil {return i, events, coalescedLogs, err}case err != nil://无法处理的错误，直接返回bc.reportBlock(block, nil, err)return i, events, coalescedLogs, err}//10 验证区块的状态// Create a new statedb using the parent block and report an// error if it fails.var parent *types.Blockif i == 0 {parent = bc.GetBlock(block.ParentHash(), block.NumberU64()-1)} else {parent = chain[i-1]}state, err := state.New(parent.Root(), bc.stateCache)if err != nil {return i, events, coalescedLogs, err}// Process block using the parent state as reference point.receipts, logs, usedGas, err := bc.processor.Process(block, state, bc.vmConfig)if err != nil {bc.reportBlock(block, receipts, err)return i, events, coalescedLogs, err}// Validate the state using the default validatorerr = bc.Validator().ValidateState(block, parent, state, receipts, usedGas)if err != nil {bc.reportBlock(block, receipts, err)return i, events, coalescedLogs, err}proctime := time.Since(bstart)// 11 调用WriteBlockWithState将区块写入区块链，返回值如果是CanonStatTy，表示写入了规范链，如果是SideStatTy表示写入了分叉// Write the block to the chain and get the status.status, err := bc.WriteBlockWithState(block, receipts, state)if err != nil {return i, events, coalescedLogs, err}switch status {case CanonStatTy:
log.Debug("Inserted new block", "number", block.Number(), "hash", block.Hash(), "uncles", len(block.Uncles()),"txs", len(block.Transactions()), "gas", block.GasUsed(), "elapsed", common.PrettyDuration(time.Since(bstart)))coalescedLogs = append(coalescedLogs, logs...)blockInsertTimer.UpdateSince(bstart)events = append(events, ChainEvent{block, block.Hash(), logs})lastCanon = block// Only count canonical blocks for GC processing timebc.gcproc += proctimecase SideStatTy:log.Debug("Inserted forked block", "number", block.Number(), "hash", block.Hash(), "diff", block.Difficulty(), "elapsed",common.PrettyDuration(time.Since(bstart)), "txs", len(block.Transactions()), "gas", block.GasUsed(), "uncles", len(block.Uncles()))blockInsertTimer.UpdateSince(bstart)events = append(events, ChainSideEvent{block})}stats.processed++stats.usedGas += usedGascache, _ := bc.stateCache.TrieDB().Size()stats.report(chain, i, cache)
}
// 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})
}
//返回插入过程中的事件，BlockChain会将这个事件post出去，让其他监听的模块可以获知这些事件
return 0, events, coalescedLogs, nil
}

headers := make([]*types.Header, len(chain))
seals := make([]bool, len(chain))

for i, block := range chain {headers[i] = block.Header()seals[i] = true
}