Struct solana_runtime::bank::Bank

pub struct Bank {
    pub rc: BankRc,
    pub src: StatusCacheRc,
    pub ancestors: HashMap<Slot, usize>,
    pub last_vote_sync: AtomicU64,
    pub rewards: Option<Vec<(Pubkey, i64)>>,
    // some fields omitted
}

Manager for the state of all accounts and programs after processing its entries.

Fields

rc: BankRc

References to accounts, parent and signature status

src: StatusCacheRc

ancestors: HashMap<Slot, usize>

The set of parents including this bank

last_vote_sync: AtomicU64

Last time when the cluster info vote listener has synced with this bank

rewards: Option<Vec<(Pubkey, i64)>>

Rewards that were paid out immediately after this bank was created

Methods

impl Bank

pub fn new(genesis_config: &GenesisConfig) -> Self

pub fn new_with_paths(
    genesis_config: &GenesisConfig,
    paths: Vec<PathBuf>,
    frozen_account_pubkeys: &[Pubkey]
) -> Self

pub fn new_from_parent(
    parent: &Arc<Bank>,
    collector_id: &Pubkey,
    slot: Slot
) -> Self

Create a new bank that points to an immutable checkpoint of another bank.

pub fn collector_id(&self) -> &Pubkey

pub fn slot(&self) -> Slot

pub fn epoch(&self) -> Epoch

pub fn freeze_lock(&self) -> RwLockReadGuard<Hash>

pub fn hash(&self) -> Hash

pub fn is_frozen(&self) -> bool

pub fn status_cache_ancestors(&self) -> Vec<u64>

pub fn unix_timestamp(&self) -> i64

computed unix_timestamp at this slot height

pub fn update_recent_blockhashes(&self)

pub fn freeze(&self)

pub fn epoch_schedule(&self) -> &EpochSchedule

pub fn squash(&self)

squash the parent's state up into this Bank, this Bank becomes a root

pub fn parent(&self) -> Option<Arc<Bank>>

Return the more recent checkpoint of this bank instance.

pub fn parent_slot(&self) -> Slot

pub fn register_native_instruction_processor(
    &self,
    name: &str,
    program_id: &Pubkey
)

pub fn last_blockhash(&self) -> Hash

Return the last block hash registered.

pub fn get_minimum_balance_for_rent_exemption(&self, data_len: usize) -> u64

pub fn last_blockhash_with_fee_calculator(&self) -> (Hash, FeeCalculator)

pub fn get_fee_calculator(&self, hash: &Hash) -> Option<FeeCalculator>

pub fn get_fee_rate_governor(&self) -> &FeeRateGovernor

pub fn confirmed_last_blockhash(&self) -> (Hash, FeeCalculator)

pub fn clear_signatures(&self)

Forget all signatures. Useful for benchmarking.

pub fn can_commit(result: &Result<()>) -> bool

pub fn register_tick(&self, hash: &Hash)

Tell the bank which Entry IDs exist on the ledger. This function assumes subsequent calls correspond to later entries, and will boot the oldest ones once its internal cache is full. Once boot, the bank will reject transactions using that hash.

pub fn is_complete(&self) -> bool

pub fn is_block_boundary(&self, tick_height: u64) -> bool

pub fn process_transaction(&self, tx: &Transaction) -> Result<()>

Process a Transaction. This is used for unit tests and simply calls the vector Bank::process_transactions method

pub fn prepare_batch<'a, 'b>(
    &'a self,
    txs: &'b [Transaction],
    iteration_order: Option<Vec<usize>>
) -> TransactionBatch<'a, 'b>

pub fn unlock_accounts(&self, batch: &mut TransactionBatch)

pub fn check_hash_age(&self, hash: &Hash, max_age: usize) -> Option<bool>

pub fn check_tx_durable_nonce(
    &self,
    tx: &Transaction
) -> Option<(Pubkey, Account)>

pub fn check_transactions(
    &self,
    txs: &[Transaction],
    iteration_order: Option<&[usize]>,
    lock_results: &[Result<()>],
    max_age: usize,
    error_counters: &mut ErrorCounters
) -> Vec<TransactionProcessResult>

pub fn collect_balances(&self, batch: &[Transaction]) -> TransactionBalances

pub fn load_and_execute_transactions(
    &self,
    batch: &TransactionBatch,
    max_age: usize
) -> (Vec<(Result<TransactionLoadResult>, Option<HashAgeKind>)>, Vec<TransactionProcessResult>, Vec<usize>, u64, u64)

pub fn commit_transactions(
    &self,
    txs: &[Transaction],
    iteration_order: Option<&[usize]>,
    loaded_accounts: &mut [(Result<TransactionLoadResult>, Option<HashAgeKind>)],
    executed: &[TransactionProcessResult],
    tx_count: u64,
    signature_count: u64
) -> TransactionResults

#[must_use]pub fn load_execute_and_commit_transactions(
    &self,
    batch: &TransactionBatch,
    max_age: usize,
    collect_balances: bool
) -> (TransactionResults, TransactionBalancesSet)

Process a batch of transactions.

#[must_use]pub fn process_transactions(&self, txs: &[Transaction]) -> Vec<Result<()>>

