manager

type AbnormalRecovering interface {
	CollectConsensusStatus(height uint32, status *msg.ConsensusStatus) error
	RecoverFromConsensusStatus(status *msg.ConsensusStatus) error
}

type Consensus interface {
	AbnormalRecovering

	IsRunning() bool
	SetRunning()
	IsReady() bool
	SetReady()

	IsOnDuty() bool
	SetOnDuty(onDuty bool)

	IsArbitratorOnDuty(arbitrator string) bool
	GetOnDutyArbitrator() string

	StartConsensus(b *types.Block)
	ProcessBlock(b *types.Block)

	ChangeView()
	TryChangeView() bool
	GetViewOffset() uint32
}

type ConsensusBlockCache struct {
	ConsensusBlocks    map[common.Uint256]*types.Block
	ConsensusBlockList []common.Uint256

	Listener ConsensusBlockCacheListener
}

type ConsensusBlockCacheListener interface {
	OnBlockAdded(b *types.Block)
}

type DposEventConditionHandler interface {
	TryStartNewConsensus(b *types.Block) bool

	ChangeView(firstBlockHash *common.Uint256)

	StartNewProposal(p types.DPosProposal)

	ProcessAcceptVote(id peer.PID, p types.DPosProposalVote)
	ProcessRejectVote(id peer.PID, p types.DPosProposalVote)
}

type DposHandlerSwitch interface {
	ViewListener
	DposEventConditionHandler

	Initialize(dispatcher ProposalDispatcher, consensus Consensus)
	SwitchTo(isOnDuty bool)

	FinishConsensus()

	RequestAbnormalRecovering()
	HelpToRecoverAbnormal(id peer.PID, height uint32)
	RecoverAbnormal(status *msg2.ConsensusStatus)

	ResponseGetBlocks(id peer.PID, startBlockHeight, endBlockHeight uint32)
}

type DposManager interface {
	NetworkEventListener

	GetPublicKey() string
	GetBlockCache() *ConsensusBlockCache
	GetArbitrators() interfaces.Arbitrators

	Initialize(handler DposHandlerSwitch, dispatcher ProposalDispatcher, consensus Consensus, network DposNetwork, illegalMonitor IllegalBehaviorMonitor, blockPool *mempool.BlockPool, txPool *mempool.TxPool, node protocol.Noder)

	Recover()

	ProcessHigherBlock(b *types.Block)
	ConfirmBlock()

	ChangeConsensus(onDuty bool)

	AppendConfirm(confirm *types.DPosProposalVoteSlot) (bool, bool, error)
	AppendToTxnPool(txn *types.Transaction) errors.ErrCode
	Relay(from protocol.Noder, message interface{}) error
}

type DposNetwork interface {
	Initialize(dnConfig DposNetworkConfig)

	Start()
	Stop() error

	SendMessageToPeer(id peer.PID, msg elap2p.Message) error
	BroadcastMessage(msg elap2p.Message)

	UpdatePeers(arbitrators [][]byte) error
	ChangeHeight(height uint32) error

	GetActivePeer() *peer.PID
}

type DposNetworkConfig struct {
	ProposalDispatcher ProposalDispatcher
	Store              interfaces.IDposStore
}

type DposNormalHandler struct {
	// contains filtered or unexported fields
}

type DposOnDutyHandler struct {
	// contains filtered or unexported fields
}

type IllegalBehaviorMonitor interface {
	IsBlockValid(block *types.Block) bool

	AddProposal(proposal types.DPosProposal)
	Reset(changeView bool)

	IsLegalProposal(p *types.DPosProposal) (*types.DPosProposal, bool)
	ProcessIllegalProposal(first, second *types.DPosProposal)

	ProcessIllegalVote(first, second *types.DPosProposalVote)
	IsLegalVote(v *types.DPosProposalVote) (*types.DPosProposalVote, bool)

	AddProposalEvidence(evidence *types.DposIllegalProposals)
	AddVoteEvidence(evidence *types.DposIllegalVotes)
	AddBlockEvidence(evidence *types.DposIllegalBlocks)
}

type NetworkEventListener interface {
	StatusSyncEventListener

	OnProposalReceived(id peer.PID, p types.DPosProposal)
	OnVoteReceived(id peer.PID, p types.DPosProposalVote)
	OnVoteRejected(id peer.PID, p types.DPosProposalVote)

	OnChangeView()
	OnBadNetwork()

	OnBlockReceived(b *types.Block, confirmed bool)
	OnConfirmReceived(p *types.DPosProposalVoteSlot)
	OnIllegalBlocksReceived(i *types.DposIllegalBlocks)
}

type ProposalDispatcher interface {
	AbnormalRecovering

	//status
	GetProcessingBlock() *types.Block
	GetProcessingProposal() *types.DPosProposal
	IsProcessingBlockEmpty() bool
	CurrentHeight() uint32

	//proposal
	StartProposal(b *types.Block)
	CleanProposals(changeView bool)
	FinishProposal()
	TryStartSpeculatingProposal(b *types.Block)
	ProcessProposal(d types.DPosProposal)

	FinishConsensus()

	ProcessVote(v types.DPosProposalVote, accept bool)
	AddPendingVote(v types.DPosProposalVote)

	OnAbnormalStateDetected()
	RequestAbnormalRecovering()
	TryAppendAndBroadcastConfirmBlockMsg() bool
}

type StatusSyncEventListener interface {
	OnPing(id peer.PID, height uint32)
	OnPong(id peer.PID, height uint32)
	OnBlock(id peer.PID, block *types.Block)
	OnInv(id peer.PID, blockHash common.Uint256)
	OnGetBlock(id peer.PID, blockHash common.Uint256)
	OnGetBlocks(id peer.PID, startBlockHeight, endBlockHeight uint32)
	OnResponseBlocks(id peer.PID, blockConfirms []*types.DposBlock)
	OnRequestConsensus(id peer.PID, height uint32)
	OnResponseConsensus(id peer.PID, status *msg.ConsensusStatus)
	OnRequestProposal(id peer.PID, hash common.Uint256)
	OnIllegalProposalReceived(id peer.PID, proposals *types.DposIllegalProposals)
	OnIllegalVotesReceived(id peer.PID, votes *types.DposIllegalVotes)
}

type ViewListener interface {
	OnViewChanged(isOnDuty bool)
}