transport

type ConnectionManager interface {
	core.Diagnosable

	// Connect attempts to make an outbound connection to the given peer if it's not already connected.
	// acceptNonAuthenticated indicates if the connection must be kept even if the other end can't be authenticated.
	// The connection can then still be used for non-authenticated purposes.
	Connect(peerAddress string, option ...ConnectionOption)

	// Peers returns a slice containing the peers that are currently connected.
	Peers() []Peer

	// RegisterObserver allows to register a callback function for stream state changes
	RegisterObserver(callback StreamStateObserverFunc)

	// Start instructs the ConnectionManager to start accepting connections and prepare to make outbound connections.
	Start() error

	// Stop shuts down the connections made by the ConnectionManager.
	Stop()
}

type ConnectionOption func(peer *Peer)

type ConnectorStats struct {
	// Address holds the target address the connector is connecting to.
	Address string
	// Attempts holds the number of times the node tried to connect to the peer.
	Attempts uint32
}

type Diagnostics struct {
	// Uptime the uptime (time since the node started) in seconds.
	Uptime time.Duration `json:"uptime"`
	// Peers contains the peer IDs of the node's peers.
	Peers []PeerID `json:"peers"`
	// NumberOfTransactions contains the total number of transactions on the node's DAG.
	NumberOfTransactions uint32 `json:"transactionNum"`
	// SoftwareVersion contains an indication of the software version of the node. It's recommended to use a (Git) commit ID that uniquely resolves to a code revision, alternatively a semantic version could be used (e.g. 1.2.5).
	SoftwareVersion string `json:"softwareVersion"`
	// SoftwareID contains an indication of the vendor of the software of the node. For open source implementations it's recommended to specify URL to the public, open source repository.
	// Proprietary implementations could specify the product's or vendor's name.
	SoftwareID string `json:"softwareID"`
}

type FixedNodeDIDResolver struct {
	NodeDID did.DID
}

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

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

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

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

type NodeDIDResolver interface {
	// Resolve tries to resolve the node DID. If it's absent, an empty DID is returned. In any other non-successful case an error is returned.
	Resolve() (did.DID, error)
}

type Peer struct {
	// ID holds the unique identificator of the peer
	ID PeerID
	// Address holds the remote address of the node we're actually connected to
	Address string
	// NodeDID holds the DID that the peer uses to identify its node on the network.
	// It is only set when properly authenticated.
	NodeDID did.DID
	// AcceptUnauthenticated indicates if a connection may be made with this Peer even if the NodeDID is not set.
	AcceptUnauthenticated bool
}

type PeerID string

type Protocol interface {
	// Configure configures the Protocol implementation, must be called before Start().
	Configure(peerID PeerID) error
	// Start starts the Protocol implementation.
	Start() error
	// Stop stops the Protocol implementation.
	Stop()
	// Diagnostics collects and returns diagnostical information on the protocol.
	Diagnostics() []core.DiagnosticResult
	// PeerDiagnostics collects and returns diagnostical information on the peers the protocol is communicating with.
	PeerDiagnostics() map[PeerID]Diagnostics
	// Version returns the version of the protocol
	Version() int
}

type StreamState string

type StreamStateObserverFunc func(peer Peer, state StreamState, protocol Protocol)