consinterface

type AdditionalForwardCheckerOps interface {
	// ShouldForward determines is forwarding is necessary based on if a message has made progress
	// towards a decision in consensus. For example in all to all communication
	// pattern it should return false since forwarding is not necessary.
	// Is proposal messages is true if the message is a proposal.
	ShouldForward(progress bool, isProposalMessage bool) bool
	// GetFanOut returns the number of nodes messages are forwarded to.
	GetFanOut() int

	// GetForwardList is called before a message is broadcast, it takes as input the list of all nodes in the system.
	// It returns the list of public keys to which the message should be sent.
	GetNewForwardListFunc() channelinterface.NewForwardFuncFilter

	// GetHalfHalfForwardListFunc is the same as GetNewForwardListFunc except is returns functions that broadcast
	// to half of the participants.
	GetHalfHalfForwardListFunc() (firstHalf, secondHalf channelinterface.NewForwardFuncFilter)

	// GetNoProgressForwardFunc is called before a noprogress message is broadcast.
	GetNoProgressForwardFunc() channelinterface.NewForwardFuncFilter
}

type BasicConsItem interface {
	// GetHeader should a blank message header for the HeaderID, this object will be used to deserialize a message into itself (see consinterface.DeserializeMessage).
	GetHeader(emptyPub sig.Pub, generalConfig *generalconfig.GeneralConfig, headerID messages.HeaderID) (messages.MsgHeader, error)
	// GetBufferCount checks a MessageID and returns the thresholds for which it should be forwarded using the BufferForwarder (see forwardchecker.ForwardChecker interface).
	// endThreshold is the number of signatures needed to fully support this message (for example a leader message would be 1, and an echo message would be n-t),
	// maxPossible is the maximum different possible signatures valid for this message (for example a leader message would be 1, and an echo message would be n),
	// msgid is the MsgID of the message.
	// Forward thresholds are computed by nextThreshold*Forwarder.GetFanOut() (i.e. it grows exponentionally), until the message is forwarded after maxPossible has been reached.
	// If endThreshold < 1, then the message is not forwarded (i.e. we expect the original sender to handling the sending to all nodes).
	GetBufferCount(messages.MsgIDHeader, *generalconfig.GeneralConfig, *MemCheckers) (endThreshold int, maxPossible int, msgid messages.MsgID, err error) // How many of the same msg to buff before forwarding
}

type BufferCountFunc func(messages.MsgIDHeader, *generalconfig.GeneralConfig, *MemCheckers) (
	endThreshold int, maxPossible int, msgid messages.MsgID, err error)

type ByzBroadcastFunc func(nextCoordPub sig.Pub,
	ci *ConsInterfaceItems,
	msg messages.InternalSignedMsgHeader,
	signMessage bool,
	filter channelinterface.NewForwardFuncFilter,
	mainChannel channelinterface.MainChannel,
	gc *generalconfig.GeneralConfig,
	additionalMsgs ...messages.MsgHeader)

type CausalConsInterfaceState struct {
	ProposalInfo map[types.ParentConsensusHash]CausalStateMachineInterface // Interface to the state machine.

	// Set of proposals to be validated.
	// It is a map from a child index to a list of proposals.
	// Proposals that try to consume a non-existing child output will be added here.
	// When the child output is created after a decision these will be reprocessed.
	// TODO if a proposal arrives after the child item is consumed it will remain here forever, need to do GC
	ProposalsToValidate map[types.ConsensusHash][]*channelinterface.RcvMsg

	IsInStorageInit bool // Used during initialization, when recovering from disk this is set to true so we don't send messages when we reply to values received.

	DecidedMap  map[types.ParentConsensusHash]bool // TODO clean this up
	LastDecided types.ParentConsensusHash
	// contains filtered or unexported fields
}

