types

type AckRes struct {
	ACK     bool
	Height  int64
	BlkHash Hash
	AppHash *Hash

	// Signature
	PubKeyType crypto.KeyType
	PubKey     []byte // crypto.PublicKey
	Signature  []byte
}

type AckStatus int

type BlockGetter interface {
	Have(Hash) bool
	Get(Hash) (*types.Block, *CommitInfo, error)
	GetByHeight(int64) (Hash, *types.Block, *CommitInfo, error) // note: we can impl GetBlockHeader easily too
}

type BlockResultsStorer interface {
	StoreResults(hash Hash, results []types.TxResult) error
	Results(hash Hash) ([]types.TxResult, error)
	Result(hash Hash, idx uint32) (*types.TxResult, error)
}

type BlockStore interface {
	BlockGetter
	BlockStorer
	TxGetter
	BlockResultsStorer

	Best() (height int64, blkHash, appHash Hash, stamp time.Time)

	PreFetch(Hash) (bool, func()) // should be app level instead (TODO: remove)

	Close() error
}

type BlockStorer interface {
	Store(*types.Block, *CommitInfo) error
}

type CommitInfo struct {
	AppHash      Hash
	Votes        []*VoteInfo
	ParamUpdates types.ParamUpdates
}

type ConsensusReset struct {
	ToHeight int64
	TxIDs    []Hash
}

type DiscoveryRequest struct{}

type DiscoveryResponse struct {
	BestHeight int64
}

type Hash = types.Hash

type HexBytes = types.HexBytes

type MemPool interface {
	Size() int
	ReapN(int) []NamedTx
	Get(Hash) *types.Transaction
	Remove(Hash)
	Store(Hash, *types.Transaction)
	PeekN(n int) []NamedTx
	// Check([]byte)
	PreFetch(txid Hash) bool // should be app level instead
}

type NamedTx struct {
	Hash Hash
	Tx   *types.Transaction
}

type NodeStatus struct {
	Role            string                   `json:"role"`
	CatchingUp      bool                     `json:"catching_up"`
	CommittedHeader *types.BlockHeader       `json:"committed_header"`
	CommitInfo      *CommitInfo              `json:"commit_info"`
	Params          *types.NetworkParameters `json:"params"`
}

type QualifiedBlock struct {
	Block    *types.Block
	Hash     Hash
	Proposed bool
	AppHash  *Hash
}

type RawGetter interface {
	GetRaw(Hash) ([]byte, error)
	GetRawByHeight(int64) (Hash, []byte)
}

type Role int

type Signature struct {
	PubKeyType crypto.KeyType
	PubKey     []byte // public key of the validator

	Data []byte
}

type TxGetter interface {
	GetTx(txHash types.Hash) (raw *types.Transaction, height int64, blkHash types.Hash, blkIdx uint32, err error)
	HaveTx(Hash) bool
}

type VoteInfo struct {
	// VoteSignature is the signature of the blkHash + nack | blkHash + ack + appHash
	Signature Signature

	// Ack is set to true if the validator agrees with the block
	// in terms of the AppHash, ValidatorSet, MerkleRoot of Txs etc.
	AckStatus AckStatus
	// AppHash is optional, it set only if the AckStatus is AckStatusDivereged.
	// AppHash is implied to be the AppHash in the CommitInfo if the AckStatus is AckStatusAgree.
	// AppHash is nil if the AckStatus is AckStatusDisagree.
	AppHash *Hash
}