Documentation

Overview

    包ETH实现以太坊协议。

    Index

    Constants

    View Source
    const (
    	//属于ETH/62的协议消息
    	StatusMsg          = 0x00
    	NewBlockHashesMsg  = 0x01
    	TxMsg              = 0x02
    	GetBlockHeadersMsg = 0x03
    	BlockHeadersMsg    = 0x04
    	GetBlockBodiesMsg  = 0x05
    	BlockBodiesMsg     = 0x06
    	NewBlockMsg        = 0x07
    
    	//属于ETH/63的协议消息
    	GetNodeDataMsg = 0x0d
    	NodeDataMsg    = 0x0e
    	GetReceiptsMsg = 0x0f
    	ReceiptsMsg    = 0x10
    )

      ETH协议报文代码

      View Source
      const (
      	ErrMsgTooLarge = iota
      	ErrDecode
      	ErrInvalidMsgCode
      	ErrProtocolVersionMismatch
      	ErrNetworkIdMismatch
      	ErrGenesisBlockMismatch
      	ErrNoStatusMsg
      	ErrExtraStatusMsg
      	ErrSuspendedPeer
      )
      View Source
      const ProtocolMaxMsgSize = 10 * 1024 * 1024 //协议消息大小的最大上限
      

      Variables

      View Source
      var DefaultConfig = Config{
      	SyncMode: downloader.FastSync,
      	Ethash: ethash.Config{
      		CacheDir:       "ethash",
      		CachesInMem:    2,
      		CachesOnDisk:   3,
      		DatasetsInMem:  1,
      		DatasetsOnDisk: 2,
      	},
      	NetworkId:     1,
      	LightPeers:    100,
      	DatabaseCache: 768,
      	TrieCache:     256,
      	TrieTimeout:   60 * time.Minute,
      	MinerGasPrice: big.NewInt(18 * params.Shannon),
      	MinerRecommit: 3 * time.Second,
      
      	TxPool: core.DefaultTxPoolConfig,
      	GPO: gasprice.Config{
      		Blocks:     20,
      		Percentile: 60,
      	},
      }

        defaultconfig包含在以太坊主网上使用的默认设置。

        View Source
        var ProtocolLengths = []uint64{17, 8}

          Protocollength是对应于不同协议版本的已实现消息数。

          View Source
          var ProtocolName = "eth"

            ProtocolName是在能力协商期间使用的协议的官方简称。

            View Source
            var ProtocolVersions = []uint{eth63, eth62}

              协议版本是ETH协议的支持版本(首先是主要版本)。

              Functions

              func CreateDB

              func CreateDB(ctx *node.ServiceContext, config *Config, name string) (ethdb.Database, error)

                createdb创建链数据库。

                func NewBloomIndexer

                func NewBloomIndexer(db ethdb.Database, size, confReq uint64) *core.ChainIndexer

                  newbloomindexer返回一个链索引器,它为 用于快速日志筛选的规范链。

                  Types

                  type BadBlockArgs

                  type BadBlockArgs struct {
                  	Hash  common.Hash            `json:"hash"`
                  	Block map[string]interface{} `json:"block"`
                  	RLP   string                 `json:"rlp"`
                  }

                    badblockargs表示查询坏块时返回的列表中的条目。

                    type BloomIndexer

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

                      BloomIndexer实现core.chainIndexer,建立旋转的BloomBits索引 对于以太坊头段Bloom过滤器,允许快速过滤。

                      func (*BloomIndexer) Commit

                      func (b *BloomIndexer) Commit() error

                        commit实现core.chainindexerbackend,完成bloom部分和 把它写进数据库。

                        func (*BloomIndexer) Process

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

                          进程实现了core.chainindexerbackend,将新头的bloom添加到 索引。

                          func (*BloomIndexer) Reset

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

                            reset实现core.chainindexerbackend,启动新的bloombits索引 部分。

                            type Config

                            type Config struct {
                            	//如果数据库为空,则插入Genesis块。
                            	//如果为零,则使用以太坊主网块。
                            	Genesis *core.Genesis `toml:",omitempty"`
                            
                            	//协议选项
                            	NetworkId uint64 //用于选择要连接的对等端的网络ID
                            	SyncMode  downloader.SyncMode
                            	NoPruning bool
                            
                            	//轻客户端选项
                            	LightServ  int `toml:",omitempty"` //允许LES请求的最大时间百分比
                            	LightPeers int `toml:",omitempty"` //最大LES客户端对等数
                            
                            	//数据库选项
                            	SkipBcVersionCheck bool `toml:"-"`
                            	DatabaseHandles    int  `toml:"-"`
                            	DatabaseCache      int
                            	TrieCache          int
                            	TrieTimeout        time.Duration
                            
                            	//Mining-related options
                            	//etherbase common.address`toml:“,omitempty”`
                            	Validator      common.Address `toml:",omitempty"`
                            	Coinbase       common.Address `toml:",omitempty"`
                            	MinerThreads   int            `toml:",omitempty"`
                            	MinerNotify    []string       `toml:",omitempty"`
                            	MinerExtraData []byte         `toml:",omitempty"`
                            	MinerGasPrice  *big.Int
                            	MinerRecommit  time.Duration
                            
                            	//乙烯利选项
                            	Ethash ethash.Config
                            
                            	//事务池选项
                            	TxPool core.TxPoolConfig
                            
                            	//天然气价格Oracle选项
                            	GPO gasprice.Config
                            
                            	//允许跟踪虚拟机中的sha3 preimages
                            	EnablePreimageRecording bool
                            
                            	//其他选项
                            	DocRoot string `toml:"-"`
                            	Dpos    bool   `toml:"-"`
                            }

                            func (Config) MarshalTOML

                            func (c Config) MarshalTOML() (interface{}, error)

                              MsHaltOML封为TOML。

                              func (*Config) UnmarshalTOML

                              func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error

                                取消标记从Toml取消标记。

                                type EthAPIBackend

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

                                  ethapi backend为完整节点实现ethapi.backend

                                  func (*EthAPIBackend) AccountManager

                                  func (b *EthAPIBackend) AccountManager() *accounts.Manager

                                  func (*EthAPIBackend) BlockByNumber

                                  func (b *EthAPIBackend) BlockByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Block, error)

                                  func (*EthAPIBackend) BloomStatus

                                  func (b *EthAPIBackend) BloomStatus() (uint64, uint64)

                                  func (*EthAPIBackend) ChainConfig

                                  func (b *EthAPIBackend) ChainConfig() *params.ChainConfig

                                    chainconfig返回活动链配置。

                                    func (*EthAPIBackend) ChainDb

                                    func (b *EthAPIBackend) ChainDb() ethdb.Database

                                    func (*EthAPIBackend) CurrentBlock

                                    func (b *EthAPIBackend) CurrentBlock() *types.Block

                                    func (*EthAPIBackend) Downloader

                                    func (b *EthAPIBackend) Downloader() *downloader.Downloader

                                    func (*EthAPIBackend) EventMux

                                    func (b *EthAPIBackend) EventMux() *event.TypeMux

                                    func (*EthAPIBackend) GetBlock

                                    func (b *EthAPIBackend) GetBlock(ctx context.Context, hash common.Hash) (*types.Block, error)

                                    func (*EthAPIBackend) GetEVM

                                    func (b *EthAPIBackend) GetEVM(ctx context.Context, msg core.Message, state *state.StateDB, header *types.Header, vmCfg vm.Config) (*vm.EVM, func() error, error)

                                    func (*EthAPIBackend) GetLogs

                                    func (b *EthAPIBackend) GetLogs(ctx context.Context, hash common.Hash) ([][]*types.Log, error)

                                    func (*EthAPIBackend) GetPoolNonce

                                    func (b *EthAPIBackend) GetPoolNonce(ctx context.Context, addr common.Address) (uint64, error)

                                    func (*EthAPIBackend) GetPoolTransaction

                                    func (b *EthAPIBackend) GetPoolTransaction(hash common.Hash) *types.Transaction

                                    func (*EthAPIBackend) GetPoolTransactions

                                    func (b *EthAPIBackend) GetPoolTransactions() (types.Transactions, error)

                                    func (*EthAPIBackend) GetReceipts

                                    func (b *EthAPIBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error)

                                    func (*EthAPIBackend) GetTd

                                    func (b *EthAPIBackend) GetTd(blockHash common.Hash) *big.Int

                                    func (*EthAPIBackend) HeaderByHash

                                    func (b *EthAPIBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error)

                                    func (*EthAPIBackend) HeaderByNumber

                                    func (b *EthAPIBackend) HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Header, error)

                                    func (*EthAPIBackend) ProtocolVersion

                                    func (b *EthAPIBackend) ProtocolVersion() int

                                    func (*EthAPIBackend) SendTx

                                    func (b *EthAPIBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error

                                    func (*EthAPIBackend) ServiceFilter

                                    func (b *EthAPIBackend) ServiceFilter(ctx context.Context, session *bloombits.MatcherSession)

                                    func (*EthAPIBackend) SetHead

                                    func (b *EthAPIBackend) SetHead(number uint64)

                                    func (*EthAPIBackend) StateAndHeaderByNumber

                                    func (b *EthAPIBackend) StateAndHeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*state.StateDB, *types.Header, error)

                                    func (*EthAPIBackend) Stats

                                    func (b *EthAPIBackend) Stats() (pending int, queued int)

                                    func (*EthAPIBackend) SubscribeChainEvent

                                    func (b *EthAPIBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription

                                    func (*EthAPIBackend) SubscribeChainHeadEvent

                                    func (b *EthAPIBackend) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription

                                    func (*EthAPIBackend) SubscribeLogsEvent

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

                                    func (*EthAPIBackend) SubscribeNewTxsEvent

                                    func (b *EthAPIBackend) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription

                                    func (*EthAPIBackend) SubscribeRemovedLogsEvent

                                    func (b *EthAPIBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription

                                    func (*EthAPIBackend) SuggestPrice

                                    func (b *EthAPIBackend) SuggestPrice(ctx context.Context) (*big.Int, error)

                                    func (*EthAPIBackend) TxPoolContent

                                    type Ethereum

                                    type Ethereum struct {
                                    	APIBackend *EthAPIBackend
                                    	// contains filtered or unexported fields
                                    }

                                      以太坊实施以太坊全节点服务。

                                      func New

                                      func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error)

                                        新建创建新的以太坊对象(包括 公共EythUM对象的初始化

                                        func (*Ethereum) APIs

                                        func (s *Ethereum) APIs() []rpc.API

                                          API返回以太坊包提供的RPC服务集合。 注意,其中一些服务可能需要转移到其他地方。

                                          func (*Ethereum) AccountManager

                                          func (s *Ethereum) AccountManager() *accounts.Manager

                                          func (*Ethereum) AddLesServer

                                          func (s *Ethereum) AddLesServer(ls LesServer)

                                          func (*Ethereum) BlockChain

                                          func (s *Ethereum) BlockChain() *core.BlockChain

                                          func (*Ethereum) ChainDb

                                          func (s *Ethereum) ChainDb() ethdb.Database

                                          func (*Ethereum) Coinbase

                                          func (s *Ethereum) Coinbase() (eb common.Address, err error)

                                          func (*Ethereum) Downloader

                                          func (s *Ethereum) Downloader() *downloader.Downloader

                                          func (*Ethereum) Engine

                                          func (s *Ethereum) Engine() consensus.Engine

                                          func (*Ethereum) EthVersion

                                          func (s *Ethereum) EthVersion() int

                                          func (*Ethereum) EventMux

                                          func (s *Ethereum) EventMux() *event.TypeMux

                                          func (*Ethereum) IsListening

                                          func (s *Ethereum) IsListening() bool

                                          func (*Ethereum) IsMining

                                          func (s *Ethereum) IsMining() bool

                                          func (*Ethereum) Miner

                                          func (s *Ethereum) Miner() *miner.Miner

                                          func (*Ethereum) NetVersion

                                          func (s *Ethereum) NetVersion() uint64

                                          func (*Ethereum) Protocols

                                          func (s *Ethereum) Protocols() []p2p.Protocol

                                            协议实现node.service,返回所有当前配置的 要启动的网络协议。

                                            func (*Ethereum) ResetWithGenesisBlock

                                            func (s *Ethereum) ResetWithGenesisBlock(gb *types.Block)

                                            func (*Ethereum) SetCoinbase

                                            func (self *Ethereum) SetCoinbase(coinbase common.Address)

                                              通过管理接口或来自cli标志的包装器在js控制台中设置

                                              func (*Ethereum) SetValidator

                                              func (self *Ethereum) SetValidator(validator common.Address)

                                                通过管理接口或来自cli标志的包装器在js控制台中设置

                                                func (*Ethereum) Start

                                                func (s *Ethereum) Start(srvr *p2p.Server) error

                                                  start实现node.service,启动 以太坊协议实现。

                                                  func (*Ethereum) StartMining

                                                  func (s *Ethereum) StartMining(local bool) error

                                                  func (*Ethereum) Stop

                                                  func (s *Ethereum) Stop() error

                                                    停止实现node.service,终止由 以太坊协议。

                                                    func (*Ethereum) StopMining

                                                    func (s *Ethereum) StopMining()

                                                    func (*Ethereum) TxPool

                                                    func (s *Ethereum) TxPool() *core.TxPool

                                                    func (*Ethereum) Validator

                                                    func (s *Ethereum) Validator() (validator common.Address, err error)

                                                    type LesServer

                                                    type LesServer interface {
                                                    	Start(srvr *p2p.Server)
                                                    	Stop()
                                                    	Protocols() []p2p.Protocol
                                                    	SetBloomBitsIndexer(bbIndexer *core.ChainIndexer)
                                                    }

                                                    type NodeInfo

                                                    type NodeInfo struct {
                                                    	Network    uint64              `json:"network"`    //以太坊网络ID(1=前沿,2=现代,Ropsten=3,Rinkeby=4)
                                                    	Difficulty *big.Int            `json:"difficulty"` //主机区块链的总难度
                                                    	Genesis    common.Hash         `json:"genesis"`    //寄主创世纪区块的沙3哈希
                                                    	Config     *params.ChainConfig `json:"config"`     //分叉规则的链配置
                                                    	Head       common.Hash         `json:"head"`       //主机最好拥有的块的sha3哈希
                                                    }

                                                      nodeinfo表示以太坊子协议元数据的简短摘要 了解主机对等机。

                                                      type PeerInfo

                                                      type PeerInfo struct {
                                                      	Version    int      `json:"version"`    //已协商以太坊协议版本
                                                      	Difficulty *big.Int `json:"difficulty"` //同行区块链的总难度
                                                      	Head       string   `json:"head"`       //对等机最好拥有的块的sha3哈希
                                                      }

                                                        PeerInfo表示已知以太坊子协议元数据的简短摘要 关于连接的对等机。

                                                        type PrivateAdminAPI

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

                                                          privateAdminAPI是以太坊完整节点相关API的集合。 在私有管理终结点上公开。

                                                          func NewPrivateAdminAPI

                                                          func NewPrivateAdminAPI(eth *Ethereum) *PrivateAdminAPI

                                                            newprivateadminapi为完整节点private创建新的api定义 EAUTHUM服务的管理方法。

                                                            func (*PrivateAdminAPI) ExportChain

                                                            func (api *PrivateAdminAPI) ExportChain(file string) (bool, error)

                                                              exportchain将当前区块链导出到本地文件中。

                                                              func (*PrivateAdminAPI) ImportChain

                                                              func (api *PrivateAdminAPI) ImportChain(file string) (bool, error)

                                                                importchain从本地文件导入区块链。

                                                                type PrivateDebugAPI

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

                                                                  privatedebugapi是通过 专用调试终结点。

                                                                  func NewPrivateDebugAPI

                                                                  func NewPrivateDebugAPI(config *params.ChainConfig, eth *Ethereum) *PrivateDebugAPI

                                                                    NealPrimeDebug GAPI为完整的节点创建一个新的API定义 以太坊服务的专用调试方法。

                                                                    func (*PrivateDebugAPI) GetBadBlocks

                                                                    func (api *PrivateDebugAPI) GetBadBlocks(ctx context.Context) ([]*BadBlockArgs, error)

                                                                      GetBadBlocks返回客户端在网络上看到的最后一个“坏块”的列表 并将其作为块哈希的JSON列表返回

                                                                      func (*PrivateDebugAPI) GetModifiedAccountsByHash

                                                                      func (api *PrivateDebugAPI) GetModifiedAccountsByHash(startHash common.Hash, endHash *common.Hash) ([]common.Address, error)

                                                                        GetModifiedAccountsByHash返回在 指定两个块。变化被定义为非现金、余额和 代码哈希或存储哈希。

                                                                        使用一个参数,返回在指定块中修改的帐户列表。

                                                                        func (*PrivateDebugAPI) GetModifiedAccountsByNumber

                                                                        func (api *PrivateDebugAPI) GetModifiedAccountsByNumber(startNum uint64, endNum *uint64) ([]common.Address, error)

                                                                          GetModifiedAccountsByNumber返回在 指定两个块。变化被定义为非现金、余额和 代码哈希或存储哈希。

                                                                          使用一个参数,返回在指定块中修改的帐户列表。

                                                                          func (*PrivateDebugAPI) Preimage

                                                                          func (api *PrivateDebugAPI) Preimage(ctx context.Context, hash common.Hash) (hexutil.Bytes, error)

                                                                            PrimI图是一个调试API函数,它返回Sh3哈希的预图像,如果已知的话。

                                                                            func (*PrivateDebugAPI) StorageRangeAt

                                                                            func (api *PrivateDebugAPI) StorageRangeAt(ctx context.Context, blockHash common.Hash, txIndex int, contractAddress common.Address, keyStart hexutil.Bytes, maxResult int) (StorageRangeResult, error)

                                                                              storagerangeat返回给定块高度和事务索引下的存储。

                                                                              func (*PrivateDebugAPI) TraceBlock

                                                                              func (api *PrivateDebugAPI) TraceBlock(ctx context.Context, blob []byte, config *TraceConfig) ([]*txTraceResult, error)

                                                                                traceblock返回在执行evm期间创建的结构化日志 并将它们作为JSON对象返回。

                                                                                func (*PrivateDebugAPI) TraceBlockByHash

                                                                                func (api *PrivateDebugAPI) TraceBlockByHash(ctx context.Context, hash common.Hash, config *TraceConfig) ([]*txTraceResult, error)

                                                                                  traceBlockByHash返回在执行期间创建的结构化日志 EVM并将其作为JSON对象返回。

                                                                                  func (*PrivateDebugAPI) TraceBlockByNumber

                                                                                  func (api *PrivateDebugAPI) TraceBlockByNumber(ctx context.Context, number rpc.BlockNumber, config *TraceConfig) ([]*txTraceResult, error)

                                                                                    traceBlockByNumber返回在执行期间创建的结构化日志 EVM并将其作为JSON对象返回。

                                                                                    func (*PrivateDebugAPI) TraceBlockFromFile

                                                                                    func (api *PrivateDebugAPI) TraceBlockFromFile(ctx context.Context, file string, config *TraceConfig) ([]*txTraceResult, error)

                                                                                      traceblockfromfile返回在执行期间创建的结构化日志 EVM并将其作为JSON对象返回。

                                                                                      func (*PrivateDebugAPI) TraceChain

                                                                                      func (api *PrivateDebugAPI) TraceChain(ctx context.Context, start, end rpc.BlockNumber, config *TraceConfig) (*rpc.Subscription, error)

                                                                                        tracechain返回在执行evm期间创建的结构化日志 在两个块之间(不包括start),并将它们作为JSON对象返回。

                                                                                        func (*PrivateDebugAPI) TraceTransaction

                                                                                        func (api *PrivateDebugAPI) TraceTransaction(ctx context.Context, hash common.Hash, config *TraceConfig) (interface{}, error)

                                                                                          traceTransaction返回执行evm期间创建的结构化日志 并将它们作为JSON对象返回。

                                                                                          type PrivateMinerAPI

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

                                                                                            privateminerapi提供私有的RPC方法来控制矿工。 这些方法可能会被外部用户滥用,并且必须被认为不受信任的用户使用是不安全的。

                                                                                            func NewPrivateMinerAPI

                                                                                            func NewPrivateMinerAPI(e *Ethereum) *PrivateMinerAPI

                                                                                              newprivateminerapi创建一个新的RPC服务,该服务控制此节点的矿工。

                                                                                              func (*PrivateMinerAPI) GetHashrate

                                                                                              func (api *PrivateMinerAPI) GetHashrate() uint64

                                                                                                GetHashrate返回矿工的当前哈希率。

                                                                                                func (*PrivateMinerAPI) SetExtra

                                                                                                func (api *PrivateMinerAPI) SetExtra(extra string) (bool, error)

                                                                                                  setextra设置此矿工挖掘块时包含的额外数据字符串。

                                                                                                  func (*PrivateMinerAPI) SetGasPrice

                                                                                                  func (api *PrivateMinerAPI) SetGasPrice(gasPrice hexutil.Big) bool

                                                                                                    setgasprice为矿工设定了最低可接受的天然气价格。

                                                                                                    func (*PrivateMinerAPI) SetRecommitInterval

                                                                                                    func (api *PrivateMinerAPI) SetRecommitInterval(interval int)

                                                                                                      setrecommittinterval更新矿工密封工作重新投入的时间间隔。

                                                                                                      func (*PrivateMinerAPI) Start

                                                                                                      func (api *PrivateMinerAPI) Start(threads *int) error

                                                                                                        用给定数量的线程启动矿工。如果线程为零,则为数字 启动的工作线程数等于 这个过程。如果挖掘已在运行,则此方法将调整 允许使用和更新事务所需的最低价格的线程 池。

                                                                                                        func (*PrivateMinerAPI) Stop

                                                                                                        func (api *PrivateMinerAPI) Stop() bool

                                                                                                          阻止矿工

                                                                                                          type ProtocolManager

                                                                                                          type ProtocolManager struct {
                                                                                                          	SubProtocols []p2p.Protocol
                                                                                                          	// contains filtered or unexported fields
                                                                                                          }

                                                                                                          func NewProtocolManager

                                                                                                          func NewProtocolManager(config *params.ChainConfig, mode downloader.SyncMode, networkID uint64, mux *event.TypeMux, txpool txPool, engine consensus.Engine, blockchain *core.BlockChain, chaindb ethdb.Database) (*ProtocolManager, error)

                                                                                                            NewProtocolManager返回新的以太坊子协议管理器。以太坊子协议管理对等端 使用以太坊网络。 NewProtocolManager返回新的以太坊子协议管理器。以太坊子协议管理对等端 使用以太坊网络。

                                                                                                            func (*ProtocolManager) BroadcastBlock

                                                                                                            func (pm *ProtocolManager) BroadcastBlock(block *types.Block, propagate bool)

                                                                                                              BroadcastBlock将把一个块传播到它的一个子集的对等端,或者 只会宣布它的可用性(取决于请求的内容)。

                                                                                                              func (*ProtocolManager) BroadcastTxs

                                                                                                              func (pm *ProtocolManager) BroadcastTxs(txs types.Transactions)

                                                                                                                BroadcastTXS将把一批事务传播到所有未知的对等端 已经有给定的事务。

                                                                                                                func (*ProtocolManager) NodeInfo

                                                                                                                func (pm *ProtocolManager) NodeInfo() *NodeInfo

                                                                                                                  nodeinfo检索有关正在运行的主机节点的一些协议元数据。

                                                                                                                  func (*ProtocolManager) Start

                                                                                                                  func (pm *ProtocolManager) Start(maxPeers int)

                                                                                                                  func (*ProtocolManager) Stop

                                                                                                                  func (pm *ProtocolManager) Stop()

                                                                                                                  type PublicDebugAPI

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

                                                                                                                    publicDebugAPI是公开的以太坊完整节点API的集合 在公共调试终结点上。

                                                                                                                    func NewPublicDebugAPI

                                                                                                                    func NewPublicDebugAPI(eth *Ethereum) *PublicDebugAPI

                                                                                                                      newpublicDebugAPI为完整节点创建新的API定义- 以太坊服务的相关公共调试方法。

                                                                                                                      func (*PublicDebugAPI) DumpBlock

                                                                                                                      func (api *PublicDebugAPI) DumpBlock(blockNr rpc.BlockNumber) (state.Dump, error)

                                                                                                                        dumpblock在给定的块中检索数据库的整个状态。

                                                                                                                        type PublicEthereumAPI

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

                                                                                                                          PublicEthereumAPI提供了一个API,用于访问与Ethereum完整节点相关的 信息。

                                                                                                                          func NewPublicEthereumAPI

                                                                                                                          func NewPublicEthereumAPI(e *Ethereum) *PublicEthereumAPI

                                                                                                                            NewPublicEthereumAPI为完整节点创建新的Ethereum协议API。

                                                                                                                            func (*PublicEthereumAPI) Coinbase

                                                                                                                            func (api *PublicEthereumAPI) Coinbase() (common.Address, error)

                                                                                                                              CoinBase是采矿奖励将发送到的地址

                                                                                                                              func (*PublicEthereumAPI) Hashrate

                                                                                                                              func (api *PublicEthereumAPI) Hashrate() hexutil.Uint64

                                                                                                                                hashRate返回pow hashRate

                                                                                                                                func (*PublicEthereumAPI) Validator

                                                                                                                                func (api *PublicEthereumAPI) Validator() (common.Address, error)

                                                                                                                                  validator是挖掘签名者的地址

                                                                                                                                  type PublicMinerAPI

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

                                                                                                                                    publicMinerapi提供了一个API来控制矿工。 它只提供对数据进行操作的方法,这些数据在公开访问时不会带来安全风险。

                                                                                                                                    func NewPublicMinerAPI

                                                                                                                                    func NewPublicMinerAPI(e *Ethereum) *PublicMinerAPI

                                                                                                                                      NewPublicMinerapi创建新的PublicMinerapi实例。

                                                                                                                                      func (*PublicMinerAPI) Mining

                                                                                                                                      func (api *PublicMinerAPI) Mining() bool

                                                                                                                                        挖掘返回当前是否正在挖掘此节点的指示。

                                                                                                                                        type StorageRangeResult

                                                                                                                                        type StorageRangeResult struct {
                                                                                                                                        	Storage storageMap   `json:"storage"`
                                                                                                                                        	NextKey *common.Hash `json:"nextKey"` //如果存储包含trie中的最后一个密钥,则为nil。
                                                                                                                                        }

                                                                                                                                          StestAgRangeReSurt是Debug的StasgStAgReangRangeAPI调用的结果。

                                                                                                                                          type TraceConfig

                                                                                                                                          type TraceConfig struct {
                                                                                                                                          	*vm.LogConfig
                                                                                                                                          	Tracer  *string
                                                                                                                                          	Timeout *string
                                                                                                                                          	Reexec  *uint64
                                                                                                                                          }

                                                                                                                                            traceconfig保存跟踪函数的额外参数。

                                                                                                                                            Directories

                                                                                                                                            Path Synopsis
                                                                                                                                            软件包下载器包含手动全链同步。
                                                                                                                                            软件包下载器包含手动全链同步。
                                                                                                                                            包过滤器为块实现以太坊过滤系统, 事务和日志事件。
                                                                                                                                            包过滤器为块实现以太坊过滤系统, 事务和日志事件。
                                                                                                                                            包跟踪程序是JavaScript事务跟踪程序的集合。
                                                                                                                                            包跟踪程序是JavaScript事务跟踪程序的集合。