Struct solana_runtime::accounts::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 default_for_tests() -> Self

pub fn new_with_config_for_tests( paths: Vec<PathBuf>, cluster_type: &ClusterType, account_indexes: AccountSecondaryIndexes, shrink_ratio: AccountShrinkThreshold ) -> Self

pub fn new_with_config_for_benches( paths: Vec<PathBuf>, cluster_type: &ClusterType, account_indexes: AccountSecondaryIndexes, shrink_ratio: AccountShrinkThreshold ) -> Self

pub fn new_with_config( paths: Vec<PathBuf>, cluster_type: &ClusterType, account_indexes: AccountSecondaryIndexes, shrink_ratio: AccountShrinkThreshold, accounts_db_config: Option<AccountsDbConfig>, accounts_update_notifier: Option<AccountsUpdateNotifier>, exit: &Arc<AtomicBool> ) -> Self

pub fn filter_executable_program_accounts<'a>( &self, ancestors: &Ancestors, txs: &[SanitizedTransaction], lock_results: &mut [TransactionCheckResult], program_owners: &[&'a Pubkey], hash_queue: &BlockhashQueue ) -> HashMap<Pubkey, (&'a Pubkey, u64)>

Returns a hash map of executable program accounts (program accounts that are not writable in the given transactions), and their owners, for the transactions with a valid blockhash or nonce.

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

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

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>

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

pub fn verify_accounts_hash_and_lamports( &self, 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 ) -> ScanResult<Vec<PubkeyAccountSlot>>

pub fn scan_all<F>( &self, ancestors: &Ancestors, bank_id: BankId, scan_func: F ) -> 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>( &self, txs: impl Iterator<Item = &'a SanitizedTransaction>, 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 SanitizedTransaction>, results: impl Iterator<Item = Result<()>>, tx_account_lock_limit: usize ) -> Vec<Result<()>>

pub fn unlock_accounts<'a>( &self, txs: impl Iterator<Item = &'a SanitizedTransaction>, results: &[Result<()>] )

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

pub fn store_accounts_cached<'a, T: ReadableAccount + Sync + ZeroLamport + 'a>( &self, accounts: impl StorableAccounts<'a, T> )

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

Add a slot to root. Root slots cannot be purged

Trait Implementations

impl AbiExample for Accounts

fn example() -> Self

impl Debug for Accounts

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

Formats the value using the given formatter.