announce

type AddressProvider interface {
	SelfNode() *enode.Node
	ValidatorAddress() common.Address
}

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

type AnnounceState struct {
	ValEnodeTable           *ValidatorEnodeDB
	VersionCertificateTable *VersionCertificateDB

	LastVersionCertificatesGossiped *AddressTime
	LastQueryEnodeGossiped          *AddressTime
}

type AnnounceStatePruner interface {
	Prune(*AnnounceState) error
}

type EnodeCertificateMsgGenerator interface {
	// GenerateEnodeCertificateMsgs generates a map of enode certificate messages.
	// One certificate message is generated for each external enode this node possesses generated for
	// each external enode this node possesses. A unproxied validator will have one enode, while a
	// proxied validator may have one for each proxy.. Each enode is a key in the returned map, and the
	// value is the certificate message.
	GenerateEnodeCertificateMsgs(ei *istanbul.EcdsaInfo, version uint) (map[enode.ID]*istanbul.EnodeCertMsg, error)
}

type EnodeCertificateMsgHolder interface {
	// Get gets the most recent enode certificate messages.
	// May be nil if no message was generated as a result of the core not being
	// started, or if a proxy has not received a message from its proxied validator
	Get() map[enode.ID]*istanbul.EnodeCertMsg
	Set(enodeCertMsgMap map[enode.ID]*istanbul.EnodeCertMsg) error
}

type EnodeQuery struct {
	RecipientAddress   common.Address
	RecipientPublicKey *ecdsa.PublicKey
	EnodeURL           string
}

type EnodeQueryGossiper interface {
	// GossipEnodeQueries will generate, encrypt, and gossip through the p2p network a new
	// QueryEnodeMsg with the enodeQueries given.
	GossipEnodeQueries(*istanbul.EcdsaInfo, []*EnodeQuery) (*istanbul.Message, error)
}

type ExternalFacingEnodeGetter interface {
	// GetEnodeCertNodesAndDestAddresses will retrieve all the external facing external nodes for this validator
	// (one for each of it's proxies, or itself for standalone validators) for the purposes of generating enode certificates
	// for those enodes.  It will also return the destination validators for each enode certificate.  If the destAddress is a
	// `nil` value, then that means that the associated enode certificate should be sent to all of the connected validators.
	GetEnodeCertNodesAndDestAddresses() ([]*enode.Node, map[enode.ID][]common.Address, error)
}

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

type Network interface {
	// Gossip gossips protocol messages
	Gossip(payload []byte, ethMsgCode uint64) error
	// RetrieveValidatorConnSet returns the validator connection set
	RetrieveValidatorConnSet() (map[common.Address]bool, error)
	// Multicast will send the eth message (with the message's payload and msgCode field set to the params
	// payload and ethMsgCode respectively) to the nodes with the signing address in the destAddresses param.
	Multicast(destAddresses []common.Address, payload []byte, ethMsgCode uint64, sendToSelf bool) error
}

type OnNewEnodeCertsMsgSentFn func(map[enode.ID]*istanbul.EnodeCertMsg) error

type OutboundVersionCertificateProcessor interface {
	Process(*AnnounceState, []*istanbul.VersionCertificate, common.Address) error
}

type PeerCounterFn func(purpose p2p.PurposeFlag) int

type ProxyContext interface {
	GetProxiedValidatorEngine() proxy.ProxiedValidatorEngine
}

type QueryEnodeEntryProvider interface {
	GetQueryEnodeValEnodeEntries(enforceRetryBackoff bool, exceptAddress common.Address) ([]*istanbul.AddressEntry, error)
}

type QueryEnodeGossipFrequencyState int

type ValEnodeEntryInfo struct {
	PublicKey                    string `json:"publicKey"`
	Enode                        string `json:"enode"`
	Version                      uint   `json:"version"`
	HighestKnownVersion          uint   `json:"highestKnownVersion"`
	NumQueryAttemptsForHKVersion uint   `json:"numQueryAttemptsForHKVersion"`
	LastQueryTimestamp           string `json:"lastQueryTimestamp"` // Unix timestamp
}

type ValProxyAssigmnentProvider interface {
	// GetValProxyAssignments returns the remote validator -> external node assignments.
	// If this is a standalone validator, it will set the external node to itself.
	// If this is a proxied validator, it will set external node to the proxy's external node.
	GetValProxyAssignments(valAddresses []common.Address) (map[common.Address]*enode.Node, error)
}

type ValidatorChecker interface {
	// IsElectedOrNearValidator returns true iff this node is currently a NearlyElectedValidator.
	IsElectedOrNearValidator() (bool, error)
	// IsValidating returns true iff the node is started and running as a Validator.
	IsValidating() bool
}

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

type ValidatorEnodeHandler interface {
	// AddValidatorPeer adds a validator peer
	AddValidatorPeer(node *enode.Node, address common.Address)

	// RemoveValidatorPeer removes a validator peer
	RemoveValidatorPeer(node *enode.Node)

	// ReplaceValidatorPeers replace all validator peers for new list of enodeURLs
	ReplaceValidatorPeers(newNodes []*enode.Node)

	// Clear all validator peers
	ClearValidatorPeers()
}

type Version interface {
	Get() uint
	Set(version uint)
}

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

type VersionCertificateEntryInfo struct {
	Address string `json:"address"`
	Version uint   `json:"version"`
}

type VersionCertificateGossiper interface {
	// GossipAllFrom gossips all version certificates to every peer. Only the entries
	// that are new to a node will end up being regossiped throughout the
	// network.
	GossipAllFrom(*VersionCertificateDB) error
	// SendAllFrom sends all VersionCertificates this node
	// has to a specific peer.
	SendAllFrom(*VersionCertificateDB, consensus.Peer) error
	// Gossip will send the given version certificates to all peers.
	Gossip(versionCertificates []*istanbul.VersionCertificate) error
}

type VersionReader interface {
	Get() uint
}

type VersionSharer interface {
	// ShareVersion generates announce data structures and
	// and shares them with relevant nodes.
	// It will:
	//  1) Generate a new enode certificate
	//  2) Multicast the new enode certificate to all peers in the validator conn set
	//	   * Note: If this is a proxied validator, it's multicast message will be wrapped within a forward
	//       message to the proxy, which will in turn send the enode certificate to remote validators.
	//  3) Generate a new version certificate
	//  4) Gossip the new version certificate to all peers
	ShareVersion(version uint) error
}

type Worker interface {
	Run()
	UpdateVersion()
	GetVersion() uint
	Stop()

	// UpdateVersionTo is only public for testing purposes
	UpdateVersionTo(version uint) error
	// GenerateAndGossipQueryEnode is only public for testing purposes
	GenerateAndGossipQueryEnode(enforceRetryBackoff bool) (*istanbul.Message, error)
}