tbft_engine

type BatchMsg interface {
	// BatchMsg的索引
	Sequence() uint64
	// 获取BatchMsg的Key
	Key() []byte
	// 获取BatchMsg签名
	GetSetSignature() interface{}
	// 设置BatchMsg签名
	SetSignature(interface{})
}

type BatchMsgInterpreter interface {
	// TBFT引擎通过监听此chan, 获取一个BatchMsg进行共识
	PrepareBatchMsg() <-chan *ProposalBatchMsg
}

type BlockVotes struct {
	Votes map[string]*tbftpb.Vote
	Sum   uint64
}

type Broadcast func(*Node, *Node) (interface{}, error)

type Coder interface {
	// 实现Proposal的marshal
	MarshalProposal(*Proposal) ([]byte, error)
	// 实现Proposal的unmarshal
	UnmarshalProposal([]byte) (*Proposal, error)
}

type Committer interface {
	// 提交batchMsg
	Commit(BatchMsg, *tbftpb.VoteSet) error
	// 完成batchMsg提交，通知共识开始下一个共识
	CommitDone() <-chan uint64
}

type ConsensusEngine struct {
	sync.RWMutex

	// node id
	Id string

	// Current Consensus State
	*ConsensusState

	// channel for notifying the user of the completion of the commit
	CommitFinishC chan interface{}

	// Timeout = TimeoutPropose + TimeoutProposeDelta * round
	TimeoutPropose        time.Duration
	TimeoutProposeDelta   time.Duration
	TimeoutProposeOptimal time.Duration
	ProposeOptimal        bool
	ProposeOptimalTimer   *time.Timer
	// contains filtered or unexported fields
}

type ConsensusFutureMsg struct {
	Proposal map[int32]*Proposal
	// contains filtered or unexported fields
}

type ConsensusFutureMsgCache struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type ConsensusMsg struct {
	Type tbftpb.TBFTMsgType
	Msg  interface{}
}

type ConsensusRollBack struct {
	Sequence      uint64
	Proposal      *Proposal
	VerifyFailTxs *VerifyFailTxs
}

type ConsensusState struct {

	// node id
	Id string
	// current height
	Height uint64
	// current round
	Round int32
	// current step
	Step tbftpb.Step

	// proposal
	Proposal *TBFTProposal
	// verifing proposal
	VerifingProposal *TBFTProposal
	LockedRound      int32
	// locked proposal
	LockedProposal *Proposal
	ValidRound     int32
	// valid proposal
	ValidProposal *Proposal
	// contains filtered or unexported fields
}

type ConsistentEngine interface {

	// Start 启动一致性引擎
	// ctx 后续扩展用，启动失败返回error
	Start(ctx context.Context) error

	// Stop 停止一致性引擎
	// ctx 后续扩展用，，停止失败返回error
	Stop(ctx context.Context) error

	// AddBroadcaster 添加状态广播器（如一个tbft状态广播器）
	// id 广播器标识，需要保证唯一性
	// broadcast 广播器，需要用户自己实现（如：tbft广播器、maxbft广播器）
	AddBroadcaster(id string, broadcast *StatusBroadcaster) error

	// UpdateNodeStatus 更新本地状态
	// id 节点标识，需要保证唯一性
	// node 需要更新的节点信息（包含节点状态，节点状态可以有多种）
	UpdateNodeStatus(id string, node *Node) error

	// PutRemoter 添加节点
	// id 节点标识，需要保证唯一性
	// node 需要添加的节点信息（包含节点状态，节点状态可以有多种）
	PutRemoter(id string, node *Node) error

	// RemoveRemoter 删除节点
	// id 节点标识，当节点不存在时返回错误消息
	RemoveRemoter(id string) error

	// RegisterStatusCoder 注册状态解析器
	// decoderType 解析器标识，需要保证唯一性
	// decoder 需要添加的解析器，由用户实现（如：tbft解析器）
	RegisterStatusCoder(decoderType int8, decoder *StatusDecoder) error

	// RegisterStatusInterceptor 注册过滤器
	// interceptorType 过滤器标识，需要保证唯一性
	// interceptor 需要添加的过滤器，由用户实现（如：tbft过滤器）
	RegisterStatusInterceptor(interceptorType int8, interceptor *StatusInterceptor) error
	//
	RegisterNetHandle(netHandler NetHandler) error
}

type CtxKey string

type Logger interface {
	Debug(args ...interface{})
	Debugf(format string, args ...interface{})
	Debugw(msg string, keysAndValues ...interface{})
	Error(args ...interface{})
	Errorf(format string, args ...interface{})
	Errorw(msg string, keysAndValues ...interface{})
	Warn(args ...interface{})
	Warnf(format string, args ...interface{})
	Warnw(msg string, keysAndValues ...interface{})
	Info(args ...interface{})
	Infof(format string, args ...interface{})
	Infow(msg string, keysAndValues ...interface{})
	Fatal(args ...interface{})
	Fatalf(format string, args ...interface{})
	Fatalw(msg string, keysAndValues ...interface{})
}

