Struct Hopr 

pub struct Hopr<Chain, Db> { /* 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> Hopr<Chain, Db>

where Chain: HoprChainApi + Clone + Send + Sync + 'static, Db: HoprNodeDbApi + Clone + Send + Sync + 'static,

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

pub fn status(&self) -> HoprState

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

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

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

pub fn get_safe_config(&self) -> SafeModule

pub fn config(&self) -> &HoprLibConfig

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

where Ct: TrafficGeneration + 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 fn subscribe_winning_tickets( &self, ) -> impl Stream<Item = VerifiedTicket> + Send

Allows external users to receive notifications about new winning tickets.

pub fn me_peer_id(&self) -> PeerId

Own PeerId used in the libp2p transport layer

pub async fn get_public_nodes( &self, ) -> Result<Vec<(PeerId, Address, Vec<Multiaddr>)>>

Get the list of all announced public nodes in the network

pub async fn ping(&self, peer: &PeerId) -> Result<(Duration, PeerStatus)>

Ping another node in the network based on the PeerId

Returns the RTT (round trip time), i.e. how long it took for the ping to return.

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 update_session_surb_balancer_config( &self, id: &SessionId, cfg: SurbBalancerConfig, ) -> Result<()>

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

List all multiaddresses announced by this node

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

List all multiaddresses on which the node is listening

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

List all multiaddresses observed for a PeerId

pub async fn multiaddresses_announced_on_chain( &self, peer: &PeerId, ) -> Result<Vec<Multiaddr>>

List all multiaddresses announced on-chain for the given node.

pub async fn network_health(&self) -> Health

Get measured network health

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

List all peers connected to this

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

Get all data collected from the network relevant for a PeerId

pub async fn all_network_peers( &self, minimum_quality: f64, ) -> Result<Vec<(Option<Address>, PeerId, PeerStatus)>>

Get peers connected peers with quality higher than some value

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

Get all tickets in a channel specified by channel_id.

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

Get all tickets

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

Get statistics for all tickets

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

Reset the ticket metrics to zero

pub fn me_onchain(&self) -> Address

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

Get ticket price

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

Get minimum incoming ticket winning probability

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

List of all accounts announced on the chain

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

Get the channel entry from Hash. @returns the channel entry of those two nodes

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

Get the channel entry between source and destination node. @param src Address @param dest Address @returns the channel entry of those two nodes

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

List all channels open from a specified Address

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

List all channels open to a specified address

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

List all channels

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

Current safe allowance balance

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

Withdraw on-chain assets to a given address @param recipient the account where the assets should be transferred to @param amount how many tokens to be transferred

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

Withdraw on-chain native assets to a given address @param recipient the account where the assets should be transferred to @param amount how many tokens to be transferred

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

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

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

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

pub fn redemption_requests( &self, ) -> Result<impl Sink<TicketSelector, Error = HoprLibError> + Clone>

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

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

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

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

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

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

impl<Chain, Db> Hopr<Chain, Db>

pub fn collect_hopr_metrics() -> Result<String>

Prometheus formatted metrics collected by the hopr-lib components.