type CausalStateMachineInterface interface {
	GeneralStateMachineInterface

	CheckOK()

	// Init is called to initialize the object, lastProposal is the number of consensus instances to run, after which a message should be sent
	// on doneChan telling the consensus to shut down.
	// If basic init is true, then the SM will just be used for checking stats and checking decisions.
	Init(gc *generalconfig.GeneralConfig, endAfter types.ConsensusInt, memberCheckerState ConsStateInterface,
		mainChannel channelinterface.MainChannel, doneChan chan channelinterface.ChannelCloseType, basicInit bool)

	// GenerateNewSM is called on this init SM to generate a new SM given the items to be consumed.
	// It should just generate the item, it should not change the state of any of the parentSMs.
	// This will be called on the initial CausalStateMachineInterface passed to the system
	GenerateNewSM(consumedIndices []types.ConsensusID, parentSMs []CausalStateMachineInterface) CausalStateMachineInterface

	// HasEchoed should return true if this SM has echoed a proposal
	// HasEchoed() bool
	// GetDependentItems returns a  list of items dependent from this SM.
	// This list must be the same as the list returned from HasDecided
	GetDependentItems() []sig.ConsIDPub

	// HasDecided is called each time a consensus decision takes place, given the index and the decided vaule.
	// Proposer is the public key of the node that proposed the decision.
	// Owners are the owners of the input consensus indices.
	// It returns a list of causally dependent ids and public keys of the owners of those ids,
	// and the decided value (in case the state machine wants to change it).
	HasDecided(proposer sig.Pub, index types.ConsensusIndex, owners []sig.Pub,
		decision []byte) (outputs []sig.ConsIDPub, updatedDecision []byte)

	// CheckDecisions is for testing and will be called at the end of the test with
	// a causally ordered tree of all the decided values, it should then check if the
	// decided values are valid.
	CheckDecisions(root *utils.StringNode) (errors []error)

	// FailAfter is for testing, once index is reached, it should send a message on doneChan (the input from Init), telling the consensus to shutdown.
	FailAfter(index types.ConsensusInt)

	// GetInitialFirstIndex returns the hash of some unique string for the first instance of the state machine.
	GetInitialFirstIndex() types.ConsensusID

	// StartInit is called on the init state machine to start the program.
	StartInit(memberCheckerState ConsStateInterface)
}

type CoinItemInterface interface {
	BasicConsItem

	// CheckCoinMessage should be called from within ProcessMessage of the ConsensusItem that is using this coin.
	// It returns the round the coin corresponds to and true in first boolean position if made progress towards decision,
	// or false if already decided, and return true in second position if the message should be forwarded.
	// A message is returned if a message should be sent.
	// If the message is invalid an error is returned.
	CheckCoinMessage(deser *deserialized.DeserializedItem, isLocal bool, alwaysGenerate bool, consItem ConsItem,
		coinMsgState CoinMessageStateInterface, msgState MessageState) (round types.ConsensusRound,
		ret messages.MsgHeader, progress, shouldForward bool, err error)

	GenerateCoinMessage(round types.ConsensusRound, alwaysGenerate bool, consItem ConsItem,
		coinMsgState CoinMessageStateInterface, msgState MessageState) (ret messages.MsgHeader)
}

type CoinMessageStateInterface interface {
	// CheckFinishedMessage checks if the message is for the coin and if the coin is already know.
	// If so true is returned, false otherwise.
	CheckFinishedMessage(deser *deserialized.DeserializedItem) bool

	// GetCoinSignType returns what type of signature is used to sign coin messages.
	GetCoinSignType() types.SignType

	// GotMsg is called by the MessageState of the consensus using this coin.
	// deser is the deserialized message object.
	// It returns an error if the message is invalid.
	GotMsg(msgState MessageState, deser *deserialized.DeserializedItem,
		gc *generalconfig.GeneralConfig, mc *MemCheckers) (types.ConsensusRound, error)

	// GetCoins returns the set of binary coin values that are currently valid.
	GetCoins(round types.ConsensusRound) []types.BinVal

	New(idx types.ConsensusIndex, presets []struct {
		Round types.ConsensusRound
		Val   types.BinVal
	}) CoinMessageStateInterface
}

type ConsInterfaceItems struct {
	ConsItem   ConsItem // The consensus item.
	MC         *MemCheckers
	MsgState   MessageState
	FwdChecker ForwardChecker
	// LastProgress is used with causal, and is set to the time the index last made progress
	LastProgress time.Time
	// ProgressListIndex is the index of the item in the list sorted by LastProgress for causal.
	ProgressListIndex int
}

type ConsInterfaceState struct {

	// StartedIndex       types.ConsensusInt                                // The maximum consensus index that has been started
	LocalIndex       types.ConsensusInt // The current consensus index.
	PredecisionIndex types.ConsensusInt // The maximum consensus index that has gotten a decided or possible decided value

	StartedIndex types.ConsensusInt // The maximum consensus index that has been started

	PreDecisions        map[types.ConsensusInt][]byte
	SupportIndex        map[types.ConsensusInt]types.ConsensusInt
	ProposalInfo        map[types.ConsensusInt]StateMachineInterface      // Interface to the state machine.
	GotProposal         map[types.ConsensusInt]bool                       // set to true if received a proposal for the index
	ProposalsToValidate map[types.ConsensusInt][]*channelinterface.RcvMsg // set of proposals to be validated

	IsInStorageInit bool // Used during initialization, when recovering from disk this is set to true so we don't send messages when we reply to values received.

	SharedLock sync.Mutex // Shared with cons item
	// contains filtered or unexported fields
}

