p2p

type ActorService interface {
	// TellRequest send actor request, which does not need to get return value, and forget it.
	TellRequest(actor string, msg interface{})
	// SendRequest send actor request, and the response is expected to go back asynchronously.
	SendRequest(actor string, msg interface{})
	// CallRequest send actor request and wait the handling of that message to finished,
	// and get return value.
	CallRequest(actor string, msg interface{}, timeout time.Duration) (interface{}, error)
	// CallRequestDefaultTimeout is CallRequest with default timeout
	CallRequestDefaultTimeout(actor string, msg interface{}) (interface{}, error)

	// FutureRequest send actor reqeust and get the Future object to get the state and return value of message
	FutureRequest(actor string, msg interface{}, timeout time.Duration) *actor.Future
	// FutureRequestDefaultTimeout is FutureRequest with default timeout
	FutureRequestDefaultTimeout(actor string, msg interface{}) *actor.Future

	GetChainAccessor() types.ChainAccessor
}

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

type BlkHash [blkhashLen]byte

type HSHeader struct {
	Magic   uint32
	Version uint32
}

type HandlerFactory interface {
	// contains filtered or unexported methods
}

type Message interface {
	Subprotocol() SubProtocol

	// Length is lenght of payload
	Length() uint32
	Timestamp() int64
	// ID is 16 bytes unique identifier
	ID() MsgID
	// OriginalID is message id of request which trigger this message. it will be all zero, if message is request or notice.
	OriginalID() MsgID

	// marshaled by google protocol buffer v3. object is determined by Subprotocol
	Payload() []byte
}

type MessageHandler interface {
	// contains filtered or unexported methods
}

type MsgID [IDLength]byte

type MsgReadWriter interface {
	MsgReader
	MsgWriter
}

type MsgReader interface {
	// ReadMsg return types.MsgHeader as header, proto.Message as data
	// The header and/or data can be nil if error is not nil
	ReadMsg() (Message, error)
}

type MsgWriter interface {
	WriteMsg(msg Message) error
}

type P2P struct {
	*component.BaseComponent
	// contains filtered or unexported fields
}

type PeerEventListener interface {
	// OnAddPeer is called just after the peer is added.
	OnAddPeer(peerID peer.ID)

	// OnRemovePeer is called just before the peer is removed
	OnRemovePeer(peerID peer.ID)
}

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

type PeerManager interface {
	host.Host
	Start() error
	Stop() error

	PrivateKey() crypto.PrivKey
	PublicKey() crypto.PubKey
	SelfMeta() PeerMeta
	SelfNodeID() peer.ID

	AddNewPeer(peer PeerMeta)
	RemovePeer(peerID peer.ID)
	// NotifyPeerHandshake is called after remote peer is completed handshake and ready to receive or send
	NotifyPeerHandshake(peerID peer.ID)
	NotifyPeerAddressReceived([]PeerMeta)

	// GetPeer return registered(handshaked) remote peer object
	GetPeer(ID peer.ID) (RemotePeer, bool)
	GetPeers() []RemotePeer
	GetPeerAddresses() ([]*types.PeerAddress, []*types.NewBlockNotice, []types.PeerState)
}

type PeerMeta struct {
	ID peer.ID
	// IPAddress is human readable form of ip address such as "192.168.0.1" or "2001:0db8:0a0b:12f0:33:1"
	IPAddress  string
	Port       uint32
	Designated bool // Designated means this peer is designated in config file and connect to in startup phase
	Outbound   bool
}

type PeerPoolManager struct {
}

type ReconnectManager interface {
	AddJob(meta PeerMeta)
	// CancelJob cancel from outer module to reconnectRunner
	CancelJob(pid peer.ID)

	Stop()
	// contains filtered or unexported methods
}

type RemotePeer interface {
	ID() peer.ID
	Meta() PeerMeta
	State() types.PeerState
	LastNotice() *types.NewBlockNotice

	// TODO
	MF() moFactory
	// contains filtered or unexported methods
}

type SubProtocol uint32

type SubProtocolMeta struct {
	SubProtocol
	// contains filtered or unexported fields
}

type SyncManager interface {
	HandleNewBlockNotice(peer RemotePeer, hash BlkHash, data *types.NewBlockNotice)
	HandleGetBlockResponse(peer RemotePeer, msg Message, resp *types.GetBlockResponse)
	HandleNewTxNotice(peer RemotePeer, hashes []TxHash, data *types.NewTransactionsNotice)

	DoSync(peer RemotePeer, hashes []message.BlockHash, stopHash message.BlockHash)
}

type TxHash [txhashLen]byte

type V020Wrapper struct {
	*types.P2PMessage
	// contains filtered or unexported fields
}

type V030HSMessage struct {
	HSHeader
	Sigature  [SigLength]byte
	PubKeyB   []byte
	Timestamp uint64
	Nonce     uint16
}

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

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

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

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

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