consensus

Documentation

Overview

Package consensus implements different Ethereum consensus engines.

Index

• Variables
• func Ecrecover(header *types.Header, sigcache *lru.ARCCache) (common.Address, error)
• func SigHash(header *types.Header) (hash common.Hash)
• type Bft
• type ChainReader
• type Engine
• type PoW

Variables

var (
	// ErrUnknownAncestor is returned when validating a block requires an ancestor
	// that is unknown.
	ErrUnknownAncestor = errors.New("unknown ancestor")

	// ErrPrunedAncestor is returned when validating a block requires an ancestor
	// that is known, but the state of which is not available.
	ErrPrunedAncestor = errors.New("pruned ancestor")

	// ErrFutureBlock is returned when a block's timestamp is in the future according
	// to the current node.
	ErrFutureBlock = errors.New("block in the future")

	// ErrInvalidNumber is returned if a block's number doesn't equal it's parent's
	// plus one.
	ErrInvalidNumber = errors.New("invalid block number")
)

var (
	ExtraSeal = 65 // Fixed number of extra-data suffix bytes reserved for signer seal
	// ErrMissingSignature is returned if a block's extra-data section doesn't seem
	// to contain a 65 byte secp256k1 signature.
	ErrMissingSignature = errors.New("extra-data 65 byte signature suffix missing")
)

Functions

func Ecrecover

func Ecrecover(header *types.Header, sigcache *lru.ARCCache) (common.Address, error)

Ecrecover extracts the Ethereum account address from a signed header.

func SigHash

func SigHash(header *types.Header) (hash common.Hash)

SigHash returns the hash which is used as input for the proof-of-authority signing. It is the hash of the entire header apart from the 65 byte signature contained at the end of the extra data.

Note, the method requires the extra data to be at least 65 bytes, otherwise it panics. This is done to avoid accidentally using both forms (signature present or not), which could be abused to produce different hashes for the same header.

Types

type Bft

type Bft interface {
	Engine

	// the current round of consensus nodes
	CurrentNodes(parentNumber *big.Int, parentHash common.Hash, blockNumber *big.Int) []*discover.Node

	IsCurrentNode(parentNumber *big.Int, parentHash common.Hash, blockNumber *big.Int) bool

	ConsensusNodes(parentNumber *big.Int, parentHash common.Hash, blockNumber *big.Int) []discover.NodeID

	// whether the current node should packing
	ShouldSeal(parentNumber *big.Int, parentHash common.Hash, commitNumber *big.Int) bool

	// received a new block signature
	// verify if the signature is signed by nodeID
	OnBlockSignature(chain ChainReader, nodeID discover.NodeID, sig *cbfttypes.BlockSignature) error

	// Process the BFT signatures
	OnNewBlock(chain ChainReader, block *types.Block) error

	// Process the BFT signatures
	OnPong(nodeID discover.NodeID, netLatency int64) error

	// Send a signal if a block synced from other peer.
	OnBlockSynced()

	// At present, the highest reasonable block, when the node is out of the block, it needs to generate the block based on the highest reasonable block.
	HighestLogicalBlock() *types.Block

	HighestConfirmedBlock() *types.Block

	GetBlock(hash common.Hash, number uint64) *types.Block
	SetPrivateKey(privateKey *ecdsa.PrivateKey)

	Election(state *state.StateDB, parentHash common.Hash, blockNumber *big.Int) ([]*discover.Node, error)

	Switch(state *state.StateDB, blockNumber *big.Int) bool

	GetWitness(state *state.StateDB, flag int, blockNumber *big.Int) ([]*discover.Node, error)

	GetOwnNodeID() discover.NodeID

	SetNodeCache(state *state.StateDB, parentNumber, currentNumber *big.Int, parentHash, currentHash common.Hash) error

	Notify(state vm.StateDB, blockNumber *big.Int) error

	StoreHash(state *state.StateDB, blockNumber *big.Int, blockHash common.Hash)

	Submit2Cache(state *state.StateDB, currBlocknumber *big.Int, blockInterval *big.Int, currBlockhash common.Hash)

	RemovePeer(nodeID discover.NodeID)
}

type ChainReader

type ChainReader interface {
	// Config retrieves the blockchain's chain configuration.
	Config() *params.ChainConfig

	// CurrentHeader retrieves the current header from the local chain.
	CurrentHeader() *types.Header

	// GetHeader retrieves a block header from the database by hash and number.
	GetHeader(hash common.Hash, number uint64) *types.Header

	// GetHeaderByNumber retrieves a block header from the database by number.
	GetHeaderByNumber(number uint64) *types.Header

	// GetHeaderByHash retrieves a block header from the database by its hash.
	GetHeaderByHash(hash common.Hash) *types.Header

	// GetBlock retrieves a block from the database by hash and number.
	GetBlock(hash common.Hash, number uint64) *types.Block
}

ChainReader defines a small collection of methods needed to access the local blockchain during header and/or uncle verification.

type Engine

type Engine interface {
	// Author retrieves the Ethereum address of the account that minted the given
	// block, which may be different from the header's coinbase if a consensus
	// engine is based on signatures.
	Author(header *types.Header) (common.Address, error)

	// VerifyHeader checks whether a header conforms to the consensus rules of a
	// given engine. Verifying the seal may be done optionally here, or explicitly
	// via the VerifySeal method.
	VerifyHeader(chain ChainReader, header *types.Header, seal bool) error

	// VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers
	// concurrently. The method returns a quit channel to abort the operations and
	// a results channel to retrieve the async verifications (the order is that of
	// the input slice).
	VerifyHeaders(chain ChainReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error)

	// VerifyUncles verifies that the given block's uncles conform to the consensus
	// rules of a given engine.
	VerifyUncles(chain ChainReader, block *types.Block) error

	// VerifySeal checks whether the crypto seal on a header is valid according to
	// the consensus rules of the given engine.
	VerifySeal(chain ChainReader, header *types.Header) error

	// Prepare initializes the consensus fields of a block header according to the
	// rules of a particular engine. The changes are executed inline.
	Prepare(chain ChainReader, header *types.Header) error

	// Finalize runs any post-transaction state modifications (e.g. block rewards)
	// and assembles the final block.
	// Note: The block header and state database might be updated to reflect any
	// consensus rules that happen at finalization (e.g. block rewards).
	Finalize(chain ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction,
		uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error)

	// Seal generates a new sealing request for the given input block and pushes
	// the result into the given channel.
	//
	// Note, the method returns immediately and will send the result async. More
	// than one result may also be returned depending on the consensus algorithm.
	Seal(chain ChainReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error

	// SealHash returns the hash of a block prior to it being sealed.
	SealHash(header *types.Header) common.Hash

	// APIs returns the RPC APIs this consensus engine provides.
	APIs(chain ChainReader) []rpc.API

	// Close terminates any background threads maintained by the consensus engine.
	Close() error
}

Engine is an algorithm agnostic consensus engine.

type PoW

type PoW interface {
	Engine

	// Hashrate returns the current mining hashrate of a PoW consensus engine.
	Hashrate() float64
}

PoW is a consensus engine based on proof-of-work.