Struct HoprIndexerDb 

pub struct HoprIndexerDb {
    pub me_onchain: Address,
    /* 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].

Fields

me_onchain: Address

Implementations

impl HoprIndexerDb

pub async fn resolve_packet_key( &self, onchain_key: &Address, ) -> Result<Option<OffchainPublicKey>>

pub async fn resolve_chain_key( &self, offchain_key: &OffchainPublicKey, ) -> Result<Option<Address>>

impl HoprIndexerDb

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

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

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

pub fn key_id_mapper_ref(&self) -> &CacheKeyMapper

Trait Implementations

impl Clone for HoprIndexerDb

fn clone(&self) -> HoprIndexerDb

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HoprIndexerDb

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

Formats the value using the given formatter.

impl HoprDbAccountOperations for HoprIndexerDb

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 stream_accounts<'a, 'async_trait>( &'a self, public_only: bool, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'a, AccountEntry>>> + Send + 'async_trait>>

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

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 HoprIndexerDb

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_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_channels<'a, 'life0, 'async_trait, T>( &'a self, source: Option<Address>, destination: Option<Address>, states: &'life0 [ChannelStatusDiscriminants], closure_range: T, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'a, ChannelEntry>>> + Send + 'async_trait>>

where T: 'async_trait + RangeBounds<DateTime<Utc>> + Send, Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait,

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 HoprIndexerDb

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 HoprIndexerDb

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 HoprIndexerDb

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

fn store_log<'a, 'async_trait>( &'a self, log: SerializableLog, ) -> Pin<Box<dyn Future<Output = Result<(), DbSqlError>> + 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<(), DbSqlError>>, DbSqlError>> + 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, DbSqlError>> + 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>, DbSqlError>> + 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, DbSqlError>> + 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>, DbSqlError>> + 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<(), DbSqlError>> + 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<(), DbSqlError>> + 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<(), DbSqlError>> + 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>, DbSqlError>> + 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, DbSqlError>> + 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<(), DbSqlError>> + 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.