Struct solana_runtime::bank::Bank

pub struct Bank { /* fields omitted */ }

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

Methods

impl Bank

pub fn new(genesis_block: &GenesisBlock) -> Self

pub fn new_with_paths(
    genesis_block: &GenesisBlock,
    paths: Option<String>
) -> Self

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

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

pub fn collector_id(&self) -> Pubkey

pub fn slot(&self) -> u64

pub fn hash(&self) -> Hash

pub fn is_frozen(&self) -> bool

pub fn freeze(&self)

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 add_native_program(&self, name: &str, program_id: &Pubkey)

pub fn last_blockhash(&self) -> Hash

Return the last block hash registered.

pub fn clear_signatures(&self)

Forget all signatures. Useful for benchmarking.

pub fn get_confirmation_timestamp(
    &self,
    slots_and_stakes: Vec<(u64, u64)>,
    supermajority_stake: u64
) -> Option<u64>

Looks through a list of tick heights and stakes, and finds the latest tick that has achieved confirmation

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 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 lock_accounts(&self, txs: &[Transaction]) -> Vec<Result<()>>

pub fn unlock_accounts(&self, txs: &[Transaction], results: &[Result<()>])

pub fn load_and_execute_transactions(
    &self,
    txs: &[Transaction],
    lock_results: Vec<Result<()>>,
    max_age: usize
) -> (Vec<Result<(Vec<Account>, Vec<Vec<(Pubkey, Account)>>)>>, Vec<Result<()>>)

pub fn commit_transactions(
    &self,
    txs: &[Transaction],
    loaded_accounts: &[Result<(Vec<Account>, Vec<Vec<(Pubkey, Account)>>)>],
    executed: &[Result<()>]
) -> Vec<Result<()>>

#[must_use]

pub fn load_execute_and_commit_transactions(
    &self,
    txs: &[Transaction],
    lock_results: Vec<Result<()>>,
    max_age: usize
) -> Vec<Result<()>>

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,
    blockhash: Hash
) -> 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 withdraw(&self, pubkey: &Pubkey, lamports: u64) -> Result<()>

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

pub fn get_account(&self, pubkey: &Pubkey) -> Option<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>

pub fn transaction_count(&self) -> u64

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

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

pub fn ticks_per_slot(&self) -> u64

Return the number of ticks per slot

pub fn tick_height(&self) -> u64

Return the number of ticks since genesis.

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

Return the number of slots per epoch for the given epoch

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

returns the epoch for which this bank's stakers_slot_offset and slot would need to cache stakers

pub fn vote_accounts(&self) -> impl Iterator<Item = (Pubkey, Account)>

current vote accounts for this bank

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

vote accounts for the specific epoch

pub fn get_epoch_and_slot_index(&self, slot: u64) -> (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 )

Trait Implementations

impl Default for Bank

fn default() -> Bank

Returns the "default value" for a type.