Struct Hopr 

pub struct Hopr<Chain, Db, Graph, Net>
where
    Graph: NetworkGraphView<NodeId = OffchainPublicKey> + NetworkGraphUpdate + Clone + Send + Sync + 'static,
    Net: NetworkView + NetworkStreamControl + Send + Sync + Clone + 'static,
{ /* private fields */ }

HOPR main object providing the entire HOPR node functionality

Instantiating this object creates all processes and objects necessary for running the HOPR node. Once created, the node can be started using the run() method.

Externally offered API should be enough to perform all necessary tasks with the HOPR node manually, but it is advised to create such a configuration that manual interaction is unnecessary.

As such, the hopr_lib serves mainly as an integration point into Rust programs.

Implementations

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

where Chain: HoprChainApi + Clone + Send + Sync + 'static, Db: HoprNodeDbApi + Clone + Send + Sync + 'static, Graph: NetworkGraphView<NodeId = OffchainPublicKey> + NetworkGraphUpdate + Clone + Send + Sync + 'static, Net: NetworkView + NetworkStreamControl + Send + Sync + Clone + 'static,

pub async fn new( identity: (&ChainKeypair, &OffchainKeypair), hopr_chain_api: Chain, hopr_node_db: Db, graph: Graph, cfg: HoprLibConfig, ) -> Result<Self>

pub fn config(&self) -> &HoprLibConfig

pub async fn network_peer_packet_stats( &self, peer: &PeerId, ) -> Result<Option<PeerPacketStatsSnapshot>>

Get packet stats for a specific peer.

pub async fn network_all_packet_stats( &self, ) -> Result<Vec<(PeerId, PeerPacketStatsSnapshot)>>

Get packet stats for all connected peers.

pub async fn run<Ct, NetBuilder, T: HoprSessionServer + Clone + Send + 'static>( &self, cover_traffic: Ct, network_builder: NetBuilder, serve_handler: T, ) -> Result<HoprTransportIO>

where Ct: ProbingTrafficGeneration + CoverTrafficGeneration + Send + Sync + 'static, NetBuilder: NetworkBuilder<Network = Net> + Send + Sync + 'static,

pub fn shutdown(&self) -> Result<(), HoprLibError>

Used to practically shut down all node’s processes without dropping the instance.

This means that the instance can be used to retrieve some information, but all active operations will stop and new will be impossible to perform. Such operations will return HoprStatusError::NotThereYet.

This is the final state and cannot be reversed by calling [HoprLib::run] again.

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

Create a client session connection returning a session object that implements [futures::io::AsyncRead] and [futures::io::AsyncWrite] and can bu used as a read/write binary session.

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

Sends keep-alive to the given [HoprSessionId], making sure the session is not closed due to inactivity.

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

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

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

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

where Graph: NetworkGraphView<NodeId = OffchainPublicKey> + NetworkGraphUpdate + Clone + Send + Sync + 'static, Net: NetworkView + NetworkStreamControl + Send + Sync + Clone + 'static,

pub fn collect_hopr_metrics() -> Result<String>

Prometheus formatted metrics collected by the hopr-lib components.

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

where Chain: HoprChainApi + Clone + Send + Sync + 'static, Db: HoprNodeDbApi + Clone + Send + Sync + 'static, Graph: NetworkGraphView<NodeId = OffchainPublicKey> + NetworkGraphUpdate + Clone + Send + Sync + 'static, Net: NetworkView + NetworkStreamControl + Send + Sync + Clone + 'static,

pub fn me_onchain(&self) -> Address

pub fn get_safe_config(&self) -> SafeModuleConfig

pub async fn get_balance<C: Currency + Send>( &self, ) -> Result<Balance<C>, HoprLibError>

pub async fn get_safe_balance<C: Currency + Send>( &self, ) -> Result<Balance<C>, HoprLibError>

pub async fn safe_allowance(&self) -> Result<HoprBalance, HoprLibError>

pub async fn chain_info(&self) -> Result<ChainInfo, HoprLibError>

pub async fn get_ticket_price(&self) -> Result<HoprBalance, HoprLibError>

pub async fn get_minimum_incoming_ticket_win_probability( &self, ) -> Result<WinningProbability, HoprLibError>

pub async fn get_channel_closure_notice_period( &self, ) -> Result<Duration, HoprLibError>

pub async fn accounts_announced_on_chain( &self, ) -> Result<Vec<AccountEntry>, HoprLibError>

pub async fn peerid_to_chain_key( &self, peer_id: &PeerId, ) -> Result<Option<Address>, HoprLibError>

pub async fn chain_key_to_peerid( &self, address: &Address, ) -> Result<Option<PeerId>, HoprLibError>

pub async fn channel_from_hash( &self, channel_id: &Hash, ) -> Result<Option<ChannelEntry>, HoprLibError>

pub async fn channel( &self, src: &Address, dest: &Address, ) -> Result<Option<ChannelEntry>, HoprLibError>

pub async fn channels_from( &self, src: &Address, ) -> Result<Vec<ChannelEntry>, HoprLibError>

