anonbcast

type AbortOp struct {
	R int
}

type AddProvisionalArgs struct {
	Server string
}

type AddProvisionalReply struct {
	Error libraft.AddProvisionalError
}

type AddRemoveArgs struct {
	Server string
	IsAdd  bool
}

type AddRemoveReply struct {
	Submitted bool
	Error     libraft.AddRemoveServerError
}

type Client struct {
	// Id is the id of this client. Each client has its own unique id.
	// Immutable.
	Id uuid.UUID

	// Config contains an immutable store of the configuration parameters for this particular instance
	Config ClientConfig
	// contains filtered or unexported fields
}

type ClientConfig struct {
	// MessageTimeout is the amount of time that the user has to return from when
	// the client calls the user's Message method. The client will abort the submit
	// phase if more than MessageTimeout + ProtocolTimeout seconds have passed.
	// A reasonable value is 30 seconds, allowing the user to come up with a message and send it.
	MessageTimeout time.Duration

	// ProtocolTimeout is the amount of time that the client will wait for another
	// client j to complete its task. Specifically, if this client has not heard of
	// an update from client j in the last ProtocolTimeout time, and client j should
	// have sent an update at the start of that interval, then this client will abort the round.
	// A reasonable value is 10 seconds, which may allow clients to crash and restart.
	ProtocolTimeout time.Duration

	// MessageSize is the maximum size, in bytes, of the message that the user can send in a round.
	// Note that to make sure that each message has indistinguishable length, each message will
	// need to be padded to this length, so in terms of cost analysis the messages will always have
	// the maximum length.
	MessageSize int
}

type CommutativeCrypto interface {
	// PrepareMsg converts a plaintext message to a plaintext Msg.
	// Returns an error if the message is too long.
	PrepareMsg(msg []byte) (Msg, error)

	// Encrypt encrypts a message
	Encrypt(key PrivateKey, m Msg) Msg

	// Decrypt decrypts a message
	Decrypt(key PrivateKey, m Msg) Msg

	// ExtractMsg reverses PrepareMsg
	ExtractMsg(m Msg) []byte

	// GenKey generates a private key
	GenKey() PrivateKey

	// DeepCopy copies itself, to avoid race conditions
	DeepCopy() CommutativeCrypto

	// Verify returns nil if and only if this crypto is safe for message sizes
	// up to and including messageSize bytes
	Verify(messageSize int) error
}

type DecryptedOp struct {
	Id       uuid.UUID
	R        int
	Messages []Msg
	// Prev is the number of participants who have previously submitted a scrambled.
	// This supports the test-and-set behavior.
	Prev int
}

type EncryptedOp struct {
	Id uuid.UUID
	R  int
	// Messages need to be in same order as before.
	Messages []Msg
	// Prev is the number of participants who have previously encrypted.
	// This supports the test-and-set behavior.
	Prev int
}

type Err string

type InConfigurationArgs struct {
	Server           string
	IsProvisionalReq bool
}

type InConfigurationReply struct {
	InConfiguration bool
	IsLeader        bool
}

type JoinOp struct {
	Id uuid.UUID
	R  int
}

type MessageOp struct {
	Id            uuid.UUID
	R             int
	Message       Msg
	RevealKeyHash []byte
}

type Messager interface {
	// Message returns the message for this participant in the given round.
	// It may block. If it takes too much time, its return value may be ignored.
	// (i.e., the protocol has timed out and moved on to the next round)
	Message(round int) []byte
}

type Msg struct {
	// M stores the raw value of the big.Int.
	// Ideally we would have used a *big.Int here, but unfortunately it cannot be sent over RPC.
	M []byte
}

type Op interface {
	Type() OpType
	Round() int
}

type OpRpcReply struct {
	Err Err
}

type OpType string

type Phase string

type PrivateKey struct {
	E, D []byte
}

type RespChannels interface {
	Create(i int, j int) chan bool
	Get(i int, j int) chan bool
	Close(i int, j int)
	Clear()
}

type RevealOp struct {
	Id        uuid.UUID
	R         int
	RevealKey PrivateKey
}

type RoundInfo struct {
	// Phase is the phase that the round is in.
	Phase Phase
	// Crypto is an object that allows us to do consistent commutative encryption. It is typically a big prime.
	Crypto CommutativeCrypto
	// Participants is a list of uuids for every participant, uniquely identifying them
	Participants []uuid.UUID
	// Messages is a list of messages, should have same length as Participants. If participant i
	// hasn't sent in a message yet, Messages[i] is the null value (i.e. "")
	// The messages change over the course of the progress of the protocol.
	Messages []Msg
	// Encrypted[i] is true if and only if participant Participants[i] has encrypted the messages
	Encrypted []bool
	// Scrambled[i] is true if and only if participant Participants[i] has scrambled the messages
	Scrambled []bool
	// Decrypted[i] is true if and only if participant Participants[i] has decrypted the messages
	Decrypted []bool
	// RevealedKeys[i] is the public/private reveal keypair of participant Participants[i],
	// or the nil value of the type if the participant has yet to submit it
	RevealedKeys []PrivateKey
	// RevealKeyHashes[i] is a SHA256 hash of the reveal key of participant Participants[i],
	// or a length 0 or nil slice if the participant has yet to submit it
	RevealKeyHashes [][]byte
}

type RoundResult struct {
	// Round is the round we're looking at.
	Round int
	// Succeeded is true if the round resulted in the DonePhase
	// and no malicious failure was detected; false otherwise.
	Succeeded bool
	// Messages contains all the plaintext messages from this round.
	Messages [][]byte
	// MaliciousError is non-nil if an inconsistency was detected where a possible
	// explanation is that a malicious user found the authors of some messages.
	// If MaliciousError is nil, then it is guaranteed that no user was able to
	// determine the origin of any messages.
	MaliciousError error
}

type ScrambledOp struct {
	Id       uuid.UUID
	R        int
	Messages []Msg
}

type Server struct {
	Me string
	// contains filtered or unexported fields
}

type StartOp struct {
	Id     uuid.UUID
	R      int
	Crypto CommutativeCrypto
}

type StateMachine struct {
	// Round is the current round that the state machine is in. It increases
	// monotonically, starting at 0.
	Round int
	// Rounds store the data for the NumRoundsPersisted last rounds, at
	// index round # mod 3
	Rounds [NumRoundsPersisted]RoundInfo
}

type UpdateMsg struct {
	ConfigurationValid bool
	Configuration      map[string]bool

	StateMachineValid bool
	StateMachine      StateMachine
}