Struct HoprBlockchainConnector 

pub struct HoprBlockchainConnector<C, B, P, R> {

    payload_generator: P,
    chain_key: ChainKeypair,
    client: Arc<C>,
    graph: Arc<RwLock<DiGraphMap<HoprKeyIdent, ChannelId, RandomState>>>,
    backend: Arc<B>,
    connection_handle: Option<AbortHandle>,
    sequencer: TransactionSequencer<C, R>,
    events: (Sender<ChainEvent>, InactiveReceiver<ChainEvent>),
    cfg: BlockchainConnectorConfig,
    mapper: HoprKeyMapper<B>,
    chain_to_packet: Cache<Address, Option<OffchainPublicKey>, RandomState>,
    packet_to_chain: Cache<OffchainPublicKey, Option<Address>, RandomState>,
    channel_by_id: Cache<ChannelId, Option<ChannelEntry>, RandomState>,
    channel_by_parties: Cache<ChannelParties, Option<ChannelEntry>, RandomState>,
    values: Cache<u32, ParsedChainInfo>,
}

A connector acting as middleware between the HOPR APIs (see the [hopr_api] crate) and the Blokli Client API (see the [blokli_client] crate).

The connector object cannot be cloned and shall be used inside an Arc if cloning is needed.

Fields

payload_generator: P

chain_key: ChainKeypair

client: Arc<C>

graph: Arc<RwLock<DiGraphMap<HoprKeyIdent, ChannelId, RandomState>>>

backend: Arc<B>

connection_handle: Option<AbortHandle>

sequencer: TransactionSequencer<C, R>

events: (Sender<ChainEvent>, InactiveReceiver<ChainEvent>)

cfg: BlockchainConnectorConfig

mapper: HoprKeyMapper<B>

chain_to_packet: Cache<Address, Option<OffchainPublicKey>, RandomState>

packet_to_chain: Cache<OffchainPublicKey, Option<Address>, RandomState>

channel_by_id: Cache<ChannelId, Option<ChannelEntry>, RandomState>

channel_by_parties: Cache<ChannelParties, Option<ChannelEntry>, RandomState>

values: Cache<u32, ParsedChainInfo>

Implementations

impl<B, C, P, R> HoprBlockchainConnector<C, B, P, R>

where B: Backend + Send + Sync + 'static,

pub(crate) fn build_account_stream( &self, selector: AccountSelector, ) -> Result<impl Stream<Item = AccountEntry> + Send + 'static, ConnectorError>

impl<B, C, P, R> HoprBlockchainConnector<C, B, P, R>

where B: Backend + Send + Sync + 'static,

pub(crate) fn build_channel_stream( &self, selector: ChannelSelector, ) -> Result<impl Stream<Item = ChannelEntry> + Send + 'static, ConnectorError>

impl<B, C, P> HoprBlockchainConnector<C, B, P, P::TxRequest>

where B: Backend + Send + Sync + 'static, C: BlokliTransactionClient + BlokliQueryClient + Send + Sync + 'static, P: PayloadGenerator + Send + Sync + 'static, P::TxRequest: Send + Sync + 'static,

async fn prepare_ticket_redeem_payload( &self, ticket: RedeemableTicket, ) -> Result<P::TxRequest, ConnectorError>

impl<B, C, P, R> HoprBlockchainConnector<C, R, B, P>

where C: BlokliQueryClient + Send + Sync + 'static,

pub(crate) async fn query_cached_chain_info( &self, ) -> Result<ParsedChainInfo, ConnectorError>

Queries chain info from cache, fetching from Blokli on cold start.

The cache has no TTL - it’s kept fresh by the Blokli subscription handler which updates it whenever ticket parameters change. This prevents the cascading timeout issue where cache expiration during packet processing would trigger blocking Blokli queries.

impl<B, C, P> HoprBlockchainConnector<C, B, P, P::TxRequest>

where B: Backend + Send + Sync + 'static, C: BlokliSubscriptionClient + BlokliQueryClient + BlokliTransactionClient + Send + Sync + 'static, P: PayloadGenerator + Send + Sync + 'static, P::TxRequest: Send + Sync + 'static,

pub fn new( chain_key: ChainKeypair, cfg: BlockchainConnectorConfig, client: C, backend: B, payload_generator: P, ) -> Self

Creates a new instance.

async fn do_connect( &self, timeout: Duration, ) -> Result<AbortHandle, ConnectorError>

pub async fn connect(&mut self) -> Result<(), ConnectorError>

Connects to the chain using the underlying client, syncs all on-chain data, and subscribes for all future updates.

If the connection does not finish within BlockchainConnectorConfig::connection_timeout the ConnectorError::ConnectionTimeout error is returned.

Most of the operations with the Connector will fail if it is not connected first.

There are some notable exceptions that DO NOT require a prior call to connect:

• all the ChainValues methods,
• all the ChainReadSafeOperations methods,
• all the ChainWriteSafeOperations methods,
• me

If you wish to only call operations from the above Chain APIs, consider constructing the HoprBlockchainReader instead.

pub fn client(&self) -> &C

Returns the reference to the underlying client.

pub fn is_connected(&self) -> bool

Checks if the connector is connected to the chain.

impl<B, C, P> HoprBlockchainConnector<C, B, P, P::TxRequest>

where C: BlokliTransactionClient + BlokliQueryClient + Send + Sync + 'static, P: PayloadGenerator + Send + Sync, P::TxRequest: Send + Sync,

async fn send_tx<'a>( &'a self, tx_req: P::TxRequest, custom_tx_multiplier: Option<u32>, ) -> Result<impl Future<Output = Result<ChainReceipt, ConnectorError>> + Send + 'a, ConnectorError>

impl<B, C, P, R> HoprBlockchainConnector<C, R, B, P>

pub(crate) fn check_connection_state(&self) -> Result<(), ConnectorError>

pub fn invalidate_caches(&self)

Invalidates all cached on-chain data.

impl<B, C, P, R> HoprBlockchainConnector<C, B, P, R>

where B: Backend + Send + Sync + 'static, C: Send + Sync, P: Send + Sync, R: Send + Sync,

pub fn as_path_resolver(&self) -> ChainPathResolver<'_, Self>

Returns a [PathAddressResolver] using this connector.

Trait Implementations

impl<B, C, P, R> ChainEvents for HoprBlockchainConnector<C, B, P, R>

where B: Backend + Send + Sync + 'static,

type Error = ConnectorError

fn subscribe_with_state_sync<I: IntoIterator<Item = StateSyncOptions>>( &self, options: I, ) -> Result<impl Stream<Item = ChainEvent> + Send + 'static, Self::Error>

Subscribe to on-chain events.

fn subscribe( &self, ) -> Result<impl Stream<Item = ChainEvent> + Send + 'static, Self::Error>

Convenience method for subscribing to on-chain events without specifying any state sync options.

impl<B, C, P, R> ChainKeyOperations for HoprBlockchainConnector<C, B, P, R>

where B: Backend + Send + Sync + 'static, C: Send + Sync, P: Send + Sync, R: Send + Sync,

type Error = ConnectorError

type Mapper = HoprKeyMapper<B>

Mapping between HoprKeyIdent and OffchainPublicKey.

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.

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.

fn key_id_mapper_ref(&self) -> &Self::Mapper

Returns the KeyIdMapping for offchain key IDs as a reference.

impl<B, C, P, R> ChainReadAccountOperations for HoprBlockchainConnector<C, B, P, R>

where B: Backend + Send + Sync + 'static, C: BlokliQueryClient + BlokliSubscriptionClient + Send + Sync + 'static, P: Send + Sync + 'static, R: Send + Sync,

type Error = ConnectorError

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.

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.

fn await_key_binding<'life0, 'life1, 'async_trait>( &'life0 self, offchain_key: &'life1 OffchainPublicKey, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<AccountEntry, Self::Error>> + Send + 'async_trait>>

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

Waits for the account with the key-binding on the offchain_key to appear on-chain or the timeout expires.

impl<B, C, P, R> ChainReadChannelOperations for HoprBlockchainConnector<C, B, P, R>

where B: Backend + Send + Sync + 'static, C: Send + Sync, P: Send + Sync, R: Send + Sync,

type Error = ConnectorError

fn me(&self) -> &Address

Returns on-chain Address of the current node.

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.

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.

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.

impl<B, C, P, R> ChainReadSafeOperations for HoprBlockchainConnector<C, B, P, R>

where B: Backend + Send + Sync + 'static, C: BlokliQueryClient + BlokliSubscriptionClient + Send + Sync + 'static, P: Send + Sync + 'static, R: Send + Sync,

type Error = ConnectorError