type ConsItem interface {
	BasicConsItem
	GetGeneralConfig() *generalconfig.GeneralConfig
	// ProcessMessage is called on every message once it has been checked that it is a valid message (using the static method ConsItem.DerserializeMessage), that it comes from a member
	// of the consensus and that it is not a duplicate message (using the MemberChecker and MessageState objects). This function should process the message and update the
	// state of the consensus.
	// It should return true in first position if made progress towards decision, or false if already decided, and return true in second position if the message should be forwarded.
	ProcessMessage(item *deserialized.DeserializedItem, isLocal bool,
		senderChan *channelinterface.SendRecvChannel) (progress, shouldForward bool)
	// HasDecided should return true if this consensus item has reached a decision.
	HasDecided() bool
	// GetBinState should return the entire state of the consensus as a string of bytes using the MessageState object (normally this would just be MessageState.GetMsgState() as the list
	// of all messages, with a messagetypes.ConsBinStateMessage header appended to the beginning), this value will be stored to disk and used to send the state to other nodes.
	// If localOnly is true then only messages signed by the local node should be included.
	GetBinState(localOnly bool) ([]byte, error)
	// PrintState()
	// GetDecision should return the decided value of the consensus. It should only be called after HasDecided returns true.
	// Proposer it the node that proposed the decision, prvIdx is the index of the decision that preceeded this decision
	// (normally this is the current index - 1), futureFixed is the first larger index that this decision does not depend
	// on (normally this is the current index + 1). prvIdx and futureFixed are different for MvCons3 as that
	// consensus piggybacks consensus instances on top of eachother.
	GetDecision() (proposer sig.Pub, decision []byte, prvIdx, futureFixed types.ConsensusIndex)
	// GetPreHeader returns the serialized header that is attached to all messages sent by this consensus item.
	// It is normally nil.
	GetPreHeader() []messages.MsgHeader
	// AddPreHeader appends a header that will be attached to all messages sent by this consensus item.
	AddPreHeader(messages.MsgHeader)
	// Start is called exactly once for each consensus instance, after start is called, the consensus may return
	// true from GetProposalInfo as soon as it is ready for a proposal from the application.
	// Note that messages may be sent to the consensus before Start is called, they should be processed as necessary.
	// Finished last index is true once the last index has decided (some consensus instances may start after the last index
	// has decided to ensure all items eventually decide)
	Start(finishedLastIndex bool)
	// HasStarted returns true if start has been called
	HasStarted() bool
	// GetProposalIndex returns the previous consensus index from which this index will use (must be at least 1
	// smaller than the current index). The value is used only if ready is true. Ready should be false until
	// this consensus index needs a proposal (this cannot return true before start is called).
	GetProposalIndex() (prevIdx types.ConsensusIndex, ready bool)
	// GotProposal is called at most once for each consensus index after start by the application as the local input to the consensus. The hdr value will be used as the input to the consensus.
	GotProposal(hdr messages.MsgHeader, mainChannel channelinterface.MainChannel) error
	// InitState is called once before running the first consensus iteration. The input values are expected to remain the same across all consensus iterations.
	// GenerateInitState(preHeaders []messages.MsgHeader, priv sig.Priv, eis ExtraInitState, stats stats.StatsInterface)
	// ResetState should reset any stored state for the current consensus index, and prepare for the new consensus index given by the input.
	GenerateNewItem(index types.ConsensusIndex, consItems *ConsInterfaceItems, mainChannel channelinterface.MainChannel,
		prevItem ConsItem, broadcastFunc ByzBroadcastFunc, gc *generalconfig.GeneralConfig) ConsItem
	// SetNextConsItem gives a pointer to the next consensus item at the next consensus instance, it is called when the next instance is created
	SetNextConsItem(next ConsItem)
	// CanStartNext should return true if it is safe to start the next consensus instance (if parallel instances are enabled),
	// in most consensus algorithms this will always return true. In MvCons3 this will return true once this consensus instance
	// know what instance it follows (i.e. the accepted init message points to), or when a timer has run out.
	CanStartNext() bool
	// GetNextInfo will be called after CanStartNext returns true.
	// It is used to get information about how the state machine for this instance will be generated.
	// prevIdx should be the index that this consensus index will follow (normally this is just idx - 1).
	// preDecision is either nil or the value that will be decided if a non-nil value is decided.
	// hasInfo returns true if the values for proposer and preDecision are ready.
	// If false is returned then the next is started, but the current instance has no state machine created.
	// This function is mainly used for MvCons3 since the order of state machines depends on depends on the execution
	// of the consensus instances.
	// For other consensus algorithms prevIdx should return (idx - 1) and hasInfo should be false unless
	// AllowConcurrent is enabled.
	GetNextInfo() (prevIdx types.ConsensusIndex, proposer sig.Pub, preDecision []byte, hasInfo bool)
	// SetInitialState should be called on the initial consensus index (1) to set the initial state.
	SetInitialState([]byte, storage.StoreInterface)
	GetIndex() types.ConsensusIndex // GetIndex returns the consensus index of the item.
	// HasValidStarted returns true if this cons item has processed a valid proposal, or if it know other nodes
	// have (i.e. if the binary reduction has terminated)
	HasValidStarted() bool
	// GetCustomRecoverMsg is called when there is no progress after a timeout. If the standard
	// recovery message is used (messagetypes.NoProgressMessage) then the recovery is handled by the
	// consensus state objects.
	// Otherwise the returned message is sent to the peers and the consensus must handle
	// the recovery itself.
	// If createEmpty is true then the message will be used to deserialize a received message.
	GetCustomRecoverMsg(createEmpty bool) messages.MsgHeader
	// GetRecoverMsgType returns the HeaderID of the recovery messages used by this consensus.
	// If messages.HdrNoProgress is returned then the default recover is used
	GetRecoverMsgType() messages.HeaderID
	// ProcessCustomRecoveryMessage is called when a valid custom recover message equal of the type
	// returned by GetCustomRecoverMessage (that is not messagetypes.NoProgressMessage).
	// The consensus should then perform the appropriate recovery.
	// Note that the message is not checked with member checkers/signatures, etc.
	ProcessCustomRecoveryMessage(item *deserialized.DeserializedItem,
		senderChan *channelinterface.SendRecvChannel)
	// GetCommitProof returns a signed message header that counts at the commit message for this consensus.
	GetCommitProof() []messages.MsgHeader
	// SetCommitProof takes the value returned from GetCommitProof of the previous consensus instance once it has decided.
	// The consensus can then use this as needed.
	SetCommitProof(prf []messages.MsgHeader)
	// GetPrevCommitProof returns a signed message header that counts at the commit message for the previous consensus.
	// This should only be called after DoneKeep has been called on this instance.
	// cordPub is the expected public key of the coordinator of the current round (used for collect broadcast)
	GetPrevCommitProof() (cordPub sig.Pub, proof []messages.MsgHeader)
	// Broadcast a value.
	// If nextCoordPub is nil the message will only be sent to that node, otherwise it will be sent
	// as normal (nextCoordPub is used when CollectBroadcast is true in test options).
	Broadcast(nextCoordPub sig.Pub, msg messages.InternalSignedMsgHeader,
		signMessage bool,
		forwardFunc channelinterface.NewForwardFuncFilter,
		mainChannel channelinterface.MainChannel,
		additionalMsgs ...messages.MsgHeader)
	// CheckMemberLocalMsg checks if the local node is a member of the consensus for this message type
	CheckMemberLocalMsg(hdr messages.InternalSignedMsgHeader) bool
	// CheckMemberLocal checks if the node is a member of the consensus.
	CheckMemberLocal() bool
	// GetConsInterfaceItems returns the ConsInterfaceItems for this consesnsus instance.
	GetConsInterfaceItems() *ConsInterfaceItems

	// PrevHasBeenReset is called when the previous consensus index has been reset to a new index
	PrevHasBeenReset()
	// SetTestConfig is run before tests to set any options specific to the consensus.
	// Test id should be the index of the node in the test.
	// SetTestConfig(testId int, options types.TestOptions)
	// GetConsType returns the type of consensus this instance implements.
	GetConsType() types.ConsType
	// Collect is called when the item is about to be garbage collected.
	Collect()
	// ForwardOldIndices should return true if messages from old consensus indices should be forwarded
	// even after decision.
	ForwardOldIndices() bool

	// NeedsCompletionConcurrentProposals returns the number of concurrent instances the consensus needs to run correctly where
	// the possible value that can be decided must be known before the next proposal is made (i.e. either that
	// value or nil is decided). Normally this returns 1.
	// Currently only MvCons3 needs a higher value since it makes concurrent proposals once the possible value
	// of the previous proposal is known.
	NeedsCompletionConcurrentProposals() types.ConsensusInt
	// ComputeDecidedValue is a static method that should return the decided value, state comes from ConsItem.GetBinState, decision comes from ConsItem.GetDecision.
	ComputeDecidedValue(state []byte, decision []byte) []byte
	// GetProposeHeaderID returns the HeaderID for the message type that will be input to GotProposal.
	GetProposeHeaderID() messages.HeaderID
	// GenerateMessageState generates a new message state object given the inputs.
	GenerateMessageState(gc *generalconfig.GeneralConfig) MessageState
	// ShouldCreatePartial returns true if the message type should be sent as a partial message
	ShouldCreatePartial(headerType messages.HeaderID) bool
}

