Documentation

Overview

    package light实现可按需检索的状态和链对象 对于以太坊Light客户端。

    Index

    Constants

    This section is empty.

    Variables

    View Source
    var (
    	//DefaultServerIndexerConfig将一组配置包装为服务器端的默认索引器配置。
    	DefaultServerIndexerConfig = &IndexerConfig{
    		ChtSize:           params.CHTFrequencyServer,
    		PairChtSize:       params.CHTFrequencyClient,
    		ChtConfirms:       params.HelperTrieProcessConfirmations,
    		BloomSize:         params.BloomBitsBlocks,
    		BloomConfirms:     params.BloomConfirms,
    		BloomTrieSize:     params.BloomTrieFrequency,
    		BloomTrieConfirms: params.HelperTrieProcessConfirmations,
    	}
    	//default client indexer config将一组配置包装为客户端的默认索引器配置。
    	DefaultClientIndexerConfig = &IndexerConfig{
    		ChtSize:           params.CHTFrequencyClient,
    		PairChtSize:       params.CHTFrequencyServer,
    		ChtConfirms:       params.HelperTrieConfirmations,
    		BloomSize:         params.BloomBitsBlocksClient,
    		BloomConfirms:     params.HelperTrieConfirmations,
    		BloomTrieSize:     params.BloomTrieFrequency,
    		BloomTrieConfirms: params.HelperTrieConfirmations,
    	}
    	//test server indexer config将一组配置包装为服务器端的测试索引器配置。
    	TestServerIndexerConfig = &IndexerConfig{
    		ChtSize:           64,
    		PairChtSize:       512,
    		ChtConfirms:       4,
    		BloomSize:         64,
    		BloomConfirms:     4,
    		BloomTrieSize:     512,
    		BloomTrieConfirms: 4,
    	}
    	//test client indexer config将一组配置包装为客户端的测试索引器配置。
    	TestClientIndexerConfig = &IndexerConfig{
    		ChtSize:           512,
    		PairChtSize:       64,
    		ChtConfirms:       32,
    		BloomSize:         512,
    		BloomConfirms:     32,
    		BloomTrieSize:     512,
    		BloomTrieConfirms: 32,
    	}
    )
    View Source
    var (
    	ErrNoTrustedCht       = errors.New("no trusted canonical hash trie")
    	ErrNoTrustedBloomTrie = errors.New("no trusted bloom trie")
    	ErrNoHeader           = errors.New("header not found")
    
    	ChtTablePrefix = "cht-"
    )
    View Source
    var (
    	BloomTrieTablePrefix = "blt-"
    )
    View Source
    var ErrNoPeers = errors.New("no suitable peers available")

      如果没有能够为排队请求提供服务的对等方可用,则返回errnopeers。

        noodr是当odr 不需要服务。

        Functions

        func GetBlock

        func GetBlock(ctx context.Context, odr OdrBackend, hash common.Hash, number uint64) (*types.Block, error)

          GetBlock检索与哈希对应的整个块,并对其进行组装 从存储的标题和正文返回。

          func GetBlockLogs

          func GetBlockLogs(ctx context.Context, odr OdrBackend, hash common.Hash, number uint64) ([][]*types.Log, error)

            GetBlockLogs检索包含在 由散列给出的块。

            func GetBlockReceipts

            func GetBlockReceipts(ctx context.Context, odr OdrBackend, hash common.Hash, number uint64) (types.Receipts, error)

              GetBlockReceipts检索由包含的事务生成的收据 在由散列给出的块中。

              func GetBloomBits

              func GetBloomBits(ctx context.Context, odr OdrBackend, bitIdx uint, sectionIdxList []uint64) ([][]byte, error)

                GetBloomBits检索属于给定位索引和节索引的一批压缩BloomBits向量

                func GetBloomTrieRoot

                func GetBloomTrieRoot(db ethdb.Database, sectionIdx uint64, sectionHead common.Hash) common.Hash

                  GetBloomTrieRoot从数据库中读取与给定节关联的BloomTrie根。

                  func GetBody

                  func GetBody(ctx context.Context, odr OdrBackend, hash common.Hash, number uint64) (*types.Body, error)

                    getBody检索与 搞砸。

                    func GetBodyRLP

                    func GetBodyRLP(ctx context.Context, odr OdrBackend, hash common.Hash, number uint64) (rlp.RawValue, error)

                      getBodyrlp在rlp编码中检索块体(事务和uncles)。

                      func GetCanonicalHash

                      func GetCanonicalHash(ctx context.Context, odr OdrBackend, number uint64) (common.Hash, error)

                      func GetChtRoot

                      func GetChtRoot(db ethdb.Database, sectionIdx uint64, sectionHead common.Hash) common.Hash

                        getchtroot从数据库中读取与给定节关联的cht根 请注意,SECTIONIDX是根据LES/1 CHT截面尺寸指定的。

                        func GetHeaderByNumber

                        func GetHeaderByNumber(ctx context.Context, odr OdrBackend, number uint64) (*types.Header, error)

                        func NewBloomTrieIndexer

                        func NewBloomTrieIndexer(db ethdb.Database, odr OdrBackend, parentSize, size uint64) *core.ChainIndexer

                          Newbloomtrieeindexer创建了一个bloomtrie链索引器

                          func NewChtIndexer

                          func NewChtIndexer(db ethdb.Database, odr OdrBackend, size, confirms uint64) *core.ChainIndexer

                            newchtIndexer创建cht链索引器

                            func NewState

                            func NewState(ctx context.Context, head *types.Header, odr OdrBackend) *state.StateDB

                            func NewStateDatabase

                            func NewStateDatabase(ctx context.Context, head *types.Header, odr OdrBackend) state.Database

                            func StoreBloomTrieRoot

                            func StoreBloomTrieRoot(db ethdb.Database, sectionIdx uint64, sectionHead, root common.Hash)

                              StoreBloomTrieRoot将与给定节关联的BloomTrie根写入数据库

                              func StoreChtRoot

                              func StoreChtRoot(db ethdb.Database, sectionIdx uint64, sectionHead, root common.Hash)

                                storechtroot将与给定节关联的cht根写入数据库 请注意,SECTIONIDX是根据LES/1 CHT截面尺寸指定的。

                                Types

                                type BlockRequest

                                type BlockRequest struct {
                                	OdrRequest
                                	Hash   common.Hash
                                	Number uint64
                                	Rlp    []byte
                                }

                                  BlockRequest是用于检索块体的ODR请求类型

                                  func (*BlockRequest) StoreResult

                                  func (req *BlockRequest) StoreResult(db ethdb.Database)

                                    storeresult将检索到的数据存储在本地数据库中

                                    type BloomRequest

                                    type BloomRequest struct {
                                    	OdrRequest
                                    	Config           *IndexerConfig
                                    	BloomTrieNum     uint64
                                    	BitIdx           uint
                                    	SectionIndexList []uint64
                                    	BloomTrieRoot    common.Hash
                                    	BloomBits        [][]byte
                                    	Proofs           *NodeSet
                                    }

                                      BloomRequest是用于从CHT结构检索Bloom筛选器的ODR请求类型。

                                      func (*BloomRequest) StoreResult

                                      func (req *BloomRequest) StoreResult(db ethdb.Database)

                                        storeresult将检索到的数据存储在本地数据库中

                                        type BloomTrieIndexerBackend

                                        type BloomTrieIndexerBackend struct {
                                        	// contains filtered or unexported fields
                                        }

                                          BloomTrieIndexerBackend实现core.chainIndexerBackend

                                          func (*BloomTrieIndexerBackend) Commit

                                          func (b *BloomTrieIndexerBackend) Commit() error

                                            commit实现core.chainindexerbackend

                                            func (*BloomTrieIndexerBackend) Process

                                            func (b *BloomTrieIndexerBackend) Process(ctx context.Context, header *types.Header) error

                                              进程实现core.chainindexerbackend

                                              func (*BloomTrieIndexerBackend) Reset

                                              func (b *BloomTrieIndexerBackend) Reset(ctx context.Context, section uint64, lastSectionHead common.Hash) error

                                                重置实现core.chainindexerbackend

                                                type ChtIndexerBackend

                                                type ChtIndexerBackend struct {
                                                	// contains filtered or unexported fields
                                                }

                                                  chindexerbackend实现core.chainindexerbackend。

                                                  func (*ChtIndexerBackend) Commit

                                                  func (c *ChtIndexerBackend) Commit() error

                                                    commit实现core.chainindexerbackend

                                                    func (*ChtIndexerBackend) Process

                                                    func (c *ChtIndexerBackend) Process(ctx context.Context, header *types.Header) error

                                                      进程实现core.chainindexerbackend

                                                      func (*ChtIndexerBackend) Reset

                                                      func (c *ChtIndexerBackend) Reset(ctx context.Context, section uint64, lastSectionHead common.Hash) error

                                                        重置实现core.chainindexerbackend

                                                        type ChtNode

                                                        type ChtNode struct {
                                                        	Hash common.Hash
                                                        	Td   *big.Int
                                                        }

                                                          chtnode结构以rlp编码格式存储在规范哈希trie中。

                                                          type ChtRequest

                                                          type ChtRequest struct {
                                                          	OdrRequest
                                                          	Config           *IndexerConfig
                                                          	ChtNum, BlockNum uint64
                                                          	ChtRoot          common.Hash
                                                          	Header           *types.Header
                                                          	Td               *big.Int
                                                          	Proof            *NodeSet
                                                          }

                                                            chtRequest是状态/存储trie项的odr请求类型

                                                            func (*ChtRequest) StoreResult

                                                            func (req *ChtRequest) StoreResult(db ethdb.Database)

                                                              storeresult将检索到的数据存储在本地数据库中

                                                              type CodeRequest

                                                              type CodeRequest struct {
                                                              	OdrRequest
                                                              	Id   *TrieID //账户参考存储检索
                                                              	Hash common.Hash
                                                              	Data []byte
                                                              }

                                                                code request是用于检索合同代码的ODR请求类型

                                                                func (*CodeRequest) StoreResult

                                                                func (req *CodeRequest) StoreResult(db ethdb.Database)

                                                                  storeresult将检索到的数据存储在本地数据库中

                                                                  type IndexerConfig

                                                                  type IndexerConfig struct {
                                                                  	//用于创建CHT的块频率。
                                                                  	ChtSize uint64
                                                                  
                                                                  	//特殊的辅助字段表示服务器配置的客户端chtsize,否则表示服务器的chtsize。
                                                                  	PairChtSize uint64
                                                                  
                                                                  	//生成/接受规范哈希帮助trie所需的确认数。
                                                                  	ChtConfirms uint64
                                                                  
                                                                  	//用于创建新Bloom位的块频率。
                                                                  	BloomSize uint64
                                                                  
                                                                  	//在认为一个大方坯段可能是最终的及其旋转的钻头之前所需的确认数量。
                                                                  	//计算。
                                                                  	BloomConfirms uint64
                                                                  
                                                                  	//创建Bloomtrie的块频率。
                                                                  	BloomTrieSize uint64
                                                                  
                                                                  	//生成/接受Bloom Trie所需的确认数。
                                                                  	BloomTrieConfirms uint64
                                                                  }

                                                                    indexerconfig包括一组用于链索引器的配置。

                                                                    type LightChain

                                                                    type LightChain struct {
                                                                    	// contains filtered or unexported fields
                                                                    }

                                                                      lightchain表示默认情况下只处理块的规范链 通过ODR按需下载块体和收据。 接口。它只在链插入期间进行头验证。

                                                                      func NewLightChain

                                                                      func NewLightChain(odr OdrBackend, config *params.ChainConfig, engine consensus.Engine) (*LightChain, error)

                                                                        newlightchain使用信息返回完全初始化的光链 在数据库中可用。它初始化默认的以太坊头文件 验证器。

                                                                        func (*LightChain) Config

                                                                        func (self *LightChain) Config() *params.ChainConfig

                                                                          config检索头链的链配置。

                                                                          func (*LightChain) CurrentHeader

                                                                          func (self *LightChain) CurrentHeader() *types.Header

                                                                            当前头检索规范链的当前头。这个 从HeaderChain的内部缓存中检索头。

                                                                            func (*LightChain) Engine

                                                                            func (bc *LightChain) Engine() consensus.Engine

                                                                              引擎检索轻链的共识引擎。

                                                                              func (*LightChain) GasLimit

                                                                              func (self *LightChain) GasLimit() uint64

                                                                                gas limit返回当前头块的气体限制。

                                                                                func (*LightChain) Genesis

                                                                                func (bc *LightChain) Genesis() *types.Block

                                                                                  Genesis返回Genesis块

                                                                                  func (*LightChain) GetAncestor

                                                                                  func (bc *LightChain) GetAncestor(hash common.Hash, number, ancestor uint64, maxNonCanonical *uint64) (common.Hash, uint64)

                                                                                    getAncestor检索给定块的第n个祖先。它假定给定的块或 它的近亲是典型的。maxnoncanonical指向向下计数器,限制 到达规范链之前要单独检查的块数。

                                                                                    注意:ancestor==0返回相同的块,1返回其父块,依此类推。

                                                                                    func (*LightChain) GetBlock

                                                                                    func (self *LightChain) GetBlock(ctx context.Context, hash common.Hash, number uint64) (*types.Block, error)

                                                                                      GetBlock通过哈希和数字从数据库或ODR服务中检索块, 如果找到,则缓存它。

                                                                                      func (*LightChain) GetBlockByHash

                                                                                      func (self *LightChain) GetBlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error)

                                                                                        GetBlockByHash通过哈希从数据库或ODR服务中检索块, 如果找到,则缓存它。

                                                                                        func (*LightChain) GetBlockByNumber

                                                                                        func (self *LightChain) GetBlockByNumber(ctx context.Context, number uint64) (*types.Block, error)

                                                                                          GetBlockByNumber通过以下方式从数据库或ODR服务中检索块 数字,如果找到,则缓存它(与其哈希关联)。

                                                                                          func (*LightChain) GetBlockHashesFromHash

                                                                                          func (self *LightChain) GetBlockHashesFromHash(hash common.Hash, max uint64) []common.Hash

                                                                                            GetBlockHashesFromHash从给定的 哈什,向创世纪街区走去。

                                                                                            func (*LightChain) GetBody

                                                                                            func (self *LightChain) GetBody(ctx context.Context, hash common.Hash) (*types.Body, error)

                                                                                              getbody从数据库中检索块体(事务和uncles) 或者通过散列来实现ODR服务,如果找到了,就缓存它。

                                                                                              func (*LightChain) GetBodyRLP

                                                                                              func (self *LightChain) GetBodyRLP(ctx context.Context, hash common.Hash) (rlp.RawValue, error)

                                                                                                getBodyrlp从数据库中检索以rlp编码的块体,或者 通过哈希的ODR服务,如果找到,将其缓存。

                                                                                                func (*LightChain) GetHeader

                                                                                                func (self *LightChain) GetHeader(hash common.Hash, number uint64) *types.Header

                                                                                                  GetHeader按哈希和数字从数据库中检索块头, 如果找到,则缓存它。

                                                                                                  func (*LightChain) GetHeaderByHash

                                                                                                  func (self *LightChain) GetHeaderByHash(hash common.Hash) *types.Header

                                                                                                    GetHeaderByHash通过哈希从数据库中检索块头,如果 找到了。

                                                                                                    func (*LightChain) GetHeaderByNumber

                                                                                                    func (self *LightChain) GetHeaderByNumber(number uint64) *types.Header

                                                                                                      GetHeaderByNumber按编号从数据库中检索块头, 如果找到,则缓存它(与其哈希关联)。

                                                                                                      func (*LightChain) GetHeaderByNumberOdr

                                                                                                      func (self *LightChain) GetHeaderByNumberOdr(ctx context.Context, number uint64) (*types.Header, error)

                                                                                                        GetHeaderByNumberODR从数据库或网络检索块头 按数字,如果找到,则缓存它(与其哈希关联)。

                                                                                                        func (*LightChain) GetTd

                                                                                                        func (self *LightChain) GetTd(hash common.Hash, number uint64) *big.Int

                                                                                                          gettd从 按哈希和数字排列的数据库,如果找到,则将其缓存。

                                                                                                          func (*LightChain) GetTdByHash

                                                                                                          func (self *LightChain) GetTdByHash(hash common.Hash) *big.Int

                                                                                                            getDByHash从 通过哈希对数据库进行缓存(如果找到)。

                                                                                                            func (*LightChain) HasBlock

                                                                                                            func (bc *LightChain) HasBlock(hash common.Hash, number uint64) bool

                                                                                                              HasBlock checks if a block is fully present in the database or not, caching 如果存在的话。

                                                                                                              func (*LightChain) HasHeader

                                                                                                              func (bc *LightChain) HasHeader(hash common.Hash, number uint64) bool

                                                                                                                hasheader检查数据库中是否存在块头,缓存 如果存在的话。

                                                                                                                func (*LightChain) InsertHeaderChain

                                                                                                                func (self *LightChain) InsertHeaderChain(chain []*types.Header, checkFreq int) (int, error)

                                                                                                                  insert header chain尝试将给定的头链插入本地 链,可能创建REORG。如果返回错误,它将返回 失败头的索引号以及描述出错原因的错误。

                                                                                                                  verify参数可用于微调非ce验证 是否应该做。可选检查背后的原因是 其中的头检索机制已经需要验证nonce,以及 因为nonce可以被稀疏地验证,不需要检查每一个。

                                                                                                                  对于光链,插入头链也创建和发布光 必要时链接事件。

                                                                                                                  func (*LightChain) LockChain

                                                                                                                  func (self *LightChain) LockChain()

                                                                                                                    lockchain为读取而锁定链互斥体,以便可以 在确保它们属于同一版本的链时检索

                                                                                                                    func (*LightChain) Odr

                                                                                                                    func (self *LightChain) Odr() OdrBackend

                                                                                                                      ODR返回链的ODR后端

                                                                                                                      func (*LightChain) Reset

                                                                                                                      func (bc *LightChain) Reset()

                                                                                                                        重置清除整个区块链,将其恢复到其创始状态。

                                                                                                                        func (*LightChain) ResetWithGenesisBlock

                                                                                                                        func (bc *LightChain) ResetWithGenesisBlock(genesis *types.Block)

                                                                                                                          ResetWithGenerisBlock清除整个区块链,将其恢复到 指定的创世状态。

                                                                                                                          func (*LightChain) Rollback

                                                                                                                          func (self *LightChain) Rollback(chain []common.Hash)

                                                                                                                            回滚的目的是从数据库中删除一系列链接,而这些链接不是 足够确定有效。

                                                                                                                            func (*LightChain) SetHead

                                                                                                                            func (bc *LightChain) SetHead(head uint64)

                                                                                                                              sethead将本地链重绕到新的head。一切都在新的之上 头将被删除,新的一套。

                                                                                                                              func (*LightChain) State

                                                                                                                              func (bc *LightChain) State() (*state.StateDB, error)

                                                                                                                                State返回基于当前头块的新可变状态。

                                                                                                                                func (*LightChain) Stop

                                                                                                                                func (bc *LightChain) Stop()

                                                                                                                                  停止停止区块链服务。如果任何导入当前正在进行中 它将使用procInterrupt中止它们。

                                                                                                                                  func (*LightChain) SubscribeChainEvent

                                                                                                                                  func (self *LightChain) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription

                                                                                                                                    subscribeChainevent注册chainEvent的订阅。

                                                                                                                                    func (*LightChain) SubscribeChainHeadEvent

                                                                                                                                    func (self *LightChain) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription

                                                                                                                                      subscribeChainHeadEvent注册chainHeadEvent的订阅。

                                                                                                                                      func (*LightChain) SubscribeChainSideEvent

                                                                                                                                      func (self *LightChain) SubscribeChainSideEvent(ch chan<- core.ChainSideEvent) event.Subscription

                                                                                                                                        subscribeChainSideEvent注册chainSideEvent的订阅。

                                                                                                                                        func (*LightChain) SubscribeLogsEvent

                                                                                                                                        func (self *LightChain) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription

                                                                                                                                          subscriptLogSevent实现了filters.backend的接口 LightChain不发送日志事件,因此返回空订阅。

                                                                                                                                          func (*LightChain) SubscribeRemovedLogsEvent

                                                                                                                                          func (self *LightChain) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription

                                                                                                                                            subscripreMovedLogSevent实现筛选器的接口。后端 LightChain不发送core.removedLogSevent,因此返回空订阅。

                                                                                                                                            func (*LightChain) SyncCht

                                                                                                                                            func (self *LightChain) SyncCht(ctx context.Context) bool

                                                                                                                                            func (*LightChain) UnlockChain

                                                                                                                                            func (self *LightChain) UnlockChain()

                                                                                                                                              解锁链解锁链互斥体

                                                                                                                                              type NodeList

                                                                                                                                              type NodeList []rlp.RawValue

                                                                                                                                                nodelist存储trie节点的有序列表。它实现ethdb.putter。

                                                                                                                                                func (NodeList) DataSize

                                                                                                                                                func (n NodeList) DataSize() int

                                                                                                                                                  data size返回列表中节点的聚合数据大小

                                                                                                                                                  func (NodeList) NodeSet

                                                                                                                                                  func (n NodeList) NodeSet() *NodeSet

                                                                                                                                                    节点集将节点列表转换为节点集

                                                                                                                                                    func (*NodeList) Put

                                                                                                                                                    func (n *NodeList) Put(key []byte, value []byte) error

                                                                                                                                                      在列表末尾放置一个新节点

                                                                                                                                                      func (NodeList) Store

                                                                                                                                                      func (n NodeList) Store(db ethdb.Putter)

                                                                                                                                                        存储将列表的内容写入给定的数据库

                                                                                                                                                        type NodeSet

                                                                                                                                                        type NodeSet struct {
                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                        }

                                                                                                                                                          nodeset存储一组trie节点。它实现了trie.database,还可以 作为另一个trie.database的缓存。

                                                                                                                                                          func NewNodeSet

                                                                                                                                                          func NewNodeSet() *NodeSet

                                                                                                                                                            newnodeset创建空节点集

                                                                                                                                                            func (*NodeSet) DataSize

                                                                                                                                                            func (db *NodeSet) DataSize() int

                                                                                                                                                              data size返回集合中节点的聚合数据大小

                                                                                                                                                              func (*NodeSet) Get

                                                                                                                                                              func (db *NodeSet) Get(key []byte) ([]byte, error)

                                                                                                                                                                get返回存储节点

                                                                                                                                                                func (*NodeSet) Has

                                                                                                                                                                func (db *NodeSet) Has(key []byte) (bool, error)

                                                                                                                                                                  如果节点集包含给定的键,则返回true

                                                                                                                                                                  func (*NodeSet) KeyCount

                                                                                                                                                                  func (db *NodeSet) KeyCount() int

                                                                                                                                                                    keycount返回集合中的节点数

                                                                                                                                                                    func (*NodeSet) NodeList

                                                                                                                                                                    func (db *NodeSet) NodeList() NodeList

                                                                                                                                                                      节点列表将节点集转换为节点列表

                                                                                                                                                                      func (*NodeSet) Put

                                                                                                                                                                      func (db *NodeSet) Put(key []byte, value []byte) error

                                                                                                                                                                        在集合中放置存储新节点

                                                                                                                                                                        func (*NodeSet) Store

                                                                                                                                                                        func (db *NodeSet) Store(target ethdb.Putter)

                                                                                                                                                                          存储将集的内容写入给定的数据库

                                                                                                                                                                          type OdrBackend

                                                                                                                                                                          type OdrBackend interface {
                                                                                                                                                                          	Database() ethdb.Database
                                                                                                                                                                          	ChtIndexer() *core.ChainIndexer
                                                                                                                                                                          	BloomTrieIndexer() *core.ChainIndexer
                                                                                                                                                                          	BloomIndexer() *core.ChainIndexer
                                                                                                                                                                          	Retrieve(ctx context.Context, req OdrRequest) error
                                                                                                                                                                          	IndexerConfig() *IndexerConfig
                                                                                                                                                                          }

                                                                                                                                                                            odr backend是后端服务的接口,用于处理odr检索类型

                                                                                                                                                                            type OdrRequest

                                                                                                                                                                            type OdrRequest interface {
                                                                                                                                                                            	StoreResult(db ethdb.Database)
                                                                                                                                                                            }

                                                                                                                                                                              ODRRequest是一个用于检索请求的接口

                                                                                                                                                                              type ReceiptsRequest

                                                                                                                                                                              type ReceiptsRequest struct {
                                                                                                                                                                              	OdrRequest
                                                                                                                                                                              	Hash     common.Hash
                                                                                                                                                                              	Number   uint64
                                                                                                                                                                              	Receipts types.Receipts
                                                                                                                                                                              }

                                                                                                                                                                                ReceiptsRequest是用于检索块体的ODR请求类型

                                                                                                                                                                                func (*ReceiptsRequest) StoreResult

                                                                                                                                                                                func (req *ReceiptsRequest) StoreResult(db ethdb.Database)

                                                                                                                                                                                  storeresult将检索到的数据存储在本地数据库中

                                                                                                                                                                                  type TrieID

                                                                                                                                                                                  type TrieID struct {
                                                                                                                                                                                  	BlockHash, Root common.Hash
                                                                                                                                                                                  	BlockNumber     uint64
                                                                                                                                                                                  	AccKey          []byte
                                                                                                                                                                                  }

                                                                                                                                                                                    trieid标识状态或帐户存储trie

                                                                                                                                                                                    func StateTrieID

                                                                                                                                                                                    func StateTrieID(header *types.Header) *TrieID

                                                                                                                                                                                      state trieid返回属于某个块的state trie的trieid 标题。

                                                                                                                                                                                      func StorageTrieID

                                                                                                                                                                                      func StorageTrieID(state *TrieID, addrHash, root common.Hash) *TrieID

                                                                                                                                                                                        storage trieid返回给定帐户上合同存储trie的trieid 一个给定的国家的。它还需要trie的根散列 检查Merkle校样。

                                                                                                                                                                                        type TrieRequest

                                                                                                                                                                                        type TrieRequest struct {
                                                                                                                                                                                        	OdrRequest
                                                                                                                                                                                        	Id    *TrieID
                                                                                                                                                                                        	Key   []byte
                                                                                                                                                                                        	Proof *NodeSet
                                                                                                                                                                                        }

                                                                                                                                                                                          trieRequest是状态/存储trie项的ODR请求类型

                                                                                                                                                                                          func (*TrieRequest) StoreResult

                                                                                                                                                                                          func (req *TrieRequest) StoreResult(db ethdb.Database)

                                                                                                                                                                                            storeresult将检索到的数据存储在本地数据库中

                                                                                                                                                                                            type TxPool

                                                                                                                                                                                            type TxPool struct {
                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                            }

                                                                                                                                                                                              TxPool为轻型客户机实现事务池,从而跟踪 本地创建的事务的状态,检测是否包含这些事务 在一个块(矿)或回卷。自从我们 始终以相同的顺序接收所有本地签名的事务 创建。

                                                                                                                                                                                              func NewTxPool

                                                                                                                                                                                              func NewTxPool(config *params.ChainConfig, chain *LightChain, relay TxRelayBackend) *TxPool

                                                                                                                                                                                                newtxpool创建新的轻型事务池

                                                                                                                                                                                                func (*TxPool) Add

                                                                                                                                                                                                func (self *TxPool) Add(ctx context.Context, tx *types.Transaction) error

                                                                                                                                                                                                  添加将事务添加到池中(如果有效)并将其传递到Tx中继 后端

                                                                                                                                                                                                  func (*TxPool) AddBatch

                                                                                                                                                                                                  func (self *TxPool) AddBatch(ctx context.Context, txs []*types.Transaction)

                                                                                                                                                                                                    addTransactions将所有有效事务添加到池中,并将它们传递给 Tx中继后端

                                                                                                                                                                                                    func (*TxPool) Content

                                                                                                                                                                                                    func (self *TxPool) Content() (map[common.Address]types.Transactions, map[common.Address]types.Transactions)

                                                                                                                                                                                                      Content检索事务池的数据内容,并返回 挂起和排队的事务,按帐户和nonce分组。

                                                                                                                                                                                                      func (*TxPool) GetNonce

                                                                                                                                                                                                      func (pool *TxPool) GetNonce(ctx context.Context, addr common.Address) (uint64, error)

                                                                                                                                                                                                        getnonce返回给定地址的“挂起”nonce。它总是询问 也属于最新标题的nonce,以便检测是否有其他标题 使用相同密钥的客户端发送了一个事务。

                                                                                                                                                                                                        func (*TxPool) GetTransaction

                                                                                                                                                                                                        func (tp *TxPool) GetTransaction(hash common.Hash) *types.Transaction

                                                                                                                                                                                                          GetTransaction返回包含在池中的事务 否则为零。

                                                                                                                                                                                                          func (*TxPool) GetTransactions

                                                                                                                                                                                                          func (self *TxPool) GetTransactions() (txs types.Transactions, err error)

                                                                                                                                                                                                            GetTransactions返回所有当前可处理的事务。 调用程序可以修改返回的切片。

                                                                                                                                                                                                            func (*TxPool) RemoveTransactions

                                                                                                                                                                                                            func (self *TxPool) RemoveTransactions(txs types.Transactions)

                                                                                                                                                                                                              removeTransactions从池中删除所有给定的事务。

                                                                                                                                                                                                              func (*TxPool) RemoveTx

                                                                                                                                                                                                              func (pool *TxPool) RemoveTx(hash common.Hash)

                                                                                                                                                                                                                removetx从池中删除具有给定哈希的事务。

                                                                                                                                                                                                                func (*TxPool) Stats

                                                                                                                                                                                                                func (pool *TxPool) Stats() (pending int)

                                                                                                                                                                                                                  stats返回当前挂起(本地创建)的事务数

                                                                                                                                                                                                                  func (*TxPool) Stop

                                                                                                                                                                                                                  func (pool *TxPool) Stop()

                                                                                                                                                                                                                    停止停止轻型事务处理池

                                                                                                                                                                                                                    func (*TxPool) SubscribeNewTxsEvent

                                                                                                                                                                                                                    func (pool *TxPool) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription

                                                                                                                                                                                                                      subscripeWtxEvent注册core.newtxSevent和的订阅 开始向给定通道发送事件。

                                                                                                                                                                                                                      type TxRelayBackend

                                                                                                                                                                                                                      type TxRelayBackend interface {
                                                                                                                                                                                                                      	Send(txs types.Transactions)
                                                                                                                                                                                                                      	NewHead(head common.Hash, mined []common.Hash, rollback []common.Hash)
                                                                                                                                                                                                                      	Discard(hashes []common.Hash)
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        txtrelaybackend提供了一个接口,用于转发Transacion的机制 到ETH网络。函数的实现应该是非阻塞的。

                                                                                                                                                                                                                        发送指示后端转发新事务 new head在tx池处理后通知后端有关新头的信息, 包括自上次事件以来的已挖掘和回滚事务 Discard通知后端应该丢弃的事务 因为它们被重新发送或被挖掘所取代 很久以前,不需要回滚