github.com/bcnmy/go-ethereum@v1.10.27/consensus/consensus.go (about) 1 // Copyright 2017 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 // Package consensus implements different Ethereum consensus engines. 18 package consensus 19 20 import ( 21 "math/big" 22 23 "github.com/ethereum/go-ethereum/common" 24 "github.com/ethereum/go-ethereum/core/state" 25 "github.com/ethereum/go-ethereum/core/types" 26 "github.com/ethereum/go-ethereum/params" 27 "github.com/ethereum/go-ethereum/rpc" 28 ) 29 30 // ChainHeaderReader defines a small collection of methods needed to access the local 31 // blockchain during header verification. 32 type ChainHeaderReader interface { 33 // Config retrieves the blockchain's chain configuration. 34 Config() *params.ChainConfig 35 36 // CurrentHeader retrieves the current header from the local chain. 37 CurrentHeader() *types.Header 38 39 // GetHeader retrieves a block header from the database by hash and number. 40 GetHeader(hash common.Hash, number uint64) *types.Header 41 42 // GetHeaderByNumber retrieves a block header from the database by number. 43 GetHeaderByNumber(number uint64) *types.Header 44 45 // GetHeaderByHash retrieves a block header from the database by its hash. 46 GetHeaderByHash(hash common.Hash) *types.Header 47 48 // GetTd retrieves the total difficulty from the database by hash and number. 49 GetTd(hash common.Hash, number uint64) *big.Int 50 } 51 52 // ChainReader defines a small collection of methods needed to access the local 53 // blockchain during header and/or uncle verification. 54 type ChainReader interface { 55 ChainHeaderReader 56 57 // GetBlock retrieves a block from the database by hash and number. 58 GetBlock(hash common.Hash, number uint64) *types.Block 59 } 60 61 // Engine is an algorithm agnostic consensus engine. 62 type Engine interface { 63 // Author retrieves the Ethereum address of the account that minted the given 64 // block, which may be different from the header's coinbase if a consensus 65 // engine is based on signatures. 66 Author(header *types.Header) (common.Address, error) 67 68 // VerifyHeader checks whether a header conforms to the consensus rules of a 69 // given engine. Verifying the seal may be done optionally here, or explicitly 70 // via the VerifySeal method. 71 VerifyHeader(chain ChainHeaderReader, header *types.Header, seal bool) error 72 73 // VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers 74 // concurrently. The method returns a quit channel to abort the operations and 75 // a results channel to retrieve the async verifications (the order is that of 76 // the input slice). 77 VerifyHeaders(chain ChainHeaderReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) 78 79 // VerifyUncles verifies that the given block's uncles conform to the consensus 80 // rules of a given engine. 81 VerifyUncles(chain ChainReader, block *types.Block) error 82 83 // Prepare initializes the consensus fields of a block header according to the 84 // rules of a particular engine. The changes are executed inline. 85 Prepare(chain ChainHeaderReader, header *types.Header) error 86 87 // Finalize runs any post-transaction state modifications (e.g. block rewards) 88 // but does not assemble the block. 89 // 90 // Note: The block header and state database might be updated to reflect any 91 // consensus rules that happen at finalization (e.g. block rewards). 92 Finalize(chain ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, 93 uncles []*types.Header) 94 95 // FinalizeAndAssemble runs any post-transaction state modifications (e.g. block 96 // rewards) and assembles the final block. 97 // 98 // Note: The block header and state database might be updated to reflect any 99 // consensus rules that happen at finalization (e.g. block rewards). 100 FinalizeAndAssemble(chain ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, 101 uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) 102 103 // Seal generates a new sealing request for the given input block and pushes 104 // the result into the given channel. 105 // 106 // Note, the method returns immediately and will send the result async. More 107 // than one result may also be returned depending on the consensus algorithm. 108 Seal(chain ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error 109 110 // SealHash returns the hash of a block prior to it being sealed. 111 SealHash(header *types.Header) common.Hash 112 113 // CalcDifficulty is the difficulty adjustment algorithm. It returns the difficulty 114 // that a new block should have. 115 CalcDifficulty(chain ChainHeaderReader, time uint64, parent *types.Header) *big.Int 116 117 // APIs returns the RPC APIs this consensus engine provides. 118 APIs(chain ChainHeaderReader) []rpc.API 119 120 // Close terminates any background threads maintained by the consensus engine. 121 Close() error 122 } 123 124 // PoW is a consensus engine based on proof-of-work. 125 type PoW interface { 126 Engine 127 128 // Hashrate returns the current mining hashrate of a PoW consensus engine. 129 Hashrate() float64 130 }