type ConsStateInterface interface {
	GetMemberChecker(cid types.ConsensusIndex) (*ConsInterfaceItems, error)
	// GetConsItem(idIdx types.ConsensusIndex) (ConsItem, error)
	GetNewPub() sig.Pub
	GetGeneralConfig() *generalconfig.GeneralConfig
	CheckGenMemberChecker(cid types.ConsensusIndex) (*ConsInterfaceItems, error)
	GetConsensusIndexFuncs() types.ConsensusIndexFuncs
	SetMainChannel(mainChannel channelinterface.MainChannel)
}

type ForwardChecker interface {
	AdditionalForwardCheckerOps
	// forwardchecker.internalForwardChecker
	// CheckForward is called each time a message is successfully processes by ConsState, sndRcvChan is the channel who sent the message, progress is given by the consensus
	// object after the message is processesed and is true if the message made progress in the consensus.
	// The inputs endThreshold, maxPossible int, msgID messages.MsgID should come from item.GetBufferCount called on the msg.
	// The input sigCount is the number of signatures received for this MsgID so for for this consensus.
	// The input memberChecker correspond to the consensus instance this message is from.
	// The forward checker should then keep this message if it should be forwarded later, messages are only forwarded when they are returned from GetNextForwardItem
	// Is propose message should be true if the message is a proposal message.
	CheckForward(sndRcvChan *channelinterface.SendRecvChannel, msg *deserialized.DeserializedItem, shouldForward bool,
		isProposalMessage bool, endThreshold, maxPossible, sigCount int,
		msgID messages.MsgID, memberChecker *MemCheckers)
	// GetNextForward item is called by ConsState after a consensus message is successfully processed and after a timeout.
	// If there is a message to be forwareded, it should return that.
	// It will be called in a loop until msg is nil. The forwardFunc function takes the list of nodes the node is connected to and returns the set
	// of nodes to forward the message to. The returned message and function are used as input to MainChannel.Send.
	GetNextForwardItem(stats.NwStatsInterface) (msg []*deserialized.DeserializedItem, forwardFunc channelinterface.NewForwardFuncFilter)
	// New creates a new ForwardChecker for the consensus index. It will be always be called on an "initialForwardChecker" that is given as input to
	// MemberCheckerState.Init. ParticipantCount is the number of nodes in the system.
	New(idx types.ConsensusIndex, participants, allPubs sig.PubList) ForwardChecker
	// ConsDecided is called when the consensus has decided, after this is called, GetNextForwardItem will be called until it returns nil.
	// This should finish any items pending to be forwarded.
	ConsDecided(stats.NwStatsInterface)
}

