p2p

type Callbacks chan chan SendPingResp

type Demuxer interface {
	RegisterProtocolHandler(handler ProtocolRegistration)
	RouteIncomingMessage(msg IncomingMessage)
}

type FindNodeCallbacks chan RespCallbackRequest

type FindNodeProtocol interface {

	// this should really be named FindClosestNodes
	FindNode(reqID []byte, serverNodeID string, id string, callback chan FindNodeResp) error
}

type FindNodeResp struct {
	*pb.FindNodeResp
	// contains filtered or unexported fields
}

type HandshakeData interface {
	LocalNode() LocalNode
	Peer() Peer
	Session() NetworkSession
	GetError() error
	SetError(err error)
}

type HandshakeProtocol interface {
	CreateSession(peer Peer)
	RegisterNewSessionCallback(callback chan HandshakeData) // register a channel to receive session state changes
}

type IncomingMessage interface {
	Sender() Peer
	Protocol() string
	Payload() []byte
}

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

type LocalNode interface {
	ID() []byte
	String() string
	Pretty() string

	PrivateKey() crypto.PrivateKey
	PublicKey() crypto.PublicKey

	DhtID() dht.ID
	TCPAddress() string    // ipv4 tcp address that the node is listing on
	PubTCPAddress() string // node's public ip address - advertised by this node

	RefreshPubTCPAddress() bool // attempt to refresh the node's public ip address

	Sign(data proto.Message) ([]byte, error)
	SignToString(data proto.Message) (string, error)
	NewProtocolMessageMetadata(protocol string, reqID []byte, gossip bool) *pb.Metadata

	GetSwarm() Swarm
	GetPing() Ping

	Config() nodeconfig.Config

	GetRemoteNodeData() node.RemoteNodeData

	// todo: add client callback when the node has shut down properly
	Shutdown()

	Info(format string, args ...interface{})
	Debug(format string, args ...interface{})
	Error(format string, args ...interface{})
	Warning(format string, args ...interface{})

	// local store persistence
	EnsureNodeDataDirectory() (string, error)
	// contains filtered or unexported methods
}

type MessagesChan chan IncomingMessage

type NetworkSession interface {
	ID() []byte         // Unique session id
	String() string     // globally unique session id for p2p debugging and key store purposes
	KeyE() []byte       // session shared sym key for enc - 32 bytes
	KeyM() []byte       // session shared sym key for mac - 32 bytes
	PubKey() []byte     // 65 bytes session-only pub key uncompressed
	Created() time.Time // time when session was established

	LocalNodeID() string  // string encoded session local node id
	RemoteNodeID() string // string encoded session remote node id

	IsAuthenticated() bool
	SetAuthenticated(val bool)

	Decrypt(in []byte) ([]byte, error) // decrypt data using session dec key
	Encrypt(in []byte) ([]byte, error) // encrypt data using session enc key
}

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

type NodeData struct {
	PubKey     string `json:"pubKey"`
	PrivKey    string `json:"priKey"`
	CoinBaseID string `json:"coinbase"` // coinbase account id
}

type NodeEvent struct {
	PeerID string
	State  NodeState
}

type NodeEventCallback chan NodeEvent

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

type NodeState int32

type Peer interface {
	ID() []byte     // node id is public key bytes
	String() string // node public key string
	Pretty() string
	TCPAddress() string // tcp address advertised by node e.g. 127.0.0.1:3058
	PublicKey() crypto.PublicKey
	GetConnections() map[string]net.Connection

	DeleteAllConnections()

	GetSessions() map[string]NetworkSession

	// returns an authenticated session with the node if one exists
	GetAuthenticatedSession() NetworkSession

	// returns an active connection with the node if we have one
	GetActiveConnection() net.Connection

	// returns RemoteNodeData for this peer
	GetRemoteNodeData() node.RemoteNodeData
}

type Ping interface {

	// Send sends a ping request to a remote node.
	// reqIdD: allows the client to match responses with requests by id.
	Send(msg string, reqID []byte, remoteNodeID string)

	// Register a callback for typed incoming ping responses (pongs) or send errors.
	Register(callback chan SendPingResp)
}

type ProtocolRegistration struct {
	Protocol string
	Handler  MessagesChan
}

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

type SendError struct {
	ReqID []byte // unique request id
	// contains filtered or unexported fields
}

type SendMessageReq struct {
	PeerID   string         // base58 message destination peer id
	ReqID    []byte         // unique request id
	Payload  []byte         // this should be a marshaled protocol msg e.g. PingReqData
	Callback chan SendError // optional callback to receive send errors or timeout
}

type SendPingResp struct {
	*pb.PingRespData
	// contains filtered or unexported fields
}

type Swarm interface {

	// Send a message to a specific remote node based just on its id without knowing its ip address
	// In this case we will try to locate the node via dht node search
	// and send the message if we obtained node ip address and were able to connect to it
	// req.msg should be marshaled protocol message. e.g. something like pb.PingReqData
	// This is designed for standard messages that require a session
	// This method is designed to be used by protocols implementations to send message to any destination
	SendMessage(req SendMessageReq)

	// Register a node with the swarm based on its id and tcp address but don't attempt to connect to it
	RegisterNode(data node.RemoteNodeData)

	// Attempt to establish a session with a remote node with a known id and tcp address
	// Used for bootstrapping known bootstrap nodes
	ConnectTo(req node.RemoteNodeData)

	// Connect to count random nodes - used for bootstrapping the swarm
	ConnectToRandomNodes(count int)

	// Forcefully disconnect form a node - close any connections and sessions with it
	DisconnectFrom(req node.RemoteNodeData)

	// Register a callback channel for state changes related to remote nodes
	// Currently used for testing network bootstrapping
	RegisterNodeEventsCallback(callback NodeEventCallback)

	// todo: allow client to register callback to get notified when swarm has shut down
	Shutdown()

	// services getters
	GetDemuxer() Demuxer
	GetLocalNode() LocalNode
	// contains filtered or unexported methods
}