p2p

type Cap struct {
	Name    string
	Version uint
}

type Config struct {
	// p2p.server will listen for incoming tcp connections. And it is for udp address used for Kad protocol
	ListenAddr string `json:"address"`

	// NetworkID used to define net type, for example main net and test net.
	NetworkID string `json:"networkID"`

	// static nodes which will be connected to find more nodes when the node started
	StaticNodes []*discovery.Node `json:"staticNodes"`

	// SubPrivateKey which will be make PrivateKey
	SubPrivateKey string `json:"privateKey"`

	// PrivateKey private key for p2p module, do not use it as any accounts
	PrivateKey *ecdsa.PrivateKey `json:"-"`
}

type Message struct {
	Code       uint16 // message code, defined in each protocol
	Payload    []byte
	ReceivedAt time.Time
}

type MsgReadWriter interface {
	MsgReader
	MsgWriter
}

type MsgReader interface {
	// ReadMsg read a message. It will block until send the message out or get errors
	ReadMsg() (*Message, error)
}

type MsgWriter interface {
	// WriteMsg sends a message. It will block until the message's
	// Payload has been consumed by the other end.
	//
	// Note that messages can be sent only once because their
	// payload reader is drained.
	WriteMsg(*Message) error
}

type Peer struct {
	Node *discovery.Node // remote peer that this peer connects
	// contains filtered or unexported fields
}

type PeerInfo struct {
	ID      string   `json:"id"`   // Unique of the node
	Caps    []string `json:"caps"` // Sum-protocols advertised by this particular peer
	Network struct {
		LocalAddress  string `json:"localAddress"`  // Local endpoint of the TCP data connection
		RemoteAddress string `json:"remoteAddress"` // Remote endpoint of the TCP data connection
	} `json:"network"`
	Protocols map[string]interface{} `json:"protocols"` // Sub-protocol specific metadata fields
	Shard     uint                   `json:"shard"`     // shard id of the node
}

type PeerInfos []PeerInfo

type ProtoHandShake struct {
	Caps      []Cap
	NodeID    common.Address
	Params    []byte
	NetworkID string
}

type Protocol struct {
	// Name should contain the official protocol name,
	// often a three-letter word.
	Name string

	// Version should contain the version number of the protocol.
	Version uint

	// Length should contain the number of message codes used by the protocol.
	Length uint16

	// AddPeer find a new peer will call this method
	AddPeer func(peer *Peer, rw MsgReadWriter) bool

	// DeletePeer this method will be called when a peer is disconnected
	DeletePeer func(peer *Peer)

	// GetPeer this method will be called for get peer information
	GetPeer func(address common.Address) interface{}
}

type Server struct {
	// Config fields may not be modified while the server is running.
	Config

	// MaxPendingPeers is the maximum number of peers that can be pending in the
	// handshake phase, counted separately for inbound and outbound connections.
	// Zero defaults to preset values.
	MaxPendingPeers int

	// Protocols should contain the protocols supported by the server.
	Protocols []Protocol

	SelfNode *discovery.Node
	// contains filtered or unexported fields
}