type GeneralStateMachineInterface interface {
	// FinishedLastRound returns true if the last test index has finished.
	FinishedLastRound() bool
	// GetIndex returns the index for this consensus
	GetIndex() types.ConsensusIndex
	// ValidateProposal should return nil if the input proposal is valid, otherwise an error.
	// Proposer is the public key of the node that proposed the value.
	// It is called on the parent state machine instance of the proposal after it has decided.
	ValidateProposal(proposer sig.Pub, proposal []byte) error
	// GetByzProposal should generate a byzantine proposal based on the configuration
	GetByzProposal(originProposal []byte, gc *generalconfig.GeneralConfig) (byzProposal []byte)
	// GetInitialState returns the initial state of the program.
	GetInitialState() []byte
	// StatsString returns statistics for the state machine.
	StatsString(testDuration time.Duration) string
	// GetDecided returns true if the SM has decided.
	GetDecided() bool
	// GetSMStats returns the statistics object for the SM.
	GetSMStats() SMStats
	// GetRand returns 32 random bytes if supported by the state machine type.
	// It should only be called after HasDecided.
	GetRand() [32]byte
	// DoneClear should be called if the instance of the state machine will no longer be used (it should perform any cleanup).
	DoneClear()
	// DoneKeep should be called if the instance of the state machine will be kept.
	DoneKeep()
	// Collect is called when the item is about to be garbage collected and is used as a sanity check.
	Collect()
	// EndTest is called when the test is finished
	EndTest()
}

type HeaderFunc func(sig.Pub, *generalconfig.GeneralConfig, messages.HeaderID) (messages.MsgHeader, error)

type MemCheckers struct {
	MC  MemberChecker           // the member checker
	SMC SpecialPubMemberChecker // the special member checker
}

