consensus

package
v0.9.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 26, 2019 License: GPL-3.0 Imports: 14 Imported by: 0

Documentation

Overview

Package consensus implements different Ethereum consensus engines.

Package consensus implements different Ethereum consensus engines.

Index

Constants

View Source 
const (
	Eth62 = 62
	Eth63 = 63
)

Constants to match up protocol versions and messages

Variables

View Source 
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")
)
View Source 
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")
)
View Source 
var (
	EthProtocol = Protocol{
		Name:     "eth",
		Versions: []uint{Eth62, Eth63},
		Lengths:  []uint64{17, 8},
	}
)

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

	// Returns the current consensus node address list.
	ConsensusNodes() ([]discover.NodeID, error)

	// Returns whether the current node is out of the block
	ShouldSeal() (bool, error)

	// Received a new block signature
	// Need to 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()

	CheckConsensusNode(nodeID discover.NodeID) (bool, error)

	IsConsensusNode() (bool, error)

	// 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)

	IsPrimaryNode() bool
}

type BftMock 

type BftMock struct {
}

func (*BftMock) APIs 

func (bm *BftMock) APIs(chain ChainReader) []rpc.API

APIs returns the RPC APIs this consensus engine provides.

func (*BftMock) Author 

func (bm *BftMock) Author(header *types.Header) (common.Address, error)

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.

func (*BftMock) CheckConsensusNode 

func (bm *BftMock) CheckConsensusNode(nodeID discover.NodeID) (bool, error)

func (*BftMock) Close 

func (bm *BftMock) Close() error

Close terminates any background threads maintained by the consensus engine.

func (*BftMock) ConsensusNodes 

func (bm *BftMock) ConsensusNodes() ([]discover.NodeID, error)

Returns the current consensus node address list.

func (*BftMock) Finalize 

func (bm *BftMock) Finalize(chain ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction,
	receipts []*types.Receipt) (*types.Block, 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).

func (*BftMock) GetBlock 

func (bm *BftMock) GetBlock(hash common.Hash, number uint64) *types.Block

func (*BftMock) HighestConfirmedBlock 

func (bm *BftMock) HighestConfirmedBlock() *types.Block

func (*BftMock) HighestLogicalBlock 

func (bm *BftMock) HighestLogicalBlock() *types.Block

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.

func (*BftMock) IsConsensusNode 

func (bm *BftMock) IsConsensusNode() (bool, error)

func (*BftMock) OnBlockSignature 

func (bm *BftMock) OnBlockSignature(chain ChainReader, nodeID discover.NodeID, sig *cbfttypes.BlockSignature) error

Received a new block signature Need to verify if the signature is signed by nodeID

func (*BftMock) OnBlockSynced 

func (bm *BftMock) OnBlockSynced()

Send a signal if a block synced from other peer.

func (*BftMock) OnNewBlock 

func (bm *BftMock) OnNewBlock(chain ChainReader, block *types.Block) error

Process the BFT signatures

func (*BftMock) OnPong 

func (bm *BftMock) OnPong(nodeID discover.NodeID, netLatency int64) error

Process the BFT signatures

func (*BftMock) Prepare 

func (bm *BftMock) Prepare(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.

func (*BftMock) Seal 

func (bm *BftMock) Seal(chain ChainReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) 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.

func (*BftMock) SealHash 

func (bm *BftMock) SealHash(header *types.Header) common.Hash

SealHash returns the hash of a block prior to it being sealed.

func (*BftMock) SetPrivateKey 

func (bm *BftMock) SetPrivateKey(privateKey *ecdsa.PrivateKey)

func (*BftMock) ShouldSeal 

func (bm *BftMock) ShouldSeal() (bool, error)

Returns whether the current node is out of the block

func (*BftMock) VerifyHeader 

func (bm *BftMock) VerifyHeader(chain ChainReader, header *types.Header, seal bool) 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.

func (*BftMock) VerifyHeaders 

func (bm *BftMock) VerifyHeaders(chain ChainReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan 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).

func (*BftMock) VerifySeal 

func (bm *BftMock) VerifySeal(chain ChainReader, header *types.Header) error

VerifySeal checks whether the crypto seal on a header is valid according to the consensus rules of the given engine.

type Broadcaster 

type Broadcaster interface {
	// Enqueue add a block into fetcher queue
	Enqueue(id string, block *types.Block)
	// FindPeers retrives peers by addresses
	FindPeers(map[common.Address]bool) map[common.Address]Peer
}

Broadcaster defines the interface to enqueue blocks to fetcher and find peer

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 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)

	// 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,
		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{}) (*types.Block, 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 Handler 

type Handler interface {
	// NewChainHead handles a new head block comes
	NewChainHead() error

	// HandleMsg handles a message from peer
	HandleMsg(address common.Address, data p2p.Msg) (bool, error)

	// SetBroadcaster sets the broadcaster to send message to peers
	SetBroadcaster(Broadcaster)
}

Handler should be implemented is the consensus needs to handle and send peer's message

type Istanbul 

type Istanbul interface {
	Engine

	ShouldSeal() bool

	// Start starts the engine
	Start(chain ChainReader, currentBlock func() *types.Block, hasBadBlock func(hash common.Hash) bool) error

	// Stop stops the engine
	Stop() error
}

Istanbul is a consensus engine to avoid byzantine failure

type Peer 

type Peer interface {
	// Send sends the message to this peer
	Send(msgcode uint64, data interface{}) error
}

Peer defines the interface to communicate with peer

type Protocol 

type Protocol struct {
	// Official short name of the protocol used during capability negotiation.
	Name string
	// Supported versions of the eth protocol (first is primary).
	Versions []uint
	// Number of implemented message corresponding to different protocol versions.
	Lengths []uint64
}

Protocol defines the protocol of the consensus

Source Files

View all Source files

Directories

Path Synopsis
Package bft implements the BFT consensus engine.
 Package bft implements the BFT consensus engine.
backend
core
validator

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.