Struct Hopr

pub struct Hopr { /* 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 sufficient 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 Hopr

pub fn new( cfg: HoprLibConfig, me: &OffchainKeypair, me_onchain: &ChainKeypair, ) -> Result<Self>

pub fn status(&self) -> HoprState

pub fn version_coerced(&self) -> String

pub fn version(&self) -> String

pub fn network(&self) -> String

pub async fn get_balance(&self, balance_type: BalanceType) -> Result<Balance>

pub async fn get_eligibility_status(&self) -> Result<bool>

pub async fn get_safe_balance( &self, balance_type: BalanceType, ) -> Result<Balance>

pub fn get_safe_config(&self) -> SafeModule

pub fn chain_config(&self) -> ChainNetworkConfig

pub fn get_provider(&self) -> String

pub async fn run<T: HoprSessionReactor + Clone + Send + 'static>( &self, serve_handler: T, ) -> Result<(HoprSocket, HashMap<HoprLibProcesses, JoinHandle<()>>)>

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 get_indexer_state(&self) -> Result<IndexerStateInfo>

Returns the most recently indexed log, if any.

pub async fn is_allowed_to_access_network(&self, peer: &PeerId) -> Result<bool>

Test whether the peer with PeerId is allowed to access 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, cfg: SessionClientConfig) -> Result<HoprSession>

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

pub async fn send_message( &self, msg: Box<[u8]>, destination: PeerId, options: RoutingOptions, application_tag: Option<u16>, ) -> Result<()>

Send a message to another peer in the network

@param msg message to send @param destination PeerId of the destination @param options optional configuration of the message path using hops and intermediatePath @param applicationTag optional tag identifying the sending application @returns ack challenge

pub async fn aggregate_tickets(&self, channel: &Hash) -> Result<()>

Attempts to aggregate all tickets in the given channel

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, ) -> 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: &Hash, ) -> Result<Option<Vec<AcknowledgedTicket>>>

Get all tickets in a channel specified by Hash

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

Get all tickets

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

Get statistics for all tickets

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

Reset the ticket metrics to zero

pub fn peer_resolver(&self) -> &impl HoprDbResolverOperations

pub fn me_onchain(&self) -> Address

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

Get ticket price

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

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<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<Balance>

Current safe allowance balance

pub async fn withdraw( &self, recipient: Address, amount: Balance, ) -> 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 open_channel( &self, destination: &Address, amount: &Balance, ) -> Result<OpenChannelResult>

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

pub async fn close_channel( &self, counterparty: &Address, direction: ChannelDirection, redeem_before_close: bool, ) -> Result<CloseChannelResult>

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

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

pub async fn redeem_all_tickets(&self, only_aggregated: bool) -> Result<()>

pub async fn redeem_tickets_with_counterparty( &self, counterparty: &Address, only_aggregated: bool, ) -> Result<()>

pub async fn redeem_tickets_in_channel( &self, channel_id: &Hash, only_aggregated: bool, ) -> Result<usize>

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>>

pub async fn export_channel_graph(&self, cfg: GraphExportConfig) -> String

pub async fn export_raw_channel_graph(&self) -> Result<String>