pub struct HoprChain { /* private fields */ }Expand description
Represents all chain interactions exported to be used in the hopr-lib
NOTE: instead of creating a unified interface the HoprChain exports some functionality (e.g. the ChainActions as a referentially used) object. This behavior will be refactored and hidden behind a trait in the future implementations.
Implementations§
Source§impl HoprChain
 
impl HoprChain
pub fn new( me_onchain: ChainKeypair, chain_config: ChainNetworkConfig, node_db: HoprNodeDb, data_dir_path: &str, module_address: Address, contract_addresses: ContractAddresses, safe_address: Address, indexer_cfg: IndexerConfig, ) -> Result<Self>
Sourcepub async fn start(&self) -> Result<HashMap<HoprChainProcess, AbortHandle>>
 
pub async fn start(&self) -> Result<HashMap<HoprChainProcess, AbortHandle>>
Execute all processes of the HoprChain object.
This method will spawn the HoprChainProcess::Indexer and HoprChainProcess::OutgoingOnchainActionQueue
processes and return join handles to the calling function.
pub fn me_onchain(&self) -> Address
pub async fn corrupted_channels(&self) -> Result<Vec<CorruptedChannelEntry>>
pub async fn get_indexer_state(&self) -> Result<IndexerStateInfo>
Trait Implementations§
Source§impl ChainEvents for HoprChain
 
impl ChainEvents for HoprChain
Source§impl ChainKeyOperations for HoprChain
 
impl ChainKeyOperations for HoprChain
type Error = HoprChainError
type Mapper = CacheKeyMapper
Source§fn chain_key_to_packet_key<'life0, 'life1, 'async_trait>(
    &'life0 self,
    chain: &'life1 Address,
) -> Pin<Box<dyn Future<Output = Result<Option<OffchainPublicKey>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
 
fn chain_key_to_packet_key<'life0, 'life1, 'async_trait>(
    &'life0 self,
    chain: &'life1 Address,
) -> Pin<Box<dyn Future<Output = Result<Option<OffchainPublicKey>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
Translates 
Address into OffchainPublicKey.Source§fn packet_key_to_chain_key<'life0, 'life1, 'async_trait>(
    &'life0 self,
    packet: &'life1 OffchainPublicKey,
) -> Pin<Box<dyn Future<Output = Result<Option<Address>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
 
fn packet_key_to_chain_key<'life0, 'life1, 'async_trait>(
    &'life0 self,
    packet: &'life1 OffchainPublicKey,
) -> Pin<Box<dyn Future<Output = Result<Option<Address>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
Translates 
OffchainPublicKey into Address.Source§fn key_id_mapper_ref(&self) -> &Self::Mapper
 
fn key_id_mapper_ref(&self) -> &Self::Mapper
Returns mapper for offchain key IDs as a reference.
Source§impl ChainReadAccountOperations for HoprChain
 
impl ChainReadAccountOperations for HoprChain
type Error = HoprChainError
Source§fn node_balance<'life0, 'async_trait, C>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Balance<C>, Self::Error>> + Send + 'async_trait>>where
    C: 'async_trait + Currency,
    Self: 'async_trait,
    'life0: 'async_trait,
 
fn node_balance<'life0, 'async_trait, C>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Balance<C>, Self::Error>> + Send + 'async_trait>>where
    C: 'async_trait + Currency,
    Self: 'async_trait,
    'life0: 'async_trait,
Returns the native or token currency balance of the current node’s account.
Source§fn safe_balance<'life0, 'async_trait, C>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Balance<C>, Self::Error>> + Send + 'async_trait>>where
    C: 'async_trait + Currency,
    Self: 'async_trait,
    'life0: 'async_trait,
 
fn safe_balance<'life0, 'async_trait, C>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Balance<C>, Self::Error>> + Send + 'async_trait>>where
    C: 'async_trait + Currency,
    Self: 'async_trait,
    'life0: 'async_trait,
Returns the native or token currency balance of the current node’s Safe.
Source§fn safe_allowance<'life0, 'async_trait, C>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Balance<C>, Self::Error>> + Send + 'async_trait>>where
    C: 'async_trait + Currency,
    Self: 'async_trait,
    'life0: 'async_trait,
 
fn safe_allowance<'life0, 'async_trait, C>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Balance<C>, Self::Error>> + Send + 'async_trait>>where
    C: 'async_trait + Currency,
    Self: 'async_trait,
    'life0: 'async_trait,
Returns the native or token currency Safe allowance.
Source§fn find_account_by_address<'life0, 'life1, 'async_trait>(
    &'life0 self,
    address: &'life1 Address,
) -> Pin<Box<dyn Future<Output = Result<Option<AccountEntry>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
 
