consensus

Documentation

Index

• Constants
• Variables
• type Broadcaster
• type ChainReader
• type ChainValidator
• type Engine
• type EngineStartStop
• type Handler
• type Peer
• type PeerState
• type Protocol
• type Tendermint

Constants

const (
	Eth62 = 62
	Eth63 = 63
)

Variables

var (
	ErrUnknownAncestor = errors.New("unknown ancestor")

	ErrPrunedAncestor = errors.New("pruned ancestor")

	ErrFutureBlock = errors.New("block in the future")

	ErrInvalidNumber = errors.New("invalid block number")
)

var (
	EthProtocol = Protocol{
		Name:     "eth",
		Versions: []uint{Eth62, Eth63},
		Lengths:  []uint64{17, 8},
	}
)

Types

type Broadcaster

type Broadcaster interface {
	Enqueue(id string, block *types.Block)

	FindPeers(map[common.Address]bool) map[common.Address]Peer

	BroadcastBlock(block *types.Block, propagate bool)

	BroadcastMessage(msgcode uint64, data interface{})

	TryFixBadPreimages()
}

type ChainReader

type ChainReader interface {
	Config() *params.ChainConfig

	CurrentHeader() *types.Header

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

	GetHeaderByNumber(number uint64) *types.Header

	GetHeaderByHash(hash common.Hash) *types.Header

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

	GetBlockByNumber(number uint64) *types.Block

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

	CurrentBlock() *types.Block

	State() (*state.StateDB, error)
}

type ChainValidator

type ChainValidator interface {
	ValidateBlock(block *types.Block) (*state.StateDB, types.Receipts, *types.PendingOps, error)
}

type Engine

type Engine interface {
	Author(header *types.Header) (common.Address, error)

	VerifyHeader(chain ChainReader, header *types.Header, seal bool) error

	VerifyHeaders(chain ChainReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error)

	VerifyUncles(chain ChainReader, block *types.Block) error

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

	Prepare(chain ChainReader, header *types.Header) error

	Finalize(chain ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, totalGasFee *big.Int,
		uncles []*types.Header, receipts []*types.Receipt, ops *types.PendingOps) (*types.Block, error)

	Seal(chain ChainReader, block *types.Block, stop <-chan struct{}) (interface{}, error)

	CalcDifficulty(chain ChainReader, time uint64, parent *types.Header) *big.Int

	APIs(chain ChainReader) []rpc.API

	Close() error

	Protocol() Protocol
}

type EngineStartStop

type EngineStartStop interface {
	Start(chain ChainReader, currentBlock func() *types.Block, hasBadBlock func(hash common.Hash) bool) error

	Stop() error
}

type Handler

type Handler interface {
	NewChainHead(block *types.Block) error

	HandleMsg(chID uint64, src Peer, msgBytes []byte) (bool, error)

	SetBroadcaster(Broadcaster)

	GetBroadcaster() Broadcaster

	AddPeer(src Peer)

	RemovePeer(src Peer)
}

type Peer

type Peer interface {
	Send(msgcode uint64, data interface{}) error

	SendNewBlock(block *types.Block, td *big.Int) error

	GetPeerState() PeerState

	GetKey() string

	GetConsensusKey() string

	SetPeerState(ps PeerState)
}

type PeerState

type PeerState interface {
	GetHeight() uint64
	Disconnect()
}

type Protocol

type Protocol struct {
	Name string

	Versions []uint

	Lengths []uint64
}

type Tendermint

type Tendermint interface {
	Engine

	EngineStartStop

	ShouldStart() bool

	IsStarted() bool

	ForceStart()

	GetEpoch() *epoch.Epoch

	SetEpoch(ep *epoch.Epoch)

	PrivateValidator() common.Address

	VerifyHeaderBeforeConsensus(chain ChainReader, header *types.Header, seal bool) error
}