Struct HoprDb 

pub struct HoprDb { /* private fields */ }

Main database handle for HOPR node operations.

Manages multiple SQLite databases for different data domains to avoid locking conflicts and improve performance:

• Index DB: Blockchain indexing and contract data
• Tickets DB: Payment tickets and acknowledgments
• Peers DB: Network peer information and metadata
• Logs DB: Blockchain logs and processing status

Supports database snapshot imports for fast synchronization via [HoprDbGeneralModelOperations::import_logs_db].

Implementations

impl HoprDb

pub async fn new( directory: &Path, chain_key: ChainKeypair, cfg: HoprDbConfig, ) -> Result<Self>

pub async fn new_in_memory(chain_key: ChainKeypair) -> Result<Self>

pub fn start_ticket_processing( &self, ticket_notifier: Option<UnboundedSender<AcknowledgedTicket>>, ) -> Result<()>

Starts ticket processing by the TicketManager with an optional new ticket notifier. Without calling this method, tickets will not be persisted into the DB.

If the notifier is given, it will receive notifications once new ticket has been persisted into the Tickets DB.

pub async fn create_pool( cfg: HoprDbConfig, directory: PathBuf, options: PoolOptions<Sqlite>, min_conn: Option<u32>, max_conn: Option<u32>, read_only: bool, path: &str, ) -> Result<SqlitePool>

impl HoprDb

pub async fn upsert_ticket<'a>( &'a self, tx: OptTx<'a>, acknowledged_ticket: AcknowledgedTicket, ) -> Result<()>

Used only by non-SQLite code and tests.

Trait Implementations

impl Clone for HoprDb

fn clone(&self) -> HoprDb

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HoprDb

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl HoprDbAccountOperations for HoprDb

fn get_account<'a, 'async_trait, T>( &'a self, tx: OptTx<'a>, key: T, ) -> Pin<Box<dyn Future<Output = Result<Option<AccountEntry>>> + Send + 'async_trait>>

where T: 'async_trait + Into<ChainOrPacketKey> + Send + Sync, Self: 'async_trait, 'a: 'async_trait,

Retrieves the account entry using a Packet key or Chain key.

fn get_self_account<'a, 'async_trait>( &'a self, tx: OptTx<'a>, ) -> Pin<Box<dyn Future<Output = Result<AccountEntry>> + Send + 'async_trait>>

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

Retrieves account entry about this node’s account. This a unique account in the database that must always be present.

fn get_accounts<'a, 'async_trait>( &'a self, tx: OptTx<'a>, public_only: bool, ) -> Pin<Box<dyn Future<Output = Result<Vec<AccountEntry>>> + Send + 'async_trait>>

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

Retrieves entries of accounts with routable address announcements (if public_only is true) or about all accounts without routeable address announcements (if public_only is false).