type MemberChecker interface {
	New(id types.ConsensusIndex) MemberChecker // New generates a new member checker for the index, this is called on the inital member checker each time.
	IsReady() bool                             // IsReady should return true if the member check knows all the members. It needs to be concurrent safe.

	AllowsChange() bool // AllowsChange returns true if the member checker allows changing members, used as a sanity check.

	// CheckMemberBytes checks the the pub key is a member and returns corresponding pub key object, nil if it is not a member
	CheckMemberBytes(types.ConsensusIndex, sig.PubKeyID) sig.Pub
	// CheckMemberBytes checks the the bytes using GetPubString and returns corresponding pub key object, nil if it is not a member
	// CheckPubString(types.ConsensusIndex, sig.PubKeyID) sig.Pub
	// CheckRandMember can be called after CheckMemberBytes is successful when ChooseRandomMember is enabled.
	// MsgID is the id of the message being checked.
	// IsProposal is true if msgID corresponds to a proposal message for the current consensus type.
	CheckRandMember(pub sig.Pub, hdr messages.InternalSignedMsgHeader, msgID messages.MsgID, isLocal bool) error
	// SelectRandMembers returns true if the member checker is selecting random members.
	RandMemberType() types.RndMemberType
	GetRnd() [32]byte

	// UpdateState is called when the previous consensus instance decides, the input is the decision plus the previous member checker.
	// Calling this should not change what IsReady returns, only after FinishUpdateState should IsReady always return true.
	// The reason is that after UpdateState is called, and before FinishUpdateState is called, SpecialMemberChecker.Update state is called.
	// Update state returns two lists of pubs.
	// fixedCoord is non-nil if we have a fixed coordinator for this instance.
	// newAllPubs are the list of all pubs in the system.
	// newMemberPubs pubs are the public keys that will now participate in consensus.
	// newMemberPubs must be a equal to or a subset of newAllPubs.
	// If membership is not changed since the previous consensus instance then nil is returned for these items.
	// Proof is the vrf proof of the current node if random membership is enabled.
	// futureFixed the same value returned by consinterface.ConsItem GetDecision(),
	// i.e. the first larger index that this decision does not depend
	// on (normally this is the current index + 1). prvIdx and futureFixed are different for MvCons3 as that
	// consensus piggybacks consensus instances on top of eachother.
	// The return values are nil if the membership has not changed.
	// ChangedMembership must be true if either of the other return values are non-nil.
	// Even if they are nil, but the membership could have changed in a different way (i.e. by random membership)
	// it must return true
	UpdateState(fixedCoord sig.Pub, prevDec []byte, randBytes [32]byte,
		prevMember MemberChecker, prevSM GeneralStateMachineInterface,
		futureFixed types.ConsensusID) (newMemberPubs, newAllPubs []sig.Pub, changedMembership bool)
	// DoneNextUpdateState is called when the member checker will no longer be used as input to generate a new member checker
	// as the prevMemberChecker to update state.
	DoneNextUpdateState() error
	// Invalidated is called if the member checker has been made invalid.
	// This happens if a different set of members was chosen then was initial proposed.
	// Currently this is only supported when using total ordering.
	Invalidated() error

	// GotVrf should be called when a node's VRF proof is received for this consensus instance.
	// If the VRF was valid it returns the uint64 that represents the vrf // TODO is it sufficient to just use the first 8 bytes of the rand?
	GotVrf(pub sig.Pub, isProposal bool, msgID messages.MsgID, proof sig.VRFProof) error
	// GetMyVRF returns the vrf proof for the local node.
	GetMyVRF(isProposal bool, id messages.MsgID) sig.VRFProof

	// GetNewPub returns an empty public key object.
	GetNewPub() sig.Pub
	GetIndex() types.ConsensusIndex
	FinishUpdateState()                         // FinishUpdate state is called after UpdateState. After this call, IsReady should always return true.
	CheckIndex(index types.ConsensusIndex) bool // CheckIndex should return true if the index is the same as the one used in New, it is for testing.
	GetMemberCount() int                        // GetMemberCount returns the number of consensus members.
	GetFaultCount() int                         // GetFaultCount returns the number of possilbe faultly nodes that the consensus can handle.
	GetParticipants() sig.PubList               // GetParticipant return the pub key of the participants.
	GetAllPubs() sig.PubList                    // GetAllPub returns all pubs in the system
	GetMyPriv() sig.Priv                        // GetMyPriv returns the local nodes private key
	// CheckRoundCoord checks if checkPub the/a coordinator for round. If it is, err is returned as nil, otherwise an
	// error is returned. If checkPub is nil, then it will return the known coordinator in coordPub.
	// Note this should only be called after the pub is verified to be a member with CheckMemberBytes
	CheckRoundCoord(msgID messages.MsgID, checkPub sig.Pub, round types.ConsensusRound) (coordPub sig.Pub, err error)
	// CheckEstimatedRoundCoordNextIndex returns the estimated public key of the coordinator for round round for the following consensus index.
	// It might not return the correct coordinator for the next index because the decision might change the membership
	// for the next index. This function should not be used if it needs to know the next coordinator for certain.
	CheckEstimatedRoundCoordNextIndex(checkPub sig.Pub,
		round types.ConsensusRound) (coordPub sig.Pub, err error)
	// CheckRandRoundCoord should be called instead of CheckRoundCoord if random membership selection is enabled.
	// If using VRFs then checkPub must not be nil.
	// If checkPub is nil, then it will return the known coordinator in coordPub.
	// If VRF is enabled randValue is the VRF random value for the inputs.
	// Note this should be called after CheckRandMember for the same pub.
	CheckRandRoundCoord(msgID messages.MsgID, checkPub sig.Pub, round types.ConsensusRound) (randValue uint64,
		coordPub sig.Pub, err error)

	// CheckFixedCoord checks if checkPub the/a coordinator for round. If it is, err is returned as nil, otherwise an
	// error is returned. If checkPub is nil, then it will return the fixed coordinator in coordPub.
	// If there is no fixedCoordinator, then an error types.ErrNoFixedCoord is returned.
	// Note this should only be called after the pub is verified to be a member with CheckMemberBytes
	CheckFixedCoord(pub sig.Pub) (coordPub sig.Pub, err error)
	GetStats() stats.StatsInterface

	// SetStats(stats.StatsInterface) // SetStats sets the stats object that will be used to keep stats, TODO clean this up
	Validated(types.SignType) // ValidatedItem is called for stats to let it know a signature was validated. TODO cleanup.

	// AddPubKeys is used for adding the public keys to the very inital member checker, and should not
	// be called on later member checkers, as they should change pub keys through the call to UpdateState.
	// priv is the local nodes private key.
	// fixedCoord is non-nil if we have a fixed coordinator for this instance.
	// allPubs are the list of all pubs in the system.
	// memberPubs pubs are the public keys that will now participate in consensus.
	// memberPubs must be equal to or a subset of newAllPubs.
	// If shared is non-nil then the local nodes on the machine will share the same initial member objects
	// (to save memory for experiments that run many nodes on the same machine).
	AddPubKeys(fixedCoord sig.Pub, memberPubKeys, allPubKeys sig.PubList, initRandBytes [32]byte, shared *Shared)

	// SetMainChannel is called on the initial member checker to inform it of the network channel object
	SetMainChannel(mainChannel channelinterface.MainChannel)
}

