istanbul

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

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

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

	// Commit delivers an approved proposal to backend.
	// The delivered proposal will be put into blockchain.
	Commit(proposal Proposal, seals [][]byte, round *big.Int) 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) (time.Duration, error)

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

	// SignWithoutHashing sign input data with the backend's private key without hashing the input data
	SignWithoutHashing([]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

	// HasBadProposal returns whether the block with the hash is a bad block
	HasBadProposal(hash common.Hash) bool

	Close() error

	// StartQBFTConsensus stops existing legacy ibft consensus and starts the new qbft consensus
	StartQBFTConsensus() error
}

type Config struct {
	RequestTimeoutSeconds              uint64              `toml:",omitempty"` // The timeout for each Istanbul round in seconds.
	MaxRequestTimeoutSeconds           uint64              `toml:",omitempty"` // Max request timeout for each Istanbul round in seconds.
	BlockPeriod                        uint64              `toml:",omitempty"` // Default minimum difference between two consecutive block's timestamps in second
	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
	AllowedFutureBlockTime             uint64              `toml:",omitempty"` // Max time (in seconds) from current time allowed for blocks, before they're considered future blocks
	Transitions                        []params.Transition // Transition data
	PriorityTransactorsContractAddress common.Address      // PriorityTransactors contract address
}

type Core interface {
	Start() error
	Stop() error
	IsProposer() bool

	// verify if a hash is the same as the proposed block in the current pending request
	//
	// this is useful when the engine is currently the proposer
	//
	// pending request is populated right at the preprepare stage so this would give us the earliest verification
	// to avoid any race condition of coming propagated blocks
	IsCurrentProposal(blockHash common.Hash) bool
}

type Engine interface {
	Address() common.Address
	Author(header *types.Header) (common.Address, error)
	Validators(header *types.Header) ([]common.Address, error)
	Signers(header *types.Header) ([]common.Address, error)
	CommitHeader(header *types.Header, seals [][]byte, round *big.Int) error
	VerifyBlockProposal(chain consensus.ChainHeaderReader, block *types.Block, validators ValidatorSet) (time.Duration, error)
	VerifyHeader(chain consensus.ChainHeaderReader, header *types.Header, parents []*types.Header, validators ValidatorSet) error
	VerifyUncles(chain consensus.ChainReader, block *types.Block) error
	VerifySeal(chain consensus.ChainHeaderReader, header *types.Header, validators ValidatorSet) error
	Prepare(chain consensus.ChainHeaderReader, header *types.Header, validators ValidatorSet) error
	Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header)
	FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error)
	Seal(chain consensus.ChainHeaderReader, block *types.Block, validators ValidatorSet) (*types.Block, error)
	SealHash(header *types.Header) common.Hash
	CalcDifficulty(chain consensus.ChainHeaderReader, time uint64, parent *types.Header) *big.Int
	WriteVote(header *types.Header, candidate common.Address, authorize bool) error
	ReadVote(header *types.Header) (candidate common.Address, authorize bool, err error)
}

type FinalCommittedEvent struct {
}

type MessageEvent struct {
	Code    uint64
	Payload []byte
}

type Preprepare struct {
	View     *View
	Proposal Proposal
}

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 struct {
	Id ProposerPolicyId    // Could be RoundRobin or Sticky
	By ValidatorSortByFunc // func that defines how the ValidatorSet should be sorted
	// contains filtered or unexported fields
}

type ProposerPolicyId uint64

type Request struct {
	Proposal Proposal
}

type RequestEvent 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() ProposerPolicy

	// SortValidators sorts the validators based on the configured By function
	SortValidators()
}

type ValidatorSortByFunc func(v1 Validator, v2 Validator) bool

type Validators []Validator

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