本文章记录以太坊源码blockchain.go的阅读笔记。该文件包含了与区块链相关的各种功能和操作，用于实现区块链核心功能。
源码开头部分定义了一个变量块，用于同时声明多个变量。
var (
// 表示头部区块数量的计量表，用于记录当前区块链的头部区块数量
headBlockGauge = metrics.NewRegisteredGauge("chain/head/block", nil)
// 表示头部头信息数量的计量表，用于记录当前区块链的头部信息数量
headHeaderGauge = metrics.NewRegisteredGauge("chain/head/header", nil)
// 表示头部快速块数量的计量表，用于记录当前区块链的头部快速块的数量
headFastBlockGauge = metrics.NewRegisteredGauge("chain/head/receipt", nil)
// 表示已最终确定的块数量的计量表，用于记录当前区块链已经最终确定的块数量
headFinalizedBlockGauge = metrics.NewRegisteredGauge("chain/head/finalized", nil)
// 表示安全块数量的计量表，用于记录当前区块链的安全块数量
headSafeBlockGauge = metrics.NewRegisteredGauge("chain/head/safe", nil)
// 表示区块链信息的计量表，用于记录与区块链相关的一般信息
chainInfoGauge = metrics.NewRegisteredGaugeInfo("chain/info", nil)
// 表示账户读取时间的重置计时器，用于记录区块链中账户读取操作的时间
accountReadTimer = metrics.NewRegisteredResettingTimer("chain/account/reads", nil)
// 表示账户哈希计算时间的重置计时器，用于记录区块链中账户哈希操作的时间
accountHashTimer = metrics.NewRegisteredResettingTimer("chain/account/hashes", nil)
// 表示账户更新时间的重置计时器，用于记录区块链中账户更新操作的时间
accountUpdateTimer = metrics.NewRegisteredResettingTimer("chain/account/updates", nil)
// 表示账户提交时间的重置计时器，用于记录区块链中账户提交操作的时间
accountCommitTimer = metrics.NewRegisteredResettingTimer("chain/account/commits", nil)
// 读取操作时间计时器
storageReadTimer = metrics.NewRegisteredResettingTimer("chain/storage/reads", nil)
// 哈希计算操作时间计时器
storageHashTimer = metrics.NewRegisteredResettingTimer("chain/storage/hashes", nil)
// 更新操作时间计时器
storageUpdateTimer = metrics.NewRegisteredResettingTimer("chain/storage/updates", nil)
// 提交操作时间计时器
storageCommitTimer = metrics.NewRegisteredResettingTimer("chain/storage/commits", nil)
// 快照中账户读取操作时间计时器
snapshotAccountReadTimer = metrics.NewRegisteredResettingTimer("chain/snapshot/account/reads", nil)
// 快照中存储读取操作时间计时器
snapshotStorageReadTimer = metrics.NewRegisteredResettingTimer("chain/snapshot/storage/reads", nil)
// 快照提交操作时间计时器
snapshotCommitTimer = metrics.NewRegisteredResettingTimer("chain/snapshot/commits", nil)
// Trie数据库提交操作计时器
triedbCommitTimer = metrics.NewRegisteredResettingTimer("chain/triedb/commits", nil)
// 区块插入操作计时器
blockInsertTimer = metrics.NewRegisteredResettingTimer("chain/inserts", nil)
// 区块验证操作计时器
blockValidationTimer = metrics.NewRegisteredResettingTimer("chain/validation", nil)
// 区块执行操作计时器
blockExecutionTimer = metrics.NewRegisteredResettingTimer("chain/execution", nil)
// 区块写入操作计时器
blockWriteTimer = metrics.NewRegisteredResettingTimer("chain/write", nil)
// 记录操作的频率
blockReorgMeter = metrics.NewRegisteredMeter("chain/reorg/executes", nil)
// 新增区块到重新组织的频率
blockReorgAddMeter = metrics.NewRegisteredMeter("chain/reorg/add", nil)
// 丢弃的区块重新组织的频率
blockReorgDropMeter = metrics.NewRegisteredMeter("chain/reorg/drop", nil)
// 区块预取执行操作的计时器
blockPrefetchExecuteTimer = metrics.NewRegisteredTimer("chain/prefetch/executes", nil)
// 区块预取中断的频率
blockPrefetchInterruptMeter = metrics.NewRegisteredMeter("chain/prefetch/interrupts", nil)
// 插入操作中断的错误信息
errInsertionInterrupted = errors.New("insertion is interrupted")
// 区块链停止的错误信息
errChainStopped = errors.New("blockchain is stopped")
// 旧区块链无效的错误信息
errInvalidOldChain = errors.New("invalid old chain")
// 新区块无效的错误信息
errInvalidNewChain = errors.New("invalid new chain")
)
上面提到了快速块和安全块，安全块和快速块是区块链中的两种不同类型的块，它们在区块链协议中具有不同的含义和作用。
安全块（Finalized Block）：
安全块是指已经被网络中大多数节点（或者特定的一组节点）确认的块，这些节点已经通过一定的共识机制达成一致，认可该块的有效性，并将其视为区块链的一部分。
一般来说，安全块是区块链的最终确认版本，即它们被认为是永久的，不可逆转的。
安全块的确认通常是通过一些共识算法（如工作量证明、权益证明等）来实现的，确保了块的有效性和整个网络的安全性。
快速块（Fast Block）：
快速块是指在某些区块链协议中，通过一定的机制使得特定的块可以更快地被确认和接受，从而提高了交易的处理速度和网络的吞吐量。
快速块可能是临时性的，它们在一定条件下可以更快地被确认，但在后续的安全确认中可能会发生变化。
快速块的引入可以带来更快的交易确认和更高的网络效率，但也可能会牺牲一定程度的安全性和去中心化特性。
总的来说，快速块可以更快的被确认，从而提高交易处理的速度，而安全块则具备更高的安全性和可靠性。
下面是常量块，用于同时声明多个常量：
const (
bodyCacheLimit = 256 // 区块体缓存的大小限制，通常包含交易等数据
blockCacheLimit = 256 // 区块缓存的大小限制，用于存储最近处理过的区块，提高性能
receiptsCacheLimit = 32 // 收据缓存的大小限制，用于存储交易执行的结果
txLookupCacheLimit = 1024 // 交易查询缓存的大小，用于存储交易哈希与区块的映射，加快查询
TriesInMemory = 128 // 内存中存储的Trie的数量
BlockChainVersion uint64 = 8 // 区块链版本号
)
上文提到的Trie结构可以参考下面的文章：以太坊Geth Trie源码解析_以太坊设计与源码之美-CSDN博客
下面是对Trie结构的配置：
type CacheConfig struct {
TrieCleanLimit int // 用于缓存内存中trie节点的内存限制（以MB为单位）
TrieCleanNoPrefetch bool // 是否禁用启发式状态预取以供后续块使用
TrieDirtyLimit int // 当脏trie节点内存占用达到多少MB时开始将其刷新到磁盘
TrieDirtyDisabled bool // 是否完全禁用trie写缓存和垃圾回收
TrieTimeLimit time.Duration // 在何时将当前内存中的trie刷新到磁盘的时间限制
SnapshotLimit int // 用于在内存中缓存快照条目的内存限制
Preimages bool // 是否将trie键的预映像存储到磁盘上
StateHistory uint64 // 从头开始保留状态历史记录的块数
StateScheme string // 用于在顶部存储以太坊状态和默克尔树节点的方案
SnapshotNoBuild bool // 是否允许后台生成快照
SnapshotWait bool // 是否在启动时等待快照构建
}
对于配置来说，以太坊提供了加载配置和默认配置：
func (c *CacheConfig) triedbConfig(isVerkle bool) *triedb.Config {
config := &triedb.Config{
Preimages: c.Preimages,
IsVerkle: isVerkle,
}
// 根据不同的方案配置不同的存储引擎
if c.StateScheme == rawdb.HashScheme {
config.HashDB = &hashdb.Config{
CleanCacheSize: c.TrieCleanLimit * 1024 * 1024,
}
}
if c.StateScheme == rawdb.PathScheme {
config.PathDB = &pathdb.Config{
StateHistory: c.StateHistory,
CleanCacheSize: c.TrieCleanLimit * 1024 * 1024,
DirtyCacheSize: c.TrieDirtyLimit * 1024 * 1024,
}
}
return config
}
// 默认的缓存配置
var defaultCacheConfig = &CacheConfig{
TrieCleanLimit: 256, // Trie节点的内存限制为256MB
TrieDirtyLimit: 256, // 脏Trie节点达到256MB被刷新到磁盘
TrieTimeLimit: 5 * time.Minute, // 5分钟后将内存的Trie刷新到磁盘
SnapshotLimit: 256, // 缓存快照条目设置为256MB
SnapshotWait: true, // 在启动时等待快照构建
StateScheme: rawdb.HashScheme, // 使用哈希方案存储以太坊状态和merkle树
}
// 指定以哈希方式存储以太坊状态和 Merkle 树节点的方式
func DefaultCacheConfigWithScheme(scheme string) *CacheConfig {
config := *defaultCacheConfig
config.StateScheme = scheme
return &config
}
上面的代码涉及到Verkle Trie树，Verkle Trie 是一种改进的 Merkle Trie 数据结构，用于存储键值对。Merkle Trie节点存储的是哈希值，而Verkle Trie存储的是哈希值以及对这个哈希值存在的证明。它是以太坊 2.0 中引入的一项技术，旨在提供更高效的存储和验证方法。Verkle Trie 相比传统的 Merkle Trie 有几个优点：
更少的存储需求：Verkle Trie 使用路径压缩和共享子树的方式来减少存储需求，特别是对于包含大量相似键的情况，可以显著减少存储空间的占用。
更高的效率：由于路径压缩和共享子树的特性，Verkle Trie 在执行插入、删除和更新操作时，通常比传统的 Merkle Trie 更高效。
更好的隐私性：Verkle Trie 可以隐藏非叶子节点的具体键值对，从而提高了对存储数据的隐私性。
下面是对交易查找的结构体封装，用于将交易对象和交易查找结果封装在一起，以便于在程序中处理和传递交易及其相关信息。通过将这两个信息结合在一起，可以更方便地在程序中使用交易对象，并且可以轻松地从交易查找结果中获取所需的信息。
type txLookup struct {
lookup *rawdb.LegacyTxLookupEntry
transaction *types.Transaction
}
下面是对区块链的结构体封装，它包含了各种与区块链操作相关的字段和方法。
type BlockChain struct {
// chainConfig 指向区块链中链和网络配置的指针。
chainConfig *params.ChainConfig
// cacheConfig 指向缓存配置的指针。
cacheConfig *CacheConfig
// db 是最终持久化数据的数据库。
db ethdb.Database
// snaps 是一个快速访问 Trie 的快照树。
snaps *snapshot.Tree
// triegc 是一个优先队列，将区块号映射到需要进行垃圾回收的 Trie。
triegc *prque.Prque[int64, common.Hash]
// gcproc 是用于累积规范块处理以进行 Trie 转储的时间间隔。
gcproc time.Duration
// lastWrite 是上一次状态被刷新时的区块号。
lastWrite uint64
// flushInterval 是用于定时刷新状态的时间间隔。
flushInterval atomic.Int64
// triedb 是用于维护 Trie 节点的数据库处理程序。
triedb *triedb.Database
// stateCache 是状态数据库，用于在导入之间重用状态。
stateCache state.Database
// txIndexer 是事务索引器，如果未启用，则可能为 nil。
txIndexer *txIndexer
// hc 是区块头链管理器。
hc *HeaderChain
// rmLogsFeed 是用于订阅链上移除日志的事件 Feed。
rmLogsFeed event.Feed
// chainFeed 是链事件的事件 Feed。
chainFeed event.Feed
// chainSideFeed 是侧链事件的事件 Feed。
chainSideFeed event.Feed
// chainHeadFeed 是链头事件的事件 Feed。
chainHeadFeed event.Feed
// logsFeed 是用于订阅链上新日志的事件 Feed。
logsFeed event.Feed
// blockProcFeed 是用于订阅块处理事件的事件 Feed。
blockProcFeed event.Feed
// scope 是事件订阅范围。
scope event.SubscriptionScope
// genesisBlock 是创世块。
genesisBlock *types.Block
// chainmu 是用于同步链写操作的互斥锁。
chainmu *syncx.ClosableMutex
// currentBlock 是当前链的头部，原子指针指向 types.Header 对象。
currentBlock atomic.Pointer[types.Header]
// currentSnapBlock 是当前快照同步的头部，原子指针指向 types.Header 对象。
currentSnapBlock atomic.Pointer[types.Header]
// currentFinalBlock 是最终确定的块，原子指针指向 types.Header 对象。
currentFinalBlock atomic.Pointer[types.Header]
// currentSafeBlock 是最近的安全块，原子指针指向 types.Header 对象。
currentSafeBlock atomic.Pointer[types.Header]
// bodyCache 是用于缓存区块体的 LRU 缓存。
bodyCache *lru.Cache[common.Hash, *types.Body]
// bodyRLPCache 是用于缓存区块体的 RLP 编码的 LRU 缓存。
bodyRLPCache *lru.Cache[common.Hash, rlp.RawValue]
// receiptsCache 是用于缓存区块的交易收据的 LRU 缓存。
receiptsCache *lru.Cache[common.Hash, []*types.Receipt]
// blockCache 是用于缓存区块的 LRU 缓存。
blockCache *lru.Cache[common.Hash, *types.Block]
// txLookupCache 是用于缓存事务查找结果的 LRU 缓存。
txLookupCache *lru.Cache[common.Hash, txLookup]
// wg 是一个 WaitGroup，用于等待所有区块链协程完成。
wg sync.WaitGroup
// quit 是一个用于发送关闭信号的通道。
quit chan struct{}
// stopping 是一个原子布尔类型，表示区块链是否正在停止。
stopping atomic.Bool
// procInterrupt 是一个原子布尔类型，用于中断块处理。
procInterrupt atomic.Bool
// engine 是共识引擎，用于验证和执行共识规则。
engine consensus.Engine
// validator 是验证器接口，用于验证区块和状态。
validator Validator
// prefetcher 是预取器接口，用于预取区块数据。
prefetcher Prefetcher
// processor 是块事务处理器接口，用于处理块中的事务。
processor Processor
// forker 是分叉选择对象，用于选择主链。
forker *ForkChoice
// vmConfig 是虚拟机配置，用于配置以太坊虚拟机。
vmConfig vm.Config
// logger 是日志记录钩子，用于记录区块链操作的日志。
logger *tracing.Hooks
}
下面函数是用来创建一个全面初始化的区块链对象的。函数接受了一系列参数，包括数据库、缓存配置、创世块信息、链覆盖、共识引擎、虚拟机配置等。
func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis, overrides *ChainOverrides, engine consensus.Engine, vmConfig vm.Config, shouldPreserve func(header *types.Header) bool, txLookupLimit *uint64) (*BlockChain, error) {
if cacheConfig == nil {
// 使用默认的缓存配置
cacheConfig = defaultCacheConfig
}
// 使用提供的数据库配置打开trie数据库
triedb := triedb.NewDatabase(db, cacheConfig.triedbConfig(genesis != nil && genesis.IsVerkle()))
// 接收SetupGenesisBlockWithOverride的三个返回值
chainConfig, genesisHash, genesisErr := SetupGenesisBlockWithOverride(db, triedb, genesis, overrides)
// 如果在创世块设置过程中发生了其他类型的错误会直接返回错误，否则如果genesisErr!=nil且是一个 // params.ConfigCompatError错误，说明创世块设置过程发生了配置不兼容的错误，但这种错误被允许
if _, ok := genesisErr.(*params.ConfigCompatError); genesisErr != nil && !ok {
return nil, genesisErr
}
// 打印空行-输出153个--分行打印配置的信息-答应153--打印空行
log.Info("")
log.Info(strings.Repeat("-", 153))
for _, line := range strings.Split(chainConfig.Description(), "\n") {
log.Info(line)
}
log.Info(strings.Repeat("-", 153))
log.Info("")
// 创建区块链
bc := &BlockChain{
chainConfig: chainConfig,
cacheConfig: cacheConfig,
db: db,
triedb: triedb,
triegc: prque.New[int64, common.Hash](nil),
quit: make(chan struct{}),
chainmu: syncx.NewClosableMutex(),
bodyCache: lru.NewCache[common.Hash, *types.Body](bodyCacheLimit),
bodyRLPCache: lru.NewCache[common.Hash, rlp.RawValue](bodyCacheLimit),
receiptsCache: lru.NewCache[common.Hash, []*types.Receipt](receiptsCacheLimit),
blockCache: lru.NewCache[common.Hash, *types.Block](blockCacheLimit),
txLookupCache: lru.NewCache[common.Hash, txLookup](txLookupCacheLimit),
engine: engine,
vmConfig: vmConfig,
logger: vmConfig.Tracer,
}
// 将缓存配置中的 trie 时间限制存储到 BlockChain 对象的 flushInterval 字段中。
bc.flushInterval.Store(int64(cacheConfig.TrieTimeLimit))
// 使用 NewForkChoice 函数创建一个分叉选择对象，并赋值给 BlockChain 对象的 forker 字段，用于处 // 理分叉选择。
bc.forker = NewForkChoice(bc, shouldPreserve)
// 使用 state.NewDatabaseWithNodeDB 函数创建一个状态数据库，并赋值给 BlockChain 对象的 // stateCache 字段。
bc.stateCache = state.NewDatabaseWithNodeDB(bc.db, bc.triedb)
// 使用 NewBlockValidator 函数创建一个区块验证器，并赋值给 BlockChain 对象的 validator 字段。
bc.validator = NewBlockValidator(chainConfig, bc, engine)
// 使用 newStatePrefetcher 函数创建一个状态预取器，并赋值给 BlockChain 对象的 prefetcher 字 // 段。
bc.prefetcher = newStatePrefetcher(chainConfig, bc, engine)
// 使用 NewStateProcessor 函数创建一个状态处理器，并赋值给 BlockChain 对象的 processor 字段。
bc.processor = NewStateProcessor(chainConfig, bc, engine)
var err error
bc.hc, err = NewHeaderChain(db, chainConfig, engine, bc.insertStopped)
if err != nil {
return nil, err
}
// 获得创世区块
bc.genesisBlock = bc.GetBlockByNumber(0)
if bc.genesisBlock == nil {
return nil, ErrNoGenesis
}
// 表示当前链上没有任何区块
bc.currentBlock.Store(nil)
bc.currentSnapBlock.Store(nil)
bc.currentFinalBlock.Store(nil)
bc.currentSafeBlock.Store(nil)
// 将当前区块链的 ID 更新到度量指标中，以便监控该区块链的状态
chainInfoGauge.Update(metrics.GaugeInfoValue{"chain_id": bc.chainConfig.ChainID.String()})
// 如果区块链是否是空，为空则从快照加载数据来初始化
if bc.empty() {
rawdb.InitDatabaseFromFreezer(bc.db)
}
// 从磁盘导入区块链状态
if err := bc.loadLastState(); err != nil {
return nil, err
}
// 获取区块链当前区块
head := bc.CurrentBlock()
if !bc.HasState(head.Root) {
// 链头状态不可用，可能是状态丢失或者本地没有同步
if head.Number.Uint64() == 0 {
// 头部区块丢失状态，需要等待同步
log.Info("Genesis state is missing, wait state sync")
} else {
var diskRoot common.Hash
// 如果启用了快照，则从快照提取快照中的根哈希值
if bc.cacheConfig.SnapshotLimit > 0 {
diskRoot = rawdb.ReadSnapshotRoot(bc.db)
}
if diskRoot != (common.Hash{}) {
// 如果哈希值不存在，尝试从快照中恢复哈希值
log.Warn("Head state missing, repairing", "number", head.Number, "hash", head.Hash(), "snaproot", diskRoot)
snapDisk, err := bc.setHeadBeyondRoot(head.Number.Uint64(), 0, diskRoot, true)
if err != nil {
return nil, err
}
// 成功恢复了状态，则将恢复的快照编号写入数据库，以便表示恢复过程
if snapDisk != 0 {
rawdb.WriteSnapshotRecoveryNumber(bc.db, snapDisk)
}
} else {
// 快照根哈希值不存在，快照未启用或不存在，调用setHeadBeyondRoot函数设置链头
// 传入一个空的哈希值，尝试从头开始恢复状态
log.Warn("Head state missing, repairing", "number", head.Number, "hash", head.Hash())
if _, err := bc.setHeadBeyondRoot(head.Number.Uint64(), 0, common.Hash{}, true); err != nil {
return nil, err
}
}
}
}
// 是否有祖先区块，声明是否需要回滚区块以及需要回滚区块的编号
if frozen, err := bc.db.Ancients(); err == nil && frozen > 0 {
var (
needRewind bool
low uint64
)
// 获取最新区块
fullBlock := bc.CurrentBlock()
// 当前区块不为空，不是创世区块且区块变化小于祖先区块-1，需要回滚
if fullBlock != nil && fullBlock.Hash() != bc.genesisBlock.Hash() && fullBlock.Number.Uint64() < frozen-1 {
needRewind = true
low = fullBlock.Number.Uint64()
}
// 获取当前区链的快照区块
snapBlock := bc.CurrentSnapBlock()
if snapBlock != nil && snapBlock.Number.Uint64() < frozen-1 {
needRewind = true
if snapBlock.Number.Uint64() < low || low == 0 {
low = snapBlock.Number.Uint64()
}
}
// 回滚操作，需要指定回滚的起始区块编号和终止区块编号，设置新的区块链头部，回滚到low区块
if needRewind {
log.Error("Truncating ancient chain", "from", bc.CurrentHeader().Number.Uint64(), "to", low)
if err := bc.SetHead(low); err != nil {
return nil, err
}
}
}
// 区块链引擎确定当前区块是否合法
bc.engine.VerifyHeader(bc, bc.CurrentHeader())
// 遍历有问题的哈希集合，如果区块头的哈希值和里面的某个值相等，表示该区块哈希值有问题需要回滚
for hash := range BadHashes {
if header := bc.GetHeaderByHash(hash); header != nil {
headerByNumber := bc.GetHeaderByNumber(header.Number.Uint64())
if headerByNumber != nil && headerByNumber.Hash() == header.Hash() {
log.Error("Found bad hash, rewinding chain", "number", header.Number, "hash", header.ParentHash)
if err := bc.SetHead(header.Number.Uint64() - 1); err != nil {
return nil, err
}
log.Error("Chain rewind was successful, resuming normal operation")
}
}
}
// 记录区块链初始化事件
if bc.logger != nil && bc.logger.OnBlockchainInit != nil {
bc.logger.OnBlockchainInit(chainConfig)
}
// 检查日志器是否有OnGenesisBlock函数，如果是创世区块则试图访问区块信息，然后执行回调函数
if bc.logger != nil && bc.logger.OnGenesisBlock != nil {
if block := bc.CurrentBlock(); block.Number.Uint64() == 0 {
alloc, err := getGenesisState(bc.db, block.Hash())
if err != nil {
return nil, fmt.Errorf("failed to get genesis state: %w", err)
}
if alloc == nil {
return nil, fmt.Errorf("live blockchain tracer requires genesis alloc to be set")
}
bc.logger.OnGenesisBlock(bc.genesisBlock, alloc)
}
}
// 启用了快照
if bc.cacheConfig.SnapshotLimit > 0 {
// 是否启用了快照恢复
var recover bool
head := bc.CurrentBlock()
if layer := rawdb.ReadSnapshotRecoveryNumber(bc.db); layer != nil && *layer >= head.Number.Uint64() {
log.Warn("Enabling snapshot recovery", "chainhead", head.Number, "diskbase", *layer)
recover = true
}
snapconfig := snapshot.Config{
CacheSize: bc.cacheConfig.SnapshotLimit,
Recovery: recover,
NoBuild: bc.cacheConfig.SnapshotNoBuild,
AsyncBuild: !bc.cacheConfig.SnapshotWait,
}
// 创建快照对象
bc.snaps, _ = snapshot.New(snapconfig, bc.db, bc.triedb, head.Root)
}
// 检查是否存在配置兼容性问题并进行相应处理
if compat, ok := genesisErr.(*params.ConfigCompatError); ok {
log.Warn("Rewinding chain to upgrade configuration", "err", compat)
if compat.RewindToTime > 0 {
// 将链回滚到指定时间
bc.SetHeadWithTimestamp(compat.RewindToTime)
} else {
// 将链回滚到指定区块id
bc.SetHead(compat.RewindToBlock)
}
// 将更新后的链配置写入数据库
rawdb.WriteChainConfig(db, genesisHash, chainConfig)
}
// 检查是否传入了交易索引限制参数，并相应的配置区块链的交易索引器
if txLookupLimit != nil {
bc.txIndexer = newTxIndexer(*txLookupLimit, bc)
}
return bc, nil
}
下面是从数据库中加载最新的链状态，
// loadLastState 从数据库中加载最新的已知链状态。该方法假设链管理器的互斥锁已被持有。
func (bc *BlockChain) loadLastState() error {
// 恢复最新的已知头区块
head := rawdb.ReadHeadBlockHash(bc.db) // 从数据库中读取最新的区块哈希
if head == (common.Hash{}) { // 如果数据库中最新的区块哈希为空，表示数据库可能损坏或为空
// 数据库损坏或为空，重新初始化区块链
log.Warn("数据库为空，正在重置链") // 发出警告日志，数据库为空，重置区块链
return bc.Reset() // 调用重置方法进行初始化
}
// 确保完整的头区块可用
headBlock := bc.GetBlockByHash(head) // 获取最新的区块
if headBlock == nil { // 如果获取的区块为空，表示数据库可能损坏或为空
// 数据库损坏或为空，重新初始化区块链
log.Warn("头区块丢失，正在重置链", "哈希", head) // 发出警告日志，头区块丢失，重置区块链
return bc.Reset() // 调用重置方法进行初始化
}
// 一切正常，将其设置为头区块
bc.currentBlock.Store(headBlock.Header()) // 存储头区块
headBlockGauge.Update(int64(headBlock.NumberU64())) // 更新头区块计数器
// 恢复最新已知的头标头
headHeader := headBlock.Header() // 获取头标头
if head := rawdb.ReadHeadHeaderHash(bc.db); head != (common.Hash{}) { // 如果数据库中存在头标头哈希
if header := bc.GetHeaderByHash(head); header != nil { // 获取头标头
headHeader = header // 设置头标头
}
}
bc.hc.SetCurrentHeader(headHeader) // 设置当前标头
// 恢复最新已知的头快照块
bc.currentSnapBlock.Store(headBlock.Header()) // 存储快照区块头
headFastBlockGauge.Update(int64(headBlock.NumberU64())) // 更新快照区块计数器
if head := rawdb.ReadHeadFastBlockHash(bc.db); head != (common.Hash{}) { // 如果数据库中存在快照区块哈希
if block := bc.GetBlockByHash(head); block != nil { // 获取快照区块
bc.currentSnapBlock.Store(block.Header()) // 存储快照区块头
headFastBlockGauge.Update(int64(block.NumberU64())) // 更新快照区块计数器
}
}
// 恢复最新已知的最终化块和安全块
// 注意：安全块未存储在磁盘上，并在启动时设置为最后已知的最终化块
if head := rawdb.ReadFinalizedBlockHash(bc.db); head != (common.Hash{}) { // 如果数据库中存在最终化块哈希
if block := bc.GetBlockByHash(head); block != nil { // 获取最终化块
bc.currentFinalBlock.Store(block.Header()) // 存储最终化块头
headFinalizedBlockGauge.Update(int64(block.NumberU64())) // 更新最终化块计数器
bc.currentSafeBlock.Store(block.Header()) // 存储安全块头
headSafeBlockGauge.Update(int64(block.NumberU64())) // 更新安全块计数器
}
}
// 向用户发出状态日志
var (
currentSnapBlock = bc.CurrentSnapBlock() // 获取当前快照区块
currentFinalBlock = bc.CurrentFinalBlock() // 获取当前最终化块
headerTd = bc.GetTd(headHeader.Hash(), headHeader.Number.Uint64()) // 获取头标头的总难度
blockTd = bc.GetTd(headBlock.Hash(), headBlock.NumberU64()) // 获取头区块的总难度
)
if headHeader.Hash() != headBlock.Hash() { // 如果头标头哈希与头区块哈希不相等
log.Info("加载最新的本地标头", "高度", headHeader.Number, "哈希", headHeader.Hash(), "总难度", headerTd, "时间", common.PrettyAge(time.Unix(int64(headHeader.Time), 0))) // 输出日志，加载最新的本地标头
}
log.Info("加载最新的本地区块", "高度", headBlock.Number(), "哈希", headBlock.Hash(), "总难度", blockTd, "时间", common.PrettyAge(time.Unix(int64(headBlock.Time()), 0))) // 输出日志，加载最新的本地区块
if headBlock.Hash() != currentSnapBlock.Hash() { // 如果头区块哈希与当前快照区块哈希不相等
snapTd := bc.GetTd(currentSnapBlock.Hash(), currentSnapBlock.Number.Uint64()) // 获取快照区块的总难度
log.Info("加载最新的本地快照区块", "高度", currentSnapBlock.Number, "哈希", currentSnapBlock.Hash(), "总难度", snapTd, "时间", common.PrettyAge(time.Unix(int64(currentSnapBlock.Time), 0))) // 输出日志，加载最新的本地快照区块
}
if currentFinalBlock != nil { // 如果存在当前最终化块
finalTd := bc.GetTd(currentFinalBlock.Hash(), currentFinalBlock.Number.Uint64()) // 获取最终化块的总难度
log.Info("加载最新的本地最终化块", "高度", currentFinalBlock.Number, "哈希", currentFinalBlock.Hash(), "总难度", finalTd, "时间", common.PrettyAge(time.Unix(int64(currentFinalBlock.Time), 0))) // 输出日志，加载最新的本地最终化块
}
if pivot := rawdb.ReadLastPivotNumber(bc.db); pivot != nil { // 如果存在最后的快照同步枢纽标记
log.Info("加载最后的快照同步枢纽标记", "高度", *pivot) // 输出日志，加载最后的快照同步枢纽标记
}
return nil // 返回空错误
}
下面这个函数的主要功能是设置链的头部，负责回滚区块链到请求的头部，并根据需要进行相关的清理工作，包括：
获取链的锁，确保只有一个线程正在进行链头设置的操作；
根据修复标志和数据库状态，决定是否执行头部的更新操作；
根据新的链头更新函数和删除函数对链更新；
清理缓存中的陈旧内容；
需要的情况下，清除已经失效的安全块和已经失效的最终化的块；
加载最新的链状态；
返回相关信息
func (bc *BlockChain) setHeadBeyondRoot(head uint64, time uint64, root common.Hash, repair bool) (uint64, error) {
// 如果无法获取锁，返回错误信息
if !bc.chainmu.TryLock() {
return 0, errChainStopped
}
defer bc.chainmu.Unlock()
var (
// 跟踪请求根哈希值的块编号
rootNumber uint64 // （如果没有根，则始终为0）
// 检索最后一个枢轴块以在其之前短路回滚，并检索当前冻结器限制以开始清理下溢的数据。
pivot = rawdb.ReadLastPivotNumber(bc.db)
)
updateFn := func(db ethdb.KeyValueWriter, header *types.Header) (*types.Header, bool) {
// 回滚区块链，确保我们不会得到一个无状态的链头块。注意，深度相等性被允许，以允许将 SetHead 用作链修复机制而不删除任何数据！
if currentBlock := bc.CurrentBlock(); currentBlock != nil && header.Number.Uint64() <= currentBlock.Number.Uint64() {
var newHeadBlock *types.Header
newHeadBlock, rootNumber = bc.rewindHead(header, root)
rawdb.WriteHeadBlockHash(db, newHeadBlock.Hash())
// 如果显式地恢复了链标记，则降级链标记。在理论上，我们应该在最后一步更新所有内存中的标记，然而 SetHead 的方向是从高到低，所以可以直接更新内存中的标记。
bc.currentBlock.Store(newHeadBlock)
headBlockGauge.Update(int64(newHeadBlock.Number.Uint64()))
// 头状态丢失，这只在基于路径的方案中可能发生。当链头被回滚到枢轴点以下时会出现这种情况。在这种情况下，除了重新运行快照同步器之外，没有可能的恢复方法。在此之前不执行任何操作。
if !bc.HasState(newHeadBlock.Root) {
if newHeadBlock.Number.Uint64() != 0 {
log.Crit("链在非创世块处处于无状态")
}
log.Info("链处于无状态，请等待状态同步", "number", newHeadBlock.Number, "hash", newHeadBlock.Hash())
}
}
// 简单地回滚快照块到目标头
if currentSnapBlock := bc.CurrentSnapBlock(); currentSnapBlock != nil && header.Number.Uint64() < currentSnapBlock.Number.Uint64() {
newHeadSnapBlock := bc.GetBlock(header.Hash(), header.Number.Uint64())
// 如果任一块达到 nil，则重置到创世状态
if newHeadSnapBlock == nil {
newHeadSnapBlock = bc.genesisBlock
}
rawdb.WriteHeadFastBlockHash(db, newHeadSnapBlock.Hash())
// 如果显式地恢复了链标记，则降级链标记。在理论上，我们应该在最后一步更新所有内存中的标记，然而 SetHead 的方向是从高到低，所以可以直接更新内存中的标记。
bc.currentSnapBlock.Store(newHeadSnapBlock.Header())
headFastBlockGauge.Update(int64(newHeadSnapBlock.NumberU64()))
}
var (
headHeader = bc.CurrentBlock()
headNumber = headHeader.Number.Uint64()
)
// 如果 SetHead 下溢冻结器阈值，并且之后的区块处理意图是完整的区块导入，则删除状态块之间的链段和设置头目标之间的链段。
var wipe bool
frozen, _ := bc.db.Ancients()
if headNumber+1 < frozen {
wipe = pivot == nil || headNumber >= *pivot
}
return headHeader, wipe // 如果是完整同步，只有在强制清理时才清除
}
// 回滚头链，删除直到所有区块体的块
delFn := func(db ethdb.KeyValueWriter, hash common.Hash, num uint64) {
// 忽略此处的错误，因为轻客户端不会走到这条路径上
frozen, _ := bc.db.Ancients()
if num+1 <= frozen {
// 从古代存储中截断所有相关数据（头部、总难度、主体、收据和规范哈希）。
if _, err := bc.db.TruncateHead(num); err != nil {
log.Crit("截断古代数据失败", "number", num, "err", err)
}
// 从活动存储中删除哈希 <-> 编号映射。
rawdb.DeleteHeaderNumber(db, hash)
} else {
// 从活动存储中删除相关体和收据。
// 头、总难度和规范哈希将在 hc.SetHead 函数中删除。
rawdb.DeleteBody(db, hash, num)
rawdb.DeleteReceipts(db, hash, num)
}
// 待办事项(rjl493456442) 事务查找、布隆位图等
}
// 如果 SetHead 仅作为链修复方法调用，则尝试跳过头链
// 如果修复冻结器已损坏，则强制进行清理。
if repair {
if target, force := updateFn(bc.db, bc.CurrentBlock()); force {
bc.hc.SetHead(target.Number.Uint64(), nil, delFn)
}
} else {
// 回滚链到请求的头部，然后向后继续，直到找到一个具有状态的块或通过快照同步枢轴。
if time > 0 {
log.Warn("回滚区块链到时间戳", "目标", time)
bc.hc.SetHeadWithTimestamp(time, updateFn, delFn)
} else {
log.Warn("回滚区块链到区块", "目标", head)
bc.hc.SetHead(head, updateFn, delFn)
}
}
// 清除缓存中的任何陈旧内容
bc.bodyCache.Purge()
bc.bodyRLPCache.Purge()
bc.receiptsCache.Purge()
bc.blockCache.Purge()
bc.txLookupCache.Purge()
// 如果需要，清除安全块、已最终化的块
if safe := bc.CurrentSafeBlock(); safe != nil && head < safe.Number.Uint64() {
log.Warn("SetHead 使安全块无效")
bc.SetSafe(nil)
}
if finalized := bc.CurrentFinalBlock(); finalized != nil && head < finalized.Number.Uint64() {
log.Error("SetHead 使已最终化的块无效")
bc.SetFinalized(nil)
}
return rootNumber, bc.loadLastState()
}
在区块链停止前，需要执行一系列的操作来确保数据的一致性和持久性，主要逻辑如下：
stopWithoutSaving 被调用，停止区块链服务但不保存数据。
如果存在快照管理器 snaps，则将当前区块的状态快照记录到磁盘日志中，并释放快照管理器。
如果区块链数据库的方案为路径方案（PathScheme），则确保将内存中的Trie节点记录到磁盘日志中。
否则，对于最近的一些区块（当前区块、当前区块的前一个区块、当前区块之前的一些区块），将其状态Trie写入磁盘以确保数据持久性。这是为了应对不同的重启场景，比如：
HEAD：为了避免在一般情况下不需要重新处理任何区块。
HEAD-1：为了避免如果HEAD成为叔块时出现大的重组。
HEAD-127：为了对重新执行的区块数量设置硬性限制。
如果存在快照基础 snapBase，则将其状态Trie写入磁盘。
对于缓存中的任何尚未写入磁盘的Trie节点，从缓存中删除。
检查数据库是否已经清空，如果没有，则记录错误。
关闭Trie数据库，释放所有资源。
打印区块链停止的信息。
func (bc *BlockChain) Stop() {
// 停止区块链服务
// 停止区块链服务但不保存状态快照
bc.stopWithoutSaving()
// 确保将完整的状态快照记录到磁盘中
var snapBase common.Hash
if bc.snaps != nil {
var err error
// 如果存在快照，则记录快照
if snapBase, err = bc.snaps.Journal(bc.CurrentBlock().Root); err != nil {
log.Error("记录状态快照失败", "err", err)
}
bc.snaps.Release() // 释放快照资源
}
// 如果 trie 数据库是基于路径的，则确保将内存中的 trie 节点正确记录到磁盘中
if bc.triedb.Scheme() == rawdb.PathScheme {
if err := bc.triedb.Journal(bc.CurrentBlock().Root); err != nil {
log.Info("记录内存中 trie 节点失败", "err", err)
}
} else {
// 否则，确保最近一个区块的状态也被存储到磁盘中
// 我们写入三种不同的状态以捕获不同的重启场景：
// - HEAD: 这样我们在一般情况下不需要重新处理任何区块
// - HEAD-1: 这样如果我们的 HEAD 成为叔块，我们不会做出大幅度的重组
// - HEAD-127: 这样我们对重新执行的区块数量有一个硬性限制
if !bc.cacheConfig.TrieDirtyDisabled {
triedb := bc.triedb
for _, offset := range []uint64{0, 1, TriesInMemory - 1} {
if number := bc.CurrentBlock().Number.Uint64(); number > offset {
recent := bc.GetBlockByNumber(number - offset)
log.Info("将缓存的状态写入磁盘", "block", recent.Number(), "hash", recent.Hash(), "root", recent.Root())
if err := triedb.Commit(recent.Root(), true); err != nil {
log.Error("提交最近状态 trie 失败", "err", err)
}
}
}
if snapBase != (common.Hash{}) {
log.Info("将快照状态写入磁盘", "root", snapBase)
if err := triedb.Commit(snapBase, true); err != nil {
log.Error("提交快照状态 trie 失败", "err", err)
}
}
// 清理 triegc 中的节点
for !bc.triegc.Empty() {
triedb.Dereference(bc.triegc.PopItem())
}
// 如果 trie 数据库中仍有节点，则输出错误信息
if _, nodes, _ := triedb.Size(); nodes != 0 { // 所有内存都包含在节点返回的 hashdb 中
log.Error("清理后仍存在悬空 trie 节点")
}
}
}
// 关闭 trie 数据库，并在最后一步释放所有资源
if err := bc.triedb.Close(); err != nil {
log.Error("关闭 trie 数据库失败", "err", err)
}
log.Info("区块链服务已停止")
}
下面函数的作用是向区块链中插入收据链（Receipt Chain）。在以太坊区块链中，每个区块都包含一个交易列表，每个交易执行完成后都会生成一个收据（Receipt），收据中包含了交易执行的结果信息，比如合约调用的执行结果、日志等。而收据链则是指一系列区块中的收据的集合。
具体来说，这个函数的主要作用包括：
将收据链插入到区块链中：
该函数接受三个参数：blockChain（区块链中的区块列表）、receiptChain（收据链，与区块链中的区块一一对应）、ancientLimit（古老区块的限制值）。
首先，函数会对提供的区块链进行一些合理性检查，确保区块的顺序和连续性。
然后，根据古老区块的限制值，将区块链分为古老区块和活跃区块。
接着，函数会将古老区块的数据写入古老存储（Ancient Store），活跃区块的数据写入活跃存储（Active Store）。
在写入数据之前，还会进行一些额外的检查和处理，比如验证区块的连续性、更新头部快照等。
最后，函数会输出一些统计信息，比如处理的区块数量、执行时间等。
在插入过程中，还会进行一些额外的处理：
在写入古老存储之前，会检查古老存储中是否已包含 Genesis 区块，如果没有则将 Genesis 区块写入古老存储。
在写入活跃存储之前，会检查活跃存储中是否已存在相同的区块，如果存在则会忽略该区块。
func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain []types.Receipts, ancientLimit uint64) (int, error) {
// 这里我们不需要 chainMu，因为我们希望最大化头部插入和收据插入的并发性。
bc.wg.Add(1) // 增加等待组计数器
defer bc.wg.Done() // 在函数退出时减少等待组计数器
var (
ancientBlocks, liveBlocks types.Blocks // 用于存放古老区块和活跃区块
ancientReceipts, liveReceipts []types.Receipts // 用于存放古老区块和活跃区块对应的收据
)
// 执行一些合理性检查，确保提供的链是有序且连续链接的
for i, block := range blockChain {
if i != 0 {
prev := blockChain[i-1]
// 检查区块号和父哈希是否连续
if block.NumberU64() != prev.NumberU64()+1 || block.ParentHash() != prev.Hash() {
log.Error("非连续的收据插入",
"number", block.Number(), "hash", block.Hash(), "parent", block.ParentHash(),
"prevnumber", prev.Number(), "prevhash", prev.Hash())
return 0, fmt.Errorf("非连续的插入：项目 %d 是 #%d [%x..]，项目 %d 是 #%d [%x..]（父级 [%x..]）",
i-1, prev.NumberU64(), prev.Hash().Bytes()[:4],
i, block.NumberU64(), block.Hash().Bytes()[:4], block.ParentHash().Bytes()[:4])
}
}
// 将区块分为古老区块和活跃区块
if block.NumberU64() <= ancientLimit {
ancientBlocks, ancientReceipts = append(ancientBlocks, block), append(ancientReceipts, receiptChain[i])
} else {
liveBlocks, liveReceipts = append(liveBlocks, block), append(liveReceipts, receiptChain[i])
}
// 在这里还验证区块中的 blob 交易是否包含附属信息。
// 虽然附属信息不影响区块哈希 / 交易哈希，但在一个区块内发送 blob 是不允许的。
for txIndex, tx := range block.Transactions() {
if tx.Type() == types.BlobTxType && tx.BlobTxSidecar() != nil {
return 0, fmt.Errorf("区块 #%d 中的交易索引 %d 包含意外的 blob 附属信息", block.NumberU64(), txIndex)
}
}
}
var (
stats = struct{ processed, ignored int32 }{} // 统计处理的区块数和被忽略的区块数
start = time.Now() // 记录插入开始时间
size = int64(0) // 记录数据大小
)
// 更新头部快照同步区块，如果插入的区块更好，并返回插入的区块是否是主链的指示器。
updateHead := func(head *types.Block) bool {
if !bc.chainmu.TryLock() {
return false
}
defer bc.chainmu.Unlock()
// 如果当前头部快照的区块号大于等于插入的区块号，则跳过
if bc.CurrentHeader().Number.Cmp(head.Number()) >= 0 {
// 如果发生重组，则跳过
reorg, err := bc.forker.ReorgNeeded(bc.CurrentSnapBlock(), head.Header())
if err != nil {
log.Warn("重组失败", "err", err)
return false
} else if !reorg {
return false
}
rawdb.WriteHeadFastBlockHash(bc.db, head.Hash())
bc.currentSnapBlock.Store(head.Header())
headFastBlockGauge.Update(int64(head.NumberU64()))
return true
}
return false
}
// 将区块链和对应的收据链写入古老存储
writeAncient := func(blockChain types.Blocks, receiptChain []types.Receipts) (int, error) {
first := blockChain[0] // 古老区块链的第一个区块
last := blockChain[len(blockChain)-1] // 古老区块链的最后一个区块
// 确保 genesis 区块在古老存储中
if first.NumberU64() == 1 {
if frozen, _ := bc.db.Ancients(); frozen == 0 {
td := bc.genesisBlock.Difficulty()
writeSize, err := rawdb.WriteAncientBlocks(bc.db, []*types.Block{bc.genesisBlock}, []types.Receipts{nil}, td)
if err != nil {
log.Error("将 genesis 写入古老存储失败", "err", err)
return 0, err
}
size += writeSize
log.Info("已将 genesis 写入古老存储")
}
}
// 在将区块写入古老存储之前，我们需要确保它们与头部链的预期一致。
// 我们只检查最后一个区块/头部，因为它是一个连续的链。
if !bc.HasHeader(last.Hash(), last.NumberU64()) {
return 0, fmt.Errorf("包含头部 #%d [%x..] 未知", last.Number(), last.Hash().Bytes()[:4])
}
// 将所有链数据写入古老存储
td := bc.GetTd(first.Hash(), first.NumberU64()) // 获取古老区块链的总难度
writeSize, err := rawdb.WriteAncientBlocks(bc.db, blockChain, receiptChain, td)
if err != nil {
log.Error("将链数据导入古老存储失败", "err", err)
return 0, err
}
size += writeSize
// 显式同步古老存储，以确保所有数据已刷新到磁盘。
if err := bc.db.Sync(); err != nil {
return 0, err
}
// 更新当前快照区块，因为所有区块数据现在都存在于 DB 中。
previousSnapBlock := bc.CurrentSnapBlock().Number.Uint64()
if !updateHead(blockChain[len(blockChain)-1]) {
// 如果头部链发生了重组，并且区块/收据与主链不匹配，则进入此处。
if _, err := bc.db.TruncateHead(previousSnapBlock + 1); err != nil {
log.Error("无法在插入失败后截断古老存储", "err", err)
}
return 0, errSideChainReceipts
}
// 从主数据库中删除区块数据
var (
batch = bc.db.NewBatch()
canonHashes = make(map[common.Hash]struct{}) // 存放主链区块哈希
)
for _, block := range blockChain {
canonHashes[block.Hash()] = struct{}{}
if block.NumberU64() == 0 {
continue
}
rawdb.DeleteCanonicalHash(batch, block.NumberU64())
rawdb.DeleteBlockWithoutNumber(batch, block.Hash(), block.NumberU64())
}
// 删除侧链哈希到编号的映射
for _, nh := range rawdb.ReadAllHashesInRange(bc.db, first.NumberU64(), last.NumberU64()) {
if _, canon := canonHashes[nh.Hash]; !canon {
rawdb.DeleteHeader(batch, nh.Hash, nh.Number)
}
}
if err := batch.Write(); err != nil {
return 0, err
}
stats.processed += int32(len(blockChain))
return 0, nil
}
// 将下载的链数据和对应的收据链数据写入古老存储和活跃存储
if len(ancientBlocks) > 0 {
if n, err := writeAncient(ancientBlocks, ancientReceipts); err != nil {
if err == errInsertionInterrupted {
return 0, nil
}
return n, err
}
}
if len(liveBlocks) > 0 {
if n, err := writeLive(liveBlocks, liveReceipts); err != nil {
if err == errInsertionInterrupted {
return 0, nil
}
return n, err
}
}
var (
head = blockChain[len(blockChain)-1]
context = []interface{}{
"count", stats.processed, "elapsed", common.PrettyDuration(time.Since(start)),
"number", head.Number(), "hash", head.Hash(), "age", common.PrettyAge(time.Unix(int64(head.Time()), 0)),
"size", common.StorageSize(size),
}
)
if stats.ignored > 0 {
context = append(context, []interface{}{"ignored", stats.ignored}...)
}
log.Debug("导入新区块收据", context...)
return 0, nil
}
下面函数是将带有状态的区块写入区块链中，并将相关状态信息存储到数据库中：
func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.Receipt, state *state.StateDB) error {
// 计算区块的总难度
ptd := bc.GetTd(block.ParentHash(), block.NumberU64()-1)
if ptd == nil {
return consensus.ErrUnknownAncestor // 如果父区块的总难度为空，则返回错误
}
// 确保在插入期间不会泄露不一致的状态
externTd := new(big.Int).Add(block.Difficulty(), ptd)
// 不考虑规范状态，将区块本身写入数据库。
// 注意：所有区块组件（总难度、哈希->编号映射、头部、主体、收据）都应原子化地写入。
// BlockBatch 用于包含所有组件。
blockBatch := bc.db.NewBatch()
rawdb.WriteTd(blockBatch, block.Hash(), block.NumberU64(), externTd) // 写入总难度
rawdb.WriteBlock(blockBatch, block) // 写入区块
rawdb.WriteReceipts(blockBatch, block.Hash(), block.NumberU64(), receipts) // 写入收据
rawdb.WritePreimages(blockBatch, state.Preimages()) // 写入预映像
if err := blockBatch.Write(); err != nil {
log.Crit("Failed to write block into disk", "err", err) // 如果写入失败，记录关键错误
}
// 将所有缓存的状态更改提交到底层内存数据库
root, err := state.Commit(block.NumberU64(), bc.chainConfig.IsEIP158(block.Number())) // 提交状态更改
if err != nil {
return err // 如果提交失败，返回错误
}
// 如果节点运行在路径模式下，跳过显式的垃圾回收操作，因为在此模式下是不必要的
if bc.triedb.Scheme() == rawdb.PathScheme {
return nil
}
// 如果节点运行在存档模式下，始终执行刷新
if bc.cacheConfig.TrieDirtyDisabled {
return bc.triedb.Commit(root, false) // 将根哈希提交到数据库
}
// 如果节点不是运行在存档模式下，进行适当的垃圾回收操作
// 引用根哈希以保持状态树存活
bc.triedb.Reference(root, common.Hash{})
// 将根哈希和区块号压入垃圾回收器
bc.triegc.Push(root, -int64(block.NumberU64()))
// 不考虑前TriesInMemory块的刷新限制
current := block.NumberU64()
if current <= TriesInMemory {
return nil
}
// 如果超出了内存限制，将成熟的单例节点刷新到磁盘
var (
_, nodes, imgs = bc.triedb.Size() // 所有内存都包含在节点返回的大小中
limit = common.StorageSize(bc.cacheConfig.TrieDirtyLimit) * 1024 * 1024
)
if nodes > limit || imgs > 4*1024*1024 {
bc.triedb.Cap(limit - ethdb.IdealBatchSize) // 限制内存使用
}
// 查找下一个需要提交的状态树
chosen := current - TriesInMemory
flushInterval := time.Duration(bc.flushInterval.Load())
// 如果超过时间允许的范围，刷新整个状态树到磁盘
if bc.gcproc > flushInterval {
// 如果缺少头部（规范链后面的标头），则正在重新组织低难度侧链。暂停提交直到此操作完成。
header := bc.GetHeaderByNumber(chosen)
if header == nil {
log.Warn("Reorg in progress, trie commit postponed", "number", chosen)
} else {
// 如果超过限制但尚未达到足够大的内存差距，警告用户系统正在变得不稳定
if chosen < bc.lastWrite+TriesInMemory && bc.gcproc >= 2*flushInterval {
log.Info("State in memory for too long, committing", "time", bc.gcproc, "allowance", flushInterval, "optimum", float64(chosen-bc.lastWrite)/TriesInMemory)
}
// 刷新整个状态树并重置计数器
bc.triedb.Commit(header.Root, true)
bc.lastWrite = chosen
bc.gcproc = 0
}
}
// 回收低于所需写入保留量的任何内容
for !bc.triegc.Empty() {
root, number := bc.triegc.Pop()
if uint64(-number) > chosen {
bc.triegc.Push(root, number)
break
}
bc.triedb.Dereference(root)
}
return nil
}
下面是将一组区块插入到区块链中。它负责验证、处理和导入给定链的区块，并根据需要设置链的头部：
func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool) (int, error) {
// 如果链已经被终止，则不执行导入操作
if bc.insertStopped() {
return 0, nil
}
// 启动并行签名恢复（在分叉转换时签名者可能会失败，性能损失最小）
SenderCacher.RecoverFromBlocks(types.MakeSigner(bc.chainConfig, chain[0].Number(), chain[0].Time()), chain)
var (
stats = insertStats{startTime: mclock.Now()} // 插入统计信息
lastCanon *types.Block // 最后一个确定的区块
)
// 在返回之前，发送一个链头事件，如果我们推进了链
defer func() {
if lastCanon != nil && bc.CurrentBlock().Hash() == lastCanon.Hash() {
bc.chainHeadFeed.Send(ChainHeadEvent{lastCanon})
}
}()
// 启动并行头部验证
headers := make([]*types.Header, len(chain))
for i, block := range chain {
headers[i] = block.Header()
}
abort, results := bc.engine.VerifyHeaders(bc, headers)
defer close(abort)
// 获取第一个区块并检查错误，以决定导入逻辑的方向
it := newInsertIterator(chain, results, bc.validator)
block, err := it.next()
// 如果导入链不需要构建快照，则跳过已知区块
if bc.skipBlock(err, it) {
// 第一个区块（和状态）已知
// 1. 我们进行了回滚，并且现在应该重新导入
// 2. 区块被存储为侧链，并且它在其状态根上说谎，并且通过了状态根
// 来自尚未验证的规范链，这是不一致的。
// 跳过我们后面已知的区块。
var (
reorg bool
current = bc.CurrentBlock()
)
for block != nil && bc.skipBlock(err, it) {
reorg, err = bc.forker.ReorgNeeded(current, block.Header())
if err != nil {
return it.index, err
}
if reorg {
// 如果分叉器表示重新组织是必要的，则切换到导入模式
// 并且区块不在规范链上。
// 在 eth2 中，分叉器总是返回 true 以进行重新组织决策
// （盲目信任外部共识引擎），但为了避免导入已知块时不必要的重新组织，
// 这里处理特殊情况。
if block.NumberU64() > current.Number.Uint64() || bc.GetCanonicalHash(block.NumberU64()) != block.Hash() {
break
}
}
log.Debug("忽略已知区块", "number", block.Number(), "hash", block.Hash())
stats.ignored++
block, err = it.next()
}
// 跳转到区块导入
}
switch {
case errors.Is(err, consensus.ErrPrunedAncestor):
// 第一个块已被修剪
if setHead {
// 第一个块已修剪，将其插入为侧链，只有在 TD 增长足够时才重新组织
log.Debug("修剪的祖先，插入为侧链", "number", block.Number(), "hash", block.Hash())
return bc.insertSideChain(block, it)
} else {
// 我们已经合并并且父块已被修剪，尝试恢复父状态
log.Debug("修剪的祖先", "number", block.Number(), "hash", block.Hash())
_, err := bc.recoverAncestors(block)
return it.index, err
}
case err != nil && !errors.Is(err, ErrKnownBlock):
// 发生了其他错误（除了 ErrKnownBlock），中止
stats.ignored += len(it.chain)
bc.reportBlock(block, nil, err)
return it.index, err
}
// 没有验证错误的第一个块（或跳过了链前缀）
var activeState *state.StateDB
defer func() {
// 区块导入过程中，该函数启动和停止了预取器。
// 如果发生了坏块或其他错误，可能会导致早期返回不正确地终止后台线程。
// 此延迟确保我们清理悬挂的预取器，而不需要每次延迟一个都持有活动引用。
if activeState != nil {
activeState.StopPrefetcher()
}
}()
for ; block != nil && err == nil || errors.Is(err, ErrKnownBlock); block, err = it.next() {
// 如果链已终止，则停止处理区块
if bc.insertStopped() {
log.Debug("区块处理过程中中止")
break
}
// 如果头部是被禁止的，则直接中止
if BadHashes[block.Hash()] {
bc.reportBlock(block, nil, ErrBannedHash)
return it.index, ErrBannedHash
}
// 如果区块是已知的（在链中间），这是 Clique 区块的特殊情况，
// 它们可以共享彼此之间的状态，因此导入旧区块可能完成后续区块的状态。
// 在这种情况下，只需跳过区块（我们已经完全验证过了它们一次，因为它们的头部和主体已经在数据库中）。
// 但是，如果缺少对应的快照层，可能需要强制重新执行以构建它。
if bc.skipBlock(err, it) {
logger := log.Debug
if bc.chainConfig.Clique == nil {
logger = log.Warn
}
logger("插入已知区块", "number", block.Number(), "hash", block.Hash(),
"uncles", len(block.Uncles()), "txs", len(block.Transactions()), "gas", block.GasUsed(),
"root", block.Root())
// 特殊情况。如果我们在链中间遇到已知块，那么就提交空的 receipt 切片。
// 它只能在 Clique 链中发生。每当我们通过 `insertSideChain` 插入块时，
// 我们只提交 `td`、`header` 和 `body`（如果不存在的话）。由于我们没有
// 事务而没有收据，所以没有什么可提交的。但是如果侧链最终会被采纳为规范链，
// 那么它需要重新执行以获得丢失的状态，但如果是这种特殊情况（跳过重新执行），
// 我们将丢失空收据条目。
if len(block.Transactions()) == 0 {
rawdb.WriteReceipts(bc.db, block.Hash(), block.NumberU64(), nil)
} else {
log.Error("请提交问题，跳过已知块执行而没有收据",
"hash", block.Hash(), "number", block.NumberU64())
}
if err := bc.writeKnownBlock(block); err != nil {
return it.index, err
}
stats.processed++
if bc.logger != nil && bc.logger.OnSkippedBlock != nil {
bc.logger.OnSkippedBlock(tracing.BlockEvent{
Block: block,
TD: bc.GetTd(block.ParentHash(), block.NumberU64()-1),
Finalized: bc.CurrentFinalBlock(),
Safe: bc.CurrentSafeBlock(),
})
}
// 在这里我们可以假定日志为空，因为连续的 Clique 区块共享状态的唯一方式是没有交易。
lastCanon = block
continue
}
// 获取父区块及其状态以在其上执行
start := time.Now()
parent := it.previous()
if parent == nil {
parent = bc.GetHeader(block.ParentHash(), block.NumberU64()-1)
}
statedb, err := state.New(parent.Root, bc.stateCache, bc.snaps)
if err != nil {
return it.index, err
}
statedb.SetLogger(bc.logger)
// 启用预取以在处理事务时拉取 Trie 节点路径
statedb.StartPrefetcher("chain")
activeState = statedb
// 如果有后续区块，则根据当前状态运行以预缓存事务和概率性地一些账户/存储 Trie 节点。
var followupInterrupt atomic.Bool
if !bc.cacheConfig.TrieCleanNoPrefetch {
if followup, err := it.peek(); followup != nil && err == nil {
throwaway, _ := state.New(parent.Root, bc.stateCache, bc.snaps)
go func(start time.Time, followup *types.Block, throwaway *state.StateDB) {
// 对预取执行禁用跟踪。
vmCfg := bc.vmConfig
vmCfg.Tracer = nil
bc.prefetcher.Prefetch(followup, throwaway, vmCfg, &followupInterrupt)
blockPrefetchExecuteTimer.Update(time.Since(start))
if followupInterrupt.Load() {
blockPrefetchInterruptMeter.Mark(1)
}
}(time.Now(), followup, throwaway)
}
}
// 区块导入的跟踪部分
res, err := bc.processBlock(block, statedb, start, setHead)
followupInterrupt.Store(true)
if err != nil {
return it.index, err
}
// 在返回各种结果之前报告导入统计信息
stats.processed++
stats.usedGas += res.usedGas
var snapDiffItems, snapBufItems common.StorageSize
if bc.snaps != nil {
snapDiffItems, snapBufItems = bc.snaps.Size()
}
trieDiffNodes, trieBufNodes, _ := bc.triedb.Size()
stats.report(chain, it.index, snapDiffItems, snapBufItems, trieDiffNodes, trieBufNodes, setHead)
if !setHead {
// 在合并后，我们预期很少的侧链。只计数
// CL 提供给我们的所有块，以用于 GC 处理时间
bc.gcproc += res.procTime
return it.index, nil // 直接插入单个块
}
switch res.status {
case CanonStatTy:
log.Debug("插入新块", "number", block.Number(), "hash", block.Hash(),
"uncles", len(block.Uncles()), "txs", len(block.Transactions()), "gas", block.GasUsed(),
"elapsed", common.PrettyDuration(time.Since(start)),
"root", block.Root())
lastCanon = block
// 仅对规范块计数以进行 GC 处理时间
bc.gcproc += res.procTime
case SideStatTy:
log.Debug("插入分叉块", "number", block.Number(), "hash", block.Hash(),
"diff", block.Difficulty(), "elapsed", common.PrettyDuration(time.Since(start)),
"txs", len(block.Transactions()), "gas", block.GasUsed(), "uncles", len(block.Uncles()),
"root", block.Root())
default:
// 理论上不可能，但是为了我们将来的自己，还是留下一条日志，
// 而不是尝试追踪不发出日志的块导入。
log.Warn("插入具有未知状态的块", "number", block.Number(), "hash", block.Hash(),
"diff", block.Difficulty(), "elapsed", common.PrettyDuration(time.Since(start)),
"txs", len(block.Transactions()), "gas", block.GasUsed(), "uncles", len(block.Uncles()),
"root", block.Root())
}
}
stats.ignored += it.remaining()
return it.index, err
}
结构体 blockProcessingResult 用于表示处理区块的结果，它包含了以下字段：
usedGas uint64：表示处理该区块时消耗的燃气数量（Gas）。在以太坊区块链中，Gas 是执行智能合约和交易时所需支付的手续费。这个字段记录了执行区块中的交易所消耗的 Gas 数量。
procTime time.Duration：表示处理该区块所花费的时间。这个字段记录了处理区块的时间长度，以 time.Duration 类型表示。
status WriteStatus：表示处理该区块的结果状态。WriteStatus 是一个枚举类型，可能的取值有 CanonStatTy（表示这个区块是规范的，是区块链上的主要分支）、SideStatTy（表示这个区块是分叉的，不是区块链的主要分支）、以及其他可能的状态。
得到区块后通过下面的函数来处理，包括下面的操作：
调用处理器（bc.processor）处理区块，执行区块中的交易，并返回区块的收据（receipts）、日志（logs）、消耗的 Gas 数量（usedGas）以及可能的错误（err）。
调用验证器（bc.validator）验证区块的状态，确保区块中的交易执行正确，并根据验证结果更新相应的指标。
将处理后的区块写入到区块链中，并设置新的区块头（如果 setHead 参数为 true）。
更新与区块处理相关的度量指标，如账户读取、存储读取、账户更新、存储更新、区块执行时间、区块验证时间等。
返回处理结果，包括使用的 Gas 数量、处理时间以及区块写入状态。
func (bc *BlockChain) processBlock(block *types.Block, statedb *state.StateDB, start time.Time, setHead bool) (_ *blockProcessingResult, blockEndErr error) {
// 如果日志记录器存在且存在块启动事件回调函数
if bc.logger != nil && bc.logger.OnBlockStart != nil {
// 获取区块的父区块的难度
td := bc.GetTd(block.ParentHash(), block.NumberU64()-1)
// 触发块启动事件回调
bc.logger.OnBlockStart(tracing.BlockEvent{
Block: block, // 当前区块
TD: td, // 父区块的难度
Finalized: bc.CurrentFinalBlock(), // 当前已经最终化的区块
Safe: bc.CurrentSafeBlock(), // 当前已经安全的区块
})
}
// 如果日志记录器存在且存在块结束事件回调函数
if bc.logger != nil && bc.logger.OnBlockEnd != nil {
// 在函数返回时触发块结束事件回调
defer func() {
bc.logger.OnBlockEnd(blockEndErr)
}()
}
// 使用父状态为参考点处理区块
pstart := time.Now() // 记录处理开始时间
// 调用处理器处理区块，执行区块中的交易，获取收据、日志、使用的 Gas 数量和可能的错误
receipts, logs, usedGas, err := bc.processor.Process(block, statedb, bc.vmConfig)
if err != nil {
// 如果处理过程中发生错误，报告区块处理错误并返回错误
bc.reportBlock(block, receipts, err)
return nil, err
}
ptime := time.Since(pstart) // 记录处理时间
vstart := time.Now() // 记录验证开始时间
// 验证区块状态，确保区块中的交易执行正确
if err := bc.validator.ValidateState(block, statedb, receipts, usedGas); err != nil {
// 如果验证过程中发生错误，报告区块验证错误并返回错误
bc.reportBlock(block, receipts, err)
return nil, err
}
vtime := time.Since(vstart) // 记录验证时间
proctime := time.Since(start) // 计算总的处理时间（处理时间 + 验证时间）
// 更新区块处理和验证期间涉及的度量指标
accountReadTimer.Update(statedb.AccountReads) // 账户读取已完成（在处理中）
storageReadTimer.Update(statedb.StorageReads) // 存储读取已完成（在处理中）
snapshotAccountReadTimer.Update(statedb.SnapshotAccountReads) // 账户读取已完成（在处理中）
snapshotStorageReadTimer.Update(statedb.SnapshotStorageReads) // 存储读取已完成（在处理中）
accountUpdateTimer.Update(statedb.AccountUpdates) // 账户更新已完成（在验证中）
storageUpdateTimer.Update(statedb.StorageUpdates) // 存储更新已完成（在验证中）
accountHashTimer.Update(statedb.AccountHashes) // 账户哈希已完成（在验证中）
storageHashTimer.Update(statedb.StorageHashes) // 存储哈希已完成（在验证中）
triehash := statedb.AccountHashes + statedb.StorageHashes // 用于哈希的 tries 的时间
trieUpdate := statedb.AccountUpdates + statedb.StorageUpdates // 用于更新的 tries 的时间
trieRead := statedb.SnapshotAccountReads + statedb.AccountReads // 用于账户读取的 tries 的时间
trieRead += statedb.SnapshotStorageReads + statedb.StorageReads // 用于存储读取的 tries 的时间
blockExecutionTimer.Update(ptime - trieRead) // 区块执行的时间（除去 trie 读取时间）
blockValidationTimer.Update(vtime - (triehash + trieUpdate)) // 区块验证的时间（除去哈希和更新时间）
// 将区块写入链中并获取状态
var (
wstart = time.Now() // 记录写入开始时间
status WriteStatus // 写入状态
)
if !setHead {
// 不设置头，仅插入区块
err = bc.writeBlockWithState(block, receipts, statedb)
} else {
// 设置头并插入区块
status, err = bc.writeBlockAndSetHead(block, receipts, logs, statedb, false)
}
if err != nil {
return nil, err
}
// 更新写入期间涉及的度量指标
accountCommitTimer.Update(statedb.AccountCommits) // 账户提交已完成，可以标记
storageCommitTimer.Update(statedb.StorageCommits) // 存储提交已完成，可以标记
snapshotCommitTimer.Update(statedb.SnapshotCommits) // 快照提交已完成，可以标记
triedbCommitTimer.Update(statedb.TrieDBCommits) // tries 数据库提交已完成，可以标记
// 更新区块写入时间指标
blockWriteTimer.Update(time.Since(wstart) - statedb.AccountCommits - statedb.StorageCommits - statedb.SnapshotCommits - statedb.TrieDBCommits)
// 更新区块插入时间指标
blockInsertTimer.UpdateSince(start)
// 返回区块处理结果，包括使用的 Gas 数量、处理时间和写入状态
return &blockProcessingResult{usedGas: usedGas, procTime: proctime, status: status}, nil
}
侧链区块是指与主链区块无关的区块，可能因为某些原因被裁减或分叉，以太坊需要对这些区块进行处理，
验证侧链区块的状态和难度，并根据情况更新外部总难度。
将侧链区块写入磁盘，同时记录区块相关信息，如交易数量、Gas消耗等。
如果外部总难度大于本地总难度，可能需要重新导入之前被裁剪的区块以重新生成所需的状态。
最后，该函数将导入侧链区块的信息记录下来，以便后续参考。
func (bc *BlockChain) insertSideChain(block *types.Block, it *insertIterator) (int, error) {
var (
externTd *big.Int // 外部总难度，用于存储外部链上当前区块的总难度
lastBlock = block // 最后一个处理的区块，默认为当前区块
current = bc.CurrentBlock() // 当前主链上的最新区块
)
// 第一个侧链区块的错误已经被验证为 ErrPrunedAncestor。
// 由于我们在这里不导入它们，因此我们期望对于剩余的侧链区块会出现 ErrUnknownAncestor 错误。
// 任何其他错误意味着该区块无效，不应写入磁盘。
err := consensus.ErrPrunedAncestor
for ; block != nil && errors.Is(err, consensus.ErrPrunedAncestor); block, err = it.next() {
// 检查该编号的规范状态根
if number := block.NumberU64(); current.Number.Uint64() >= number {
canonical := bc.GetBlockByNumber(number)
if canonical != nil && canonical.Hash() == block.Hash() {
// 不是侧链区块，这是一个重新导入的正常区块，其状态已被裁剪
// 收集该区块的难度。由于我们知道它是一个正常区块，
// 我们可以直接获取它，而不是像下面的方式那样使用父区块，然后在其上添加该区块
externTd = bc.GetTd(block.Hash(), block.NumberU64())
continue
}
if canonical != nil && canonical.Root() == block.Root() {
// 这很可能是一个影子状态攻击。当一个分叉被导入到数据库中，并且最终达到一个未裁剪的区块高度时，
// 我们刚刚发现状态已经存在！这意味着侧链区块引用的状态已经存在于我们的主链中。
//
// 如果不检查，我们现在将继续导入区块，而没有实际验证以前区块的状态。
log.Warn("侧链影子状态攻击检测到", "编号", block.NumberU64(), "侧链根", block.Root(), "主链根", canonical.Root())
// 如果有人合法地侧矿块，它们仍然会像往常一样被导入。然而，
// 当我们明显的目标是裁剪机制时，我们不能冒险写入未经验证的区块到磁盘上。
return it.index, errors.New("侧链影子状态攻击")
}
}
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()) {
start := time.Now()
if err := bc.writeBlockWithoutState(block, externTd); err != nil {
return it.index, err
}
log.Debug("注入侧链区块", "编号", block.Number(), "哈希", block.Hash(),
"难度", block.Difficulty(), "经过时间", common.PrettyDuration(time.Since(start)),
"交易数", len(block.Transactions()), "gas消耗", block.GasUsed(), "叔块数", len(block.Uncles()),
"根", block.Root())
}
lastBlock = block
}
// 此时，我们已将所有侧链区块写入数据库。循环要么在其他错误上结束，要么全部被处理。
// 如果出现其他错误，我们可以忽略剩余的区块。
//
// 如果 externTd 大于我们的本地总难度，则需要重新导入之前的区块以重新生成所需的状态
reorg, err := bc.forker.ReorgNeeded(current, lastBlock.Header())
if err != nil {
return it.index, err
}
if !reorg {
localTd := bc.GetTd(current.Hash(), current.Number.Uint64())
log.Info("侧链已写入磁盘", "开始", it.first().NumberU64(), "结束", it.previous().Number, "侧链总难度", externTd, "本地总难度", localTd)
return it.index, err
}
// 收集所有侧链哈希（完整区块可能会占用大量内存）
var (
hashes []common.Hash
numbers []uint64
)
parent := it.previous()
for parent != nil && !bc.HasState(parent.Root) {
if bc.stateRecoverable(parent.Root) {
if err := bc.triedb.Recover(parent.Root); err != nil {
return 0, err
}
break
}
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, errors.New("缺少父区块")
}
// 导入所有被裁剪的区块以使状态可用
var (
blocks []*types.Block
memory uint64
)
for i := len(hashes) - 1; i >= 0; i-- {
// 将下一个区块追加到我们的批处理中
block := bc.GetBlock(hashes[i], numbers[i])
blocks = append(blocks, block)
memory += block.Size()
// 如果内存使用量增长太大，则导入并继续。遗憾的是，我们需要丢弃
// 由于内存使用过重，此处的所有事件和日志通知。
if len(blocks) >= 2048 || memory > 64*1024*1024 {
log.Info("导入重量级侧链片段", "区块数", len(blocks), "开始", blocks[0].NumberU64(), "结束", block.NumberU64())
if _, err := bc.insertChain(blocks, true); err != nil {
return 0, err
}
blocks, memory = blocks[:0], 0
// 如果链正在终止，停止处理区块
if bc.insertStopped() {
log.Debug("在处理区块时中止")
return 0, nil
}
}
}
if len(blocks) > 0 {
log.Info("导入侧链片段", "开始", blocks[0].NumberU64(), "结束", blocks[len(blocks)-1].NumberU64())
return bc.insertChain(blocks, true)
}
return 0, nil
}
当发生分叉时，需要重新组织区块链，需要执行的操作如下：
确定两条链的共同祖先块（commonBlock）。
根据共同祖先块，将两条链分为旧链（oldChain）和新链（newChain）。
将旧链上的所有块标记为已删除，并收集旧链上的所有交易。
将新链上的所有块标记为待添加，并收集新链上的所有交易。
发送链事件，通知有关旧链和新链的变化。
更新交易查找缓存，以清除过时的交易查找。
将新链（除了头块）按正确的增量顺序插入到链中。
删除无用的索引，包括非规范交易索引和超过头部的规范链索引。
发送事件以通知删除的日志和新增的日志。
func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Block) error {
var (
newChain types.Blocks // 新链
oldChain types.Blocks // 旧链
commonBlock *types.Block // 共同祖先块
deletedTxs []common.Hash // 已删除的交易哈希列表
addedTxs []common.Hash // 待添加的交易哈希列表
)
// 获取旧链和新链的头块
oldBlock := bc.GetBlock(oldHead.Hash(), oldHead.Number.Uint64())
if oldBlock == nil {
return errors.New("current head block missing") // 当前头块缺失
}
newBlock := newHead
// 将较长的链缩短为与较短链相同数量的块
if oldBlock.NumberU64() > newBlock.NumberU64() {
// 旧链更长，收集所有交易和日志作为已删除项
for ; oldBlock != nil && oldBlock.NumberU64() != newBlock.NumberU64(); oldBlock = bc.GetBlock(oldBlock.ParentHash(), oldBlock.NumberU64()-1) {
oldChain = append(oldChain, oldBlock)
for _, tx := range oldBlock.Transactions() {
deletedTxs = append(deletedTxs, tx.Hash())
}
}
} else {
// 新链更长，保存所有块以供后续插入
for ; newBlock != nil && newBlock.NumberU64() != oldBlock.NumberU64(); newBlock = bc.GetBlock(newBlock.ParentHash(), newBlock.NumberU64()-1) {
newChain = append(newChain, newBlock)
}
}
// 确保旧链块不为空
if oldBlock == nil {
return errInvalidOldChain // 无效的旧链
}
if newBlock == nil {
return errInvalidNewChain // 无效的新链
}
// 两边的链达到相同数量后，继续缩短直到找到共同祖先块
for {
// 如果找到了共同祖先块，则退出循环
if oldBlock.Hash() == newBlock.Hash() {
commonBlock = oldBlock
break
}
// 将旧块移除，并将新块存储起来
oldChain = append(oldChain, oldBlock)
for _, tx := range oldBlock.Transactions() {
deletedTxs = append(deletedTxs, tx.Hash())
}
newChain = append(newChain, newBlock)
// 同时将两边的链向前移动一步
oldBlock = bc.GetBlock(oldBlock.ParentHash(), oldBlock.NumberU64()-1)
if oldBlock == nil {
return errInvalidOldChain // 无效的旧链
}
newBlock = bc.GetBlock(newBlock.ParentHash(), newBlock.NumberU64()-1)
if newBlock == nil {
return errInvalidNewChain // 无效的新链
}
}
// 确保用户看到大的链重组
if len(oldChain) > 0 && len(newChain) > 0 {
logFn := log.Info
msg := "Chain reorg detected" // 检测到链重组
if len(oldChain) > 63 {
msg = "Large chain reorg detected" // 检测到大型链重组
logFn = log.Warn
}
logFn(msg, "number", commonBlock.Number(), "hash", commonBlock.Hash(),
"drop", len(oldChain), "dropfrom", oldChain[0].Hash(), "add", len(newChain), "addfrom", newChain[0].Hash())
blockReorgAddMeter.Mark(int64(len(newChain)))
blockReorgDropMeter.Mark(int64(len(oldChain)))
blockReorgMeter.Mark(1)
} else if len(newChain) > 0 {
// 特殊情况发生在后续合并阶段，当前头块是新头块的祖先，但这两个块不是连续的
log.Info("Extend chain", "add", len(newChain), "number", newChain[0].Number(), "hash", newChain[0].Hash())
blockReorgAddMeter.Mark(int64(len(newChain)))
} else {
// len(newChain) == 0 && len(oldChain) > 0
// 将规范链倒回到较低的位置。
log.Error("Impossible reorg, please file an issue", "oldnum", oldBlock.Number(), "oldhash", oldBlock.Hash(), "oldblocks", len(oldChain), "newnum", newBlock.Number(), "newhash", newBlock.Hash(), "newblocks", len(newChain))
}
// 在写入新链数据之前，重置交易查找缓存，以清除过时的交易查找。
bc.txLookupCache.Purge()
// 将新链（除了头块）按适当的增量顺序插入链中。
for i := len(newChain) - 1; i >= 1; i-- {
// 按照规范的方式插入块，重写历史记录
bc.writeHeadBlock(newChain[i])
// 收集新添加的交易
for _, tx := range newChain[i].Transactions() {
addedTxs = append(addedTxs, tx.Hash())
}
}
// 删除无用的索引，包括非规范交易索引和超过头部的规范链索引。
var (
indexesBatch = bc.db.NewBatch()
diffs = types.HashDifference(deletedTxs, addedTxs)
)
for _, tx := range diffs {
rawdb.DeleteTxLookupEntry(indexesBatch, tx)
}
// 删除所有不属于新规范链的哈希标记。
number := commonBlock.NumberU64()
if len(newChain) > 1 {
number = newChain[1].NumberU64()
}
for i := number + 1; ; i++ {
hash := rawdb.ReadCanonicalHash(bc.db, i)
if hash == (common.Hash{}) {
break
}
rawdb.DeleteCanonicalHash(indexesBatch, i)
}
if err := indexesBatch.Write(); err != nil {
log.Crit("Failed to delete useless indexes", "err", err)
}
// 发送事件以通知删除的日志和新增的日志。
// 已删除的日志 + 块：
var deletedLogs []*types.Log
for i := len(oldChain) - 1; i >= 0; i-- {
// 也为从规范链中删除的块发送事件。
bc.chainSideFeed.Send(ChainSideEvent{Block: oldChain[i]})
// 收集已删除日志以进行通知
if logs := bc.collectLogs(oldChain[i], true); len(logs) > 0 {
deletedLogs = append(deletedLogs, logs...)
}
if len(deletedLogs) > 512 {
bc.rmLogsFeed.Send(RemovedLogsEvent{deletedLogs})
deletedLogs = nil
}
}
if len(deletedLogs) > 0 {
bc.rmLogsFeed.Send(RemovedLogsEvent{deletedLogs})
}
// 新日志：
var rebirthLogs []*types.Log
for i := len(newChain) - 1; i >= 1; i-- {
if logs := bc.collectLogs(newChain[i], false); len(logs) > 0 {
rebirthLogs = append(rebirthLogs, logs...)
}
if len(rebirthLogs) > 512 {
bc.logsFeed.Send(rebirthLogs)
rebirthLogs = nil
}
}
if len(rebirthLogs) > 0 {
bc.logsFeed.Send(rebirthLogs)
}
return nil
}
最后给出其他函数的功能说明：
| 函数签名 | 说明 |
|---|---|
| func (bc *BlockChain) empty() bool | 区块链是不是空的 |
| func (bc *BlockChain) SetHead(head uint64) error | 修改区块的id |
| func (bc *BlockChain) SetHeadWithTimestamp(timestamp uint64) error | 根据时间戳设置区块头 |
| func (bc *BlockChain) SetFinalized(header *types.Header) | 更新区块链的最终化区块，并将相关信息写入数据库 |
| func (bc *BlockChain) SetSafe(header *types.Header) | 设置安全区块（经过指定数目区块确认） |
| func (bc *BlockChain) rewindHashHead(head types.Header, root common.Hash) (types.Header, uint64) | 在区块链中找到一个新的链头，以便在区块链的状态发生变化或重新组织时进行更新（哈希方案） |
| func (bc *BlockChain) rewindPathHead(head types.Header, root common.Hash) (types.Header, uint64) | 在区块链中找到一个新的链头，以便在区块链的状态发生变化或重新组织时进行更新（路径方案） |
| func (bc *BlockChain) rewindHead(head types.Header, root common.Hash) (types.Header, uint64) | 根据方案（路径方案或哈希方案）调用相应的链头回溯函数 |
| func (bc *BlockChain) SnapSyncCommitHead(hash common.Hash) error | 在进行快照同步时提交链的头部 |
| func (bc *BlockChain) Reset() error | 函数的作用是清除整个区块链，将其恢复到创世状态 |
| func (bc *BlockChain) ResetWithGenesisBlock(genesis *types.Block) error | 将活动链导出到给定的写入器 |
| func (bc *BlockChain) Export(w io.Writer) error | 将活动链导出到给定的写入器 |
| func (bc *BlockChain) ExportN(w io.Writer, first uint64, last uint64) error | 将活动链的子集导出到给定的写入器，指定区间 |
| func (bc *BlockChain) writeHeadBlock(block *types.Block) | 更新链的索引和标记，将指定的区块设置为链的头部块 |
| func (bc *BlockChain) stopWithoutSaving() | 停止区块链服务，但不执行保存数据的后续工作 |
| func (bc *BlockChain) StopInsert() | 停止区块链的插入过程 |
| func (bc *BlockChain) insertStopped() bool | 检查插入过程是否已经停止 |
| func (bc *BlockChain) writeBlockWithoutState(block *types.Block, td *big.Int) (err error) | 将一个区块写入到数据库中，但不包含状态数据（即账户状态）的写入 |
| func (bc *BlockChain) writeKnownBlock(block *types.Block) error | 写入已知的区块到区块链中 |
| func (bc *BlockChain) writeBlockAndSetHead(block types.Block, receipts []types.Receipt, logs []*types.Log, state *state.StateDB, emitHeadEvent bool) (status WriteStatus, err error) | 将区块写入区块链数据库，并根据区块的规范性与否，更新区块链的头区块，在需要情况下发送事件通知 |
| func (bc *BlockChain) InsertChain(chain types.Blocks) (int, error) | 将一组区块导入到区块链 |
| func (bc *BlockChain) recoverAncestors(block *types.Block) (common.Hash, error) | 从给定的区块开始，向上追溯并恢复所有被裁剪或丢失的祖先区块的状态 |
| func (bc *BlockChain) collectLogs(b types.Block, removed bool) []types.Log | 收集指定区块中的日志信息，并返回一个包含所有日志的切片 |
| func (bc *BlockChain) InsertBlockWithoutSetHead(block *types.Block) error | 向区块链中插入新的区块，但不设置成头块 |
| func (bc *BlockChain) SetCanonical(head *types.Block) (common.Hash, error) | 将指定区块设置为区块链头块，并在需要时运行重新组织过程 |
| func (bc *BlockChain) skipBlock(err error, it *insertIterator) bool | 是否可以跳过处理导入的区块 |
| func (bc *BlockChain) reportBlock(block *types.Block, receipts types.Receipts, err error) | 记录和报告区块处理过程中遇到的错误 |
| func summarizeBadBlock(block types.Block, receipts []types.Receipt, config *params.ChainConfig, err error) string | 生成一个包含了坏区块相关信息的字符串 |
| func (bc *BlockChain) SetBlockValidatorAndProcessorForTesting(v Validator, p Processor) | 设置用于验证和处理区块的验证器（Validator）和处理器（Processor） |
| func (bc *BlockChain) SetTrieFlushInterval(interval time.Duration) | 配置内存中 trie 刷新到磁盘的间隔时间 |
| func (bc *BlockChain) GetTrieFlushInterval() time.Duration | 获取内存中 trie 刷新到磁盘的间隔时间 |