committee

type BalancesMsg struct {
	Balances map[valuetransaction.ID][]*balance.Balance
}

type BatchHeaderMsg struct {
	PeerMsgHeader
	// state index of the batch
	Size uint16
	// approving transaction id
	StateTransactionId valuetransaction.ID
}

type Committee interface {
	Address() *address.Address
	OwnerAddress() *address.Address
	Color() *balance.Color
	Size() uint16
	Quorum() uint16
	OwnPeerIndex() uint16
	NumPeers() uint16
	SendMsg(targetPeerIndex uint16, msgType byte, msgData []byte) error
	SendMsgToCommitteePeers(msgType byte, msgData []byte, ts int64) uint16
	SendMsgInSequence(msgType byte, msgData []byte, seqIndex uint16, seq []uint16) (uint16, error)
	IsAlivePeer(peerIndex uint16) bool
	ReceiveMessage(msg interface{})
	InitTestRound()
	HasQuorum() bool
	PeerStatus() []*PeerStatus
	//
	SetReadyStateManager()
	SetReadyConsensus()
	Dismiss()
	IsDismissed() bool
	GetRequestProcessingStatus(*sctransaction.RequestId) RequestProcessingStatus
}

type GetBatchMsg struct {
	PeerMsgHeader
}

type NotifyFinalResultPostedMsg struct {
	PeerMsgHeader
	TxId valuetransaction.ID
}

type NotifyReqMsg struct {
	PeerMsgHeader
	// list of request ids ordered by the time of arrival
	RequestIds []sctransaction.RequestId
}

type Operator interface {
	EventProcessorReady(ProcessorIsReady)
	EventStateTransitionMsg(*StateTransitionMsg)
	EventBalancesMsg(BalancesMsg)
	EventRequestMsg(*RequestMsg)
	EventNotifyReqMsg(*NotifyReqMsg)
	EventStartProcessingBatchMsg(*StartProcessingBatchMsg)
	EventResultCalculated(*vm.VMTask)
	EventSignedHashMsg(*SignedHashMsg)
	EventNotifyFinalResultPostedMsg(*NotifyFinalResultPostedMsg)
	EventTransactionInclusionLevelMsg(msg *TransactionInclusionLevelMsg)
	EventTimerMsg(TimerTick)
	//
	IsRequestInBacklog(*sctransaction.RequestId) bool
}

type PeerMsgHeader struct {
	// is set upon receive the message
	SenderIndex uint16
	// state index in the context of which the message is sent
	StateIndex uint32
}

type PeerStatus struct {
	Index     int
	PeeringID string
	IsSelf    bool
	Connected bool
}

type PendingBatchMsg struct {
	Batch state.Batch
}

type ProcessorIsReady struct {
	ProgramHash string // base58
}

type RequestMsg struct {
	*sctransaction.Transaction
	Index uint16
}

type RequestProcessingStatus int

type SignedHashMsg struct {
	PeerMsgHeader
	// timestamp of this message. Field is set upon receive the message to sender's timestamp
	Timestamp int64
	// returns hash of all req ids
	BatchHash hashing.HashValue
	// original timestamp, the parameter for calculations, which is signed as part of the essence
	OrigTimestamp int64
	// hash of the signed data (essence)
	EssenceHash hashing.HashValue
	// signature
	SigShare tbdn.SigShare
}

type StartProcessingBatchMsg struct {
	PeerMsgHeader
	// timestamp of the message. Field is set upon receive the message to sender's timestamp
	Timestamp int64
	// batch of request ids
	RequestIds []sctransaction.RequestId
	// reward address
	RewardAddress address.Address
	// balances/outputs
	Balances map[valuetransaction.ID][]*balance.Balance
}

type StateIndexPingPongMsg struct {
	PeerMsgHeader
	RSVP bool
}

type StateManager interface {
	EvidenceStateIndex(idx uint32)
	EventStateIndexPingPongMsg(msg *StateIndexPingPongMsg)
	EventGetBatchMsg(msg *GetBatchMsg)
	EventBatchHeaderMsg(msg *BatchHeaderMsg)
	EventStateUpdateMsg(msg *StateUpdateMsg)
	EventStateTransactionMsg(msg *StateTransactionMsg)
	EventPendingBatchMsg(msg PendingBatchMsg)
	EventTimerMsg(msg TimerTick)
}

type StateTransactionEvidenced struct {
	TxId      valuetransaction.ID
	StateHash hashing.HashValue
}

type StateTransactionMsg struct {
	*sctransaction.Transaction
}

type StateTransitionMsg struct {
	// new variable state
	VariableState state.VirtualState
	// corresponding state transaction
	StateTransaction *sctransaction.Transaction
	// processed requests
	RequestIds []*sctransaction.RequestId
	// is the state index last seen
	Synchronized bool
}

type StateUpdateMsg struct {
	PeerMsgHeader
	// state update
	StateUpdate state.StateUpdate
	// position in a batch
	BatchIndex uint16
}

type TestTraceMsg struct {
	PeerMsgHeader
	InitTime      int64
	InitPeerIndex uint16
	Sequence      []uint16
	NumHops       uint16
}

type TimerTick int

type TransactionInclusionLevelMsg struct {
	TxId  *valuetransaction.ID
	Level byte
}