pub async fn channels_to( &self, dest: &Address, ) -> Result<Vec<ChannelEntry>, HoprLibError>

pub async fn all_channels(&self) -> Result<Vec<ChannelEntry>, HoprLibError>

pub async fn open_channel( &self, destination: &Address, amount: HoprBalance, ) -> Result<OpenChannelResult, HoprLibError>

pub async fn fund_channel( &self, channel_id: &ChannelId, amount: HoprBalance, ) -> Result<Hash, HoprLibError>

pub async fn close_channel_by_id( &self, channel_id: &ChannelId, ) -> Result<CloseChannelResult, HoprLibError>

pub async fn tickets_in_channel( &self, channel_id: &ChannelId, ) -> Result<Option<Vec<RedeemableTicket>>, HoprLibError>

pub async fn all_tickets(&self) -> Result<Vec<VerifiedTicket>, HoprLibError>

pub async fn ticket_statistics( &self, ) -> Result<ChannelTicketStatistics, HoprLibError>

pub async fn reset_ticket_statistics(&self) -> Result<(), HoprLibError>

pub async fn redeem_all_tickets<B: Into<HoprBalance> + Send>( &self, min_value: B, ) -> Result<(), HoprLibError>

pub async fn redeem_tickets_with_counterparty<B: Into<HoprBalance> + Send>( &self, counterparty: &Address, min_value: B, ) -> Result<(), HoprLibError>

pub async fn redeem_tickets_in_channel<B: Into<HoprBalance> + Send>( &self, channel_id: &Hash, min_value: B, ) -> Result<(), HoprLibError>

pub async fn redeem_ticket( &self, ack_ticket: AcknowledgedTicket, ) -> Result<(), HoprLibError>

pub fn subscribe_winning_tickets( &self, ) -> impl Stream<Item = VerifiedTicket> + Send + 'static

pub fn redemption_requests(&self) -> Result<SinkMap, HoprLibError>

pub async fn withdraw_tokens( &self, recipient: Address, amount: HoprBalance, ) -> Result<Hash, HoprLibError>

pub async fn withdraw_native( &self, recipient: Address, amount: XDaiBalance, ) -> Result<Hash, HoprLibError>

Trait Implementations

impl<Chain, Db, Graph, Net> HoprNodeNetworkOperations for Hopr<Chain, Db, Graph, Net>

where Chain: HoprChainApi + Clone + Send + Sync + 'static, Db: HoprNodeDbApi + Clone + Send + Sync + 'static, Graph: NetworkGraphView<NodeId = OffchainPublicKey> + NetworkGraphUpdate + Clone + Send + Sync + 'static, Net: NetworkView + NetworkStreamControl + Send + Sync + Clone + 'static,

type Error = HoprLibError

Error type for node operations.

type TransportObservable = <Graph as NetworkGraphView>::Observed

Observable type returned by peer information queries.

fn me_peer_id(&self) -> PeerId

Returns the PeerId of this node used in the transport layer.

fn get_public_nodes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<(PeerId, Address, Vec<Multiaddr>)>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns all public nodes announced on the network.

fn network_health<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Health> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the current network health status.

fn network_connected_peers<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<PeerId>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns all currently connected peers.

fn network_peer_info(&self, peer: &PeerId) -> Option<Self::TransportObservable>

Returns observations for a specific peer.

fn all_network_peers<'life0, 'async_trait>( &'life0 self, minimum_score: f64, ) -> Pin<Box<dyn Future<Output = Result<Vec<(Option<Address>, PeerId, Self::TransportObservable)>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns all network peers with quality above the minimum score.

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

Returns the multiaddresses this node is announcing.

fn listening_multiaddresses<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Vec<Multiaddr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the multiaddresses this node is listening on.

fn network_observed_multiaddresses<'life0, 'life1, 'async_trait>( &'life0 self, peer: &'life1 PeerId, ) -> Pin<Box<dyn Future<Output = Vec<Multiaddr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns the observed multiaddresses for a peer.

fn multiaddresses_announced_on_chain<'life0, 'life1, 'async_trait>( &'life0 self, peer: &'life1 PeerId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Multiaddr>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns the multiaddresses announced on-chain for a peer.

fn ping<'life0, 'life1, 'async_trait>( &'life0 self, peer: &'life1 PeerId, ) -> Pin<Box<dyn Future<Output = Result<(Duration, Self::TransportObservable), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Pings a peer and returns the round-trip time along with observable data.

impl<Chain, Db, Graph, Net> HoprNodeOperations for Hopr<Chain, Db, Graph, Net>

where Chain: HoprChainApi + Clone + Send + Sync + 'static, Db: HoprNodeDbApi + Clone + Send + Sync + 'static, Graph: NetworkGraphView<NodeId = OffchainPublicKey> + NetworkGraphUpdate + Clone + Send + Sync + 'static, Net: NetworkView + NetworkStreamControl + Send + Sync + Clone + 'static,

fn status(&self) -> HoprState