committee

type Commitment struct {
	Data  []byte // Data should be persisted for future initialization
	Proof []byte // Proof denotes the proof the data was honestly computed
	From  int32  // From who this commitment was sent
}

type Config struct {
	// Nodes denotes all nodes the committee can be selected from
	Nodes Nodes
	// How many consensus rounds at minimum the committee remains
	MinimumLifespan int32
	// FailedTotalNodesPercentage is the assumed upper bound
	// on the percentage of nodes that can fail out of all nodes
	// in the network.
	FailedTotalNodesPercentage int64
	// InverseFailureChance is 1/p where p is the probability
	// to select more than a third
	// of failed nodes to the committee.
	// The higher this number is, the larger the committee.
	// The lower this number is, the bigger chance to select
	// a committee with too many failed nodes.
	InverseFailureChance int64
	// ExcludedNodes are nodes the current committee decided
	// not to be included in this committee
	ExcludedNodes []int32
	// MandatoryNodes are nodes that current committee decided
	// that must be in this committee
	MandatoryNodes []int32
	// Weights denote relative multipliers for each node's chance
	// to be selected into a committee.
	Weights []Weight
}

type Feedback struct {
	Commitment    *Commitment  // Commitment to broadcast, if applicable
	ReconShares   []ReconShare // ReconShares to broadcast, if applicable
	NextCommittee []int32      // The next committee, if applicable. It may be equal to the current committee
}

type Input struct {
	// Commitments denotes commitments arriving from nodes
	Commitments []Commitment
	// ReconShares denote the ReconShares received from all nodes if applicable
	ReconShares []ReconShare
	// NextConfig is the configuration of the next committee selection if applicable
	NextConfig Config
}

type Logger interface {
	Debugf(template string, args ...interface{})
	Infof(template string, args ...interface{})
	Errorf(template string, args ...interface{})
	Warnf(template string, args ...interface{})
	Panicf(template string, args ...interface{})
}

type Node struct {
	ID     int32
	PubKey []byte
}

type Nodes []Node

type PrivateKey []byte

type PublicKey []byte

type ReconShare struct {
	Data  []byte // Data should be persisted for future initialization
	Proof []byte // Proof denotes the proof the data was honestly computed
	About int32  // About denotes whose randomness are we reconstructing
	From  int32  // Who sent this ReconShare
}

type Selection interface {
	// GeneratePrivateKey generates a private key for an instance using the given randomness
	GenerateKeyPair(rand io.Reader) (PublicKey, PrivateKey, error)
	// Initialize initializes the committee selection instance with the given identifier and private key,
	// as well as with all the other nodes.
	Initialize(ID int32, PrivateKey PrivateKey, nodes Nodes) error
	// Process interacts with the committee selection and feeds it with events of other remote instances from Input,
	// and receives feedback on a committee change or requests of messages to be sent via Feedback.
	// The operation operates on the given state and the new state is returned.
	Process(State, Input) (Feedback, State, error)
	// VerifyCommitment should be called whenever the node receives a commitment
	// and before passing it to the library or persisting it
	VerifyCommitment(Commitment) error
	// VerifyReconShare should be called whenever the node receives a ReconShare
	// and before passing it to the library or persisting it
	VerifyReconShare(ReconShare) error
}

type State interface {
	Initialize([]byte) error
	ToBytes() []byte
}

type Weight struct {
	ID, Weight int32
}