tendermint

type Backend interface {
	// Address returns the NeuralChain address of the node running this backend
	Address() common.Address

	// EventMux returns the event mux used for Core to subscribe/ send events back to Backend.
	// Think of it as pub/sub models
	EventMux() *event.TypeMux

	// Sign signs input data with the backend's private key
	Sign([]byte) ([]byte, error)

	// Gossip sends a message to all validators (exclude self)
	// these message are send via p2p network interface.
	Gossip(valSet ValidatorSet, blockNumber *big.Int, round int64, msgType uint64, payload []byte) error

	// Broadcast sends a message to all validators (including self)
	// It will call gossip and post an identical event to its EventMux().
	Broadcast(valSet ValidatorSet, blockNumber *big.Int, round int64, msgType uint64, payload []byte) error

	// Multicast sends a message to a group of given address
	// returns error if sending is failed, or not found the targets address
	Multicast(targets map[common.Address]bool, payload []byte) error

	// Validators returns the validator set
	// we should only use this method when core is started.
	Validators(blockNumber *big.Int) ValidatorSet

	// CurrentHeadBlock get the current block of from the canonical chain.
	CurrentHeadBlock() *types.Block

	// FindExistingPeers check validator peers exist or not by address
	FindExistingPeers(targets ValidatorSet) map[common.Address]consensus.Peer

	//Commit send the consensus block back to miner, it should also handle the logic after a block get enough vote to be the next block in chain
	Commit(block *types.Block)

	//Cancel send the consensus block back to miner if it is invalid for consensus.
	Cancel(block *types.Block)

	// VerifyProposalHeader 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.
	VerifyProposalHeader(header *types.Header) error

	// VerifyProposalBlock verify post-processor state of proposal block (txs, Root, receipt).
	// If success, the result will be send to the pending tasks of miner
	VerifyProposalBlock(block *types.Block) error
}

type Config struct {
	ProposerPolicy        ProposerPolicy   `toml:",omitempty"` // The policy for proposer selection
	Epoch                 uint64           `toml:",omitempty"` // The number of blocks after which to checkpoint and reset the pending votes
	StakingSCAddress      *common.Address  `toml:",omitempty"` // The staking SC address for validating when deploy SC
	BlockPeriod           uint64           `toml:",omitempty"` // Default minimum difference between two consecutive block's timestamps in second
	TimeoutPropose        time.Duration    //Duration waiting a propose
	TimeoutProposeDelta   time.Duration    //Increment if timeout happens at propose step to reach eventually synchronous
	TimeoutPrevote        time.Duration    //Duration waiting for more prevote after 2/3 received
	TimeoutPrevoteDelta   time.Duration    //Increment if timeout happens at prevoteWait to reach eventually synchronous
	TimeoutPrecommit      time.Duration    //Duration waiting for more precommit after 2/3 received
	TimeoutPrecommitDelta time.Duration    //Duration waiting to increase if precommit wait expired to reach eventually synchronous
	TimeoutCommit         time.Duration    //Duration waiting to start round with new height
	FixedValidators       []common.Address // The fixed validators
	BlockReward           *big.Int         //BlockReward for accumulating reward

	FaultyMode uint64 `toml:",omitempty"` // The faulty node indicates the faulty node's behavior

	UseEVMCaller        bool
	IndexStateVariables *staking.IndexConfigs //The index of state variables has stored in stateDB
}

type FaultyMode uint64

type FinalCommittedEvent struct {
	BlockNumber *big.Int
}

type MessageEvent struct {
	Payload []byte
}

type NewBlockEvent struct {
	Block *types.Block
}

type ProposalSelector func(ValidatorSet, common.Address, int64) Validator

type ProposerPolicy uint64

type StopCoreEvent struct{}

type Validator interface {
	// Address returns address
	Address() common.Address

	// String representation of Validator
	String() string
}

type ValidatorSet interface {
	// Return the validator size
	Size() int
	// Return the validator array
	List() []Validator
	// Get validator by index
	GetByIndex(i int64) Validator
	// Get validator by given address
	// If the address does not exist in the validator set, it will return -1
	GetByAddress(addr common.Address) (int, Validator)
	// AddValidator add the input validator to a list validators. It return false if this validator existed.
	AddValidator(address common.Address) bool
	// RemoveValidator remove the input validator from a list. It return false if the validator exist and is removed.
	// If the validator is not in the set, this function will return false
	RemoveValidator(address common.Address) bool
	// Copy validator set
	Copy() ValidatorSet
	// Get the minimum number of votes for a polka
	MinMajority() int
	// Get the minimum number of peers to archive consensus
	MinPeers() int
	// Get the maximum number of faulty nodes
	F() int
	// V get the minimum number of vote nodes
	V() int
	// Get proposer policy
	Policy() ProposerPolicy
	// Check whether the validator with given address is a proposer
	IsProposer(address common.Address) bool
	// CalcProposer return the proposer for the different of round number indicated
	CalcProposer(lastProposer common.Address, roundDiff int64)
	// GetProposer return the current proposer
	GetProposer() Validator
	// Height return block height when valSet is init
	Height() int64
	// GetNeighbors returns address of neighbor to rebroadcast tendermint message
	GetNeighbors(addr common.Address) map[common.Address]bool
}

type Validators []Validator

type View struct {
	Round       int64
	BlockNumber *big.Int
}