type MessageState interface {
	// GotMessage takes a deserialized message and the member checker for the current consensus index.
	// If the message contains no new valid signatures then an error is returned.
	// The value newTotalSigCount is the new number of signatures for the specific message, the value newMsgIDSigCount is the
	// number of signatures for the MsgID of the message (see messages.MsgID).
	// If the message is not a signed type message (not type *sig.MultipleSignedMessage then (0, 0, nil) is returned).
	GotMsg(HeaderFunc,
		*deserialized.DeserializedItem, *generalconfig.GeneralConfig, *MemCheckers) ([]*deserialized.DeserializedItem, error)
	// GetMsgState should return the serialized state of all the valid messages received for this consensus instance.
	// This should be able to be processed by UnwrapMessage.
	// If generalconfig.UseFullBinaryState is true it returns the received signed messages together in a list.
	// Otherwise it returns each unique message with the list of signatures for each message behind it.
	// bufferContFunc is the same as consinterface.ConsItem.GetBufferCount(), the returned value endThreshold will
	// determine how many of each signature is added for each message type.
	// If localOnly is true then only proposal messages and signatures from the local node will be included.
	GetMsgState(priv sig.Priv, localOnly bool,
		bufferCountFunc BufferCountFunc,
		mc *MemCheckers) ([]byte, error)
	// New creates a new empty MessageState object for the consensus index idx.
	New(idx types.ConsensusIndex) MessageState
	// GetIndex returns the consensus index.
	GetIndex() types.ConsensusIndex
	// SetupSigned message takes a messages.InternalSignedMsgHeader, serializes the message appending signatures
	// creating and returning a new *sig.MultipleSignedMessage.
	// If generateMySig is true, the serialized message will include the local nodes signature.
	// Up to addOtherSigs number of signatures received so far for this message will additionally be appended.
	SetupSignedMessage(hdr messages.InternalSignedMsgHeader, generateMySig bool, addOthersSigsCount int, mc *MemCheckers) (*sig.MultipleSignedMessage, error)
	SetupUnsignedMessage(hdr messages.InternalSignedMsgHeader,
		mc *MemCheckers) (*sig.UnsignedMessage, error)
	// SetupSignedMessageDuplicates takes a list of headers that are assumed to have the same set of bytes to sign
	// (i.e. the signed parts are all the same though they may have different contents following the signed part,
	// for example this is true with partial messages)
	SetupSignedMessagesDuplicates(combined *messagetypes.CombinedMessage, hdrs []messages.InternalSignedMsgHeader,
		mc *MemCheckers) (combinedSigned *sig.MultipleSignedMessage, partialsSigned []*sig.MultipleSignedMessage, err error)
	GetSigCountMsg(types.HashStr) int                                                           // GetSigCountMsg returns the number of signatures received for this message.
	GetSigCountMsgHeader(header messages.InternalSignedMsgHeader, mc *MemCheckers) (int, error) // GetSigCountMsgHeader returns the number of signatures received for this header.
	GetSigCountMsgID(messages.MsgID) int                                                        // GetSigCountMsgID returns the number of sigs for this message's MsgID (see messages.MsgID).
	// GetSigCountMsgIDList returns list of received messages that have msgID for their MsgID and how many signatures have been received for each.
	GetSigCountMsgIDList(msgID messages.MsgID) []MsgIDCount
	// GetThreshSig returns the threshold signature for the message ID (if supported).
	GetThreshSig(hdr messages.InternalSignedMsgHeader, threshold int, mc *MemCheckers) (*sig.SigItem, error)
	// GetCoinVal returns the threshold coin value for the message ID (if supported).
	GetCoinVal(hdr messages.InternalSignedMsgHeader, threshold int, mc *MemCheckers) (coinVal types.BinVal, ready bool, err error)
}