pub fn transfer(
    &self,
    n: u64,
    keypair: &Keypair,
    to: &Pubkey
) -> Result<Signature>

Create, sign, and process a Transaction from keypair to to of n lamports where blockhash is the last Entry ID observed by the client.

pub fn read_balance(account: &Account) -> u64

pub fn get_balance(&self, pubkey: &Pubkey) -> u64

Each program would need to be able to introspect its own state this is hard-coded to the Budget language

pub fn parents(&self) -> Vec<Arc<Bank>>

Compute all the parents of the bank in order

pub fn store_account(&self, pubkey: &Pubkey, account: &Account)

pub fn withdraw(&self, pubkey: &Pubkey, lamports: u64) -> Result<()>

pub fn deposit(&self, pubkey: &Pubkey, lamports: u64)

pub fn accounts(&self) -> Arc<Accounts>

pub fn set_bank_rc(&mut self, bank_rc: BankRc, status_cache_rc: StatusCacheRc)

pub fn set_parent(&mut self, parent: &Arc<Bank>)

pub fn set_inflation(&self, inflation: Inflation)

pub fn hard_forks(&self) -> Arc<RwLock<HardForks>>

pub fn set_entered_epoch_callback(
    &self,
    entered_epoch_callback: EnteredEpochCallback
)

pub fn get_account(&self, pubkey: &Pubkey) -> Option<Account>

pub fn get_program_accounts(
    &self,
    program_id: Option<&Pubkey>
) -> Vec<(Pubkey, Account)>

pub fn get_program_accounts_modified_since_parent(
    &self,
    program_id: &Pubkey
) -> Vec<(Pubkey, Account)>

pub fn get_account_modified_since_parent(
    &self,
    pubkey: &Pubkey
) -> Option<(Account, Slot)>

pub fn transaction_count(&self) -> u64

pub fn signature_count(&self) -> u64

pub fn get_signature_status_processed_since_parent(
    &self,
    signature: &Signature
) -> Option<Result<()>>

pub fn get_signature_confirmation_status(
    &self,
    signature: &Signature
) -> Option<SignatureConfirmationStatus<Result<()>>>

pub fn get_signature_status(&self, signature: &Signature) -> Option<Result<()>>

pub fn has_signature(&self, signature: &Signature) -> bool

pub fn get_snapshot_storages(&self) -> SnapshotStorages

pub fn get_accounts_hash(&self) -> Hash

pub fn update_accounts_hash(&self) -> Hash

pub fn verify_snapshot_bank(&self) -> bool

A snapshot bank should be purged of 0 lamport accounts which are not part of the hash calculation and could shield other real accounts.

pub fn hashes_per_tick(&self) -> &Option<u64>

Return the number of hashes per tick

pub fn ticks_per_slot(&self) -> u64

Return the number of ticks per slot

pub fn slots_per_year(&self) -> f64

Return the number of slots per year

pub fn slots_per_segment(&self) -> u64

Return the number of slots per segment

pub fn tick_height(&self) -> u64

Return the number of ticks since genesis.

pub fn inflation(&self) -> Inflation

Return the inflation parameters of the Bank

pub fn capitalization(&self) -> u64

Return the total capititalization of the Bank

pub fn max_tick_height(&self) -> u64

Return this bank's max_tick_height

pub fn block_height(&self) -> u64

Return the block_height of this bank

pub fn get_slots_in_epoch(&self, epoch: Epoch) -> u64

Return the number of slots per epoch for the given epoch

pub fn get_leader_schedule_epoch(&self, slot: Slot) -> Epoch

returns the epoch for which this bank's leader_schedule_slot_offset and slot would need to cache leader_schedule

pub fn storage_accounts(&self) -> StorageAccounts

pub fn stake_delegations(&self) -> HashMap<Pubkey, Delegation>

current stake delegations for this bank Note: this method is exposed publicly for external usage

pub fn vote_accounts(&self) -> HashMap<Pubkey, (u64, Account)>

current vote accounts for this bank along with the stake attributed to each account

pub fn epoch_vote_accounts(
    &self,
    epoch: Epoch
) -> Option<&HashMap<Pubkey, (u64, Account)>>

vote accounts for the specific epoch along with the stake attributed to each account

pub fn get_epoch_and_slot_index(&self, slot: Slot) -> (u64, u64)

given a slot, return the epoch and offset into the epoch this slot falls e.g. with a fixed number for slots_per_epoch, the calculation is simply:

( slot/slots_per_epoch, slot % slots_per_epoch )

pub fn is_empty(&self) -> bool

pub fn add_instruction_processor(
    &mut self,
    program_id: Pubkey,
    process_instruction: ProcessInstruction
)

Add an instruction processor to intercept instructions before the dynamic loader.

pub fn compare_bank(&self, dbank: &Bank)

pub fn clean_accounts(&self)

Trait Implementations

impl Default for Bank

fn default() -> Bank

Returns the "default value" for a type.

impl<'de> Deserialize<'de> for Bank

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Drop for Bank

fn drop(&mut self)

Executes the destructor for this type.

impl Serialize for Bank

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.