fn insert_account<'a, 'async_trait>( &'a self, tx: OptTx<'a>, account: AccountEntry, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Inserts a new account entry to the database. Fails if such an entry already exists.

fn insert_announcement<'a, 'async_trait, T>( &'a self, tx: OptTx<'a>, key: T, multiaddr: Multiaddr, at_block: u32, ) -> Pin<Box<dyn Future<Output = Result<AccountEntry>> + Send + 'async_trait>>

where T: Into<ChainOrPacketKey> + Send + Sync + 'async_trait, Self: 'async_trait, 'a: 'async_trait,

Inserts a routable address announcement linked to a specific entry.

fn delete_all_announcements<'a, 'async_trait, T>( &'a self, tx: OptTx<'a>, key: T, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where T: Into<ChainOrPacketKey> + Send + Sync + 'async_trait, Self: 'async_trait, 'a: 'async_trait,

Deletes all address announcements for the given account.

fn delete_account<'a, 'async_trait, T>( &'a self, tx: OptTx<'a>, key: T, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where T: Into<ChainOrPacketKey> + Send + Sync + 'async_trait, Self: 'async_trait, 'a: 'async_trait,

Deletes account with the given key (chain or off-chain).

fn translate_key<'a, 'async_trait, T>( &'a self, tx: OptTx<'a>, key: T, ) -> Pin<Box<dyn Future<Output = Result<Option<ChainOrPacketKey>>> + Send + 'async_trait>>

where T: 'async_trait + Into<ChainOrPacketKey> + Send + Sync, Self: 'async_trait, 'a: 'async_trait,

Translates the given Chain or Packet key to its counterpart.

impl HoprDbChannelOperations for HoprDb

fn get_channel_by_id<'a, 'life0, 'async_trait>( &'a self, tx: OptTx<'a>, id: &'life0 Hash, ) -> Pin<Box<dyn Future<Output = Result<Option<ChannelEntry>>> + Send + 'async_trait>>

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

Retrieves channel by its channel ID hash.

fn begin_channel_update<'a, 'life0, 'async_trait>( &'a self, tx: OptTx<'a>, id: &'life0 Hash, ) -> Pin<Box<dyn Future<Output = Result<Option<ChannelEditor>>> + Send + 'async_trait>>

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

Start changes to channel entry. If the channel with the given ID exists, the ChannelEditor is returned. Use HoprDbChannelOperations::finish_channel_update to commit edits to the DB when done.

fn finish_channel_update<'a, 'async_trait>( &'a self, tx: OptTx<'a>, editor: ChannelEditor, ) -> Pin<Box<dyn Future<Output = Result<Option<ChannelEntry>>> + Send + 'async_trait>>

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

Commits changes of the channel to the database. Returns the updated channel, or on deletion, the deleted channel entry.

fn get_channel_by_parties<'a, 'life0, 'life1, 'async_trait>( &'a self, tx: OptTx<'a>, src: &'life0 Address, dst: &'life1 Address, use_cache: bool, ) -> Pin<Box<dyn Future<Output = Result<Option<ChannelEntry>>> + Send + 'async_trait>>

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

Retrieves the channel by source and destination. This operation should be able to use cache since it can be also called from performance-sensitive locations.

fn get_channels_via<'a, 'life0, 'async_trait>( &'a self, tx: OptTx<'a>, direction: ChannelDirection, target: &'life0 Address, ) -> Pin<Box<dyn Future<Output = Result<Vec<ChannelEntry>>> + Send + 'async_trait>>

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

Fetches all channels that are Incoming to the given target, or Outgoing from the given target

fn get_incoming_channels<'a, 'async_trait>( &'a self, tx: OptTx<'a>, ) -> Pin<Box<dyn Future<Output = Result<Vec<ChannelEntry>>> + Send + 'async_trait>>

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

Fetches all channels that are Incoming to this node. Shorthand for get_channels_via(tx, ChannelDirection::Incoming, my_node)

fn get_outgoing_channels<'a, 'async_trait>( &'a self, tx: OptTx<'a>, ) -> Pin<Box<dyn Future<Output = Result<Vec<ChannelEntry>>> + Send + 'async_trait>>

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

Fetches all channels that are Outgoing from this node. Shorthand for get_channels_via(tx, ChannelDirection::Outgoing, my_node)

fn get_all_channels<'a, 'async_trait>( &'a self, tx: OptTx<'a>, ) -> Pin<Box<dyn Future<Output = Result<Vec<ChannelEntry>>> + Send + 'async_trait>>

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

Retrieves all channels information from the DB.

