cleisthenes

type AbstractTx map[string]interface{}

type Address struct {
	Ip   string
	Port uint16
}

type Batch struct {
	// contains filtered or unexported fields
}

type BatchChannel struct {
	// contains filtered or unexported fields
}

type BatchMessage struct {
	Epoch Epoch
	Batch map[Member][]byte
}

type BatchReceiver interface {
	Receive() <-chan BatchMessage
}

type BatchSender interface {
	Send(msg BatchMessage)
}

type Binary = bool

type BinaryChannel struct {
	// contains filtered or unexported fields
}

type BinaryMessage struct {
	Member Member
	Binary Binary
}

type BinaryReceiver interface {
	Receive() <-chan BinaryMessage
}

type BinarySender interface {
	Send(msg BinaryMessage)
}

type BinaryState struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type Broadcaster interface {
	// ShareMessage is a function that broadcast Single message to all nodes
	ShareMessage(msg pb.Message)

	// DistributeMessage is a function that broadcast multiple different messages one by one to all nodes
	DistributeMessage(msgList []pb.Message)
}

type CStreamWrapper struct {
	// contains filtered or unexported fields
}

type CipherText []byte

type Coin Binary

type CoinGenerator interface {
	Coin(uint64) Coin
}

type ConnHandler func(conn Connection)

type ConnId = string

type Connection interface {
	Send(msg pb.Message, successCallBack func(interface{}), errCallBack func(error))
	Ip() Address
	Id() ConnId
	Close()
	Start() error
	Handle(handler Handler)
}

type ConnectionPool struct {
	// contains filtered or unexported fields
}

type Contribution struct {
	TxList []Transaction
}

type DataChannel struct {
	// contains filtered or unexported fields
}

type DataMessage struct {
	Member Member
	Data   []byte
}

type DataReceiver interface {
	Receive() <-chan DataMessage
}

type DataSender interface {
	Send(msg DataMessage)
}

type DecryptionShare [96]byte

type DefaultTxQueueManager struct {
	// contains filtered or unexported fields
}

type DialOpts struct {
	// Ip is target address which grpc client is going to dial
	Addr Address

	// Duration for which to block while established a new connection
	Timeout time.Duration
}

type Epoch uint64

type ErrHandler func(err error)

type GrpcClient struct{}

type GrpcConnection struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type GrpcServer struct {
	// contains filtered or unexported fields
}

type Handler interface {
	ServeRequest(msg Message)
}

type HoneyBadger interface {
	HandleContribution(contribution Contribution)
	HandleMessage(msg *pb.Message) error
	OnConsensus() bool
}

type MemCacheTracer struct {
	// contains filtered or unexported fields
}

type MemTxQueue struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type Member struct {
	Address Address
}

type MemberMap struct {
	// contains filtered or unexported fields
}

type Message struct {
	*pb.Message
	Conn Connection
}

type MessageEndpoint interface {
	HandleMessage(*pb.Message) error
}

type PublicKey []byte

type Request interface {
	Recv()
}

type RequestRepository interface {
	Save(addr Address, req Request) error
	Find(addr Address) (Request, error)
	FindAll() []Request
}

type ResultChannel struct {
	// contains filtered or unexported fields
}

type ResultMessage struct {
	Epoch Epoch
	Batch []AbstractTx
}

type ResultReceiver interface {
	Receive() <-chan ResultMessage
}

type ResultSender interface {
	Send(msg ResultMessage)
}

type SStreamWrapper struct {
	ServerStream pb.StreamService_MessageStreamServer
	// contains filtered or unexported fields
}

type SecretKey [32]byte

type Stream interface {
	Send(message *pb.Message) error
	Recv() (*pb.Message, error)
}

type StreamWrapper interface {
	Stream
	Close()
	GetStream() Stream
}

type Tpke interface {
	Encrypt(msg interface{}) ([]byte, error)
	DecShare(ctBytes []byte) DecryptionShare
	Decrypt(enc []byte) ([]Transaction, error)
	AcceptDecShare(addr Address, decShare DecryptionShare)
	ClearDecShare()
}

type Tracer interface {
	Log(keyvals ...string)
	Trace()
}

type Transaction interface{}

type TxQueue interface {
	Push(tx Transaction)
	Poll() (Transaction, error)
	Len() int
}

type TxQueueManager interface {
	AddTransaction(tx Transaction) error
}

type TxValidator func(Transaction) bool