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: &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>

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, ) -> 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_cached( &self, slot: Slot, txs: &[SanitizedTransaction], res: &[TransactionExecutionResult], loaded: &mut [TransactionLoadResult], rent_collector: &RentCollector, durable_nonce: &DurableNonce, lamports_per_signature: u64, )

Store the accounts into the DB

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.