p2p

type Cmd = uint16

type CmdSet = uint32

type Config struct {
	Discovery       bool
	Name            string
	NetID           network.ID         // which network server runs on
	MaxPeers        uint               // max peers can be connected
	MaxPendingPeers uint               // max peers waiting for connect
	MaxInboundRatio uint               // max inbound peers: MaxPeers / MaxInboundRatio
	Port            uint               // TCP and UDP listen port
	DataDir         string             // the directory for storing node table, default is "~/viteisbest/p2p"
	PeerKey         ed25519.PrivateKey // use for encrypt message, the corresponding public key use for NodeID
	ExtNodeData     []byte             // extension data for Node
	Protocols       []*Protocol        // protocols server supported
	BootNodes       []string           // nodes as discovery seed
	StaticNodes     []string           // nodes to connect
}

type ConnProperty struct {
	LocalID    string `json:"localID"`
	LocalIP    net.IP `json:"localIP"`
	LocalPort  uint16 `json:"localPort"`
	RemoteID   string `json:"remoteID"`
	RemoteIP   net.IP `json:"remoteIP"`
	RemotePort uint16 `json:"remotePort"`
}

type DiscReason uint64

type Handshake struct {
	// peer name, use for readability and log
	Name string
	// peer remoteID
	ID discovery.NodeID
	// command set supported
	CmdSets []CmdSet
	// peer`s IP
	RemoteIP net.IP
	// peer`s Port
	RemotePort uint16
	// tell peer our tcp listen port, could use for update discovery info
	Port uint16
}

type Msg struct {
	CmdSet     CmdSet
	Cmd        Cmd
	Id         uint64 // as message context
	Payload    []byte
	ReceivedAt time.Time
	SendAt     time.Time
}

type MsgReadWriter interface {
	MsgReader
	MsgWriter
}

type MsgReader interface {
	ReadMsg() (*Msg, error)
}

type MsgWriter interface {
	WriteMsg(*Msg) error
}

type NodeInfo struct {
	ID        string     `json:"remoteID"`
	Name      string     `json:"name"`
	Url       string     `json:"url"`
	NetID     network.ID `json:"netId"`
	Address   *address   `json:"address"`
	Protocols []string   `json:"protocols"`
}

type P2PVersion = uint32

type Peer struct {
	Created time.Time
	// contains filtered or unexported fields
}

type PeerInfo struct {
	ID      string   `json:"id"`
	Name    string   `json:"name"`
	CmdSets []string `json:"cmdSets"`
	Address string   `json:"address"`
	Inbound bool     `json:"inbound"`
}

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

type Plugin interface {
	Start(p2p Server) error
	Stop()
}

type ProtoFrame struct {
	*Protocol

	Received  map[Cmd]uint64
	Discarded map[Cmd]uint64
	Send      map[Cmd]uint64
	// contains filtered or unexported fields
}

type Protocol struct {
	// description of the protocol
	Name string
	// use for message command set, should be unique
	ID CmdSet
	// read and write Msg with rw
	Handle func(p *Peer, rw *ProtoFrame) error
}

type Serializable interface {
	Serialize() ([]byte, error)
	Deserialize(buf []byte) error
}

type Server interface {
	Start() error
	Stop()
	AddPlugin(plugin Plugin)
	Connect(id discovery.NodeID, addr *net.TCPAddr)
	Peers() []*PeerInfo
	PeersCount() uint
	NodeInfo() *NodeInfo
	Available() bool
	Nodes() (urls []string)
	SubNodes(ch chan<- *discovery.Node)
	UnSubNodes(ch chan<- *discovery.Node)
	URL() string
	Config() *Config
	Block(id discovery.NodeID, ip net.IP, err error)
}

type Transport interface {
	MsgReadWriter
	Close()
	Handshake(our *Handshake) (their *Handshake, err error)
}