Struct Accounts

pub struct Accounts {
    pub accounts_db: Arc<AccountsDb>,
    /* private fields */
}

This structure handles synchronization for db

Fields

accounts_db: Arc<AccountsDb>

Single global AccountsDb

Implementations

impl Accounts

pub fn new(accounts_db: Arc<AccountsDb>) -> Self

pub fn load_lookup_table_addresses( &self, ancestors: &Ancestors, address_table_lookup: SVMMessageAddressTableLookup<'_>, slot_hashes: &SlotHashes, ) -> Result<(LoadedAddresses, Slot), AddressLookupError>

Return loaded addresses and the deactivation slot. If the table hasn’t been deactivated, the deactivation slot is u64::MAX.

pub fn load_lookup_table_addresses_into( &self, ancestors: &Ancestors, address_table_lookup: SVMMessageAddressTableLookup<'_>, slot_hashes: &SlotHashes, loaded_addresses: &mut LoadedAddresses, ) -> Result<Slot, AddressLookupError>

Fill loaded_addresses and return the deactivation slot. If no tables are de-activating, the deactivation slot is u64::MAX.

pub fn load_with_fixed_root( &self, ancestors: &Ancestors, pubkey: &Pubkey, ) -> Option<(AccountSharedData, Slot)>

pub fn load_with_fixed_root_do_not_populate_read_cache( &self, ancestors: &Ancestors, pubkey: &Pubkey, ) -> Option<(AccountSharedData, Slot)>

same as load_with_fixed_root except: if the account is not already in the read cache, it is NOT put in the read cache on successful load

pub fn load_without_fixed_root( &self, ancestors: &Ancestors, pubkey: &Pubkey, ) -> Option<(AccountSharedData, Slot)>

pub fn scan_slot<F, B>(&self, slot: Slot, func: F) -> Vec<B>

where F: Fn(&LoadedAccount<'_>) -> Option<B> + Send + Sync, B: Sync + Send + Default + Eq,

scans underlying accounts_db for this delta (slot) with a map function from LoadedAccount to B returns only the latest/current version of B for this slot

pub fn load_by_program_slot( &self, slot: Slot, program_id: Option<&Pubkey>, ) -> Vec<TransactionAccount>

Returns all the accounts from slot

If program_id is Some, filter the results to those whose owner matches program_id

pub fn load_largest_accounts( &self, ancestors: &Ancestors, bank_id: BankId, num: usize, filter_by_address: &HashSet<Pubkey>, filter: AccountAddressFilter, sort_results: bool, ) -> ScanResult<Vec<(Pubkey, u64)>>

pub fn verify_accounts_hash_and_lamports( &self, snapshot_storages_and_slots: (&[Arc<AccountStorageEntry>], &[Slot]), slot: Slot, total_lamports: u64, base: Option<(Slot, u64)>, config: VerifyAccountsHashAndLamportsConfig<'_>, ) -> bool

Only called from startup or test code.

pub fn is_loadable(lamports: u64) -> bool

pub fn load_by_program( &self, ancestors: &Ancestors, bank_id: BankId, program_id: &Pubkey, config: &ScanConfig, ) -> ScanResult<Vec<TransactionAccount>>

pub fn load_by_program_with_filter<F: Fn(&AccountSharedData) -> bool>( &self, ancestors: &Ancestors, bank_id: BankId, program_id: &Pubkey, filter: F, config: &ScanConfig, ) -> ScanResult<Vec<TransactionAccount>>

pub fn load_by_index_key_with_filter<F: Fn(&AccountSharedData) -> bool>( &self, ancestors: &Ancestors, bank_id: BankId, index_key: &IndexKey, filter: F, config: &ScanConfig, byte_limit_for_scan: Option<usize>, ) -> ScanResult<Vec<TransactionAccount>>

pub fn account_indexes_include_key(&self, key: &Pubkey) -> bool

pub fn load_all( &self, ancestors: &Ancestors, bank_id: BankId, sort_results: bool, ) -> ScanResult<Vec<PubkeyAccountSlot>>

pub fn scan_all<F>( &self, ancestors: &Ancestors, bank_id: BankId, scan_func: F, sort_results: bool, ) -> ScanResult<()>

where F: FnMut(Option<(&Pubkey, AccountSharedData, Slot)>),

pub fn hold_range_in_memory<R>( &self, range: &R, start_holding: bool, thread_pool: &ThreadPool, )

where R: RangeBounds<Pubkey> + Debug + Sync,

pub fn load_to_collect_rent_eagerly<R: RangeBounds<Pubkey> + Debug>( &self, ancestors: &Ancestors, range: R, ) -> Vec<PubkeyAccountSlot>

pub fn store_slow_uncached( &self, slot: Slot, pubkey: &Pubkey, account: &AccountSharedData, )

Slow because lock is held for 1 operation instead of many. WARNING: This noncached version is only to be used for tests/benchmarking as bypassing the cache in general is not supported

pub fn lock_accounts<'a, Tx: SVMMessage + 'a>( &self, txs: impl Iterator<Item = &'a Tx>, tx_account_lock_limit: usize, ) -> Vec<Result<()>>

This function will prevent multiple threads from modifying the same account state at the same time

pub fn lock_accounts_with_results<'a>( &self, txs: impl Iterator<Item = &'a (impl SVMMessage + 'a)>, results: impl Iterator<Item = Result<()>>, tx_account_lock_limit: usize, ) -> Vec<Result<()>>

pub fn unlock_accounts<'a, Tx: SVMMessage + 'a>( &self, txs_and_results: impl Iterator<Item = (&'a Tx, &'a Result<()>)> + Clone, )

Once accounts are unlocked, new transactions that modify that state can enter the pipeline

pub fn store_cached<'a>( &self, accounts: impl StorableAccounts<'a>, transactions: Option<&'a [&'a SanitizedTransaction]>, )

Store the accounts into the DB

pub fn store_accounts_cached<'a>(&self, accounts: impl StorableAccounts<'a>)

pub fn add_root(&self, slot: Slot) -> AccountsAddRootTiming

Add a slot to root. Root slots cannot be purged

Trait Implementations

impl Debug for Accounts

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

Formats the value using the given formatter.