type Message interface {

	// Send 一致性引擎对外发送数据
	// payload 需要发送的消息
	Send(payload interface{})

	// Receive 一致性引擎接收外部数据
	// 返回接收到的消息
	Receive() interface{}

	AddNetMsg(interface{})
}

type NetHandler interface {
	// 发送消息
	// to是发送给指导者，to为""则是广播给所有节点
	BroadCastNetMsg([]byte, string) error
	// TBFT引擎通过监听此chan，可以获取到接收到的网络消息
	Listen() <-chan interface{}
}

type Node struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type ParamsHandler interface {
	// 新的一次共识开始时调用，获取共识需要的参数
	GetNewParams() (validators []string, timeoutPropose time.Duration,
		timeoutProposeDelta time.Duration, tbftBlocksPerProposer uint64,
		proposeOptimal bool, TimeoutProposeOptimal time.Duration, err error)
	GetLastBlockProposer() string
}

type Proposal struct {
	Proposer  string
	Sequence  uint64
	Round     int32
	Content   BatchMsg
	Key       []byte
	Signature interface{}
	TxsRwSet  interface{}
	Qc        []*tbftpb.Vote
}

type ProposalBatchMsg struct {
	BatchMsg    BatchMsg
	CutBatchMsg BatchMsg
	TxsRwSet    interface{}
}

type RemoteState struct {
	sync.RWMutex
	//node id
	Id string
	//current height
	Height uint64
	// current round
	Round int32
	// current step
	Step tbftpb.Step

	// proposal
	Proposal         []byte
	VerifingProposal []byte
	LockedRound      int32
	// locked proposal
	LockedProposal *tbftpb.Proposal
	ValidRound     int32
	// valid proposal
	ValidProposal *tbftpb.Proposal
	RoundVoteSet  *roundVoteSet
}

type Status interface {

	// Type 状态类型
	Type() int8

	// Data 状态内容
	Data() interface{}

	// Update 更新状态
	Update(status Status)
}

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

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

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

type StatusInterceptor struct {
}

type TBFTConsensuEngine interface {
	// 开始
	Start(ctx context.Context) error
	// 结束
	Stop() error
	// 注册网络处理器
	RegisterNetHandler(NetHandler) error
	// 注册共识内容处理器
	RegisterInterpreter(BatchMsgInterpreter) error
	// 注册共识验证器
	RegisterVerifyHandler(Verifier) error
	// 注册wal处理器
	RegisterWalHandler(WalHandler) error
	// 注册提交处理器
	RegisterCommitter(Committer) error
	// 注册日志处理器
	RegisterLogger(Logger) error
	// 注册共识参数处理器
	RegisterParamsHandler(ParamsHandler) error
	// 注册共识Proposal处理器
	RegisterProposalCoder(Coder) error
	// 获取共识状态
	Status() *tbftpb.Status
	// 通知调用者发起提案
	ProposeState() <-chan bool
	// 通知调用者这一轮共识失败
	RollBack() <-chan *ConsensusRollBack
}

type TBFTProposal struct {
	PbMsg *Proposal
	// byte format *tbftpb.Proposal
	Bytes []byte
}

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

type Verifier interface {
	// 对Proposal签名
	SignProposal(*Proposal) (interface{}, error)
	// 对BatchMsg签名
	SignBatchMsg(BatchMsg) (interface{}, error)
	// 对vote签名
	SignVote(*tbftpb.Vote) ([]byte, error)
	// 验证Proposal
	VerifyProposal(*Proposal) error
	// 验证BatchMsg
	VerifyBatchMsg(BatchMsg) (*VerifyResult, error)
	// 通过读写集验证BatchMsg
	VerifyBlockWithRwSets(BatchMsg, interface{}, *tbftpb.VoteSet) error
	// 验证vote
	VerifyVote(*tbftpb.Vote) error
}

type VerifyFailTxs struct {
	Sequence  uint64
	BlockHash []byte
	TxIds     []string
}

type VerifyResult struct {
	VerifiedBatchMsg BatchMsg
	Code             tbftpb.VerifyResult_Code
	Msg              string
	TxsRwSet         interface{}
	VerifyFailTxs    []string
}

type VoteSet struct {
	Type         tbftpb.VoteType
	Height       uint64
	Round        int32
	Sum          uint64
	Maj23        []byte
	Votes        map[string]*tbftpb.Vote
	VotesByBlock map[string]*BlockVotes
	// contains filtered or unexported fields
}

type WalEntry struct {
	WalEntryType tbftpb.WalEntryType
	Sequence     uint64
	Proposal     *Proposal
}

type WalHandler interface {
	Write(*WalEntry) error
	// 读取一个最新的wal内容
	// tbft引擎启动时恢复只需要一个最新的wal内容
	ReadLast() (*WalEntry, error)
}