fn find_account_by_address<'life0, 'life1, 'async_trait>(
    &'life0 self,
    address: &'life1 Address,
) -> Pin<Box<dyn Future<Output = Result<Option<AccountEntry>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
Returns account entry given the on-chain 
address.Source§fn find_account_by_packet_key<'life0, 'life1, 'async_trait>(
    &'life0 self,
    packet_key: &'life1 OffchainPublicKey,
) -> Pin<Box<dyn Future<Output = Result<Option<AccountEntry>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
 
fn find_account_by_packet_key<'life0, 'life1, 'async_trait>(
    &'life0 self,
    packet_key: &'life1 OffchainPublicKey,
) -> Pin<Box<dyn Future<Output = Result<Option<AccountEntry>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
Returns account entry given the off-chain 
packet_key.Source§fn check_node_safe_module_status<'life0, 'async_trait>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
 
fn check_node_safe_module_status<'life0, 'async_trait>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
Validates the node’s Safe setup.
Source§fn can_register_with_safe<'life0, 'life1, 'async_trait>(
    &'life0 self,
    safe_address: &'life1 Address,
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
 
fn can_register_with_safe<'life0, 'life1, 'async_trait>(
    &'life0 self,
    safe_address: &'life1 Address,
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
Checks if the given safe address can be registered with the current node.
Source§fn stream_accounts<'a, 'async_trait>(
    &'a self,
    selector: AccountSelector,
) -> Pin<Box<dyn Future<Output = Result<BoxStream<'a, AccountEntry>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,
 
fn stream_accounts<'a, 'async_trait>(
    &'a self,
    selector: AccountSelector,
) -> Pin<Box<dyn Future<Output = Result<BoxStream<'a, AccountEntry>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,
Returns on-chain node accounts with the given 
AccountSelector.Source§fn count_accounts<'life0, 'async_trait>(
    &'life0 self,
    selector: AccountSelector,
) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
 
fn count_accounts<'life0, 'async_trait>(
    &'life0 self,
    selector: AccountSelector,
) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
Counts the accounts with the given 
AccountSelector. Read moreSource§impl ChainReadChannelOperations for HoprChain
 
impl ChainReadChannelOperations for HoprChain
type Error = HoprChainError
Source§fn channel_by_parties<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    src: &'life1 Address,
    dst: &'life2 Address,
) -> Pin<Box<dyn Future<Output = Result<Option<ChannelEntry>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
 
fn channel_by_parties<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    src: &'life1 Address,
    dst: &'life2 Address,
) -> Pin<Box<dyn Future<Output = Result<Option<ChannelEntry>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
Returns a single channel given 
src and dst.Source§fn channel_by_id<'life0, 'life1, 'async_trait>(
    &'life0 self,
    channel_id: &'life1 ChannelId,
) -> Pin<Box<dyn Future<Output = Result<Option<ChannelEntry>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
 
fn channel_by_id<'life0, 'life1, 'async_trait>(
    &'life0 self,
    channel_id: &'life1 ChannelId,
) -> Pin<Box<dyn Future<Output = Result<Option<ChannelEntry>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
Returns a single channel given 
channel_id.Source§fn stream_channels<'a, 'async_trait>(
    &'a self,
    selector: ChannelSelector,
) -> Pin<Box<dyn Future<Output = Result<BoxStream<'a, ChannelEntry>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,
 
fn stream_channels<'a, 'async_trait>(
    &'a self,
    selector: ChannelSelector,
) -> Pin<Box<dyn Future<Output = Result<BoxStream<'a, ChannelEntry>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,
Returns a stream of channels given the 
ChannelSelector.Source§impl ChainValues for HoprChain
 
impl ChainValues for HoprChain
type Error = HoprChainError
Source§fn domain_separators<'life0, 'async_trait>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<DomainSeparators, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
 
fn domain_separators<'life0, 'async_trait>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<DomainSeparators, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
Retrieves the domain separators of HOPR smart contracts.
Source§fn minimum_incoming_ticket_win_prob<'life0, 'async_trait>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<WinningProbability, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
 
fn minimum_incoming_ticket_win_prob<'life0, 'async_trait>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<WinningProbability, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
Retrieves the network-set minimum incoming ticket winning probability.
Source§fn minimum_ticket_price<'life0, 'async_trait>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<HoprBalance, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
 
fn minimum_ticket_price<'life0, 'async_trait>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<HoprBalance, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
Retrieves the network-set minimum ticket price.
Source§impl ChainWriteAccountOperations for HoprChain
 