fn stream_active_channels<'a, 'async_trait>( &'a self, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'a, Result<ChannelEntry>>>> + Send + 'async_trait>>

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

Returns a stream of all channels that are Open or PendingToClose with an active grace period.s

fn upsert_channel<'a, 'async_trait>( &'a self, tx: OptTx<'a>, channel_entry: ChannelEntry, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Inserts or updates the given channel entry.

impl HoprDbCorruptedChannelOperations for HoprDb

fn get_corrupted_channel_by_id<'a, 'life0, 'async_trait>( &'a self, tx: OptTx<'a>, id: &'life0 Hash, ) -> Pin<Box<dyn Future<Output = Result<Option<CorruptedChannelEntry>>> + Send + 'async_trait>>

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

Retrieves corrupted channel by its channel ID hash.

fn get_all_corrupted_channels<'a, 'async_trait>( &'a self, tx: OptTx<'a>, ) -> Pin<Box<dyn Future<Output = Result<Vec<CorruptedChannelEntry>>> + Send + 'async_trait>>

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

Retrieves all corrupted channels information from the DB.

fn upsert_corrupted_channel<'a, 'async_trait>( &'a self, tx: OptTx<'a>, channel_id: ChannelId, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Inserts the given ChannelID as a corrupted channel entry.

impl HoprDbGeneralModelOperations for HoprDb

fn conn(&self, target_db: TargetDb) -> &DatabaseConnection

Retrieves raw database connection to the given DB.

fn begin_transaction_in_db<'life0, 'async_trait>( &'life0 self, target_db: TargetDb, ) -> Pin<Box<dyn Future<Output = Result<OpenTransaction>> + Send + 'async_trait>>

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

Starts a new transaction in the given DB.

fn import_logs_db<'async_trait>( self, src_dir: PathBuf, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait,

Import logs database from a snapshot directory.

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

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

Same as HoprDbGeneralModelOperations::begin_transaction_in_db with default TargetDb.

fn nest_transaction_in_db<'life0, 'life1, 'async_trait>( &'life0 self, tx: OptTx<'life1>, target_db: TargetDb, ) -> Pin<Box<dyn Future<Output = Result<OpenTransaction>> + Send + 'async_trait>>

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

Creates a nested transaction inside the given transaction.

fn nest_transaction<'life0, 'life1, 'async_trait>( &'life0 self, tx: OptTx<'life1>, ) -> Pin<Box<dyn Future<Output = Result<OpenTransaction>> + Send + 'async_trait>>

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

Same as HoprDbGeneralModelOperations::nest_transaction_in_db with default TargetDb.

impl HoprDbInfoOperations for HoprDb

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

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

Checks if the index is empty.

fn clear_index_db<'a, 'async_trait>( &'a self, tx: OptTx<'a>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Removes all data from all tables in the index database.

fn get_safe_hopr_balance<'a, 'async_trait>( &'a self, tx: OptTx<'a>, ) -> Pin<Box<dyn Future<Output = Result<HoprBalance>> + Send + 'async_trait>>

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

Gets node’s Safe balance of HOPR tokens.

fn set_safe_hopr_balance<'a, 'async_trait>( &'a self, tx: OptTx<'a>, new_balance: HoprBalance, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Sets node’s Safe balance of HOPR tokens.

fn get_safe_hopr_allowance<'a, 'async_trait>( &'a self, tx: OptTx<'a>, ) -> Pin<Box<dyn Future<Output = Result<HoprBalance>> + Send + 'async_trait>>

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

Gets node’s Safe allowance of HOPR tokens.

fn set_safe_hopr_allowance<'a, 'async_trait>( &'a self, tx: OptTx<'a>, new_allowance: HoprBalance, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Sets node’s Safe allowance of HOPR tokens.

fn get_safe_info<'a, 'async_trait>( &'a self, tx: OptTx<'a>, ) -> Pin<Box<dyn Future<Output = Result<Option<SafeInfo>>> + Send + 'async_trait>>

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

Gets node’s Safe addresses info.

fn set_safe_info<'a, 'async_trait>( &'a self, tx: OptTx<'a>, safe_info: SafeInfo, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Sets node’s Safe addresses info.

fn get_indexer_data<'a, 'async_trait>( &'a self, tx: OptTx<'a>, ) -> Pin<Box<dyn Future<Output = Result<IndexerData>> + Send + 'async_trait>>

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

Gets stored Indexer data (either from the cache or from the DB).

fn set_domain_separator<'a, 'async_trait>( &'a self, tx: OptTx<'a>, dst_type: DomainSeparator, value: Hash, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Sets a domain separator.

fn set_minimum_incoming_ticket_win_prob<'a, 'async_trait>( &'a self, tx: OptTx<'a>, win_prob: WinningProbability, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Sets the minimum required winning probability for incoming tickets. The value must be between zero and 1.

fn update_ticket_price<'a, 'async_trait>( &'a self, tx: OptTx<'a>, price: HoprBalance, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Updates the ticket price. To retrieve the stored ticket price, use HoprDbInfoOperations::get_indexer_data, note that this setter should invalidate the cache.

fn get_indexer_state_info<'a, 'async_trait>( &'a self, tx: OptTx<'a>, ) -> Pin<Box<dyn Future<Output = Result<IndexerStateInfo>> + Send + 'async_trait>>

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

Gets the indexer state info.

fn set_indexer_state_info<'a, 'async_trait>( &'a self, tx: OptTx<'a>, block_num: u32, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Updates the indexer state info.

fn set_network_registry_enabled<'a, 'async_trait>( &'a self, tx: OptTx<'a>, enabled: bool, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Updates the network registry state. To retrieve the stored network registry state, use HoprDbInfoOperations::get_indexer_data, note that this setter should invalidate the cache.

fn get_global_setting<'a, 'life0, 'async_trait>( &'a self, tx: OptTx<'a>, key: &'life0 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Box<[u8]>>>> + Send + 'async_trait>>

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

Gets global setting value with the given key.

fn set_global_setting<'a, 'life0, 'life1, 'async_trait>( &'a self, tx: OptTx<'a>, key: &'life0 str, value: Option<&'life1 [u8]>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Sets the global setting value with the given key.

impl HoprDbLogOperations for HoprDb

fn store_log<'a, 'async_trait>( &'a self, log: SerializableLog, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Stores a single log entry in the database.

fn store_logs<'life0, 'async_trait>( &'life0 self, logs: Vec<SerializableLog>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Result<()>>>> + Send + 'async_trait>>

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

Stores multiple log entries in the database.

fn get_log<'life0, 'async_trait>( &'life0 self, block_number: u64, tx_index: u64, log_index: u64, ) -> Pin<Box<dyn Future<Output = Result<SerializableLog>> + Send + 'async_trait>>

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

Retrieves a specific log entry from the database.

fn get_logs<'a, 'async_trait>( &'a self, block_number: Option<u64>, block_offset: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<Vec<SerializableLog>>> + Send + 'async_trait>>

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

Retrieves multiple log entries from the database.

fn get_logs_count<'life0, 'async_trait>( &'life0 self, block_number: Option<u64>, block_offset: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>

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

Retrieves the count of log entries from the database.

fn get_logs_block_numbers<'a, 'async_trait>( &'a self, block_number: Option<u64>, block_offset: Option<u64>, processed: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<Vec<u64>>> + Send + 'async_trait>>

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

Retrieves block numbers of log entries from the database.

fn set_logs_processed<'life0, 'async_trait>( &'life0 self, block_number: Option<u64>, block_offset: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Marks multiple log entries as processed.

fn set_log_processed<'a, 'async_trait>( &'a self, log: SerializableLog, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Marks a specific log entry as processed.

fn set_logs_unprocessed<'life0, 'async_trait>( &'life0 self, block_number: Option<u64>, block_offset: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Marks multiple log entries as unprocessed.

fn get_last_checksummed_log<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<SerializableLog>>> + Send + 'async_trait>>

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

Retrieves the last checksummed log entry from the database.

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

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

Updates checksums for log entries in the database.

fn ensure_logs_origin<'life0, 'async_trait>( &'life0 self, contract_address_topics: Vec<(Address, Hash)>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Ensures that logs in this database have been created by scanning the given contract address and their corresponding topics. If the log DB is empty, the given addresses and topics are used to prime the table.

impl HoprDbPeersOperations for HoprDb

fn add_network_peer<'life0, 'life1, 'async_trait>( &'life0 self, peer: &'life1 PeerId, origin: PeerOrigin, mas: Vec<Multiaddr>, backoff: f64, quality_window: u32, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Adds a peer to the backend.

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

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

Removes the peer from the backend.

fn update_network_peer<'life0, 'async_trait>( &'life0 self, new_status: PeerStatus, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Updates stored information about the peer. Should fail if the peer does not exist in the store.

fn get_network_peer<'life0, 'life1, 'async_trait>( &'life0 self, peer: &'life1 PeerId, ) -> Pin<Box<dyn Future<Output = Result<Option<PeerStatus>>> + Send + 'async_trait>>

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

Gets stored information about the peer.

fn get_network_peers<'a, 'async_trait>( &'a self, selector: PeerSelector, sort_last_seen_asc: bool, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'a, PeerStatus>>> + Send + 'async_trait>>

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

Returns a stream of all stored peers, optionally matching the given [PeerSelector] filter.

fn network_peer_stats<'life0, 'async_trait>( &'life0 self, quality_threshold: f64, ) -> Pin<Box<dyn Future<Output = Result<Stats>> + Send + 'async_trait>>

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

Returns the statistics on the stored peers.

impl HoprDbProtocolOperations for HoprDb

fn handle_acknowledgement<'life0, 'async_trait>( &'life0 self, ack: VerifiedAcknowledgement, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Processes the acknowledgements for the pending tickets

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

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

Loads (presumably cached) value of the network’s minimum winning probability from the DB.

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

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

Loads (presumably cached) value of the network’s minimum ticket price from the DB.

fn find_surb<'life0, 'async_trait>( &'life0 self, matcher: SurbMatcher, ) -> Pin<Box<dyn Future<Output = Result<FoundSurb>> + Send + 'async_trait>>

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

Attempts to find SURB and its ID given the [SurbMatcher].

fn get_surb_config(&self) -> SurbCacheConfig

Returns the SURB cache configuration.

fn to_send_no_ack<'life0, 'async_trait>( &'life0 self, data: Box<[u8]>, destination: OffchainPublicKey, ) -> Pin<Box<dyn Future<Output = Result<OutgoingPacket>> + Send + 'async_trait>>

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

Process the data into an outgoing packet that is not going to be acknowledged.

fn to_send<'life0, 'async_trait>( &'life0 self, data: Box<[u8]>, routing: ResolvedTransportRouting, outgoing_ticket_win_prob: WinningProbability, outgoing_ticket_price: HoprBalance, signals: PacketSignals, ) -> Pin<Box<dyn Future<Output = Result<OutgoingPacket>> + Send + 'async_trait>>

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

Process the data into an outgoing packet

fn from_recv<'life0, 'life1, 'async_trait>( &'life0 self, data: Box<[u8]>, pkt_keypair: &'life1 OffchainKeypair, sender: OffchainPublicKey, outgoing_ticket_win_prob: WinningProbability, outgoing_ticket_price: HoprBalance, ) -> Pin<Box<dyn Future<Output = Result<IncomingPacket>> + Send + 'async_trait>>

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

Process the incoming packet into data

impl HoprDbRegistryOperations for HoprDb

fn set_access_in_network_registry<'a, 'async_trait>( &'a self, tx: OptTx<'a>, address: Address, allowed: bool, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Sets the given node as allowed or denied in network registry.

fn is_allowed_in_network_registry<'a, 'life0, 'async_trait, T>( &'a self, tx: OptTx<'a>, address_like: &'life0 T, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Address: TryFrom<T>, T: Clone + Sync + 'async_trait, Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait,

Returns true if the given node is allowed in network registry.

fn set_safe_eligibility<'a, 'async_trait>( &'a self, tx: OptTx<'a>, address: Address, eligible: bool, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Sets or unsets Safe NR eligibility.

fn is_safe_eligible<'a, 'async_trait>( &'a self, tx: OptTx<'a>, address: Address, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

Returns true if the given Safe is NR eligible.

impl HoprDbResolverOperations for HoprDb

fn resolve_packet_key<'life0, 'life1, 'async_trait>( &'life0 self, onchain_key: &'life1 Address, ) -> Pin<Box<dyn Future<Output = Result<Option<OffchainPublicKey>>> + Send + 'async_trait>>

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

Tries to resolve off-chain public key given the on-chain address

fn resolve_chain_key<'life0, 'life1, 'async_trait>( &'life0 self, offchain_key: &'life1 OffchainPublicKey, ) -> Pin<Box<dyn Future<Output = Result<Option<Address>>> + Send + 'async_trait>>

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

Tries to resolve on-chain public key given the off-chain public key

impl HoprDbTicketOperations for HoprDb

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

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

Retrieve acknowledged winning tickets, according to the given selector.

fn get_tickets<'life0, 'async_trait>( &'life0 self, selector: TicketSelector, ) -> Pin<Box<dyn Future<Output = Result<Vec<AcknowledgedTicket>>> + Send + 'async_trait>>

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

Retrieve acknowledged winning tickets, according to the given selector.

fn mark_tickets_as<'life0, 'async_trait>( &'life0 self, selector: TicketSelector, mark_as: TicketMarker, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

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

Marks tickets as the given [TicketMarker], removing them from the DB and updating the ticket statistics for each ticket’s channel.

fn mark_unsaved_ticket_rejected<'life0, 'life1, 'async_trait>( &'life0 self, ticket: &'life1 Ticket, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Updates the ticket statistics according to the fact that the given ticket has been rejected by the packet processing pipeline.

fn update_ticket_states_and_fetch<'a, 'async_trait>( &'a self, selector: TicketSelector, new_state: AcknowledgedTicketStatus, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'a, AcknowledgedTicket>>> + Send + 'async_trait>>

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

Updates state of the tickets matching the given selector.

fn update_ticket_states<'life0, 'async_trait>( &'life0 self, selector: TicketSelector, new_state: AcknowledgedTicketStatus, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

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

Updates state of the tickets matching the given selector.

fn get_ticket_statistics<'life0, 'async_trait>( &'life0 self, channel_id: Option<Hash>, ) -> Pin<Box<dyn Future<Output = Result<ChannelTicketStatistics>> + Send + 'async_trait>>

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

Retrieves the ticket statistics for the given channel.

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

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

Resets the ticket statistics about neglected, rejected, and redeemed tickets.

fn get_tickets_value<'life0, 'async_trait>( &'life0 self, selector: TicketSelector, ) -> Pin<Box<dyn Future<Output = Result<(usize, HoprBalance)>> + Send + 'async_trait>>

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

Counts the tickets matching the given selector and their total value.

fn compare_and_set_outgoing_ticket_index<'life0, 'async_trait>( &'life0 self, channel_id: Hash, index: u64, ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>

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

Sets the stored outgoing ticket index to index, only if the currently stored value is less than index. This ensures the stored value can only be growing.

fn reset_outgoing_ticket_index<'life0, 'async_trait>( &'life0 self, channel_id: Hash, ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>

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

Resets the outgoing ticket index to 0 for the given channel id.

fn increment_outgoing_ticket_index<'life0, 'async_trait>( &'life0 self, channel_id: Hash, ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>

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

Increments the outgoing ticket index in the given channel ID and returns the value before incrementing.

fn get_outgoing_ticket_index<'life0, 'async_trait>( &'life0 self, channel_id: Hash, ) -> Pin<Box<dyn Future<Output = Result<Arc<AtomicU64>>> + Send + 'async_trait>>

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

Gets the current outgoing ticket index for the given channel id.

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

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

Compares outgoing ticket indices in the cache with the stored values and updates the stored value where changed.

fn prepare_aggregation_in_channel<'life0, 'life1, 'async_trait>( &'life0 self, channel: &'life1 Hash, prerequisites: AggregationPrerequisites, ) -> Pin<Box<dyn Future<Output = Result<Option<(OffchainPublicKey, Vec<TransferableWinningTicket>, Hash)>>> + Send + 'async_trait>>

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

Prepare a viable collection of tickets to be aggregated.

fn rollback_aggregation_in_channel<'life0, 'async_trait>( &'life0 self, channel: Hash, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Perform a ticket aggregation rollback in the channel.

fn process_received_aggregated_ticket<'life0, 'life1, 'async_trait>( &'life0 self, aggregated_ticket: Ticket, chain_keypair: &'life1 ChainKeypair, ) -> Pin<Box<dyn Future<Output = Result<AcknowledgedTicket>> + Send + 'async_trait>>

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

Replace the aggregated tickets locally with an aggregated ticket from the counterparty.

fn aggregate_tickets<'life0, 'life1, 'async_trait>( &'life0 self, destination: OffchainPublicKey, acked_tickets: Vec<TransferableWinningTicket>, me: &'life1 ChainKeypair, ) -> Pin<Box<dyn Future<Output = Result<VerifiedTicket>> + Send + 'async_trait>>

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

Performs ticket aggregation as an issuing party of the given tickets.

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

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

Fix the next ticket state if it’s out-of-sync in all this node’s channels.

impl PathAddressResolver for HoprDb

fn resolve_transport_address<'life0, 'life1, 'async_trait>( &'life0 self, address: &'life1 Address, ) -> Pin<Box<dyn Future<Output = Result<Option<OffchainPublicKey>, PathError>> + Send + 'async_trait>>

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

Resolve [OffchainPublicKey] from the given [Address]

fn resolve_chain_address<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 OffchainPublicKey, ) -> Pin<Box<dyn Future<Output = Result<Option<Address>, PathError>> + Send + 'async_trait>>

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

Resolve [Address] from the given [OffchainPublicKey]

impl HoprDbAllOperations for HoprDb