iris

type Backend interface {
	// Address returns the owner's address
	Address() common.Address

	// Validators returns the validator set
	Validators(proposal Proposal) ValidatorSet

	// EventMux returns the event mux in backend
	EventMux() *event.TypeMux

	MsgFeed() *event.Feed

	// Broadcast sends a message to all validators (include self)
	Broadcast(valSet ValidatorSet, payload []byte) error

	// Gossip sends a message to all validators (exclude self)
	Gossip(valSet ValidatorSet, payload []byte) error

	// Commit delivers an approved proposal to backend.
	// The delivered proposal will be put into blockchain.
	Commit(proposal Proposal, seals [][]byte) error

	// Verify verifies the proposal. If a consensus.ErrFutureBlock error is returned,
	// the time difference of the proposal and current time is also returned.
	Verify(Proposal, bool) (time.Duration, error)

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

	// CheckSignature verifies the signature by checking if it's signed by
	// the given validator
	CheckSignature(data []byte, addr common.Address, sig []byte) error

	// LastProposal retrieves latest committed proposal and the address of proposer
	LastProposal() (Proposal, common.Address)

	// HasPropsal checks if the combination of the given hash and height matches any existing blocks
	HasPropsal(hash common.Hash, number *big.Int) bool

	// GetProposer returns the proposer of the given block height
	GetProposer(number uint64) common.Address

	// ParentValidators returns the validator set of the given proposal's parent block
	ParentValidators(proposal Proposal) ValidatorSet

	// SetConsensusTypeMuxSub set TypeMuxSubscription
	SetConsensusTypeMuxSub(event *event.TypeMuxSubscription)

	GetConsensusTypeMuxSub() (*event.TypeMuxSubscription, error)
	//SetConsensusStartTime set consensus start time
	SetConsensusStartTime(time uint64)

	//GetConsensusStartTime get consensus start time
	GetConsensusStartTime() uint64
}

type CommittedEvent struct {
	BlockNum           uint64
	ConsensusStartTime uint64
	CommittedTime      uint64
	TxCount            uint64
}

type Config params.IstanbulConfig

type FinalCommittedEvent struct {
}

type MessageEvent struct {
	Payload []byte
}

type Preprepare struct {
	View     *View
	Proposal Proposal

	LockedHash     common.Hash
	LockedRound    *big.Int
	LockedPrepares interface{}
}

type Proposal interface {
	// Number retrieves the sequence number of this proposal.
	Number() *big.Int

	// Hash retrieves the hash of this proposal.
	Hash() common.Hash

	EncodeRLP(w io.Writer) error

	DecodeRLP(s *rlp.Stream) error

	String() string
}

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

type ProposerPolicy params.ProposerPolicy

type Request struct {
	Proposal Proposal
	Round    *big.Int
}

type RequestEvent struct {
	Proposal Proposal
}

type SingleCommittedEvent struct {
	Proposal Proposal
}

type Subject struct {
	View   *View
	Digest common.Hash
}

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

	// String representation of Validator
	String() string
}

type ValidatorSet interface {
	// Calculate the proposer
	CalcProposer(lastProposer common.Address, round uint64)
	// Return the validator size
	Size() int
	// Return the validator array
	List() []Validator
	// Get validator by index
	GetByIndex(i uint64) Validator
	// Get validator by given address
	GetByAddress(addr common.Address) (int, Validator)
	// Get current proposer
	GetProposer() Validator
	// Check whether the validator with given address is a proposer
	IsProposer(address common.Address) bool
	// Add validator
	AddValidator(address common.Address) bool
	// Remove validator
	RemoveValidator(address common.Address) bool
	// Copy validator set
	Copy() ValidatorSet
	// Get the maximum number of faulty nodes
	F() int
	// Get proposer policy
	Policy() params.ProposerPolicy
}

type Validators []Validator

type View struct {
	Round    *big.Int
	Sequence *big.Int
}