impl ChainWriteAccountOperations for HoprChain
type Error = HoprChainError
Source§fn announce<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    multiaddrs: &'life1 [Multiaddr],
    key: &'life2 OffchainKeypair,
) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'_, Result<ChainReceipt, Self::Error>>, AnnouncementError<Self::Error>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
 
fn announce<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    multiaddrs: &'life1 [Multiaddr],
    key: &'life2 OffchainKeypair,
) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'_, Result<ChainReceipt, Self::Error>>, AnnouncementError<Self::Error>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
Announces transport key and list of multi addresses.
Source§fn withdraw<'life0, 'life1, 'async_trait, C>(
    &'life0 self,
    balance: Balance<C>,
    recipient: &'life1 Address,
) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'_, Result<ChainReceipt, Self::Error>>, Self::Error>> + Send + 'async_trait>>
 
fn withdraw<'life0, 'life1, 'async_trait, C>( &'life0 self, balance: Balance<C>, recipient: &'life1 Address, ) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'_, Result<ChainReceipt, Self::Error>>, Self::Error>> + Send + 'async_trait>>
Withdraws native or token currency.
Source§fn register_safe<'life0, 'life1, 'async_trait>(
    &'life0 self,
    safe_address: &'life1 Address,
) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'_, Result<ChainReceipt, Self::Error>>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
 
fn register_safe<'life0, 'life1, 'async_trait>(
    &'life0 self,
    safe_address: &'life1 Address,
) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'_, Result<ChainReceipt, Self::Error>>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
Registers Safe address with the current node.
Source§impl ChainWriteChannelOperations for HoprChain
 
impl ChainWriteChannelOperations for HoprChain
type Error = HoprChainError
Source§fn open_channel<'a, 'async_trait>(
    &'a self,
    dst: &'a Address,
    amount: HoprBalance,
) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'a, Result<(ChannelId, ChainReceipt), Self::Error>>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,
 
fn open_channel<'a, 'async_trait>(
    &'a self,
    dst: &'a Address,
    amount: HoprBalance,
) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'a, Result<(ChannelId, ChainReceipt), Self::Error>>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,
Opens a channel with 
dst and amount.Source§fn fund_channel<'a, 'async_trait>(
    &'a self,
    channel_id: &'a ChannelId,
    amount: HoprBalance,
) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'a, Result<ChainReceipt, Self::Error>>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,
 
fn fund_channel<'a, 'async_trait>(
    &'a self,
    channel_id: &'a ChannelId,
    amount: HoprBalance,
) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'a, Result<ChainReceipt, Self::Error>>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,
Funds an existing channel.
Source§fn close_channel<'a, 'async_trait>(
    &'a self,
    channel_id: &'a ChannelId,
) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'a, Result<(ChannelStatus, ChainReceipt), Self::Error>>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,
 
fn close_channel<'a, 'async_trait>(
    &'a self,
    channel_id: &'a ChannelId,
) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'a, Result<(ChannelStatus, ChainReceipt), Self::Error>>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,
Closes an existing channel.
Source§impl ChainWriteTicketOperations for HoprChain
 
impl ChainWriteTicketOperations for HoprChain
type Error = HoprChainError
Source§fn redeem_ticket<'life0, 'async_trait>(
    &'life0 self,
    ticket: AcknowledgedTicket,
) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'_, Result<ChainReceipt, Self::Error>>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
 
fn redeem_ticket<'life0, 'async_trait>(
    &'life0 self,
    ticket: AcknowledgedTicket,
) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'_, Result<ChainReceipt, Self::Error>>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
Redeems a single ticket on-chain.
Source§fn redeem_tickets_via_selector<'life0, 'async_trait>(
    &'life0 self,
    selector: TicketSelector,
) -> Pin<Box<dyn Future<Output = Result<Vec<BoxFuture<'_, Result<ChainReceipt, Self::Error>>>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
 
fn redeem_tickets_via_selector<'life0, 'async_trait>(
    &'life0 self,
    selector: TicketSelector,
) -> Pin<Box<dyn Future<Output = Result<Vec<BoxFuture<'_, Result<ChainReceipt, Self::Error>>>, Self::Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
Allows to batch-redeem multiple tickets on-chain.
Auto Trait Implementations§
impl Freeze for HoprChain
impl !RefUnwindSafe for HoprChain
impl Send for HoprChain
impl Sync for HoprChain
impl Unpin for HoprChain
impl !UnwindSafe for HoprChain
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
    T: ?Sized,
 
impl<T> BorrowMut<T> for Twhere
    T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
 
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
Source§impl<T> CloneToUninit for Twhere
    T: Clone,
 
impl<T> CloneToUninit for Twhere
    T: Clone,
§impl<T> Instrument for T
 
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
 
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
 
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> IntoEither for T
 
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
 
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts 
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
 
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
Converts 
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more