fn safe_allowance<'life0, 'async_trait, Cy, A>( &'life0 self, safe_address: A, ) -> Pin<Box<dyn Future<Output = Result<Balance<Cy>, Self::Error>> + Send + 'async_trait>>

where Cy: 'async_trait + Currency, A: 'async_trait + Into<Address> + Send, Self: 'async_trait, 'life0: 'async_trait,

Returns the native or token currency Safe allowance.

fn safe_info<'life0, 'async_trait>( &'life0 self, selector: SafeSelector, ) -> Pin<Box<dyn Future<Output = Result<Option<DeployedSafe>, Self::Error>> + Send + 'async_trait>>

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

Retrieves DeployedSafe information using the given selector.

fn await_safe_deployment<'life0, 'async_trait>( &'life0 self, selector: SafeSelector, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<DeployedSafe, Self::Error>> + Send + 'async_trait>>

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

Waits for a Safe matching the given selector to be deployed up to the given timeout.

fn predict_module_address<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, nonce: u64, owner: &'life1 Address, safe_address: &'life2 Address, ) -> Pin<Box<dyn Future<Output = Result<Address, Self::Error>> + Send + 'async_trait>>

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

Predicts the Module address based on the given nonce, owner and safe_address of the Safe.

impl<B, R, C, P> ChainValues for HoprBlockchainConnector<C, B, P, R>

where B: Send + Sync, C: BlokliQueryClient + Send + Sync + 'static, P: Send + Sync, R: Send + Sync,

type Error = ConnectorError

fn balance<'life0, 'async_trait, Cy, A>( &'life0 self, address: A, ) -> Pin<Box<dyn Future<Output = Result<Balance<Cy>, Self::Error>> + Send + 'async_trait>>

where Cy: 'async_trait + Currency, A: 'async_trait + Into<Address> + Send, Self: 'async_trait, 'life0: 'async_trait,

Returns the native or token currency balance of the given on-chain account.

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.

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.

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.

fn key_binding_fee<'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 current key binding fee used for new key-binding announcements.

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

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

Gets the grace period for channel closure finalization.

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

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

Gets the information about the HOPR network on-chain deployment.

fn outgoing_ticket_values<'life0, 'async_trait>( &'life0 self, cfg_out_wp: Option<WinningProbability>, cfg_out_price: Option<Balance<WxHOPR>>, ) -> Pin<Box<dyn Future<Output = Result<(WinningProbability, Balance<WxHOPR>), Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Convenience function to determine the winning probability and ticket price for outgoing tickets.

impl<B, C, P> ChainWriteAccountOperations for HoprBlockchainConnector<C, B, P, P::TxRequest>

where B: Send + Sync, C: BlokliTransactionClient + BlokliQueryClient + Send + Sync + 'static, P: PayloadGenerator + Send + Sync + 'static, P::TxRequest: Send + Sync + 'static,

type Error = ConnectorError

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.

fn withdraw<'life0, 'life1, 'async_trait, Cy>( &'life0 self, balance: Balance<Cy>, recipient: &'life1 Address, ) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'_, Result<ChainReceipt, Self::Error>>, Self::Error>> + Send + 'async_trait>>

where Cy: 'async_trait + Currency + Send, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Withdraws native or token currency from the Safe or node account (depends on the used [PayloadGenerator]).

fn register_safe<'life0, 'life1, 'async_trait>( &'life0 self, safe_address: &'life1 Address, ) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'_, Result<ChainReceipt, Self::Error>>, SafeRegistrationError<Self::Error>>> + Send + 'async_trait>>

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

Registers Safe address with the current node.

impl<B, C, P> ChainWriteChannelOperations for HoprBlockchainConnector<C, B, P, P::TxRequest>

where B: Backend + Send + Sync + 'static, C: BlokliQueryClient + BlokliTransactionClient + Send + Sync + 'static, P: PayloadGenerator + Send + Sync + 'static, P::TxRequest: Send + Sync + 'static,

type Error = ConnectorError

fn open_channel<'a, 'async_trait>( &'a self, dst: &'a Address, 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,

Opens a channel with dst and amount.

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.

fn close_channel<'a, 'async_trait>( &'a self, channel_id: &'a ChannelId, ) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'a, Result<ChainReceipt, Self::Error>>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait,

Closes an existing channel.

impl<B, C, P> ChainWriteSafeOperations for HoprBlockchainConnector<C, B, P, P::TxRequest>

where B: Send + Sync + 'static, C: BlokliQueryClient + BlokliTransactionClient + Send + Sync + 'static, P: PayloadGenerator + Send + Sync + 'static, P::TxRequest: Send + Sync + 'static,

type Error = ConnectorError

fn deploy_safe<'a, 'async_trait>( &'a self, balance: 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,

Deploys Safe with the given balance of wxHOPR tokens.

impl<B, C, P> ChainWriteTicketOperations for HoprBlockchainConnector<C, B, P, P::TxRequest>

where B: Backend + Send + Sync + 'static, C: BlokliTransactionClient + BlokliQueryClient + Send + Sync + 'static, P: PayloadGenerator + Send + Sync + 'static, P::TxRequest: Send + Sync + 'static,

type Error = ConnectorError

fn redeem_ticket<'a, 'async_trait>( &'a self, ticket: RedeemableTicket, ) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'a, Result<(VerifiedTicket, ChainReceipt), TicketRedeemError<Self::Error>>>, TicketRedeemError<Self::Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait,

Redeems a single ticket on-chain.

impl<B, C, P, R> Drop for HoprBlockchainConnector<C, R, B, P>

fn drop(&mut self)

Executes the destructor for this type.