consensus

type AergoRaftAccessor interface {
	Process(ctx context.Context, peerID types.PeerID, m raftpb.Message) error
	IsIDRemoved(peerID types.PeerID) bool
	ReportUnreachable(peerID types.PeerID)
	ReportSnapshot(peerID types.PeerID, status raft.SnapshotStatus)

	SaveFromRemote(r io.Reader, id uint64, msg raftpb.Message) (int64, error)

	GetMemberByID(id uint64) *Member
	GetMemberByPeerID(peerID types.PeerID) *Member
}

type BlockFactory interface {
	Start()
	JobQueue() chan<- interface{}
}

type ChainConsensus interface {
	ChainConsensusCluster

	GetType() ConsensusType
	IsTransactionValid(tx *types.Tx) bool
	VerifyTimestamp(block *types.Block) bool
	VerifySign(block *types.Block) error
	IsBlockValid(block *types.Block, bestBlock *types.Block) error
	Update(block *types.Block)
	Save(tx TxWriter) error
	NeedReorganization(rootNo types.BlockNo) bool
	NeedNotify() bool
	HasWAL() bool // if consensus has WAL, block has already written in db
	IsConnectedBlock(block *types.Block) bool
	IsForkEnable() bool
	Info() string
}

type ChainConsensusCluster interface {
	MakeConfChangeProposal(req *types.MembershipChange) (*ConfChangePropose, error)
}

type ChainDB interface {
	GetBestBlock() (*types.Block, error)
	GetBlockByNo(blockNo types.BlockNo) (*types.Block, error)
	GetHashByNo(blockNo types.BlockNo) ([]byte, error)
	GetBlock(hash []byte) (*types.Block, error)
	GetGenesisInfo() *types.Genesis
	Get(key []byte) []byte
	NewTx() db.Transaction
}

type ChainSnapshot struct {
	No   types.BlockNo `json:"no"`
	Hash []byte        `json:"hash"`
}

type ChainWAL interface {
	ChainDB

	ClearWAL()
	ResetWAL(hardStateInfo *types.HardStateInfo) error
	WriteRaftEntry([]*WalEntry, []*types.Block, []*raftpb.ConfChange) error
	GetRaftEntry(idx uint64) (*WalEntry, error)
	HasWal(identity RaftIdentity) (bool, error)
	GetRaftEntryOfBlock(hash []byte) (*WalEntry, error)
	GetRaftEntryLastIdx() (uint64, error)
	GetRaftEntryIndexOfBlock(hash []byte) (uint64, error)
	GetHardState() (*raftpb.HardState, error)
	WriteHardState(hardstate *raftpb.HardState) error
	WriteSnapshot(snap *raftpb.Snapshot) error
	GetSnapshot() (*raftpb.Snapshot, error)
	WriteIdentity(id *RaftIdentity) error
	GetIdentity() (*RaftIdentity, error)
	WriteConfChangeProgress(id uint64, progress *types.ConfChangeProgress) error
	GetConfChangeProgress(id uint64) (*types.ConfChangeProgress, error)
}

type ConfChangePropose struct {
	Ctx context.Context
	Cc  *raftpb.ConfChange

	ReplyC chan *ConfChangeReply
}

type ConfChangeReply struct {
	Member *Member
	Err    error
}

type Consensus interface {
	ChainConsensus
	ConsensusAccessor
	Ticker() *time.Ticker
	// QueueJob queues block generation job.
	// It waits until next block generation time is reached in raft consensus and sbp.
	QueueJob(now time.Time, jq chan<- interface{})
	BlockFactory() BlockFactory
	QuitChan() chan interface{}
}

type ConsensusAccessor interface {
	ConsensusInfo() *types.ConsensusInfo
	ClusterInfo([]byte) *types.GetClusterInfoResponse
	ConfChange(req *types.MembershipChange) (*Member, error)
	ConfChangeInfo(requestID uint64) (*types.ConfChangeProgress, error)
	// RaftAccessor returns AergoRaftAccessor. It is only valid if chain is raft consensus
	RaftAccessor() AergoRaftAccessor
}

type ConsensusType int

type Constructor func() (Consensus, error)

type DummyRaftAccessor struct {
}

type EntryType int8

type ErrorConsensus struct {
	Msg string
	Err error
}

type Info struct {
	Type   string
	Status *json.RawMessage `json:",omitempty"`
}

type Member struct {
	types.MemberAttr
}

type MembersByName []*Member

type RaftIdentity struct {
	ClusterID uint64
	ID        uint64
	Name      string
	PeerID    string // base58 encoded format
}

type SnapshotData struct {
	Chain          ChainSnapshot `json:"chain"`
	Members        []*Member     `json:"members"`
	RemovedMembers []*Member
}

type TxWriter interface {
	Set(key, value []byte)
}

type WalEntry struct {
	Type  EntryType
	Term  uint64
	Index uint64
	Data  []byte // hash is set if Type is EntryBlock
}