type MsgIDCount struct {
	MsgHeader *sig.MultipleSignedMessage
	Count     int // Count is the number of signatures received for MsgHeader.
}

type SMStats interface {
	StatsString(testDuration time.Duration) string
}

type Shared struct {
	PubKeys   sig.PubList    // The sorted list of public keys
	DSSShared *ed.CoinShared // Information for threshold keys
	BlsShare  *bls.BlsShared // state of Shared generated keys when using threshold BLS
	BlsShare2 *bls.BlsShared // state of Shared generated keys when using threshold BLS
	// contains filtered or unexported fields
}

type SortedTimeConsInterfaceItems []*ConsInterfaceItems

type SpecialPubMemberChecker interface {
	New(id types.ConsensusIndex) SpecialPubMemberChecker                                     // New generates a new member checker for the index, this is called on the inital special member checker each time.
	UpdateState(newPubs sig.PubList, randBytes [32]byte, prevMember SpecialPubMemberChecker) // UpdateState is called after MemberCheck.Update state. New pubs should be nil if they didn't change from the previous iteration.
	// CheckMemberLocalMsg checks if pub is a special member and returns new pub that has all the values filled.
	// This is called after MemberChecker.CheckMemberBytes in case a normal member is not found.
	// This sould be safe to be called concurrently.
	// It should also check if the member is a random member by calling CheckRandMember before returning successfullly.
	// TODO use a special pub type?
	// TODO this should be called with just they bytes like MemberChecker.CheckMemberBytes
	CheckMember(idx types.ConsensusIndex, pub sig.Pub, mc MemberChecker,
		hdr messages.InternalSignedMsgHeader, msgID messages.MsgID) (sig.Pub, error)
}

type StateMachineInterface interface {
	GeneralStateMachineInterface

	// GetProposal is called when a consensus index is ready for a proposal.
	// It should send the proposal for the consensus index by calling mainChannel.HasProposal().
	GetProposal()
	// HasDecided is called each time a consensus decision takes place, given the index and the decided vaule.
	// The indecies can be expected to be called in order starting at 1.
	// Proposer is the public key of the node that proposed the decision.
	HasDecided(proposer sig.Pub, index types.ConsensusInt, decision []byte)
	// StartIndex is called when the previous consensus index has finished.
	// It is called on the previous consensus index with the index of next state machine.
	// This might be called multiple times with multiple indicies as allowed by certain consensuses (e.g. mvcons3).
	// It should return the state machine instance for index index.
	StartIndex(index types.ConsensusInt) StateMachineInterface
	// FailAfter is for testing, once index is reached, it should send a message on doneChan (the input from Init), telling the consensus to shutdown.
	FailAfter(index types.ConsensusInt)
	// Init is called to initialize the object, lastProposal is the number of consensus instances to run, after which a message should be sent
	// on doneChan telling the consensus to shut down.
	// Need concurrent is the number of consensus indicies that need to be additionally run for the consensus to complete.
	// If basic init is true, then the SM will just be used for checking stats and checking decisions.
	Init(generalConfig *generalconfig.GeneralConfig, lastProposal types.ConsensusInt, needsConcurrent types.ConsensusInt,
		mainChannel channelinterface.MainChannel, doneChan chan channelinterface.ChannelCloseType, basicInit bool) // To set state
	// GetDone returns the done status of this SM.
	GetDone() types.DoneType
	// CheckDecisions is for testing and will be called at the end of the test with the ordered list of all the decided values, it should then check if the
	// decided values are valid.
	// Out of order errors are caused by committing proposals that did not see the previous proposal, which may be allowed by some consensuses.
	CheckDecisions([][]byte) (outOfOrderErrors, errors []error)
	// CheckStartStatsRecording is called before allocating an index to check if stats recording should start.
	CheckStartStatsRecording(index types.ConsensusInt)
}