Struct HoprTransport 

pub struct HoprTransport<Chain, Db, Graph, Net>
where
    Graph: NetworkGraphView<NodeId = OffchainPublicKey> + NetworkGraphUpdate + Clone + Send + Sync + 'static,
    Net: NetworkView + NetworkStreamControl + Clone + Send + Sync + 'static,
{

    pub(crate) packet_key: OffchainKeypair,
    pub(crate) chain_key: ChainKeypair,
    pub(crate) db: Db,
    pub(crate) chain_api: Chain,
    pub(crate) ping: Arc<OnceLock<Pinger>>,
    pub(crate) network: Arc<OnceLock<Net>>,
    pub(crate) graph: Graph,
    pub(crate) path_planner: PathPlanner<MemorySurbStore, Chain, HoprGraphPathSelector<Graph>>,
    pub(crate) my_multiaddresses: Vec<Multiaddr>,
    pub(crate) smgr: SessionManager<Sender<(DestinationRouting, ApplicationDataOut)>, Sender<IncomingSession>>,
    pub(crate) session_telemetry_tag_allocator: Arc<dyn TagAllocator + Send + Sync>,
    pub(crate) probing_tag_allocator: Arc<dyn TagAllocator + Send + Sync>,
    pub(crate) counters: PeerProtocolCounterRegistry,
    pub(crate) cfg: HoprProtocolConfig,
}

Interface into the physical transport mechanism allowing all off-chain HOPR-related tasks on the transport.

Fields

packet_key: OffchainKeypair

chain_key: ChainKeypair

db: Db

chain_api: Chain

ping: Arc<OnceLock<Pinger>>

network: Arc<OnceLock<Net>>

graph: Graph

path_planner: PathPlanner<MemorySurbStore, Chain, HoprGraphPathSelector<Graph>>

my_multiaddresses: Vec<Multiaddr>

smgr: SessionManager<Sender<(DestinationRouting, ApplicationDataOut)>, Sender<IncomingSession>>

session_telemetry_tag_allocator: Arc<dyn TagAllocator + Send + Sync>

probing_tag_allocator: Arc<dyn TagAllocator + Send + Sync>

counters: PeerProtocolCounterRegistry

cfg: HoprProtocolConfig

Implementations

impl<Chain, Db, Graph, Net> HoprTransport<Chain, Db, Graph, Net>

where Db: HoprDbTicketOperations + Clone + Send + Sync + 'static, Chain: ChainReadChannelOperations + ChainReadAccountOperations + ChainKeyOperations + ChainValues + Clone + Send + Sync + 'static, Graph: NetworkGraphView<NodeId = OffchainPublicKey> + NetworkGraphUpdate + NetworkGraphWrite<NodeId = OffchainPublicKey> + NetworkGraphTraverse<NodeId = OffchainPublicKey> + Clone + Send + Sync + 'static, <Graph as NetworkGraphView>::Observed: EdgeObservableRead + Send, <Graph as NetworkGraphTraverse>::Observed: EdgeObservableRead + Send + 'static, <Graph as NetworkGraphWrite>::Observed: EdgeObservableWrite + Send, Net: NetworkView + NetworkStreamControl + Clone + Send + Sync + 'static,

pub fn new( identity: (&ChainKeypair, &OffchainKeypair), resolver: Chain, db: Db, graph: Graph, my_multiaddresses: Vec<Multiaddr>, cfg: HoprProtocolConfig, ) -> Result<Self>

pub async fn run<T, Ct, NetBuilder>( &self, cover_traffic: Ct, network_builder: NetBuilder, ticket_events: T, on_incoming_session: Sender<IncomingSession>, ) -> Result<(HoprSocket<Receiver<ApplicationDataIn>, Sender<(DestinationRouting, ApplicationDataOut)>>, AbortableList<HoprTransportProcess>)>

where T: Sink<TicketEvent> + Clone + Send + Unpin + 'static, T::Error: Error, Ct: ProbingTrafficGeneration + CoverTrafficGeneration + Send + Sync + 'static, NetBuilder: NetworkBuilder<Network = Net> + Send + Sync + 'static,

Execute all processes of the HoprTransport object.

This method will spawn the HoprTransportProcess::Heartbeat, HoprTransportProcess::BloomFilterSave, HoprTransportProcess::Swarm and session-related processes and return join handles to the calling function. These processes are not started immediately but are waiting for a trigger from this piece of code.

pub async fn ping( &self, peer: &OffchainPublicKey, ) -> Result<(Duration, <Graph as NetworkGraphView>::Observed)>

pub async fn new_session( &self, destination: Address, target: SessionTarget, cfg: SessionClientConfig, ) -> Result<HoprSession>

pub async fn probe_session(&self, id: &SessionId) -> Result<()>

pub async fn session_surb_balancing_cfg( &self, id: &SessionId, ) -> Result<Option<SurbBalancerConfig>>

pub async fn update_session_surb_balancing_cfg( &self, id: &SessionId, cfg: SurbBalancerConfig, ) -> Result<()>

pub async fn listening_multiaddresses(&self) -> Vec<Multiaddr>

pub fn announceable_multiaddresses(&self) -> Vec<Multiaddr>

pub fn local_multiaddresses(&self) -> Vec<Multiaddr>

pub async fn network_observed_multiaddresses( &self, peer: &OffchainPublicKey, ) -> Vec<Multiaddr>

pub async fn network_health(&self) -> Health

pub async fn network_connected_peers(&self) -> Result<Vec<OffchainPublicKey>>

pub fn network_peer_observations( &self, peer: &OffchainPublicKey, ) -> Option<<Graph as NetworkGraphView>::Observed>

pub async fn all_network_peers( &self, minimum_score: f64, ) -> Result<Vec<(OffchainPublicKey, <Graph as NetworkGraphView>::Observed)>>

Get connected peers with quality higher than some value.