//! The `bank` module tracks client accounts and the progress of on-chain //! programs. It offers a high-level API that signs transactions //! on behalf of the caller, and a low-level API for when they have //! already been signed and verified. use crate::{ accounts::{Accounts, TransactionAccounts, TransactionLoadResult, TransactionLoaders}, accounts_db::{AccountsDBSerialize, ErrorCounters, SnapshotStorage, SnapshotStorages}, blockhash_queue::BlockhashQueue, epoch_stakes::{EpochStakes, NodeVoteAccounts}, message_processor::{MessageProcessor, ProcessInstruction}, nonce_utils, rent_collector::RentCollector, serde_utils::{ deserialize_atomicbool, deserialize_atomicu64, serialize_atomicbool, serialize_atomicu64, }, stakes::Stakes, status_cache::{SlotDelta, StatusCache}, storage_utils, storage_utils::StorageAccounts, system_instruction_processor::{get_system_account_kind, SystemAccountKind}, transaction_batch::TransactionBatch, transaction_utils::OrderedIterator, }; use bincode::{deserialize_from, serialize_into}; use byteorder::{ByteOrder, LittleEndian}; use itertools::Itertools; use log::*; use serde::{Deserialize, Serialize}; use solana_measure::measure::Measure; use solana_metrics::{ datapoint_debug, inc_new_counter_debug, inc_new_counter_error, inc_new_counter_info, }; use solana_sdk::{ account::Account, clock::{ get_segment_from_slot, Epoch, Slot, UnixTimestamp, MAX_PROCESSING_AGE, MAX_RECENT_BLOCKHASHES, }, epoch_schedule::EpochSchedule, fee_calculator::{FeeCalculator, FeeRateGovernor}, genesis_config::GenesisConfig, hard_forks::HardForks, hash::{extend_and_hash, hashv, Hash}, inflation::Inflation, native_loader, nonce, pubkey::Pubkey, signature::{Keypair, Signature}, slot_hashes::SlotHashes, slot_history::SlotHistory, system_transaction, sysvar::{self, Sysvar}, timing::years_as_slots, transaction::{Result, Transaction, TransactionError}, }; use solana_stake_program::stake_state::{self, Delegation}; use solana_vote_program::vote_state::VoteState; use std::{ cell::RefCell, collections::HashMap, io::{BufReader, Cursor, Error as IOError, Read}, path::{Path, PathBuf}, rc::Rc, sync::atomic::{AtomicBool, AtomicU64, Ordering}, sync::{Arc, RwLock, RwLockReadGuard}, }; pub const SECONDS_PER_YEAR: f64 = 365.25 * 24.0 * 60.0 * 60.0; pub const MAX_SNAPSHOT_DATA_FILE_SIZE: u64 = 32 * 1024 * 1024 * 1024; // 32 GiB pub const MAX_LEADER_SCHEDULE_STAKES: Epoch = 5; type BankStatusCache = StatusCache>; pub type BankSlotDelta = SlotDelta>; type TransactionAccountRefCells = Vec>>; type TransactionLoaderRefCells = Vec)>>; #[derive(Default)] pub struct BankRc { /// where all the Accounts are stored accounts: Arc, /// Previous checkpoint of this bank parent: RwLock>>, /// Current slot slot: Slot, } impl BankRc { pub fn from_stream>( account_paths: &[PathBuf], slot: Slot, ancestors: &HashMap, frozen_account_pubkeys: &[Pubkey], mut stream: &mut BufReader, stream_append_vecs_path: P, ) -> std::result::Result { let _len: usize = deserialize_from(&mut stream).map_err(|e| BankRc::get_io_error(&e.to_string()))?; let accounts = Accounts::from_stream( account_paths, ancestors, frozen_account_pubkeys, stream, stream_append_vecs_path, )?; Ok(BankRc { accounts: Arc::new(accounts), parent: RwLock::new(None), slot, }) } pub fn get_snapshot_storages(&self, slot: Slot) -> SnapshotStorages { self.accounts.accounts_db.get_snapshot_storages(slot) } fn get_io_error(error: &str) -> IOError { warn!("BankRc error: {:?}", error); std::io::Error::new(std::io::ErrorKind::Other, error) } } pub struct BankRcSerialize<'a, 'b> { pub bank_rc: &'a BankRc, pub snapshot_storages: &'b [SnapshotStorage], } impl<'a, 'b> Serialize for BankRcSerialize<'a, 'b> { fn serialize(&self, serializer: S) -> std::result::Result where S: serde::ser::Serializer, { use serde::ser::Error; let mut wr = Cursor::new(Vec::new()); let accounts_db_serialize = AccountsDBSerialize::new( &*self.bank_rc.accounts.accounts_db, self.bank_rc.slot, self.snapshot_storages, ); serialize_into(&mut wr, &accounts_db_serialize).map_err(Error::custom)?; let len = wr.position() as usize; serializer.serialize_bytes(&wr.into_inner()[..len]) } } #[derive(Default)] pub struct StatusCacheRc { /// where all the Accounts are stored /// A cache of signature statuses pub status_cache: Arc>, } impl StatusCacheRc { pub fn slot_deltas(&self, slots: &[Slot]) -> Vec { let sc = self.status_cache.read().unwrap(); sc.slot_deltas(slots) } pub fn roots(&self) -> Vec { self.status_cache .read() .unwrap() .roots() .iter() .cloned() .sorted() .collect() } pub fn append(&self, slot_deltas: &[BankSlotDelta]) { let mut sc = self.status_cache.write().unwrap(); sc.append(slot_deltas); } } pub type EnteredEpochCallback = Box () + Sync + Send>; pub type TransactionProcessResult = (Result<()>, Option); pub struct TransactionResults { pub fee_collection_results: Vec>, pub processing_results: Vec, } pub struct TransactionBalancesSet { pub pre_balances: TransactionBalances, pub post_balances: TransactionBalances, } impl TransactionBalancesSet { pub fn new(pre_balances: TransactionBalances, post_balances: TransactionBalances) -> Self { assert_eq!(pre_balances.len(), post_balances.len()); Self { pre_balances, post_balances, } } } pub type TransactionBalances = Vec>; #[derive(Clone, Debug, Eq, PartialEq)] pub enum HashAgeKind { Extant, DurableNonce(Pubkey, Account), } impl HashAgeKind { pub fn is_durable_nonce(&self) -> bool { match self { HashAgeKind::DurableNonce(_, _) => true, _ => false, } } } /// Manager for the state of all accounts and programs after processing its entries. #[derive(Default, Deserialize, Serialize)] pub struct Bank { /// References to accounts, parent and signature status #[serde(skip)] pub rc: BankRc, #[serde(skip)] pub src: StatusCacheRc, /// FIFO queue of `recent_blockhash` items blockhash_queue: RwLock, /// The set of parents including this bank pub ancestors: HashMap, /// Hash of this Bank's state. Only meaningful after freezing. hash: RwLock, /// Hash of this Bank's parent's state parent_hash: Hash, /// parent's slot parent_slot: Slot, /// slots to hard fork at hard_forks: Arc>, /// The number of transactions processed without error #[serde(serialize_with = "serialize_atomicu64")] #[serde(deserialize_with = "deserialize_atomicu64")] transaction_count: AtomicU64, /// Bank tick height #[serde(serialize_with = "serialize_atomicu64")] #[serde(deserialize_with = "deserialize_atomicu64")] tick_height: AtomicU64, /// The number of signatures from valid transactions in this slot #[serde(serialize_with = "serialize_atomicu64")] #[serde(deserialize_with = "deserialize_atomicu64")] signature_count: AtomicU64, /// Total capitalization, used to calculate inflation #[serde(serialize_with = "serialize_atomicu64")] #[serde(deserialize_with = "deserialize_atomicu64")] capitalization: AtomicU64, // Bank max_tick_height max_tick_height: u64, /// The number of hashes in each tick. None value means hashing is disabled. hashes_per_tick: Option, /// The number of ticks in each slot. ticks_per_slot: u64, /// length of a slot in ns ns_per_slot: u128, /// genesis time, used for computed clock genesis_creation_time: UnixTimestamp, /// The number of slots per year, used for inflation slots_per_year: f64, /// The number of slots per Storage segment slots_per_segment: u64, /// Bank slot (i.e. block) slot: Slot, /// Bank epoch epoch: Epoch, /// Bank block_height block_height: u64, /// The pubkey to send transactions fees to. collector_id: Pubkey, /// Fees that have been collected #[serde(serialize_with = "serialize_atomicu64")] #[serde(deserialize_with = "deserialize_atomicu64")] collector_fees: AtomicU64, /// Latest transaction fees for transactions processed by this bank fee_calculator: FeeCalculator, /// Track cluster signature throughput and adjust fee rate fee_rate_governor: FeeRateGovernor, /// Rent that have been collected #[serde(serialize_with = "serialize_atomicu64")] #[serde(deserialize_with = "deserialize_atomicu64")] collected_rent: AtomicU64, /// latest rent collector, knows the epoch rent_collector: RentCollector, /// initialized from genesis epoch_schedule: EpochSchedule, /// inflation specs inflation: Arc>, /// cache of vote_account and stake_account state for this fork stakes: RwLock, /// cache of validator and archiver storage accounts for this fork storage_accounts: RwLock, /// staked nodes on epoch boundaries, saved off when a bank.slot() is at /// a leader schedule calculation boundary epoch_stakes: HashMap, /// A boolean reflecting whether any entries were recorded into the PoH /// stream for the slot == self.slot #[serde(serialize_with = "serialize_atomicbool")] #[serde(deserialize_with = "deserialize_atomicbool")] is_delta: AtomicBool, /// The Message processor message_processor: MessageProcessor, /// Callback to be notified when a bank enters a new Epoch /// (used to adjust cluster features over time) #[serde(skip)] entered_epoch_callback: Arc>>, /// Last time when the cluster info vote listener has synced with this bank #[serde(skip)] pub last_vote_sync: AtomicU64, /// Rewards that were paid out immediately after this bank was created #[serde(skip)] pub rewards: Option>, } impl Default for BlockhashQueue { fn default() -> Self { Self::new(MAX_RECENT_BLOCKHASHES) } } impl Bank { pub fn new(genesis_config: &GenesisConfig) -> Self { Self::new_with_paths(&genesis_config, Vec::new(), &[]) } pub fn new_with_paths( genesis_config: &GenesisConfig, paths: Vec, frozen_account_pubkeys: &[Pubkey], ) -> Self { let mut bank = Self::default(); bank.ancestors.insert(bank.slot(), 0); bank.rc.accounts = Arc::new(Accounts::new(paths)); bank.process_genesis_config(genesis_config); // Freeze accounts after process_genesis_config creates the initial append vecs Arc::get_mut(&mut bank.rc.accounts) .unwrap() .freeze_accounts(&bank.ancestors, frozen_account_pubkeys); // genesis needs stakes for all epochs up to the epoch implied by // slot = 0 and genesis configuration { let stakes = bank.stakes.read().unwrap(); for epoch in 0..=bank.get_leader_schedule_epoch(bank.slot) { bank.epoch_stakes .insert(epoch, EpochStakes::new(&stakes, epoch)); } bank.update_stake_history(None); } bank.update_clock(); bank.update_rent(); bank.update_epoch_schedule(); bank.update_recent_blockhashes(); bank } /// Create a new bank that points to an immutable checkpoint of another bank. pub fn new_from_parent(parent: &Arc, collector_id: &Pubkey, slot: Slot) -> Self { parent.freeze(); assert_ne!(slot, parent.slot()); let rc = BankRc { accounts: Arc::new(Accounts::new_from_parent( &parent.rc.accounts, slot, parent.slot(), )), parent: RwLock::new(Some(parent.clone())), slot, }; let src = StatusCacheRc { status_cache: parent.src.status_cache.clone(), }; let epoch_schedule = parent.epoch_schedule; let epoch = epoch_schedule.get_epoch(slot); let fee_rate_governor = FeeRateGovernor::new_derived(&parent.fee_rate_governor, parent.signature_count()); let mut new = Bank { rc, src, slot, epoch, blockhash_queue: RwLock::new(parent.blockhash_queue.read().unwrap().clone()), // TODO: clean this up, soo much special-case copying... hashes_per_tick: parent.hashes_per_tick, ticks_per_slot: parent.ticks_per_slot, ns_per_slot: parent.ns_per_slot, genesis_creation_time: parent.genesis_creation_time, slots_per_segment: parent.slots_per_segment, slots_per_year: parent.slots_per_year, epoch_schedule, collected_rent: AtomicU64::new(0), rent_collector: parent.rent_collector.clone_with_epoch(epoch), max_tick_height: (slot + 1) * parent.ticks_per_slot, block_height: parent.block_height + 1, fee_calculator: fee_rate_governor.create_fee_calculator(), fee_rate_governor, capitalization: AtomicU64::new(parent.capitalization()), inflation: parent.inflation.clone(), transaction_count: AtomicU64::new(parent.transaction_count()), stakes: RwLock::new(parent.stakes.read().unwrap().clone_with_epoch(epoch)), epoch_stakes: parent.epoch_stakes.clone(), storage_accounts: RwLock::new(parent.storage_accounts.read().unwrap().clone()), parent_hash: parent.hash(), parent_slot: parent.slot(), collector_id: *collector_id, collector_fees: AtomicU64::new(0), ancestors: HashMap::new(), hash: RwLock::new(Hash::default()), is_delta: AtomicBool::new(false), tick_height: AtomicU64::new(parent.tick_height.load(Ordering::Relaxed)), signature_count: AtomicU64::new(0), message_processor: MessageProcessor::default(), entered_epoch_callback: parent.entered_epoch_callback.clone(), hard_forks: parent.hard_forks.clone(), last_vote_sync: AtomicU64::new(parent.last_vote_sync.load(Ordering::Relaxed)), rewards: None, }; datapoint_info!( "bank-new_from_parent-heights", ("slot_height", slot, i64), ("block_height", new.block_height, i64) ); let leader_schedule_epoch = epoch_schedule.get_leader_schedule_epoch(slot); if parent.epoch() < new.epoch() { if let Some(entered_epoch_callback) = parent.entered_epoch_callback.read().unwrap().as_ref() { entered_epoch_callback(&mut new) } } new.update_epoch_stakes(leader_schedule_epoch); new.ancestors.insert(new.slot(), 0); new.parents().iter().enumerate().for_each(|(i, p)| { new.ancestors.insert(p.slot(), i + 1); }); new.update_slot_hashes(); new.update_rewards(parent.epoch()); new.update_stake_history(Some(parent.epoch())); new.update_clock(); new.update_fees(); new.update_recent_blockhashes(); new } pub fn collector_id(&self) -> &Pubkey { &self.collector_id } pub fn slot(&self) -> Slot { self.slot } pub fn epoch(&self) -> Epoch { self.epoch } pub fn freeze_lock(&self) -> RwLockReadGuard { self.hash.read().unwrap() } pub fn hash(&self) -> Hash { *self.hash.read().unwrap() } pub fn is_frozen(&self) -> bool { *self.hash.read().unwrap() != Hash::default() } pub fn status_cache_ancestors(&self) -> Vec { let mut roots = self.src.status_cache.read().unwrap().roots().clone(); let min = roots.iter().min().cloned().unwrap_or(0); for ancestor in self.ancestors.keys() { if *ancestor >= min { roots.insert(*ancestor); } } let mut ancestors: Vec<_> = roots.into_iter().collect(); ancestors.sort(); ancestors } /// computed unix_timestamp at this slot height pub fn unix_timestamp(&self) -> i64 { self.genesis_creation_time + ((self.slot as u128 * self.ns_per_slot) / 1_000_000_000) as i64 } fn update_sysvar_account(&self, pubkey: &Pubkey, updater: F) where F: Fn(&Option) -> Account, { let old_account = self.get_sysvar_account(pubkey); let mut new_account = updater(&old_account); // Normally, just use the hash from parent slot. However, use the // existing stored hash if any for the sake of bank hash's idempotent. if let Some((modified_account, _)) = self.get_account_modified_since_parent(pubkey) { new_account.hash = modified_account.hash; } else if let Some(old_account) = old_account { new_account.hash = old_account.hash; } self.store_account(pubkey, &new_account); } fn update_clock(&self) { self.update_sysvar_account(&sysvar::clock::id(), |_| { sysvar::clock::Clock { slot: self.slot, segment: get_segment_from_slot(self.slot, self.slots_per_segment), epoch: self.epoch_schedule.get_epoch(self.slot), leader_schedule_epoch: self.epoch_schedule.get_leader_schedule_epoch(self.slot), unix_timestamp: self.unix_timestamp(), } .create_account(1) }); } fn update_slot_history(&self) { self.update_sysvar_account(&sysvar::slot_history::id(), |account| { let mut slot_history = account .as_ref() .map(|account| SlotHistory::from_account(&account).unwrap()) .unwrap_or_default(); slot_history.add(self.slot()); slot_history.create_account(1) }); } fn update_slot_hashes(&self) { self.update_sysvar_account(&sysvar::slot_hashes::id(), |account| { let mut slot_hashes = account .as_ref() .map(|account| SlotHashes::from_account(&account).unwrap()) .unwrap_or_default(); slot_hashes.add(self.parent_slot, self.parent_hash); slot_hashes.create_account(1) }); } fn update_epoch_stakes(&mut self, leader_schedule_epoch: Epoch) { // update epoch_stakes cache // if my parent didn't populate for this staker's epoch, we've // crossed a boundary if self.epoch_stakes.get(&leader_schedule_epoch).is_none() { self.epoch_stakes.retain(|&epoch, _| { epoch >= leader_schedule_epoch.saturating_sub(MAX_LEADER_SCHEDULE_STAKES) }); let vote_stakes: HashMap<_, _> = self .stakes .read() .unwrap() .vote_accounts() .iter() .map(|(epoch, (stake, _))| (*epoch, *stake)) .collect(); let new_epoch_stakes = EpochStakes::new(&self.stakes.read().unwrap(), leader_schedule_epoch); info!( "new epoch stakes, epoch: {}, stakes: {:#?}, total_stake: {}", leader_schedule_epoch, vote_stakes, new_epoch_stakes.total_stake(), ); self.epoch_stakes .insert(leader_schedule_epoch, new_epoch_stakes); } } fn update_fees(&self) { self.update_sysvar_account(&sysvar::fees::id(), |_| { sysvar::fees::create_account(1, &self.fee_calculator) }); } fn update_rent(&self) { self.update_sysvar_account(&sysvar::rent::id(), |_| { sysvar::rent::create_account(1, &self.rent_collector.rent) }); } fn update_epoch_schedule(&self) { self.update_sysvar_account(&sysvar::epoch_schedule::id(), |_| { sysvar::epoch_schedule::create_account(1, &self.epoch_schedule) }); } fn update_stake_history(&self, epoch: Option) { if epoch == Some(self.epoch()) { return; } // if I'm the first Bank in an epoch, ensure stake_history is updated self.update_sysvar_account(&sysvar::stake_history::id(), |_| { sysvar::stake_history::create_account(1, self.stakes.read().unwrap().history()) }); } // update reward for previous epoch fn update_rewards(&mut self, epoch: Epoch) { if epoch == self.epoch() { return; } // if I'm the first Bank in an epoch, count, claim, disburse rewards from Inflation // years_elapsed = slots_elapsed / slots/year let year = (self.epoch_schedule.get_last_slot_in_epoch(epoch)) as f64 / self.slots_per_year; // period: time that has passed as a fraction of a year, basically the length of // an epoch as a fraction of a year // years_elapsed = slots_elapsed / slots/year let period = self.epoch_schedule.get_slots_in_epoch(epoch) as f64 / self.slots_per_year; let (validator_rewards, storage_rewards) = { let inflation = self.inflation.read().unwrap(); ( (*inflation).validator(year) * self.capitalization() as f64 * period, (*inflation).storage(year) * self.capitalization() as f64 * period, ) }; let validator_points = self.stakes.write().unwrap().claim_points(); let storage_points = self.storage_accounts.write().unwrap().claim_points(); let (validator_point_value, storage_point_value) = self.check_point_values( validator_rewards / validator_points as f64, storage_rewards / storage_points as f64, ); self.update_sysvar_account(&sysvar::rewards::id(), |_| { sysvar::rewards::create_account(1, validator_point_value, storage_point_value) }); let validator_rewards = self.pay_validator_rewards(validator_point_value); self.capitalization.fetch_add( validator_rewards + storage_rewards as u64, Ordering::Relaxed, ); } /// iterate over all stakes, redeem vote credits for each stake we can /// successfully load and parse, return total payout fn pay_validator_rewards(&mut self, point_value: f64) -> u64 { let stake_history = self.stakes.read().unwrap().history().clone(); let mut validator_rewards = HashMap::new(); let total_validator_rewards = self .stake_delegations() .iter() .map(|(stake_pubkey, delegation)| { match ( self.get_account(&stake_pubkey), self.get_account(&delegation.voter_pubkey), ) { (Some(mut stake_account), Some(mut vote_account)) => { let rewards = stake_state::redeem_rewards( &mut stake_account, &mut vote_account, point_value, Some(&stake_history), ); if let Ok((stakers_reward, voters_reward)) = rewards { self.store_account(&stake_pubkey, &stake_account); self.store_account(&delegation.voter_pubkey, &vote_account); if voters_reward > 0 { *validator_rewards .entry(delegation.voter_pubkey) .or_insert(0i64) += voters_reward as i64; } if stakers_reward > 0 { *validator_rewards.entry(*stake_pubkey).or_insert(0i64) += stakers_reward as i64; } stakers_reward + voters_reward } else { debug!( "stake_state::redeem_rewards() failed for {}: {:?}", stake_pubkey, rewards ); 0 } } (_, _) => 0, } }) .sum(); assert_eq!(self.rewards, None); self.rewards = Some(validator_rewards.drain().collect()); total_validator_rewards } pub fn update_recent_blockhashes(&self) { self.update_sysvar_account(&sysvar::recent_blockhashes::id(), |_| { let blockhash_queue = self.blockhash_queue.read().unwrap(); let recent_blockhash_iter = blockhash_queue.get_recent_blockhashes(); sysvar::recent_blockhashes::create_account_with_data(1, recent_blockhash_iter) }); } // If the point values are not `normal`, bring them back into range and // set them to the last value or 0. fn check_point_values( &self, mut validator_point_value: f64, mut storage_point_value: f64, ) -> (f64, f64) { let rewards = sysvar::rewards::Rewards::from_account( &self .get_account(&sysvar::rewards::id()) .unwrap_or_else(|| sysvar::rewards::create_account(1, 0.0, 0.0)), ) .unwrap_or_else(Default::default); if !validator_point_value.is_normal() { validator_point_value = rewards.validator_point_value; } if !storage_point_value.is_normal() { storage_point_value = rewards.storage_point_value } (validator_point_value, storage_point_value) } fn collect_fees(&self) { let collector_fees = self.collector_fees.load(Ordering::Relaxed) as u64; if collector_fees != 0 { let (unburned, burned) = self.fee_rate_governor.burn(collector_fees); // burn a portion of fees self.deposit(&self.collector_id, unburned); self.capitalization.fetch_sub(burned, Ordering::Relaxed); } } pub fn freeze(&self) { let mut hash = self.hash.write().unwrap(); if *hash == Hash::default() { // finish up any deferred changes to account state self.collect_fees(); self.distribute_rent(); self.update_slot_history(); // freeze is a one-way trip, idempotent *hash = self.hash_internal_state(); } } pub fn epoch_schedule(&self) -> &EpochSchedule { &self.epoch_schedule } /// squash the parent's state up into this Bank, /// this Bank becomes a root pub fn squash(&self) { self.freeze(); //this bank and all its parents are now on the rooted path let mut roots = vec![self.slot()]; roots.append(&mut self.parents().iter().map(|p| p.slot()).collect()); *self.rc.parent.write().unwrap() = None; let mut squash_accounts_time = Measure::start("squash_accounts_time"); for slot in roots.iter().rev() { // root forks cannot be purged self.rc.accounts.add_root(*slot); } squash_accounts_time.stop(); let mut squash_cache_time = Measure::start("squash_cache_time"); roots .iter() .for_each(|slot| self.src.status_cache.write().unwrap().add_root(*slot)); squash_cache_time.stop(); datapoint_debug!( "tower-observed", ("squash_accounts_ms", squash_accounts_time.as_ms(), i64), ("squash_cache_ms", squash_cache_time.as_ms(), i64) ); } /// Return the more recent checkpoint of this bank instance. pub fn parent(&self) -> Option> { self.rc.parent.read().unwrap().clone() } pub fn parent_slot(&self) -> Slot { self.parent_slot } fn process_genesis_config(&mut self, genesis_config: &GenesisConfig) { // Bootstrap validator collects fees until `new_from_parent` is called. self.fee_rate_governor = genesis_config.fee_rate_governor.clone(); self.fee_calculator = self.fee_rate_governor.create_fee_calculator(); self.update_fees(); for (pubkey, account) in genesis_config.accounts.iter() { if self.get_account(&pubkey).is_some() { panic!("{} repeated in genesis config", pubkey); } self.store_account(pubkey, account); self.capitalization .fetch_add(account.lamports, Ordering::Relaxed); } for (pubkey, account) in genesis_config.rewards_pools.iter() { if self.get_account(&pubkey).is_some() { panic!("{} repeated in genesis config", pubkey); } self.store_account(pubkey, account); } // highest staked node is the first collector self.collector_id = self .stakes .read() .unwrap() .highest_staked_node() .unwrap_or_default(); self.blockhash_queue .write() .unwrap() .genesis_hash(&genesis_config.hash(), &self.fee_calculator); self.hashes_per_tick = genesis_config.poh_config.hashes_per_tick; self.ticks_per_slot = genesis_config.ticks_per_slot; self.ns_per_slot = genesis_config.poh_config.target_tick_duration.as_nanos() * genesis_config.ticks_per_slot as u128; self.genesis_creation_time = genesis_config.creation_time; self.slots_per_segment = genesis_config.slots_per_segment; self.max_tick_height = (self.slot + 1) * self.ticks_per_slot; self.slots_per_year = years_as_slots( 1.0, &genesis_config.poh_config.target_tick_duration, self.ticks_per_slot, ); self.epoch_schedule = genesis_config.epoch_schedule; self.inflation = Arc::new(RwLock::new(genesis_config.inflation)); self.rent_collector = RentCollector::new( self.epoch, &self.epoch_schedule, self.slots_per_year, &genesis_config.rent, ); // Add additional native programs specified in the genesis config for (name, program_id) in &genesis_config.native_instruction_processors { self.register_native_instruction_processor(name, program_id); } } pub fn register_native_instruction_processor(&self, name: &str, program_id: &Pubkey) { debug!("Adding native program {} under {:?}", name, program_id); let account = native_loader::create_loadable_account(name); self.store_account(program_id, &account); } /// Return the last block hash registered. pub fn last_blockhash(&self) -> Hash { self.blockhash_queue.read().unwrap().last_hash() } pub fn get_minimum_balance_for_rent_exemption(&self, data_len: usize) -> u64 { self.rent_collector.rent.minimum_balance(data_len) } pub fn last_blockhash_with_fee_calculator(&self) -> (Hash, FeeCalculator) { let blockhash_queue = self.blockhash_queue.read().unwrap(); let last_hash = blockhash_queue.last_hash(); ( last_hash, blockhash_queue .get_fee_calculator(&last_hash) .unwrap() .clone(), ) } pub fn get_fee_calculator(&self, hash: &Hash) -> Option { let blockhash_queue = self.blockhash_queue.read().unwrap(); blockhash_queue.get_fee_calculator(hash).cloned() } pub fn get_fee_rate_governor(&self) -> &FeeRateGovernor { &self.fee_rate_governor } pub fn confirmed_last_blockhash(&self) -> (Hash, FeeCalculator) { const NUM_BLOCKHASH_CONFIRMATIONS: usize = 3; let parents = self.parents(); if parents.is_empty() { self.last_blockhash_with_fee_calculator() } else { let index = NUM_BLOCKHASH_CONFIRMATIONS.min(parents.len() - 1); parents[index].last_blockhash_with_fee_calculator() } } /// Forget all signatures. Useful for benchmarking. pub fn clear_signatures(&self) { self.src.status_cache.write().unwrap().clear_signatures(); } pub fn can_commit(result: &Result<()>) -> bool { match result { Ok(_) => true, Err(TransactionError::InstructionError(_, _)) => true, Err(_) => false, } } fn update_transaction_statuses( &self, txs: &[Transaction], iteration_order: Option<&[usize]>, res: &[TransactionProcessResult], ) { let mut status_cache = self.src.status_cache.write().unwrap(); for (i, tx) in OrderedIterator::new(txs, iteration_order).enumerate() { let (res, _hash_age_kind) = &res[i]; if Self::can_commit(res) && !tx.signatures.is_empty() { status_cache.insert( &tx.message().recent_blockhash, &tx.signatures[0], self.slot(), res.clone(), ); } } } /// 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 register_tick(&self, hash: &Hash) { assert!( !self.is_frozen(), "register_tick() working on a frozen bank!" ); inc_new_counter_debug!("bank-register_tick-registered", 1); // Grab blockhash lock before incrementing tick height so that replay stage does // not attempt to freeze after observing the last tick and before blockhash is // updated let mut w_blockhash_queue = self.blockhash_queue.write().unwrap(); let current_tick_height = self.tick_height.fetch_add(1, Ordering::Relaxed) as u64; if self.is_block_boundary(current_tick_height + 1) { w_blockhash_queue.register_hash(hash, &self.fee_calculator); } } pub fn is_complete(&self) -> bool { self.tick_height() == self.max_tick_height() } pub fn is_block_boundary(&self, tick_height: u64) -> bool { tick_height % self.ticks_per_slot == 0 } /// Process a Transaction. This is used for unit tests and simply calls the vector /// Bank::process_transactions method pub fn process_transaction(&self, tx: &Transaction) -> Result<()> { let txs = vec![tx.clone()]; self.process_transactions(&txs)[0].clone()?; tx.signatures .get(0) .map_or(Ok(()), |sig| self.get_signature_status(sig).unwrap()) } pub fn prepare_batch<'a, 'b>( &'a self, txs: &'b [Transaction], iteration_order: Option>, ) -> TransactionBatch<'a, 'b> { let results = self .rc .accounts .lock_accounts(txs, iteration_order.as_deref()); TransactionBatch::new(results, &self, txs, iteration_order) } pub fn unlock_accounts(&self, batch: &mut TransactionBatch) { if batch.needs_unlock { batch.needs_unlock = false; self.rc.accounts.unlock_accounts( batch.transactions(), batch.iteration_order(), batch.lock_results(), ) } } fn load_accounts( &self, txs: &[Transaction], iteration_order: Option<&[usize]>, results: Vec, error_counters: &mut ErrorCounters, ) -> Vec<(Result, Option)> { self.rc.accounts.load_accounts( &self.ancestors, txs, iteration_order, results, &self.blockhash_queue.read().unwrap(), error_counters, &self.rent_collector, ) } fn check_refs( &self, txs: &[Transaction], iteration_order: Option<&[usize]>, lock_results: &[Result<()>], error_counters: &mut ErrorCounters, ) -> Vec> { OrderedIterator::new(txs, iteration_order) .zip(lock_results) .map(|(tx, lock_res)| { if lock_res.is_ok() && !tx.verify_refs() { error_counters.invalid_account_index += 1; Err(TransactionError::InvalidAccountIndex) } else { lock_res.clone() } }) .collect() } fn check_age( &self, txs: &[Transaction], iteration_order: Option<&[usize]>, lock_results: Vec>, max_age: usize, error_counters: &mut ErrorCounters, ) -> Vec { let hash_queue = self.blockhash_queue.read().unwrap(); OrderedIterator::new(txs, iteration_order) .zip(lock_results.into_iter()) .map(|(tx, lock_res)| match lock_res { Ok(()) => { let message = tx.message(); let hash_age = hash_queue.check_hash_age(&message.recent_blockhash, max_age); if hash_age == Some(true) { (Ok(()), Some(HashAgeKind::Extant)) } else if let Some((pubkey, acc)) = self.check_tx_durable_nonce(&tx) { (Ok(()), Some(HashAgeKind::DurableNonce(pubkey, acc))) } else if hash_age == Some(false) { error_counters.blockhash_too_old += 1; (Err(TransactionError::BlockhashNotFound), None) } else { error_counters.blockhash_not_found += 1; (Err(TransactionError::BlockhashNotFound), None) } } Err(e) => (Err(e), None), }) .collect() } fn check_signatures( &self, txs: &[Transaction], iteration_order: Option<&[usize]>, lock_results: Vec, error_counters: &mut ErrorCounters, ) -> Vec { let rcache = self.src.status_cache.read().unwrap(); OrderedIterator::new(txs, iteration_order) .zip(lock_results.into_iter()) .map(|(tx, lock_res)| { if tx.signatures.is_empty() { return lock_res; } { let (lock_res, hash_age_kind) = &lock_res; if lock_res.is_ok() && rcache .get_signature_status( &tx.signatures[0], &tx.message().recent_blockhash, &self.ancestors, ) .is_some() { error_counters.duplicate_signature += 1; return ( Err(TransactionError::DuplicateSignature), hash_age_kind.clone(), ); } } lock_res }) .collect() } pub fn check_hash_age(&self, hash: &Hash, max_age: usize) -> Option { self.blockhash_queue .read() .unwrap() .check_hash_age(hash, max_age) } pub fn check_tx_durable_nonce(&self, tx: &Transaction) -> Option<(Pubkey, Account)> { nonce_utils::transaction_uses_durable_nonce(&tx) .and_then(|nonce_ix| nonce_utils::get_nonce_pubkey_from_instruction(&nonce_ix, &tx)) .and_then(|nonce_pubkey| { self.get_account(&nonce_pubkey) .map(|acc| (*nonce_pubkey, acc)) }) .filter(|(_pubkey, nonce_account)| { nonce_utils::verify_nonce_account(nonce_account, &tx.message().recent_blockhash) }) } pub fn check_transactions( &self, txs: &[Transaction], iteration_order: Option<&[usize]>, lock_results: &[Result<()>], max_age: usize, mut error_counters: &mut ErrorCounters, ) -> Vec { let refs_results = self.check_refs(txs, iteration_order, lock_results, &mut error_counters); let age_results = self.check_age( txs, iteration_order, refs_results, max_age, &mut error_counters, ); self.check_signatures(txs, iteration_order, age_results, &mut error_counters) } pub fn collect_balances(&self, batch: &[Transaction]) -> TransactionBalances { let mut balances: TransactionBalances = vec![]; for transaction in batch.iter() { let mut transaction_balances: Vec = vec![]; for account_key in transaction.message.account_keys.iter() { transaction_balances.push(self.get_balance(account_key)); } balances.push(transaction_balances); } balances } #[allow(clippy::cognitive_complexity)] fn update_error_counters(error_counters: &ErrorCounters) { if 0 != error_counters.total { inc_new_counter_error!( "bank-process_transactions-error_count", error_counters.total ); } if 0 != error_counters.account_not_found { inc_new_counter_error!( "bank-process_transactions-account_not_found", error_counters.account_not_found ); } if 0 != error_counters.account_in_use { inc_new_counter_error!( "bank-process_transactions-account_in_use", error_counters.account_in_use ); } if 0 != error_counters.account_loaded_twice { inc_new_counter_error!( "bank-process_transactions-account_loaded_twice", error_counters.account_loaded_twice ); } if 0 != error_counters.blockhash_not_found { inc_new_counter_error!( "bank-process_transactions-error-blockhash_not_found", error_counters.blockhash_not_found ); } if 0 != error_counters.blockhash_too_old { inc_new_counter_error!( "bank-process_transactions-error-blockhash_too_old", error_counters.blockhash_too_old ); } if 0 != error_counters.invalid_account_index { inc_new_counter_error!( "bank-process_transactions-error-invalid_account_index", error_counters.invalid_account_index ); } if 0 != error_counters.invalid_account_for_fee { inc_new_counter_error!( "bank-process_transactions-error-invalid_account_for_fee", error_counters.invalid_account_for_fee ); } if 0 != error_counters.insufficient_funds { inc_new_counter_error!( "bank-process_transactions-error-insufficient_funds", error_counters.insufficient_funds ); } if 0 != error_counters.instruction_error { inc_new_counter_error!( "bank-process_transactions-error-instruction_error", error_counters.instruction_error ); } if 0 != error_counters.duplicate_signature { inc_new_counter_error!( "bank-process_transactions-error-duplicate_signature", error_counters.duplicate_signature ); } } /// Converts Accounts into RefCell, this involves moving /// ownership by draining the source #[allow(clippy::wrong_self_convention)] fn into_refcells( accounts: &mut TransactionAccounts, loaders: &mut TransactionLoaders, ) -> (TransactionAccountRefCells, TransactionLoaderRefCells) { let account_refcells: Vec<_> = accounts .drain(..) .map(|account| Rc::new(RefCell::new(account))) .collect(); let loader_refcells: Vec> = loaders .iter_mut() .map(|v| { v.drain(..) .map(|(pubkey, account)| (pubkey, RefCell::new(account))) .collect() }) .collect(); (account_refcells, loader_refcells) } /// Converts back from RefCell to Account, this involves moving /// ownership by draining the sources fn from_refcells( accounts: &mut TransactionAccounts, loaders: &mut TransactionLoaders, mut account_refcells: TransactionAccountRefCells, loader_refcells: TransactionLoaderRefCells, ) { account_refcells.drain(..).for_each(|account_refcell| { accounts.push(Rc::try_unwrap(account_refcell).unwrap().into_inner()) }); loaders .iter_mut() .zip(loader_refcells) .for_each(|(ls, mut lrcs)| { lrcs.drain(..) .for_each(|(pubkey, lrc)| ls.push((pubkey, lrc.into_inner()))) }); } #[allow(clippy::type_complexity)] pub fn load_and_execute_transactions( &self, batch: &TransactionBatch, max_age: usize, ) -> ( Vec<(Result, Option)>, Vec, Vec, u64, u64, ) { let txs = batch.transactions(); debug!("processing transactions: {}", txs.len()); inc_new_counter_info!("bank-process_transactions", txs.len()); let mut error_counters = ErrorCounters::default(); let mut load_time = Measure::start("accounts_load"); let retryable_txs: Vec<_> = OrderedIterator::new(batch.lock_results(), batch.iteration_order()) .enumerate() .filter_map(|(index, res)| match res { Err(TransactionError::AccountInUse) => { error_counters.account_in_use += 1; Some(index) } Ok(_) => None, Err(_) => None, }) .collect(); let sig_results = self.check_transactions( txs, batch.iteration_order(), batch.lock_results(), max_age, &mut error_counters, ); let mut loaded_accounts = self.load_accounts( txs, batch.iteration_order(), sig_results, &mut error_counters, ); load_time.stop(); let mut execution_time = Measure::start("execution_time"); let mut signature_count: u64 = 0; let executed: Vec = loaded_accounts .iter_mut() .zip(OrderedIterator::new(txs, batch.iteration_order())) .map(|(accs, tx)| match accs { (Err(e), hash_age_kind) => (Err(e.clone()), hash_age_kind.clone()), (Ok((accounts, loaders, _rents)), hash_age_kind) => { signature_count += u64::from(tx.message().header.num_required_signatures); let (account_refcells, loader_refcells) = Self::into_refcells(accounts, loaders); let process_result = self.message_processor.process_message( tx.message(), &loader_refcells, &account_refcells, &self.rent_collector, ); Self::from_refcells(accounts, loaders, account_refcells, loader_refcells); if let Err(TransactionError::InstructionError(_, _)) = &process_result { error_counters.instruction_error += 1; } (process_result, hash_age_kind.clone()) } }) .collect(); execution_time.stop(); debug!( "load: {}us execute: {}us txs_len={}", load_time.as_us(), execution_time.as_us(), txs.len(), ); let mut tx_count: u64 = 0; let err_count = &mut error_counters.total; for ((r, _hash_age_kind), tx) in executed.iter().zip(txs.iter()) { if r.is_ok() { tx_count += 1; } else { if *err_count == 0 { debug!("tx error: {:?} {:?}", r, tx); } *err_count += 1; } } if *err_count > 0 { debug!( "{} errors of {} txs", *err_count, *err_count as u64 + tx_count ); } Self::update_error_counters(&error_counters); ( loaded_accounts, executed, retryable_txs, tx_count, signature_count, ) } fn filter_program_errors_and_collect_fee( &self, txs: &[Transaction], iteration_order: Option<&[usize]>, executed: &[TransactionProcessResult], ) -> Vec> { let hash_queue = self.blockhash_queue.read().unwrap(); let mut fees = 0; let results = OrderedIterator::new(txs, iteration_order) .zip(executed.iter()) .map(|(tx, (res, hash_age_kind))| { let (fee_calculator, is_durable_nonce) = match hash_age_kind { Some(HashAgeKind::DurableNonce(_, account)) => { (nonce_utils::fee_calculator_of(account), true) } _ => ( hash_queue .get_fee_calculator(&tx.message().recent_blockhash) .cloned(), false, ), }; let fee_calculator = fee_calculator.ok_or(TransactionError::BlockhashNotFound)?; let fee = fee_calculator.calculate_fee(tx.message()); let message = tx.message(); match *res { Err(TransactionError::InstructionError(_, _)) => { // credit the transaction fee even in case of InstructionError // necessary to withdraw from account[0] here because previous // work of doing so (in accounts.load()) is ignored by store_account() // // ...except nonce accounts, which will have their post-load, // pre-execute account state stored if !is_durable_nonce { self.withdraw(&message.account_keys[0], fee)?; } fees += fee; Ok(()) } Ok(()) => { fees += fee; Ok(()) } _ => res.clone(), } }) .collect(); self.collector_fees.fetch_add(fees, Ordering::Relaxed); results } pub fn commit_transactions( &self, txs: &[Transaction], iteration_order: Option<&[usize]>, loaded_accounts: &mut [(Result, Option)], executed: &[TransactionProcessResult], tx_count: u64, signature_count: u64, ) -> TransactionResults { assert!( !self.is_frozen(), "commit_transactions() working on a frozen bank!" ); self.increment_transaction_count(tx_count); self.increment_signature_count(signature_count); inc_new_counter_info!("bank-process_transactions-txs", tx_count as usize); inc_new_counter_info!("bank-process_transactions-sigs", signature_count as usize); if executed .iter() .any(|(res, _hash_age_kind)| Self::can_commit(res)) { self.is_delta.store(true, Ordering::Relaxed); } let mut write_time = Measure::start("write_time"); self.rc.accounts.store_accounts( self.slot(), txs, iteration_order, executed, loaded_accounts, &self.rent_collector, &self.last_blockhash(), ); self.collect_rent(executed, loaded_accounts); self.update_cached_accounts(txs, iteration_order, executed, loaded_accounts); // once committed there is no way to unroll write_time.stop(); debug!("store: {}us txs_len={}", write_time.as_us(), txs.len(),); self.update_transaction_statuses(txs, iteration_order, &executed); let fee_collection_results = self.filter_program_errors_and_collect_fee(txs, iteration_order, executed); TransactionResults { fee_collection_results, processing_results: executed.to_vec(), } } fn distribute_rent_to_validators( &self, vote_account_hashmap: &HashMap, rent_to_be_distributed: u64, ) { let mut total_staked = 0; let mut rent_distributed_in_initial_round = 0; // Collect the stake associated with each validator. // Note that a validator may be present in this vector multiple times if it happens to have // more than one staked vote account somehow let mut validator_stakes = vote_account_hashmap .iter() .filter_map(|(_vote_pubkey, (staked, account))| { if *staked == 0 { None } else { total_staked += *staked; VoteState::deserialize(&account.data) .ok() .map(|vote_state| (vote_state.node_pubkey, *staked)) } }) .collect::>(); // Sort first by stake and then by validator identity pubkey for determinism validator_stakes.sort_by(|(pubkey1, staked1), (pubkey2, staked2)| { match staked2.cmp(staked1) { std::cmp::Ordering::Equal => pubkey2.cmp(pubkey1), other => other, } }); let validator_rent_shares = validator_stakes .into_iter() .map(|(pubkey, staked)| { let rent_share = (((staked * rent_to_be_distributed) as f64) / (total_staked as f64)) as u64; rent_distributed_in_initial_round += rent_share; (pubkey, rent_share) }) .collect::>(); // Leftover lamports after fraction calculation, will be paid to validators starting from highest stake // holder let mut leftover_lamports = rent_to_be_distributed - rent_distributed_in_initial_round; validator_rent_shares .into_iter() .for_each(|(pubkey, rent_share)| { let rent_to_be_paid = if leftover_lamports > 0 { leftover_lamports -= 1; rent_share + 1 } else { rent_share }; let mut account = self.get_account(&pubkey).unwrap_or_default(); account.lamports += rent_to_be_paid; self.store_account(&pubkey, &account); }); } fn distribute_rent(&self) { let total_rent_collected = self.collected_rent.load(Ordering::Relaxed); let (burned_portion, rent_to_be_distributed) = self .rent_collector .rent .calculate_burn(total_rent_collected); self.capitalization .fetch_sub(burned_portion, Ordering::Relaxed); if rent_to_be_distributed == 0 { return; } self.distribute_rent_to_validators(&self.vote_accounts(), rent_to_be_distributed); } fn collect_rent( &self, res: &[TransactionProcessResult], loaded_accounts: &[(Result, Option)], ) { let mut collected_rent: u64 = 0; for (i, (raccs, _hash_age_kind)) in loaded_accounts.iter().enumerate() { let (res, _hash_age_kind) = &res[i]; if res.is_err() || raccs.is_err() { continue; } let acc = raccs.as_ref().unwrap(); collected_rent += acc.2; } self.collected_rent .fetch_add(collected_rent, Ordering::Relaxed); } /// Process a batch of transactions. #[must_use] pub fn load_execute_and_commit_transactions( &self, batch: &TransactionBatch, max_age: usize, collect_balances: bool, ) -> (TransactionResults, TransactionBalancesSet) { let pre_balances = if collect_balances { self.collect_balances(batch.transactions()) } else { vec![] }; let (mut loaded_accounts, executed, _, tx_count, signature_count) = self.load_and_execute_transactions(batch, max_age); let results = self.commit_transactions( batch.transactions(), batch.iteration_order(), &mut loaded_accounts, &executed, tx_count, signature_count, ); let post_balances = if collect_balances { self.collect_balances(batch.transactions()) } else { vec![] }; ( results, TransactionBalancesSet::new(pre_balances, post_balances), ) } #[must_use] pub fn process_transactions(&self, txs: &[Transaction]) -> Vec> { let batch = self.prepare_batch(txs, None); self.load_execute_and_commit_transactions(&batch, MAX_PROCESSING_AGE, false) .0 .fee_collection_results } /// 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 transfer(&self, n: u64, keypair: &Keypair, to: &Pubkey) -> Result { let blockhash = self.last_blockhash(); let tx = system_transaction::transfer(keypair, to, n, blockhash); let signature = tx.signatures[0]; self.process_transaction(&tx).map(|_| signature) } pub fn read_balance(account: &Account) -> u64 { account.lamports } /// Each program would need to be able to introspect its own state /// this is hard-coded to the Budget language pub fn get_balance(&self, pubkey: &Pubkey) -> u64 { self.get_account(pubkey) .map(|x| Self::read_balance(&x)) .unwrap_or(0) } /// Compute all the parents of the bank in order pub fn parents(&self) -> Vec> { let mut parents = vec![]; let mut bank = self.parent(); while let Some(parent) = bank { parents.push(parent.clone()); bank = parent.parent(); } parents } pub fn store_account(&self, pubkey: &Pubkey, account: &Account) { self.rc.accounts.store_slow(self.slot(), pubkey, account); if Stakes::is_stake(account) { self.stakes.write().unwrap().store(pubkey, account); } else if storage_utils::is_storage(account) { self.storage_accounts .write() .unwrap() .store(pubkey, account); } } pub fn withdraw(&self, pubkey: &Pubkey, lamports: u64) -> Result<()> { match self.get_account(pubkey) { Some(mut account) => { let min_balance = match get_system_account_kind(&account) { Some(SystemAccountKind::Nonce) => self .rent_collector .rent .minimum_balance(nonce::State::size()), _ => 0, }; if lamports + min_balance > account.lamports { return Err(TransactionError::InsufficientFundsForFee); } account.lamports -= lamports; self.store_account(pubkey, &account); Ok(()) } None => Err(TransactionError::AccountNotFound), } } pub fn deposit(&self, pubkey: &Pubkey, lamports: u64) { let mut account = self.get_account(pubkey).unwrap_or_default(); self.collected_rent .fetch_add(self.rent_collector.update(&mut account), Ordering::Relaxed); account.lamports += lamports; self.store_account(pubkey, &account); } pub fn accounts(&self) -> Arc { self.rc.accounts.clone() } pub fn set_bank_rc(&mut self, bank_rc: BankRc, status_cache_rc: StatusCacheRc) { self.rc = bank_rc; self.src = status_cache_rc; } pub fn set_parent(&mut self, parent: &Arc) { self.rc.parent = RwLock::new(Some(parent.clone())); } pub fn set_inflation(&self, inflation: Inflation) { *self.inflation.write().unwrap() = inflation; } pub fn hard_forks(&self) -> Arc> { self.hard_forks.clone() } pub fn set_entered_epoch_callback(&self, entered_epoch_callback: EnteredEpochCallback) { *self.entered_epoch_callback.write().unwrap() = Some(entered_epoch_callback); } pub fn get_account(&self, pubkey: &Pubkey) -> Option { self.rc .accounts .load_slow(&self.ancestors, pubkey) .map(|(acc, _slot)| acc) } // Exclude self to really fetch the parent Bank's account hash and data. // // Being idempotent is needed to make the lazy initialization possible, // especially for update_slot_hashes at the moment, which can be called // multiple times with the same parent_slot in the case of forking. // // Generally, all of sysvar update granularity should be slot boundaries. fn get_sysvar_account(&self, pubkey: &Pubkey) -> Option { let mut ancestors = self.ancestors.clone(); ancestors.remove(&self.slot()); self.rc .accounts .load_slow(&ancestors, pubkey) .map(|(acc, _slot)| acc) } pub fn get_program_accounts(&self, program_id: Option<&Pubkey>) -> Vec<(Pubkey, Account)> { self.rc .accounts .load_by_program(&self.ancestors, program_id) } pub fn get_program_accounts_modified_since_parent( &self, program_id: &Pubkey, ) -> Vec<(Pubkey, Account)> { self.rc .accounts .load_by_program_slot(self.slot(), program_id) } pub fn get_account_modified_since_parent(&self, pubkey: &Pubkey) -> Option<(Account, Slot)> { let just_self: HashMap = vec![(self.slot(), 0)].into_iter().collect(); if let Some((account, slot)) = self.rc.accounts.load_slow(&just_self, pubkey) { if slot == self.slot() { return Some((account, slot)); } } None } pub fn transaction_count(&self) -> u64 { self.transaction_count.load(Ordering::Relaxed) } fn increment_transaction_count(&self, tx_count: u64) { self.transaction_count .fetch_add(tx_count, Ordering::Relaxed); } pub fn signature_count(&self) -> u64 { self.signature_count.load(Ordering::Relaxed) } fn increment_signature_count(&self, signature_count: u64) { self.signature_count .fetch_add(signature_count, Ordering::Relaxed); } pub fn get_signature_status_processed_since_parent( &self, signature: &Signature, ) -> Option> { if let Some((slot, status)) = self.get_signature_status_slot(signature) { if slot <= self.slot() { return Some(status); } } None } pub fn get_signature_status_slot(&self, signature: &Signature) -> Option<(Slot, Result<()>)> { let rcache = self.src.status_cache.read().unwrap(); rcache.get_signature_slot(signature, &self.ancestors) } pub fn get_signature_status(&self, signature: &Signature) -> Option> { self.get_signature_status_slot(signature).map(|v| v.1) } pub fn has_signature(&self, signature: &Signature) -> bool { self.get_signature_status_slot(signature).is_some() } /// Hash the `accounts` HashMap. This represents a validator's interpretation /// of the delta of the ledger since the last vote and up to now fn hash_internal_state(&self) -> Hash { // If there are no accounts, return the hash of the previous state and the latest blockhash let accounts_delta_hash = self.rc.accounts.bank_hash_info_at(self.slot()); let mut signature_count_buf = [0u8; 8]; LittleEndian::write_u64(&mut signature_count_buf[..], self.signature_count() as u64); let mut hash = hashv(&[ self.parent_hash.as_ref(), accounts_delta_hash.hash.as_ref(), &signature_count_buf, self.last_blockhash().as_ref(), ]); if let Some(buf) = self .hard_forks .read() .unwrap() .get_hash_data(self.slot(), self.parent_slot()) { info!("hard fork at bank {}", self.slot()); hash = extend_and_hash(&hash, &buf) } info!( "bank frozen: {} hash: {} accounts_delta: {} signature_count: {} last_blockhash: {}", self.slot(), hash, accounts_delta_hash.hash, self.signature_count(), self.last_blockhash(), ); info!( "accounts hash slot: {} stats: {:?}", self.slot(), accounts_delta_hash.stats, ); hash } /// Recalculate the hash_internal_state from the account stores. Would be used to verify a /// snapshot. #[must_use] fn verify_bank_hash(&self) -> bool { self.rc .accounts .verify_bank_hash(self.slot(), &self.ancestors) } pub fn get_snapshot_storages(&self) -> SnapshotStorages { self.rc .get_snapshot_storages(self.slot()) .into_iter() .collect() } #[must_use] fn verify_hash(&self) -> bool { assert!(self.is_frozen()); let calculated_hash = self.hash_internal_state(); let expected_hash = self.hash(); if calculated_hash == expected_hash { true } else { warn!( "verify failed: slot: {}, {} (calculated) != {} (expected)", self.slot(), calculated_hash, expected_hash ); false } } pub fn get_accounts_hash(&self) -> Hash { self.rc.accounts.accounts_db.get_accounts_hash(self.slot) } pub fn update_accounts_hash(&self) -> Hash { self.rc .accounts .accounts_db .update_accounts_hash(self.slot(), &self.ancestors) } /// 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 verify_snapshot_bank(&self) -> bool { self.clean_accounts(); self.shrink_all_stale_slots(); // Order and short-circuiting is significant; verify_hash requires a valid bank hash self.verify_bank_hash() && self.verify_hash() } /// Return the number of hashes per tick pub fn hashes_per_tick(&self) -> &Option { &self.hashes_per_tick } /// Return the number of ticks per slot pub fn ticks_per_slot(&self) -> u64 { self.ticks_per_slot } /// Return the number of slots per year pub fn slots_per_year(&self) -> f64 { self.slots_per_year } /// Return the number of slots per segment pub fn slots_per_segment(&self) -> u64 { self.slots_per_segment } /// Return the number of ticks since genesis. pub fn tick_height(&self) -> u64 { self.tick_height.load(Ordering::Relaxed) } /// Return the inflation parameters of the Bank pub fn inflation(&self) -> Inflation { *self.inflation.read().unwrap() } /// Return the total capititalization of the Bank pub fn capitalization(&self) -> u64 { self.capitalization.load(Ordering::Relaxed) } /// Return this bank's max_tick_height pub fn max_tick_height(&self) -> u64 { self.max_tick_height } /// Return the block_height of this bank pub fn block_height(&self) -> u64 { self.block_height } /// Return the number of slots per epoch for the given epoch pub fn get_slots_in_epoch(&self, epoch: Epoch) -> u64 { self.epoch_schedule.get_slots_in_epoch(epoch) } /// returns the epoch for which this bank's leader_schedule_slot_offset and slot would /// need to cache leader_schedule pub fn get_leader_schedule_epoch(&self, slot: Slot) -> Epoch { self.epoch_schedule.get_leader_schedule_epoch(slot) } /// a bank-level cache of vote accounts fn update_cached_accounts( &self, txs: &[Transaction], iteration_order: Option<&[usize]>, res: &[TransactionProcessResult], loaded: &[(Result, Option)], ) { for (i, ((raccs, _load_hash_age_kind), tx)) in loaded .iter() .zip(OrderedIterator::new(txs, iteration_order)) .enumerate() { let (res, _res_hash_age_kind) = &res[i]; if res.is_err() || raccs.is_err() { continue; } let message = &tx.message(); let acc = raccs.as_ref().unwrap(); for (pubkey, account) in message .account_keys .iter() .zip(acc.0.iter()) .filter(|(_key, account)| { (Stakes::is_stake(account)) || storage_utils::is_storage(account) }) { if Stakes::is_stake(account) { self.stakes.write().unwrap().store(pubkey, account); } else if storage_utils::is_storage(account) { self.storage_accounts .write() .unwrap() .store(pubkey, account); } } } } pub fn storage_accounts(&self) -> StorageAccounts { self.storage_accounts.read().unwrap().clone() } /// current stake delegations for this bank /// Note: this method is exposed publicly for external usage pub fn stake_delegations(&self) -> HashMap { self.stakes.read().unwrap().stake_delegations().clone() } /// current vote accounts for this bank along with the stake /// attributed to each account pub fn vote_accounts(&self) -> HashMap { self.stakes.read().unwrap().vote_accounts().clone() } /// Get the EpochStakes for a given epoch pub fn epoch_stakes(&self, epoch: Epoch) -> Option<&EpochStakes> { self.epoch_stakes.get(&epoch) } /// vote accounts for the specific epoch along with the stake /// attributed to each account pub fn epoch_vote_accounts(&self, epoch: Epoch) -> Option<&HashMap> { self.epoch_stakes .get(&epoch) .map(|epoch_stakes| Stakes::vote_accounts(epoch_stakes.stakes())) } /// Get the fixed authorized voter for the given vote account for the /// current epoch pub fn epoch_authorized_voter(&self, vote_account: &Pubkey) -> Option<&Pubkey> { self.epoch_stakes .get(&self.epoch) .expect("Epoch stakes for bank's own epoch must exist") .epoch_authorized_voters() .get(vote_account) } /// Get the fixed set of vote accounts for the given node id for the /// current epoch pub fn epoch_vote_accounts_for_node_id(&self, node_id: &Pubkey) -> Option<&NodeVoteAccounts> { self.epoch_stakes .get(&self.epoch) .expect("Epoch stakes for bank's own epoch must exist") .node_id_to_vote_accounts() .get(node_id) } /// Get the fixed total stake of all vote accounts for current epoch pub fn total_epoch_stake(&self) -> u64 { self.epoch_stakes .get(&self.epoch) .expect("Epoch stakes for bank's own epoch must exist") .total_stake() } /// Get the fixed stake of the given vote account for the current epoch pub fn epoch_vote_account_stake(&self, voting_pubkey: &Pubkey) -> u64 { *self .epoch_vote_accounts(self.epoch()) .expect("Bank epoch vote accounts must contain entry for the bank's own epoch") .get(voting_pubkey) .map(|(stake, _)| stake) .unwrap_or(&0) } /// 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 get_epoch_and_slot_index(&self, slot: Slot) -> (u64, u64) { self.epoch_schedule.get_epoch_and_slot_index(slot) } pub fn is_empty(&self) -> bool { !self.is_delta.load(Ordering::Relaxed) } /// Add an instruction processor to intercept instructions before the dynamic loader. pub fn add_instruction_processor( &mut self, program_id: Pubkey, process_instruction: ProcessInstruction, ) { self.message_processor .add_instruction_processor(program_id, process_instruction); if let Some(program_account) = self.get_account(&program_id) { // It is not valid to intercept instructions for a non-native loader account assert_eq!(program_account.owner, solana_sdk::native_loader::id()); } else { // Register a bogus executable account, which will be loaded and ignored. self.register_native_instruction_processor("", &program_id); } } pub fn compare_bank(&self, dbank: &Bank) { assert_eq!(self.slot, dbank.slot); assert_eq!(self.collector_id, dbank.collector_id); assert_eq!(self.epoch_schedule, dbank.epoch_schedule); assert_eq!(self.hashes_per_tick, dbank.hashes_per_tick); assert_eq!(self.ticks_per_slot, dbank.ticks_per_slot); assert_eq!(self.parent_hash, dbank.parent_hash); assert_eq!( self.tick_height.load(Ordering::Relaxed), dbank.tick_height.load(Ordering::Relaxed) ); assert_eq!( self.is_delta.load(Ordering::Relaxed), dbank.is_delta.load(Ordering::Relaxed) ); let st = self.stakes.read().unwrap(); let dst = dbank.stakes.read().unwrap(); assert_eq!(*st, *dst); let bh = self.hash.read().unwrap(); let dbh = dbank.hash.read().unwrap(); assert_eq!(*bh, *dbh); let bhq = self.blockhash_queue.read().unwrap(); let dbhq = dbank.blockhash_queue.read().unwrap(); assert_eq!(*bhq, *dbhq); let sc = self.src.status_cache.read().unwrap(); let dsc = dbank.src.status_cache.read().unwrap(); assert_eq!(*sc, *dsc); assert_eq!( self.rc.accounts.bank_hash_at(self.slot), dbank.rc.accounts.bank_hash_at(dbank.slot) ); } pub fn clean_accounts(&self) { self.rc.accounts.accounts_db.clean_accounts(); } pub fn process_dead_slots(&self) { self.rc.accounts.accounts_db.process_dead_slots(); } pub fn process_stale_slot(&self) { self.rc.accounts.accounts_db.process_stale_slot(); } pub fn shrink_all_stale_slots(&self) { self.rc.accounts.accounts_db.shrink_all_stale_slots(); } } impl Drop for Bank { fn drop(&mut self) { // For root slots this is a noop self.rc.accounts.purge_slot(self.slot()); } } pub fn goto_end_of_slot(bank: &mut Bank) { let mut tick_hash = bank.last_blockhash(); loop { tick_hash = hashv(&[&tick_hash.as_ref(), &[42]]); bank.register_tick(&tick_hash); if tick_hash == bank.last_blockhash() { bank.freeze(); return; } } } // This guards against possible memory exhaustions in bincode when restoring // the full state from snapshot data files by imposing a fixed hard limit with // ample of headrooms for such a usecase. pub fn deserialize_from_snapshot(reader: R) -> bincode::Result where R: Read, T: serde::de::DeserializeOwned, { bincode::config() .limit(MAX_SNAPSHOT_DATA_FILE_SIZE) .deserialize_from(reader) } #[cfg(test)] mod tests { use super::*; use crate::{ accounts_db::{get_temp_accounts_paths, tests::copy_append_vecs}, genesis_utils::{ create_genesis_config_with_leader, GenesisConfigInfo, BOOTSTRAP_VALIDATOR_LAMPORTS, }, status_cache::MAX_CACHE_ENTRIES, }; use bincode::{serialize_into, serialized_size}; use solana_sdk::{ account::KeyedAccount, account_utils::StateMut, clock::DEFAULT_TICKS_PER_SLOT, epoch_schedule::MINIMUM_SLOTS_PER_EPOCH, genesis_config::create_genesis_config, instruction::{AccountMeta, CompiledInstruction, Instruction, InstructionError}, message::{Message, MessageHeader}, nonce, poh_config::PohConfig, rent::Rent, signature::{Keypair, Signer}, system_instruction, system_program::{self, solana_system_program}, sysvar::{fees::Fees, rewards::Rewards}, timing::duration_as_s, }; use solana_stake_program::{ stake_instruction, stake_state::{self, Authorized, Delegation, Lockup, Stake}, }; use solana_vote_program::vote_state::VoteStateVersions; use solana_vote_program::{ vote_instruction, vote_state::{self, Vote, VoteInit, VoteState, MAX_LOCKOUT_HISTORY}, }; use std::{io::Cursor, result, time::Duration}; use tempfile::TempDir; #[test] fn test_hash_age_kind_is_durable_nonce() { assert!( HashAgeKind::DurableNonce(Pubkey::default(), Account::default()).is_durable_nonce() ); assert!(!HashAgeKind::Extant.is_durable_nonce()); } #[test] fn test_bank_unix_timestamp() { let (genesis_config, _mint_keypair) = create_genesis_config(1); let mut bank = Arc::new(Bank::new(&genesis_config)); assert_eq!(genesis_config.creation_time, bank.unix_timestamp()); let slots_per_sec = 1.0 / (duration_as_s(&genesis_config.poh_config.target_tick_duration) * genesis_config.ticks_per_slot as f32); for _i in 0..slots_per_sec as usize + 1 { bank = Arc::new(new_from_parent(&bank)); } assert!(bank.unix_timestamp() - genesis_config.creation_time >= 1); } #[test] fn test_bank_new() { let dummy_leader_pubkey = Pubkey::new_rand(); let dummy_leader_lamports = BOOTSTRAP_VALIDATOR_LAMPORTS; let mint_lamports = 10_000; let GenesisConfigInfo { mut genesis_config, mint_keypair, voting_keypair, .. } = create_genesis_config_with_leader( mint_lamports, &dummy_leader_pubkey, dummy_leader_lamports, ); genesis_config.rent = Rent { lamports_per_byte_year: 5, exemption_threshold: 1.2, burn_percent: 5, }; let bank = Bank::new(&genesis_config); assert_eq!(bank.get_balance(&mint_keypair.pubkey()), mint_lamports); assert_eq!( bank.get_balance(&voting_keypair.pubkey()), dummy_leader_lamports /* 1 token goes to the vote account associated with dummy_leader_lamports */ ); let rent_account = bank.get_account(&sysvar::rent::id()).unwrap(); let rent = sysvar::rent::Rent::from_account(&rent_account).unwrap(); assert_eq!(rent.burn_percent, 5); assert_eq!(rent.exemption_threshold, 1.2); assert_eq!(rent.lamports_per_byte_year, 5); } #[test] fn test_bank_block_height() { let (genesis_config, _mint_keypair) = create_genesis_config(1); let bank0 = Arc::new(Bank::new(&genesis_config)); assert_eq!(bank0.block_height(), 0); let bank1 = Arc::new(new_from_parent(&bank0)); assert_eq!(bank1.block_height(), 1); } #[test] fn test_bank_update_epoch_stakes() { impl Bank { fn epoch_stake_keys(&self) -> Vec { let mut keys: Vec = self.epoch_stakes.keys().map(|k| *k).collect(); keys.sort(); keys } fn epoch_stake_key_info(&self) -> (Epoch, Epoch, usize) { let mut keys: Vec = self.epoch_stakes.keys().map(|k| *k).collect(); keys.sort(); (*keys.first().unwrap(), *keys.last().unwrap(), keys.len()) } } let (genesis_config, _mint_keypair) = create_genesis_config(100_000); let mut bank = Bank::new(&genesis_config); let initial_epochs = bank.epoch_stake_keys(); assert_eq!(initial_epochs, vec![0, 1]); for existing_epoch in &initial_epochs { bank.update_epoch_stakes(*existing_epoch); assert_eq!(bank.epoch_stake_keys(), initial_epochs); } for epoch in (initial_epochs.len() as Epoch)..MAX_LEADER_SCHEDULE_STAKES { bank.update_epoch_stakes(epoch); assert_eq!(bank.epoch_stakes.len() as Epoch, epoch + 1); } assert_eq!( bank.epoch_stake_key_info(), ( 0, MAX_LEADER_SCHEDULE_STAKES - 1, MAX_LEADER_SCHEDULE_STAKES as usize ) ); bank.update_epoch_stakes(MAX_LEADER_SCHEDULE_STAKES); assert_eq!( bank.epoch_stake_key_info(), ( 0, MAX_LEADER_SCHEDULE_STAKES, MAX_LEADER_SCHEDULE_STAKES as usize + 1 ) ); bank.update_epoch_stakes(MAX_LEADER_SCHEDULE_STAKES + 1); assert_eq!( bank.epoch_stake_key_info(), ( 1, MAX_LEADER_SCHEDULE_STAKES + 1, MAX_LEADER_SCHEDULE_STAKES as usize + 1 ) ); } #[test] fn test_bank_capitalization() { let bank = Arc::new(Bank::new(&GenesisConfig { accounts: (0..42) .into_iter() .map(|_| (Pubkey::new_rand(), Account::new(42, 0, &Pubkey::default()))) .collect(), ..GenesisConfig::default() })); assert_eq!(bank.capitalization(), 42 * 42); let bank1 = Bank::new_from_parent(&bank, &Pubkey::default(), 1); assert_eq!(bank1.capitalization(), 42 * 42); } #[test] fn test_bank_inflation() { let key = Pubkey::default(); let bank = Arc::new(Bank::new(&GenesisConfig { accounts: (0..42) .into_iter() .map(|_| (Pubkey::new_rand(), Account::new(42, 0, &key))) .collect(), ..GenesisConfig::default() })); assert_eq!(bank.capitalization(), 42 * 42); // With inflation bank.set_entered_epoch_callback(Box::new(move |bank: &mut Bank| { let mut inflation = Inflation::default(); inflation.initial = 1_000_000.0; bank.set_inflation(inflation) })); let bank1 = Bank::new_from_parent(&bank, &key, MINIMUM_SLOTS_PER_EPOCH + 1); assert_ne!(bank.capitalization(), bank1.capitalization()); // Without inflation bank.set_entered_epoch_callback(Box::new(move |bank: &mut Bank| { bank.set_inflation(Inflation::new_disabled()) })); let bank2 = Bank::new_from_parent(&bank, &key, MINIMUM_SLOTS_PER_EPOCH * 2 + 1); assert_eq!(bank.capitalization(), bank2.capitalization()); } #[test] fn test_credit_debit_rent_no_side_effect_on_hash() { let (mut genesis_config, _mint_keypair) = create_genesis_config(10); let keypair1: Keypair = Keypair::new(); let keypair2: Keypair = Keypair::new(); let keypair3: Keypair = Keypair::new(); let keypair4: Keypair = Keypair::new(); // Transaction between these two keypairs will fail let keypair5: Keypair = Keypair::new(); let keypair6: Keypair = Keypair::new(); genesis_config.rent = Rent { lamports_per_byte_year: 1, exemption_threshold: 21.0, burn_percent: 10, }; let root_bank = Arc::new(Bank::new(&genesis_config)); let bank = Bank::new_from_parent( &root_bank, &Pubkey::default(), years_as_slots( 2.0, &genesis_config.poh_config.target_tick_duration, genesis_config.ticks_per_slot, ) as u64, ); let root_bank_2 = Arc::new(Bank::new(&genesis_config)); let bank_with_success_txs = Bank::new_from_parent( &root_bank_2, &Pubkey::default(), years_as_slots( 2.0, &genesis_config.poh_config.target_tick_duration, genesis_config.ticks_per_slot, ) as u64, ); assert_eq!(bank.last_blockhash(), genesis_config.hash()); // Initialize credit-debit and credit only accounts let account1 = Account::new(264, 0, &Pubkey::default()); let account2 = Account::new(264, 1, &Pubkey::default()); let account3 = Account::new(264, 0, &Pubkey::default()); let account4 = Account::new(264, 1, &Pubkey::default()); let account5 = Account::new(10, 0, &Pubkey::default()); let account6 = Account::new(10, 1, &Pubkey::default()); bank.store_account(&keypair1.pubkey(), &account1); bank.store_account(&keypair2.pubkey(), &account2); bank.store_account(&keypair3.pubkey(), &account3); bank.store_account(&keypair4.pubkey(), &account4); bank.store_account(&keypair5.pubkey(), &account5); bank.store_account(&keypair6.pubkey(), &account6); bank_with_success_txs.store_account(&keypair1.pubkey(), &account1); bank_with_success_txs.store_account(&keypair2.pubkey(), &account2); bank_with_success_txs.store_account(&keypair3.pubkey(), &account3); bank_with_success_txs.store_account(&keypair4.pubkey(), &account4); bank_with_success_txs.store_account(&keypair5.pubkey(), &account5); bank_with_success_txs.store_account(&keypair6.pubkey(), &account6); // Make native instruction loader rent exempt let system_program_id = solana_system_program().1; let mut system_program_account = bank.get_account(&system_program_id).unwrap(); system_program_account.lamports = bank.get_minimum_balance_for_rent_exemption(system_program_account.data.len()); bank.store_account(&system_program_id, &system_program_account); bank_with_success_txs.store_account(&system_program_id, &system_program_account); let t1 = system_transaction::transfer(&keypair1, &keypair2.pubkey(), 1, genesis_config.hash()); let t2 = system_transaction::transfer(&keypair3, &keypair4.pubkey(), 1, genesis_config.hash()); let t3 = system_transaction::transfer(&keypair5, &keypair6.pubkey(), 1, genesis_config.hash()); let res = bank.process_transactions(&vec![t1.clone(), t2.clone(), t3.clone()]); assert_eq!(res.len(), 3); assert_eq!(res[0], Ok(())); assert_eq!(res[1], Ok(())); assert_eq!(res[2], Err(TransactionError::AccountNotFound)); bank.freeze(); let rwlockguard_bank_hash = bank.hash.read().unwrap(); let bank_hash = rwlockguard_bank_hash.as_ref(); let res = bank_with_success_txs.process_transactions(&vec![t2.clone(), t1.clone()]); assert_eq!(res.len(), 2); assert_eq!(res[0], Ok(())); assert_eq!(res[1], Ok(())); bank_with_success_txs.freeze(); let rwlockguard_bank_with_success_txs_hash = bank_with_success_txs.hash.read().unwrap(); let bank_with_success_txs_hash = rwlockguard_bank_with_success_txs_hash.as_ref(); assert_eq!(bank_with_success_txs_hash, bank_hash); } #[derive(Serialize, Deserialize)] enum MockInstruction { Deduction, } fn mock_process_instruction( _program_id: &Pubkey, keyed_accounts: &[KeyedAccount], data: &[u8], ) -> result::Result<(), InstructionError> { if let Ok(instruction) = bincode::deserialize(data) { match instruction { MockInstruction::Deduction => { keyed_accounts[1].account.borrow_mut().lamports += 1; keyed_accounts[2].account.borrow_mut().lamports -= 1; Ok(()) } } } else { Err(InstructionError::InvalidInstructionData) } } fn create_mock_transaction( payer: &Keypair, keypair1: &Keypair, keypair2: &Keypair, read_only_keypair: &Keypair, mock_program_id: Pubkey, recent_blockhash: Hash, ) -> Transaction { let account_metas = vec![ AccountMeta::new(payer.pubkey(), true), AccountMeta::new(keypair1.pubkey(), true), AccountMeta::new(keypair2.pubkey(), true), AccountMeta::new_readonly(read_only_keypair.pubkey(), false), ]; let deduct_instruction = Instruction::new(mock_program_id, &MockInstruction::Deduction, account_metas); Transaction::new_signed_with_payer( &[deduct_instruction], Some(&payer.pubkey()), &[payer, keypair1, keypair2], recent_blockhash, ) } fn store_accounts_for_rent_test( bank: &Bank, keypairs: &mut Vec, mock_program_id: Pubkey, generic_rent_due_for_system_account: u64, ) { let mut account_pairs: Vec<(Pubkey, Account)> = Vec::with_capacity(keypairs.len() - 1); account_pairs.push(( keypairs[0].pubkey(), Account::new( generic_rent_due_for_system_account + 2, 0, &Pubkey::default(), ), )); account_pairs.push(( keypairs[1].pubkey(), Account::new( generic_rent_due_for_system_account + 2, 0, &Pubkey::default(), ), )); account_pairs.push(( keypairs[2].pubkey(), Account::new( generic_rent_due_for_system_account + 2, 0, &Pubkey::default(), ), )); account_pairs.push(( keypairs[3].pubkey(), Account::new( generic_rent_due_for_system_account + 2, 0, &Pubkey::default(), ), )); account_pairs.push(( keypairs[4].pubkey(), Account::new(10, 0, &Pubkey::default()), )); account_pairs.push(( keypairs[5].pubkey(), Account::new(10, 0, &Pubkey::default()), )); account_pairs.push(( keypairs[6].pubkey(), Account::new( (2 * generic_rent_due_for_system_account) + 24, 0, &Pubkey::default(), ), )); account_pairs.push(( keypairs[8].pubkey(), Account::new( generic_rent_due_for_system_account + 2 + 929, 0, &Pubkey::default(), ), )); account_pairs.push(( keypairs[9].pubkey(), Account::new(10, 0, &Pubkey::default()), )); // Feeding to MockProgram to test read only rent behaviour account_pairs.push(( keypairs[10].pubkey(), Account::new( generic_rent_due_for_system_account + 3, 0, &Pubkey::default(), ), )); account_pairs.push(( keypairs[11].pubkey(), Account::new(generic_rent_due_for_system_account + 3, 0, &mock_program_id), )); account_pairs.push(( keypairs[12].pubkey(), Account::new(generic_rent_due_for_system_account + 3, 0, &mock_program_id), )); account_pairs.push(( keypairs[13].pubkey(), Account::new(14, 22, &mock_program_id), )); for account_pair in account_pairs.iter() { bank.store_account(&account_pair.0, &account_pair.1); } } fn create_child_bank_for_rent_test( root_bank: &Arc, genesis_config: &GenesisConfig, mock_program_id: Pubkey, ) -> Bank { let mut bank = Bank::new_from_parent( root_bank, &Pubkey::default(), years_as_slots( 2.0, &genesis_config.poh_config.target_tick_duration, genesis_config.ticks_per_slot, ) as u64, ); bank.rent_collector.slots_per_year = 421_812.0; bank.add_instruction_processor(mock_program_id, mock_process_instruction); bank } #[test] fn test_rent_distribution() { let bootstrap_validator_pubkey = Pubkey::new_rand(); let bootstrap_validator_stake_lamports = 30; let mut genesis_config = create_genesis_config_with_leader( 10, &bootstrap_validator_pubkey, bootstrap_validator_stake_lamports, ) .genesis_config; genesis_config.epoch_schedule = EpochSchedule::custom( MINIMUM_SLOTS_PER_EPOCH, genesis_config.epoch_schedule.leader_schedule_slot_offset, false, ); genesis_config.rent = Rent { lamports_per_byte_year: 1, exemption_threshold: 2.0, burn_percent: 10, }; let rent = Rent::free(); let validator_1_pubkey = Pubkey::new_rand(); let validator_1_stake_lamports = 20; let validator_1_staking_keypair = Keypair::new(); let validator_1_voting_keypair = Keypair::new(); let validator_1_vote_account = vote_state::create_account( &validator_1_voting_keypair.pubkey(), &validator_1_pubkey, 0, validator_1_stake_lamports, ); let validator_1_stake_account = stake_state::create_account( &validator_1_staking_keypair.pubkey(), &validator_1_voting_keypair.pubkey(), &validator_1_vote_account, &rent, validator_1_stake_lamports, ); genesis_config.accounts.insert( validator_1_pubkey, Account::new(42, 0, &system_program::id()), ); genesis_config.accounts.insert( validator_1_staking_keypair.pubkey(), validator_1_stake_account, ); genesis_config.accounts.insert( validator_1_voting_keypair.pubkey(), validator_1_vote_account, ); let validator_2_pubkey = Pubkey::new_rand(); let validator_2_stake_lamports = 20; let validator_2_staking_keypair = Keypair::new(); let validator_2_voting_keypair = Keypair::new(); let validator_2_vote_account = vote_state::create_account( &validator_2_voting_keypair.pubkey(), &validator_2_pubkey, 0, validator_2_stake_lamports, ); let validator_2_stake_account = stake_state::create_account( &validator_2_staking_keypair.pubkey(), &validator_2_voting_keypair.pubkey(), &validator_2_vote_account, &rent, validator_2_stake_lamports, ); genesis_config.accounts.insert( validator_2_pubkey, Account::new(42, 0, &system_program::id()), ); genesis_config.accounts.insert( validator_2_staking_keypair.pubkey(), validator_2_stake_account, ); genesis_config.accounts.insert( validator_2_voting_keypair.pubkey(), validator_2_vote_account, ); let validator_3_pubkey = Pubkey::new_rand(); let validator_3_stake_lamports = 30; let validator_3_staking_keypair = Keypair::new(); let validator_3_voting_keypair = Keypair::new(); let validator_3_vote_account = vote_state::create_account( &validator_3_voting_keypair.pubkey(), &validator_3_pubkey, 0, validator_3_stake_lamports, ); let validator_3_stake_account = stake_state::create_account( &validator_3_staking_keypair.pubkey(), &validator_3_voting_keypair.pubkey(), &validator_3_vote_account, &rent, validator_3_stake_lamports, ); genesis_config.accounts.insert( validator_3_pubkey, Account::new(42, 0, &system_program::id()), ); genesis_config.accounts.insert( validator_3_staking_keypair.pubkey(), validator_3_stake_account, ); genesis_config.accounts.insert( validator_3_voting_keypair.pubkey(), validator_3_vote_account, ); genesis_config.rent = Rent { lamports_per_byte_year: 1, exemption_threshold: 10.0, burn_percent: 10, }; let mut bank = Bank::new(&genesis_config); // Enable rent collection bank.rent_collector.epoch = 5; bank.rent_collector.slots_per_year = 192.0; let payer = Keypair::new(); let payer_account = Account::new(400, 0, &system_program::id()); bank.store_account(&payer.pubkey(), &payer_account); let payee = Keypair::new(); let payee_account = Account::new(70, 1, &system_program::id()); bank.store_account(&payee.pubkey(), &payee_account); let bootstrap_validator_initial_balance = bank.get_balance(&bootstrap_validator_pubkey); let tx = system_transaction::transfer(&payer, &payee.pubkey(), 180, genesis_config.hash()); let result = bank.process_transaction(&tx); assert_eq!(result, Ok(())); let mut total_rent_deducted = 0; // 400 - 128(Rent) - 180(Transfer) assert_eq!(bank.get_balance(&payer.pubkey()), 92); total_rent_deducted += 128; // 70 - 70(Rent) + 180(Transfer) - 21(Rent) assert_eq!(bank.get_balance(&payee.pubkey()), 159); total_rent_deducted += 70 + 21; let previous_capitalization = bank.capitalization.load(Ordering::Relaxed); bank.freeze(); assert_eq!( bank.collected_rent.load(Ordering::Relaxed), total_rent_deducted ); let burned_portion = total_rent_deducted * u64::from(bank.rent_collector.rent.burn_percent) / 100; let rent_to_be_distributed = total_rent_deducted - burned_portion; let bootstrap_validator_portion = ((bootstrap_validator_stake_lamports * rent_to_be_distributed) as f64 / 100.0) as u64 + 1; // Leftover lamport assert_eq!( bank.get_balance(&bootstrap_validator_pubkey), bootstrap_validator_portion + bootstrap_validator_initial_balance ); // Since, validator 1 and validator 2 has equal smallest stake, it comes down to comparison // between their pubkey. let tweak_1 = if validator_1_pubkey > validator_2_pubkey { 1 } else { 0 }; let validator_1_portion = ((validator_1_stake_lamports * rent_to_be_distributed) as f64 / 100.0) as u64 + tweak_1; assert_eq!( bank.get_balance(&validator_1_pubkey), validator_1_portion + 42 - tweak_1, ); // Since, validator 1 and validator 2 has equal smallest stake, it comes down to comparison // between their pubkey. let tweak_2 = if validator_2_pubkey > validator_1_pubkey { 1 } else { 0 }; let validator_2_portion = ((validator_2_stake_lamports * rent_to_be_distributed) as f64 / 100.0) as u64 + tweak_2; assert_eq!( bank.get_balance(&validator_2_pubkey), validator_2_portion + 42 - tweak_2, ); let validator_3_portion = ((validator_3_stake_lamports * rent_to_be_distributed) as f64 / 100.0) as u64 + 1; assert_eq!( bank.get_balance(&validator_3_pubkey), validator_3_portion + 42 ); let current_capitalization = bank.capitalization.load(Ordering::Relaxed); assert_eq!( previous_capitalization - current_capitalization, burned_portion ); } #[test] fn test_rent_exempt_executable_account() { let (mut genesis_config, mint_keypair) = create_genesis_config(100000); genesis_config.rent = Rent { lamports_per_byte_year: 1, exemption_threshold: 1000.0, burn_percent: 10, }; let root_bank = Arc::new(Bank::new(&genesis_config)); let bank = create_child_bank_for_rent_test(&root_bank, &genesis_config, Pubkey::new_rand()); let account_pubkey = Pubkey::new_rand(); let account_balance = 1; let mut account = Account::new(account_balance, 0, &Pubkey::new_rand()); account.executable = true; bank.store_account(&account_pubkey, &account); let transfer_lamports = 1; let tx = system_transaction::transfer( &mint_keypair, &account_pubkey, transfer_lamports, genesis_config.hash(), ); assert_eq!( bank.process_transaction(&tx), Err(TransactionError::InstructionError( 0, InstructionError::ExecutableLamportChange )) ); assert_eq!(bank.get_balance(&account_pubkey), account_balance); } #[test] #[allow(clippy::cognitive_complexity)] fn test_rent_complex() { let mock_program_id = Pubkey::new(&[2u8; 32]); let (mut genesis_config, _mint_keypair) = create_genesis_config(10); let mut keypairs: Vec = Vec::with_capacity(14); for _i in 0..14 { keypairs.push(Keypair::new()); } genesis_config.rent = Rent { lamports_per_byte_year: 1, exemption_threshold: 1000.0, burn_percent: 10, }; let root_bank = Arc::new(Bank::new(&genesis_config)); let bank = create_child_bank_for_rent_test(&root_bank, &genesis_config, mock_program_id); assert_eq!(bank.last_blockhash(), genesis_config.hash()); let slots_elapsed: u64 = (0..=bank.epoch) .map(|epoch| { bank.rent_collector .epoch_schedule .get_slots_in_epoch(epoch + 1) }) .sum(); let (generic_rent_due_for_system_account, _) = bank.rent_collector.rent.due( bank.get_minimum_balance_for_rent_exemption(0) - 1, 0, slots_elapsed as f64 / bank.rent_collector.slots_per_year, ); store_accounts_for_rent_test( &bank, &mut keypairs, mock_program_id, generic_rent_due_for_system_account, ); let magic_rent_number = 131; // yuck, derive this value programmatically one day let t1 = system_transaction::transfer( &keypairs[0], &keypairs[1].pubkey(), 1, genesis_config.hash(), ); let t2 = system_transaction::transfer( &keypairs[2], &keypairs[3].pubkey(), 1, genesis_config.hash(), ); let t3 = system_transaction::transfer( &keypairs[4], &keypairs[5].pubkey(), 1, genesis_config.hash(), ); let t4 = system_transaction::transfer( &keypairs[6], &keypairs[7].pubkey(), generic_rent_due_for_system_account + 1, genesis_config.hash(), ); let t5 = system_transaction::transfer( &keypairs[8], &keypairs[9].pubkey(), 929, genesis_config.hash(), ); let t6 = create_mock_transaction( &keypairs[10], &keypairs[11], &keypairs[12], &keypairs[13], mock_program_id, genesis_config.hash(), ); let res = bank.process_transactions(&[ t6.clone(), t5.clone(), t1.clone(), t2.clone(), t3.clone(), t4.clone(), ]); assert_eq!(res.len(), 6); assert_eq!(res[0], Ok(())); assert_eq!(res[1], Ok(())); assert_eq!(res[2], Ok(())); assert_eq!(res[3], Ok(())); assert_eq!(res[4], Err(TransactionError::AccountNotFound)); assert_eq!(res[5], Ok(())); bank.freeze(); let mut rent_collected = 0; // 48992 - generic_rent_due_for_system_account(Rent) - 1(transfer) assert_eq!(bank.get_balance(&keypairs[0].pubkey()), 1); rent_collected += generic_rent_due_for_system_account; // 48992 - generic_rent_due_for_system_account(Rent) + 1(transfer) assert_eq!(bank.get_balance(&keypairs[1].pubkey()), 3); rent_collected += generic_rent_due_for_system_account; // 48992 - generic_rent_due_for_system_account(Rent) - 1(transfer) assert_eq!(bank.get_balance(&keypairs[2].pubkey()), 1); rent_collected += generic_rent_due_for_system_account; // 48992 - generic_rent_due_for_system_account(Rent) + 1(transfer) assert_eq!(bank.get_balance(&keypairs[3].pubkey()), 3); rent_collected += generic_rent_due_for_system_account; // No rent deducted assert_eq!(bank.get_balance(&keypairs[4].pubkey()), 10); assert_eq!(bank.get_balance(&keypairs[5].pubkey()), 10); // 98004 - generic_rent_due_for_system_account(Rent) - 48991(transfer) assert_eq!(bank.get_balance(&keypairs[6].pubkey()), 23); rent_collected += generic_rent_due_for_system_account; // 0 + 48990(transfer) - magic_rent_number(Rent) assert_eq!( bank.get_balance(&keypairs[7].pubkey()), generic_rent_due_for_system_account + 1 - magic_rent_number ); // Epoch should be updated // Rent deducted on store side let account8 = bank.get_account(&keypairs[7].pubkey()).unwrap(); // Epoch should be set correctly. assert_eq!(account8.rent_epoch, bank.epoch + 1); rent_collected += magic_rent_number; // 49921 - generic_rent_due_for_system_account(Rent) - 929(Transfer) assert_eq!(bank.get_balance(&keypairs[8].pubkey()), 2); rent_collected += generic_rent_due_for_system_account; let account10 = bank.get_account(&keypairs[9].pubkey()).unwrap(); // Account was overwritten at load time, since it didn't have sufficient balance to pay rent // Then, at store time we deducted `magic_rent_number` rent for the current epoch, once it has balance assert_eq!(account10.rent_epoch, bank.epoch + 1); // account data is blank now assert_eq!(account10.data.len(), 0); // 10 - 10(Rent) + 929(Transfer) - magic_rent_number(Rent) assert_eq!(account10.lamports, 929 - magic_rent_number); rent_collected += magic_rent_number + 10; // 48993 - generic_rent_due_for_system_account(Rent) assert_eq!(bank.get_balance(&keypairs[10].pubkey()), 3); rent_collected += generic_rent_due_for_system_account; // 48993 - generic_rent_due_for_system_account(Rent) + 1(Addition by program) assert_eq!(bank.get_balance(&keypairs[11].pubkey()), 4); rent_collected += generic_rent_due_for_system_account; // 48993 - generic_rent_due_for_system_account(Rent) - 1(Deduction by program) assert_eq!(bank.get_balance(&keypairs[12].pubkey()), 2); rent_collected += generic_rent_due_for_system_account; // No rent for read-only account assert_eq!(bank.get_balance(&keypairs[13].pubkey()), 14); // Bank's collected rent should be sum of rent collected from all accounts assert_eq!(bank.collected_rent.load(Ordering::Relaxed), rent_collected); } #[test] fn test_bank_update_rewards() { // create a bank that ticks really slowly... let bank = Arc::new(Bank::new(&GenesisConfig { accounts: (0..42) .into_iter() .map(|_| { ( Pubkey::new_rand(), Account::new(1_000_000_000, 0, &Pubkey::default()), ) }) .collect(), // set it up so the first epoch is a full year long poh_config: PohConfig { target_tick_duration: Duration::from_secs( SECONDS_PER_YEAR as u64 / MINIMUM_SLOTS_PER_EPOCH as u64 / DEFAULT_TICKS_PER_SLOT, ), hashes_per_tick: None, target_tick_count: None, }, ..GenesisConfig::default() })); assert_eq!(bank.capitalization(), 42 * 1_000_000_000); assert_eq!(bank.rewards, None); let ((vote_id, mut vote_account), (stake_id, stake_account)) = crate::stakes::tests::create_staked_node_accounts(1_0000); let ((validator_id, validator_account), (archiver_id, archiver_account)) = crate::storage_utils::tests::create_storage_accounts_with_credits(100); // set up stakes, vote, and storage accounts bank.store_account(&stake_id, &stake_account); bank.store_account(&validator_id, &validator_account); bank.store_account(&archiver_id, &archiver_account); // generate some rewards let mut vote_state = Some(VoteState::from(&vote_account).unwrap()); for i in 0..MAX_LOCKOUT_HISTORY + 42 { vote_state .as_mut() .map(|v| v.process_slot_vote_unchecked(i as u64)); let versioned = VoteStateVersions::Current(Box::new(vote_state.take().unwrap())); VoteState::to(&versioned, &mut vote_account).unwrap(); bank.store_account(&vote_id, &vote_account); match versioned { VoteStateVersions::Current(v) => { vote_state = Some(*v); } _ => panic!("Has to be of type Current"), }; } bank.store_account(&vote_id, &vote_account); let validator_points = bank.stakes.read().unwrap().points(); let storage_points = bank.storage_accounts.read().unwrap().points(); // put a child bank in epoch 1, which calls update_rewards()... let bank1 = Bank::new_from_parent( &bank, &Pubkey::default(), bank.get_slots_in_epoch(bank.epoch()) + 1, ); // verify that there's inflation assert_ne!(bank1.capitalization(), bank.capitalization()); // verify the inflation is represented in validator_points * let inflation = bank1.capitalization() - bank.capitalization(); let rewards = bank1 .get_account(&sysvar::rewards::id()) .map(|account| Rewards::from_account(&account).unwrap()) .unwrap(); // verify the stake and vote accounts are the right size assert!( ((bank1.get_balance(&stake_id) - stake_account.lamports + bank1.get_balance(&vote_id) - vote_account.lamports) as f64 - rewards.validator_point_value * validator_points as f64) .abs() < 1.0 ); // verify the rewards are the right size assert!( ((rewards.validator_point_value * validator_points as f64 + rewards.storage_point_value * storage_points as f64) - inflation as f64) .abs() < 1.0 // rounding, truncating ); // verify validator rewards show up in bank1.rewards vector // (currently storage rewards will not show up) assert_eq!( bank1.rewards, Some(vec![( stake_id, (rewards.validator_point_value * validator_points as f64) as i64 )]) ); } // Test that purging 0 lamports accounts works. #[test] fn test_purge_empty_accounts() { solana_logger::setup(); let (genesis_config, mint_keypair) = create_genesis_config(500_000); let parent = Arc::new(Bank::new(&genesis_config)); let mut bank = parent; for _ in 0..10 { let blockhash = bank.last_blockhash(); let pubkey = Pubkey::new_rand(); let tx = system_transaction::transfer(&mint_keypair, &pubkey, 0, blockhash); bank.process_transaction(&tx).unwrap(); bank.squash(); bank = Arc::new(new_from_parent(&bank)); } let hash = bank.update_accounts_hash(); bank.clean_accounts(); assert_eq!(bank.update_accounts_hash(), hash); let bank0 = Arc::new(new_from_parent(&bank)); let blockhash = bank.last_blockhash(); let keypair = Keypair::new(); let tx = system_transaction::transfer(&mint_keypair, &keypair.pubkey(), 10, blockhash); bank0.process_transaction(&tx).unwrap(); let bank1 = Arc::new(new_from_parent(&bank0)); let pubkey = Pubkey::new_rand(); let blockhash = bank.last_blockhash(); let tx = system_transaction::transfer(&keypair, &pubkey, 10, blockhash); bank1.process_transaction(&tx).unwrap(); assert_eq!(bank0.get_account(&keypair.pubkey()).unwrap().lamports, 10); assert_eq!(bank1.get_account(&keypair.pubkey()), None); info!("bank0 purge"); let hash = bank0.update_accounts_hash(); bank0.clean_accounts(); assert_eq!(bank0.update_accounts_hash(), hash); assert_eq!(bank0.get_account(&keypair.pubkey()).unwrap().lamports, 10); assert_eq!(bank1.get_account(&keypair.pubkey()), None); info!("bank1 purge"); bank1.clean_accounts(); assert_eq!(bank0.get_account(&keypair.pubkey()).unwrap().lamports, 10); assert_eq!(bank1.get_account(&keypair.pubkey()), None); assert!(bank0.verify_bank_hash()); // Squash and then verify hash_internal value bank0.squash(); assert!(bank0.verify_bank_hash()); bank1.squash(); bank1.update_accounts_hash(); assert!(bank1.verify_bank_hash()); // keypair should have 0 tokens on both forks assert_eq!(bank0.get_account(&keypair.pubkey()), None); assert_eq!(bank1.get_account(&keypair.pubkey()), None); bank1.clean_accounts(); assert!(bank1.verify_bank_hash()); } #[test] fn test_two_payments_to_one_party() { let (genesis_config, mint_keypair) = create_genesis_config(10_000); let pubkey = Pubkey::new_rand(); let bank = Bank::new(&genesis_config); assert_eq!(bank.last_blockhash(), genesis_config.hash()); bank.transfer(1_000, &mint_keypair, &pubkey).unwrap(); assert_eq!(bank.get_balance(&pubkey), 1_000); bank.transfer(500, &mint_keypair, &pubkey).unwrap(); assert_eq!(bank.get_balance(&pubkey), 1_500); assert_eq!(bank.transaction_count(), 2); } #[test] fn test_one_source_two_tx_one_batch() { let (genesis_config, mint_keypair) = create_genesis_config(1); let key1 = Pubkey::new_rand(); let key2 = Pubkey::new_rand(); let bank = Bank::new(&genesis_config); assert_eq!(bank.last_blockhash(), genesis_config.hash()); let t1 = system_transaction::transfer(&mint_keypair, &key1, 1, genesis_config.hash()); let t2 = system_transaction::transfer(&mint_keypair, &key2, 1, genesis_config.hash()); let res = bank.process_transactions(&vec![t1.clone(), t2.clone()]); assert_eq!(res.len(), 2); assert_eq!(res[0], Ok(())); assert_eq!(res[1], Err(TransactionError::AccountInUse)); assert_eq!(bank.get_balance(&mint_keypair.pubkey()), 0); assert_eq!(bank.get_balance(&key1), 1); assert_eq!(bank.get_balance(&key2), 0); assert_eq!(bank.get_signature_status(&t1.signatures[0]), Some(Ok(()))); // TODO: Transactions that fail to pay a fee could be dropped silently. // Non-instruction errors don't get logged in the signature cache assert_eq!(bank.get_signature_status(&t2.signatures[0]), None); } #[test] fn test_one_tx_two_out_atomic_fail() { let (genesis_config, mint_keypair) = create_genesis_config(1); let key1 = Pubkey::new_rand(); let key2 = Pubkey::new_rand(); let bank = Bank::new(&genesis_config); let instructions = system_instruction::transfer_many(&mint_keypair.pubkey(), &[(key1, 1), (key2, 1)]); let tx = Transaction::new_signed_instructions( &[&mint_keypair], &instructions, genesis_config.hash(), ); assert_eq!( bank.process_transaction(&tx).unwrap_err(), TransactionError::InstructionError( 1, InstructionError::new_result_with_negative_lamports(), ) ); assert_eq!(bank.get_balance(&mint_keypair.pubkey()), 1); assert_eq!(bank.get_balance(&key1), 0); assert_eq!(bank.get_balance(&key2), 0); } #[test] fn test_one_tx_two_out_atomic_pass() { let (genesis_config, mint_keypair) = create_genesis_config(2); let key1 = Pubkey::new_rand(); let key2 = Pubkey::new_rand(); let bank = Bank::new(&genesis_config); let instructions = system_instruction::transfer_many(&mint_keypair.pubkey(), &[(key1, 1), (key2, 1)]); let tx = Transaction::new_signed_instructions( &[&mint_keypair], &instructions, genesis_config.hash(), ); bank.process_transaction(&tx).unwrap(); assert_eq!(bank.get_balance(&mint_keypair.pubkey()), 0); assert_eq!(bank.get_balance(&key1), 1); assert_eq!(bank.get_balance(&key2), 1); } // This test demonstrates that fees are paid even when a program fails. #[test] fn test_detect_failed_duplicate_transactions() { let (mut genesis_config, mint_keypair) = create_genesis_config(2); genesis_config.fee_rate_governor = FeeRateGovernor::new(1, 0); let bank = Bank::new(&genesis_config); let dest = Keypair::new(); // source with 0 program context let tx = system_transaction::transfer(&mint_keypair, &dest.pubkey(), 2, genesis_config.hash()); let signature = tx.signatures[0]; assert!(!bank.has_signature(&signature)); assert_eq!( bank.process_transaction(&tx), Err(TransactionError::InstructionError( 0, InstructionError::new_result_with_negative_lamports(), )) ); // The lamports didn't move, but the from address paid the transaction fee. assert_eq!(bank.get_balance(&dest.pubkey()), 0); // This should be the original balance minus the transaction fee. assert_eq!(bank.get_balance(&mint_keypair.pubkey()), 1); } #[test] fn test_account_not_found() { let (genesis_config, mint_keypair) = create_genesis_config(0); let bank = Bank::new(&genesis_config); let keypair = Keypair::new(); assert_eq!( bank.transfer(1, &keypair, &mint_keypair.pubkey()), Err(TransactionError::AccountNotFound) ); assert_eq!(bank.transaction_count(), 0); } #[test] fn test_insufficient_funds() { let (genesis_config, mint_keypair) = create_genesis_config(11_000); let bank = Bank::new(&genesis_config); let pubkey = Pubkey::new_rand(); bank.transfer(1_000, &mint_keypair, &pubkey).unwrap(); assert_eq!(bank.transaction_count(), 1); assert_eq!(bank.get_balance(&pubkey), 1_000); assert_eq!( bank.transfer(10_001, &mint_keypair, &pubkey), Err(TransactionError::InstructionError( 0, InstructionError::new_result_with_negative_lamports(), )) ); assert_eq!(bank.transaction_count(), 1); let mint_pubkey = mint_keypair.pubkey(); assert_eq!(bank.get_balance(&mint_pubkey), 10_000); assert_eq!(bank.get_balance(&pubkey), 1_000); } #[test] fn test_transfer_to_newb() { solana_logger::setup(); let (genesis_config, mint_keypair) = create_genesis_config(10_000); let bank = Bank::new(&genesis_config); let pubkey = Pubkey::new_rand(); bank.transfer(500, &mint_keypair, &pubkey).unwrap(); assert_eq!(bank.get_balance(&pubkey), 500); } #[test] fn test_bank_deposit() { let (genesis_config, _mint_keypair) = create_genesis_config(100); let bank = Bank::new(&genesis_config); // Test new account let key = Keypair::new(); bank.deposit(&key.pubkey(), 10); assert_eq!(bank.get_balance(&key.pubkey()), 10); // Existing account bank.deposit(&key.pubkey(), 3); assert_eq!(bank.get_balance(&key.pubkey()), 13); } #[test] fn test_bank_withdraw() { let (genesis_config, _mint_keypair) = create_genesis_config(100); let bank = Bank::new(&genesis_config); // Test no account let key = Keypair::new(); assert_eq!( bank.withdraw(&key.pubkey(), 10), Err(TransactionError::AccountNotFound) ); bank.deposit(&key.pubkey(), 3); assert_eq!(bank.get_balance(&key.pubkey()), 3); // Low balance assert_eq!( bank.withdraw(&key.pubkey(), 10), Err(TransactionError::InsufficientFundsForFee) ); // Enough balance assert_eq!(bank.withdraw(&key.pubkey(), 2), Ok(())); assert_eq!(bank.get_balance(&key.pubkey()), 1); } #[test] fn test_bank_withdraw_from_nonce_account() { let (mut genesis_config, _mint_keypair) = create_genesis_config(100_000); genesis_config.rent.lamports_per_byte_year = 42; let bank = Bank::new(&genesis_config); let min_balance = bank.get_minimum_balance_for_rent_exemption(nonce::State::size()); let nonce = Keypair::new(); let nonce_account = Account::new_data( min_balance + 42, &nonce::state::Versions::new_current(nonce::State::Initialized( nonce::state::Data::default(), )), &system_program::id(), ) .unwrap(); bank.store_account(&nonce.pubkey(), &nonce_account); assert_eq!(bank.get_balance(&nonce.pubkey()), min_balance + 42); // Resulting in non-zero, but sub-min_balance balance fails assert_eq!( bank.withdraw(&nonce.pubkey(), min_balance / 2), Err(TransactionError::InsufficientFundsForFee) ); assert_eq!(bank.get_balance(&nonce.pubkey()), min_balance + 42); // Resulting in exactly rent-exempt balance succeeds bank.withdraw(&nonce.pubkey(), 42).unwrap(); assert_eq!(bank.get_balance(&nonce.pubkey()), min_balance); // Account closure fails assert_eq!( bank.withdraw(&nonce.pubkey(), min_balance), Err(TransactionError::InsufficientFundsForFee), ); } #[test] fn test_bank_tx_fee() { let arbitrary_transfer_amount = 42; let mint = arbitrary_transfer_amount * 100; let leader = Pubkey::new_rand(); let GenesisConfigInfo { mut genesis_config, mint_keypair, .. } = create_genesis_config_with_leader(mint, &leader, 3); genesis_config.fee_rate_governor = FeeRateGovernor::new(4, 0); // something divisible by 2 let expected_fee_paid = genesis_config .fee_rate_governor .create_fee_calculator() .lamports_per_signature; let (expected_fee_collected, expected_fee_burned) = genesis_config.fee_rate_governor.burn(expected_fee_paid); let mut bank = Bank::new(&genesis_config); let capitalization = bank.capitalization(); let key = Keypair::new(); let tx = system_transaction::transfer( &mint_keypair, &key.pubkey(), arbitrary_transfer_amount, bank.last_blockhash(), ); let initial_balance = bank.get_balance(&leader); assert_eq!(bank.process_transaction(&tx), Ok(())); assert_eq!(bank.get_balance(&key.pubkey()), arbitrary_transfer_amount); assert_eq!( bank.get_balance(&mint_keypair.pubkey()), mint - arbitrary_transfer_amount - expected_fee_paid ); assert_eq!(bank.get_balance(&leader), initial_balance); goto_end_of_slot(&mut bank); assert_eq!(bank.signature_count(), 1); assert_eq!( bank.get_balance(&leader), initial_balance + expected_fee_collected ); // Leader collects fee after the bank is frozen // verify capitalization assert_eq!(capitalization - expected_fee_burned, bank.capitalization()); // Verify that an InstructionError collects fees, too let mut bank = Bank::new_from_parent(&Arc::new(bank), &leader, 1); let mut tx = system_transaction::transfer(&mint_keypair, &key.pubkey(), 1, bank.last_blockhash()); // Create a bogus instruction to system_program to cause an instruction error tx.message.instructions[0].data[0] = 40; bank.process_transaction(&tx) .expect_err("instruction error"); assert_eq!(bank.get_balance(&key.pubkey()), arbitrary_transfer_amount); // no change assert_eq!( bank.get_balance(&mint_keypair.pubkey()), mint - arbitrary_transfer_amount - 2 * expected_fee_paid ); // mint_keypair still pays a fee goto_end_of_slot(&mut bank); assert_eq!(bank.signature_count(), 1); // Profit! 2 transaction signatures processed at 3 lamports each assert_eq!( bank.get_balance(&leader), initial_balance + 2 * expected_fee_collected ); } #[test] fn test_bank_blockhash_fee_schedule() { //solana_logger::setup(); let leader = Pubkey::new_rand(); let GenesisConfigInfo { mut genesis_config, mint_keypair, .. } = create_genesis_config_with_leader(1_000_000, &leader, 3); genesis_config .fee_rate_governor .target_lamports_per_signature = 1000; genesis_config.fee_rate_governor.target_signatures_per_slot = 1; let mut bank = Bank::new(&genesis_config); goto_end_of_slot(&mut bank); let (cheap_blockhash, cheap_fee_calculator) = bank.last_blockhash_with_fee_calculator(); assert_eq!(cheap_fee_calculator.lamports_per_signature, 0); let mut bank = Bank::new_from_parent(&Arc::new(bank), &leader, 1); goto_end_of_slot(&mut bank); let (expensive_blockhash, expensive_fee_calculator) = bank.last_blockhash_with_fee_calculator(); assert!( cheap_fee_calculator.lamports_per_signature < expensive_fee_calculator.lamports_per_signature ); let bank = Bank::new_from_parent(&Arc::new(bank), &leader, 2); // Send a transfer using cheap_blockhash let key = Keypair::new(); let initial_mint_balance = bank.get_balance(&mint_keypair.pubkey()); let tx = system_transaction::transfer(&mint_keypair, &key.pubkey(), 1, cheap_blockhash); assert_eq!(bank.process_transaction(&tx), Ok(())); assert_eq!(bank.get_balance(&key.pubkey()), 1); assert_eq!( bank.get_balance(&mint_keypair.pubkey()), initial_mint_balance - 1 - cheap_fee_calculator.lamports_per_signature ); // Send a transfer using expensive_blockhash let key = Keypair::new(); let initial_mint_balance = bank.get_balance(&mint_keypair.pubkey()); let tx = system_transaction::transfer(&mint_keypair, &key.pubkey(), 1, expensive_blockhash); assert_eq!(bank.process_transaction(&tx), Ok(())); assert_eq!(bank.get_balance(&key.pubkey()), 1); assert_eq!( bank.get_balance(&mint_keypair.pubkey()), initial_mint_balance - 1 - expensive_fee_calculator.lamports_per_signature ); } #[test] fn test_filter_program_errors_and_collect_fee() { let leader = Pubkey::new_rand(); let GenesisConfigInfo { mut genesis_config, mint_keypair, .. } = create_genesis_config_with_leader(100, &leader, 3); genesis_config.fee_rate_governor = FeeRateGovernor::new(2, 0); let bank = Bank::new(&genesis_config); let key = Keypair::new(); let tx1 = system_transaction::transfer(&mint_keypair, &key.pubkey(), 2, genesis_config.hash()); let tx2 = system_transaction::transfer(&mint_keypair, &key.pubkey(), 5, genesis_config.hash()); let results = vec![ (Ok(()), Some(HashAgeKind::Extant)), ( Err(TransactionError::InstructionError( 1, InstructionError::new_result_with_negative_lamports(), )), Some(HashAgeKind::Extant), ), ]; let initial_balance = bank.get_balance(&leader); let results = bank.filter_program_errors_and_collect_fee(&vec![tx1, tx2], None, &results); bank.freeze(); assert_eq!( bank.get_balance(&leader), initial_balance + bank .fee_rate_governor .burn(bank.fee_calculator.lamports_per_signature * 2) .0 ); assert_eq!(results[0], Ok(())); assert_eq!(results[1], Ok(())); } #[test] fn test_debits_before_credits() { let (genesis_config, mint_keypair) = create_genesis_config(2); let bank = Bank::new(&genesis_config); let keypair = Keypair::new(); let tx0 = system_transaction::transfer( &mint_keypair, &keypair.pubkey(), 2, genesis_config.hash(), ); let tx1 = system_transaction::transfer( &keypair, &mint_keypair.pubkey(), 1, genesis_config.hash(), ); let txs = vec![tx0, tx1]; let results = bank.process_transactions(&txs); assert!(results[1].is_err()); // Assert bad transactions aren't counted. assert_eq!(bank.transaction_count(), 1); } #[test] fn test_readonly_accounts() { let GenesisConfigInfo { genesis_config, mint_keypair, .. } = create_genesis_config_with_leader(500, &Pubkey::new_rand(), 0); let bank = Bank::new(&genesis_config); let vote_pubkey0 = Pubkey::new_rand(); let vote_pubkey1 = Pubkey::new_rand(); let vote_pubkey2 = Pubkey::new_rand(); let authorized_voter = Keypair::new(); let payer0 = Keypair::new(); let payer1 = Keypair::new(); // Create vote accounts let vote_account0 = vote_state::create_account(&vote_pubkey0, &authorized_voter.pubkey(), 0, 100); let vote_account1 = vote_state::create_account(&vote_pubkey1, &authorized_voter.pubkey(), 0, 100); let vote_account2 = vote_state::create_account(&vote_pubkey2, &authorized_voter.pubkey(), 0, 100); bank.store_account(&vote_pubkey0, &vote_account0); bank.store_account(&vote_pubkey1, &vote_account1); bank.store_account(&vote_pubkey2, &vote_account2); // Fund payers bank.transfer(10, &mint_keypair, &payer0.pubkey()).unwrap(); bank.transfer(10, &mint_keypair, &payer1.pubkey()).unwrap(); bank.transfer(1, &mint_keypair, &authorized_voter.pubkey()) .unwrap(); let vote = Vote::new(vec![1], Hash::default()); let ix0 = vote_instruction::vote(&vote_pubkey0, &authorized_voter.pubkey(), vote.clone()); let tx0 = Transaction::new_signed_with_payer( &[ix0], Some(&payer0.pubkey()), &[&payer0, &authorized_voter], bank.last_blockhash(), ); let ix1 = vote_instruction::vote(&vote_pubkey1, &authorized_voter.pubkey(), vote.clone()); let tx1 = Transaction::new_signed_with_payer( &[ix1], Some(&payer1.pubkey()), &[&payer1, &authorized_voter], bank.last_blockhash(), ); let txs = vec![tx0, tx1]; let results = bank.process_transactions(&txs); // If multiple transactions attempt to read the same account, they should succeed. // Vote authorized_voter and sysvar accounts are given read-only handling assert_eq!(results[0], Ok(())); assert_eq!(results[1], Ok(())); let ix0 = vote_instruction::vote(&vote_pubkey2, &authorized_voter.pubkey(), vote.clone()); let tx0 = Transaction::new_signed_with_payer( &[ix0], Some(&payer0.pubkey()), &[&payer0, &authorized_voter], bank.last_blockhash(), ); let tx1 = system_transaction::transfer( &authorized_voter, &Pubkey::new_rand(), 1, bank.last_blockhash(), ); let txs = vec![tx0, tx1]; let results = bank.process_transactions(&txs); // However, an account may not be locked as read-only and writable at the same time. assert_eq!(results[0], Ok(())); assert_eq!(results[1], Err(TransactionError::AccountInUse)); } #[test] fn test_interleaving_locks() { let (genesis_config, mint_keypair) = create_genesis_config(3); let bank = Bank::new(&genesis_config); let alice = Keypair::new(); let bob = Keypair::new(); let tx1 = system_transaction::transfer(&mint_keypair, &alice.pubkey(), 1, genesis_config.hash()); let pay_alice = vec![tx1]; let lock_result = bank.prepare_batch(&pay_alice, None); let results_alice = bank .load_execute_and_commit_transactions(&lock_result, MAX_PROCESSING_AGE, false) .0 .fee_collection_results; assert_eq!(results_alice[0], Ok(())); // try executing an interleaved transfer twice assert_eq!( bank.transfer(1, &mint_keypair, &bob.pubkey()), Err(TransactionError::AccountInUse) ); // the second time should fail as well // this verifies that `unlock_accounts` doesn't unlock `AccountInUse` accounts assert_eq!( bank.transfer(1, &mint_keypair, &bob.pubkey()), Err(TransactionError::AccountInUse) ); drop(lock_result); assert!(bank.transfer(2, &mint_keypair, &bob.pubkey()).is_ok()); } #[test] fn test_readonly_relaxed_locks() { let (genesis_config, _) = create_genesis_config(3); let bank = Bank::new(&genesis_config); let key0 = Keypair::new(); let key1 = Keypair::new(); let key2 = Keypair::new(); let key3 = Pubkey::new_rand(); let message = Message { header: MessageHeader { num_required_signatures: 1, num_readonly_signed_accounts: 0, num_readonly_unsigned_accounts: 1, }, account_keys: vec![key0.pubkey(), key3], recent_blockhash: Hash::default(), instructions: vec![], }; let tx = Transaction::new(&[&key0], message, genesis_config.hash()); let txs = vec![tx]; let batch0 = bank.prepare_batch(&txs, None); assert!(batch0.lock_results()[0].is_ok()); // Try locking accounts, locking a previously read-only account as writable // should fail let message = Message { header: MessageHeader { num_required_signatures: 1, num_readonly_signed_accounts: 0, num_readonly_unsigned_accounts: 0, }, account_keys: vec![key1.pubkey(), key3], recent_blockhash: Hash::default(), instructions: vec![], }; let tx = Transaction::new(&[&key1], message, genesis_config.hash()); let txs = vec![tx]; let batch1 = bank.prepare_batch(&txs, None); assert!(batch1.lock_results()[0].is_err()); // Try locking a previously read-only account a 2nd time; should succeed let message = Message { header: MessageHeader { num_required_signatures: 1, num_readonly_signed_accounts: 0, num_readonly_unsigned_accounts: 1, }, account_keys: vec![key2.pubkey(), key3], recent_blockhash: Hash::default(), instructions: vec![], }; let tx = Transaction::new(&[&key2], message, genesis_config.hash()); let txs = vec![tx]; let batch2 = bank.prepare_batch(&txs, None); assert!(batch2.lock_results()[0].is_ok()); } #[test] fn test_bank_invalid_account_index() { let (genesis_config, mint_keypair) = create_genesis_config(1); let keypair = Keypair::new(); let bank = Bank::new(&genesis_config); let tx = system_transaction::transfer( &mint_keypair, &keypair.pubkey(), 1, genesis_config.hash(), ); let mut tx_invalid_program_index = tx.clone(); tx_invalid_program_index.message.instructions[0].program_id_index = 42; assert_eq!( bank.process_transaction(&tx_invalid_program_index), Err(TransactionError::InvalidAccountIndex) ); let mut tx_invalid_account_index = tx.clone(); tx_invalid_account_index.message.instructions[0].accounts[0] = 42; assert_eq!( bank.process_transaction(&tx_invalid_account_index), Err(TransactionError::InvalidAccountIndex) ); } #[test] fn test_bank_pay_to_self() { let (genesis_config, mint_keypair) = create_genesis_config(1); let key1 = Keypair::new(); let bank = Bank::new(&genesis_config); bank.transfer(1, &mint_keypair, &key1.pubkey()).unwrap(); assert_eq!(bank.get_balance(&key1.pubkey()), 1); let tx = system_transaction::transfer(&key1, &key1.pubkey(), 1, genesis_config.hash()); let _res = bank.process_transaction(&tx); assert_eq!(bank.get_balance(&key1.pubkey()), 1); // TODO: Why do we convert errors to Oks? //res[0].clone().unwrap_err(); bank.get_signature_status(&tx.signatures[0]) .unwrap() .unwrap_err(); } fn new_from_parent(parent: &Arc) -> Bank { Bank::new_from_parent(parent, &Pubkey::default(), parent.slot() + 1) } /// Verify that the parent's vector is computed correctly #[test] fn test_bank_parents() { let (genesis_config, _) = create_genesis_config(1); let parent = Arc::new(Bank::new(&genesis_config)); let bank = new_from_parent(&parent); assert!(Arc::ptr_eq(&bank.parents()[0], &parent)); } /// Verifies that last ids and status cache are correctly referenced from parent #[test] fn test_bank_parent_duplicate_signature() { let (genesis_config, mint_keypair) = create_genesis_config(2); let key1 = Keypair::new(); let parent = Arc::new(Bank::new(&genesis_config)); let tx = system_transaction::transfer(&mint_keypair, &key1.pubkey(), 1, genesis_config.hash()); assert_eq!(parent.process_transaction(&tx), Ok(())); let bank = new_from_parent(&parent); assert_eq!( bank.process_transaction(&tx), Err(TransactionError::DuplicateSignature) ); } /// Verifies that last ids and accounts are correctly referenced from parent #[test] fn test_bank_parent_account_spend() { let (genesis_config, mint_keypair) = create_genesis_config(2); let key1 = Keypair::new(); let key2 = Keypair::new(); let parent = Arc::new(Bank::new(&genesis_config)); let tx = system_transaction::transfer(&mint_keypair, &key1.pubkey(), 1, genesis_config.hash()); assert_eq!(parent.process_transaction(&tx), Ok(())); let bank = new_from_parent(&parent); let tx = system_transaction::transfer(&key1, &key2.pubkey(), 1, genesis_config.hash()); assert_eq!(bank.process_transaction(&tx), Ok(())); assert_eq!(parent.get_signature_status(&tx.signatures[0]), None); } #[test] fn test_bank_hash_internal_state() { let (genesis_config, mint_keypair) = create_genesis_config(2_000); let bank0 = Bank::new(&genesis_config); let bank1 = Bank::new(&genesis_config); let initial_state = bank0.hash_internal_state(); assert_eq!(bank1.hash_internal_state(), initial_state); let pubkey = Pubkey::new_rand(); bank0.transfer(1_000, &mint_keypair, &pubkey).unwrap(); assert_ne!(bank0.hash_internal_state(), initial_state); bank1.transfer(1_000, &mint_keypair, &pubkey).unwrap(); assert_eq!(bank0.hash_internal_state(), bank1.hash_internal_state()); // Checkpointing should always result in a new state let bank2 = new_from_parent(&Arc::new(bank1)); assert_ne!(bank0.hash_internal_state(), bank2.hash_internal_state()); let pubkey2 = Pubkey::new_rand(); info!("transfer 2 {}", pubkey2); bank2.transfer(10, &mint_keypair, &pubkey2).unwrap(); bank2.update_accounts_hash(); assert!(bank2.verify_bank_hash()); } #[test] fn test_bank_hash_internal_state_verify() { solana_logger::setup(); let (genesis_config, mint_keypair) = create_genesis_config(2_000); let bank0 = Bank::new(&genesis_config); let pubkey = Pubkey::new_rand(); info!("transfer 0 {} mint: {}", pubkey, mint_keypair.pubkey()); bank0.transfer(1_000, &mint_keypair, &pubkey).unwrap(); let bank0_state = bank0.hash_internal_state(); let bank0 = Arc::new(bank0); // Checkpointing should result in a new state while freezing the parent let bank2 = Bank::new_from_parent(&bank0, &Pubkey::new_rand(), 1); assert_ne!(bank0_state, bank2.hash_internal_state()); // Checkpointing should modify the checkpoint's state when freezed assert_ne!(bank0_state, bank0.hash_internal_state()); // Checkpointing should never modify the checkpoint's state once frozen let bank0_state = bank0.hash_internal_state(); bank2.update_accounts_hash(); assert!(bank2.verify_bank_hash()); let bank3 = Bank::new_from_parent(&bank0, &Pubkey::new_rand(), 2); assert_eq!(bank0_state, bank0.hash_internal_state()); assert!(bank2.verify_bank_hash()); bank3.update_accounts_hash(); assert!(bank3.verify_bank_hash()); let pubkey2 = Pubkey::new_rand(); info!("transfer 2 {}", pubkey2); bank2.transfer(10, &mint_keypair, &pubkey2).unwrap(); bank2.update_accounts_hash(); assert!(bank2.verify_bank_hash()); assert!(bank3.verify_bank_hash()); } #[test] #[should_panic(expected = "assertion failed: self.is_frozen()")] fn test_verify_hash_unfrozen() { let (genesis_config, _mint_keypair) = create_genesis_config(2_000); let bank = Bank::new(&genesis_config); assert!(bank.verify_hash()); } #[test] fn test_verify_snapshot_bank() { let pubkey = Pubkey::new_rand(); let (genesis_config, mint_keypair) = create_genesis_config(2_000); let bank = Bank::new(&genesis_config); bank.transfer(1_000, &mint_keypair, &pubkey).unwrap(); bank.freeze(); bank.update_accounts_hash(); assert!(bank.verify_snapshot_bank()); // tamper the bank after freeze! bank.increment_signature_count(1); assert!(!bank.verify_snapshot_bank()); } // Test that two bank forks with the same accounts should not hash to the same value. #[test] fn test_bank_hash_internal_state_same_account_different_fork() { solana_logger::setup(); let (genesis_config, mint_keypair) = create_genesis_config(2_000); let bank0 = Arc::new(Bank::new(&genesis_config)); let initial_state = bank0.hash_internal_state(); let bank1 = Bank::new_from_parent(&bank0.clone(), &Pubkey::default(), 1); assert_ne!(bank1.hash_internal_state(), initial_state); info!("transfer bank1"); let pubkey = Pubkey::new_rand(); bank1.transfer(1_000, &mint_keypair, &pubkey).unwrap(); assert_ne!(bank1.hash_internal_state(), initial_state); info!("transfer bank2"); // bank2 should not hash the same as bank1 let bank2 = Bank::new_from_parent(&bank0, &Pubkey::default(), 2); bank2.transfer(1_000, &mint_keypair, &pubkey).unwrap(); assert_ne!(bank2.hash_internal_state(), initial_state); assert_ne!(bank1.hash_internal_state(), bank2.hash_internal_state()); } #[test] fn test_hash_internal_state_genesis() { let bank0 = Bank::new(&create_genesis_config(10).0); let bank1 = Bank::new(&create_genesis_config(20).0); assert_ne!(bank0.hash_internal_state(), bank1.hash_internal_state()); } // See that the order of two transfers does not affect the result // of hash_internal_state #[test] fn test_hash_internal_state_order() { let (genesis_config, mint_keypair) = create_genesis_config(100); let bank0 = Bank::new(&genesis_config); let bank1 = Bank::new(&genesis_config); assert_eq!(bank0.hash_internal_state(), bank1.hash_internal_state()); let key0 = Pubkey::new_rand(); let key1 = Pubkey::new_rand(); bank0.transfer(10, &mint_keypair, &key0).unwrap(); bank0.transfer(20, &mint_keypair, &key1).unwrap(); bank1.transfer(20, &mint_keypair, &key1).unwrap(); bank1.transfer(10, &mint_keypair, &key0).unwrap(); assert_eq!(bank0.hash_internal_state(), bank1.hash_internal_state()); } #[test] fn test_hash_internal_state_error() { solana_logger::setup(); let (genesis_config, mint_keypair) = create_genesis_config(100); let bank = Bank::new(&genesis_config); let key0 = Pubkey::new_rand(); bank.transfer(10, &mint_keypair, &key0).unwrap(); let orig = bank.hash_internal_state(); // Transfer will error but still take a fee assert!(bank.transfer(1000, &mint_keypair, &key0).is_err()); assert_ne!(orig, bank.hash_internal_state()); let orig = bank.hash_internal_state(); let empty_keypair = Keypair::new(); assert!(bank.transfer(1000, &empty_keypair, &key0).is_err()); assert_eq!(orig, bank.hash_internal_state()); } #[test] fn test_bank_hash_internal_state_squash() { let collector_id = Pubkey::default(); let bank0 = Arc::new(Bank::new(&create_genesis_config(10).0)); let hash0 = bank0.hash_internal_state(); // save hash0 because new_from_parent // updates sysvar entries let bank1 = Bank::new_from_parent(&bank0, &collector_id, 1); // no delta in bank1, hashes should always update assert_ne!(hash0, bank1.hash_internal_state()); // remove parent bank1.squash(); assert!(bank1.parents().is_empty()); } /// Verifies that last ids and accounts are correctly referenced from parent #[test] fn test_bank_squash() { solana_logger::setup(); let (genesis_config, mint_keypair) = create_genesis_config(2); let key1 = Keypair::new(); let key2 = Keypair::new(); let parent = Arc::new(Bank::new(&genesis_config)); let tx_transfer_mint_to_1 = system_transaction::transfer(&mint_keypair, &key1.pubkey(), 1, genesis_config.hash()); trace!("parent process tx "); assert_eq!(parent.process_transaction(&tx_transfer_mint_to_1), Ok(())); trace!("done parent process tx "); assert_eq!(parent.transaction_count(), 1); assert_eq!( parent.get_signature_status(&tx_transfer_mint_to_1.signatures[0]), Some(Ok(())) ); trace!("new from parent"); let bank = new_from_parent(&parent); trace!("done new from parent"); assert_eq!( bank.get_signature_status(&tx_transfer_mint_to_1.signatures[0]), Some(Ok(())) ); assert_eq!(bank.transaction_count(), parent.transaction_count()); let tx_transfer_1_to_2 = system_transaction::transfer(&key1, &key2.pubkey(), 1, genesis_config.hash()); assert_eq!(bank.process_transaction(&tx_transfer_1_to_2), Ok(())); assert_eq!(bank.transaction_count(), 2); assert_eq!(parent.transaction_count(), 1); assert_eq!( parent.get_signature_status(&tx_transfer_1_to_2.signatures[0]), None ); for _ in 0..3 { // first time these should match what happened above, assert that parents are ok assert_eq!(bank.get_balance(&key1.pubkey()), 0); assert_eq!(bank.get_account(&key1.pubkey()), None); assert_eq!(bank.get_balance(&key2.pubkey()), 1); trace!("start"); assert_eq!( bank.get_signature_status(&tx_transfer_mint_to_1.signatures[0]), Some(Ok(())) ); assert_eq!( bank.get_signature_status(&tx_transfer_1_to_2.signatures[0]), Some(Ok(())) ); // works iteration 0, no-ops on iteration 1 and 2 trace!("SQUASH"); bank.squash(); assert_eq!(parent.transaction_count(), 1); assert_eq!(bank.transaction_count(), 2); } } #[test] fn test_bank_get_account_in_parent_after_squash() { let (genesis_config, mint_keypair) = create_genesis_config(500); let parent = Arc::new(Bank::new(&genesis_config)); let key1 = Keypair::new(); parent.transfer(1, &mint_keypair, &key1.pubkey()).unwrap(); assert_eq!(parent.get_balance(&key1.pubkey()), 1); let bank = new_from_parent(&parent); bank.squash(); assert_eq!(parent.get_balance(&key1.pubkey()), 1); } #[test] fn test_bank_get_account_in_parent_after_squash2() { solana_logger::setup(); let (genesis_config, mint_keypair) = create_genesis_config(500); let bank0 = Arc::new(Bank::new(&genesis_config)); let key1 = Keypair::new(); bank0.transfer(1, &mint_keypair, &key1.pubkey()).unwrap(); assert_eq!(bank0.get_balance(&key1.pubkey()), 1); let bank1 = Arc::new(Bank::new_from_parent(&bank0, &Pubkey::default(), 1)); bank1.transfer(3, &mint_keypair, &key1.pubkey()).unwrap(); let bank2 = Arc::new(Bank::new_from_parent(&bank0, &Pubkey::default(), 2)); bank2.transfer(2, &mint_keypair, &key1.pubkey()).unwrap(); let bank3 = Arc::new(Bank::new_from_parent(&bank1, &Pubkey::default(), 3)); bank1.squash(); // This picks up the values from 1 which is the highest root: // TODO: if we need to access rooted banks older than this, // need to fix the lookup. assert_eq!(bank0.get_balance(&key1.pubkey()), 4); assert_eq!(bank3.get_balance(&key1.pubkey()), 4); assert_eq!(bank2.get_balance(&key1.pubkey()), 3); bank3.squash(); assert_eq!(bank1.get_balance(&key1.pubkey()), 4); let bank4 = Arc::new(Bank::new_from_parent(&bank3, &Pubkey::default(), 4)); bank4.transfer(4, &mint_keypair, &key1.pubkey()).unwrap(); assert_eq!(bank4.get_balance(&key1.pubkey()), 8); assert_eq!(bank3.get_balance(&key1.pubkey()), 4); bank4.squash(); let bank5 = Arc::new(Bank::new_from_parent(&bank4, &Pubkey::default(), 5)); bank5.squash(); let bank6 = Arc::new(Bank::new_from_parent(&bank5, &Pubkey::default(), 6)); bank6.squash(); // This picks up the values from 4 which is the highest root: // TODO: if we need to access rooted banks older than this, // need to fix the lookup. assert_eq!(bank3.get_balance(&key1.pubkey()), 8); assert_eq!(bank2.get_balance(&key1.pubkey()), 8); assert_eq!(bank4.get_balance(&key1.pubkey()), 8); } #[test] fn test_bank_get_account_modified_since_parent() { let pubkey = Pubkey::new_rand(); let (genesis_config, mint_keypair) = create_genesis_config(500); let bank1 = Arc::new(Bank::new(&genesis_config)); bank1.transfer(1, &mint_keypair, &pubkey).unwrap(); let result = bank1.get_account_modified_since_parent(&pubkey); assert!(result.is_some()); let (account, slot) = result.unwrap(); assert_eq!(account.lamports, 1); assert_eq!(slot, 0); let bank2 = Arc::new(Bank::new_from_parent(&bank1, &Pubkey::default(), 1)); assert!(bank2.get_account_modified_since_parent(&pubkey).is_none()); bank2.transfer(100, &mint_keypair, &pubkey).unwrap(); let result = bank1.get_account_modified_since_parent(&pubkey); assert!(result.is_some()); let (account, slot) = result.unwrap(); assert_eq!(account.lamports, 1); assert_eq!(slot, 0); let result = bank2.get_account_modified_since_parent(&pubkey); assert!(result.is_some()); let (account, slot) = result.unwrap(); assert_eq!(account.lamports, 101); assert_eq!(slot, 1); bank1.squash(); let bank3 = Bank::new_from_parent(&bank2, &Pubkey::default(), 3); assert_eq!(None, bank3.get_account_modified_since_parent(&pubkey)); } #[test] fn test_bank_update_sysvar_account() { use sysvar::clock::Clock; let dummy_clock_id = Pubkey::new_rand(); let (genesis_config, _mint_keypair) = create_genesis_config(500); let expected_previous_slot = 3; let expected_next_slot = expected_previous_slot + 1; // First, initialize the clock sysvar let bank1 = Arc::new(Bank::new(&genesis_config)); bank1.update_sysvar_account(&dummy_clock_id, |optional_account| { assert!(optional_account.is_none()); Clock { slot: expected_previous_slot, ..Clock::default() } .create_account(1) }); let current_account = bank1.get_account(&dummy_clock_id).unwrap(); assert_eq!( expected_previous_slot, Clock::from_account(¤t_account).unwrap().slot ); // Updating should increment the clock's slot let bank2 = Arc::new(Bank::new_from_parent(&bank1, &Pubkey::default(), 1)); bank2.update_sysvar_account(&dummy_clock_id, |optional_account| { let slot = Clock::from_account(optional_account.as_ref().unwrap()) .unwrap() .slot + 1; Clock { slot, ..Clock::default() } .create_account(1) }); let current_account = bank2.get_account(&dummy_clock_id).unwrap(); //let added_bank_hash = BankHash::from_hash(¤t_account.hash); assert_eq!( expected_next_slot, Clock::from_account(¤t_account).unwrap().slot ); // Updating again should give bank1's sysvar to the closure not bank2's. // Thus, assert with same expected_next_slot as previously bank2.update_sysvar_account(&dummy_clock_id, |optional_account| { let slot = Clock::from_account(optional_account.as_ref().unwrap()) .unwrap() .slot + 1; Clock { slot, ..Clock::default() } .create_account(1) }); let current_account = bank2.get_account(&dummy_clock_id).unwrap(); assert_eq!( expected_next_slot, Clock::from_account(¤t_account).unwrap().slot ); } #[test] fn test_bank_epoch_vote_accounts() { let leader_pubkey = Pubkey::new_rand(); let leader_lamports = 3; let mut genesis_config = create_genesis_config_with_leader(5, &leader_pubkey, leader_lamports).genesis_config; // set this up weird, forces future generation, odd mod(), etc. // this says: "vote_accounts for epoch X should be generated at slot index 3 in epoch X-2... const SLOTS_PER_EPOCH: u64 = MINIMUM_SLOTS_PER_EPOCH as u64; const LEADER_SCHEDULE_SLOT_OFFSET: u64 = SLOTS_PER_EPOCH * 3 - 3; // no warmup allows me to do the normal division stuff below genesis_config.epoch_schedule = EpochSchedule::custom(SLOTS_PER_EPOCH, LEADER_SCHEDULE_SLOT_OFFSET, false); let parent = Arc::new(Bank::new(&genesis_config)); let mut leader_vote_stake: Vec<_> = parent .epoch_vote_accounts(0) .map(|accounts| { accounts .iter() .filter_map(|(pubkey, (stake, account))| { if let Ok(vote_state) = VoteState::deserialize(&account.data) { if vote_state.node_pubkey == leader_pubkey { Some((*pubkey, *stake)) } else { None } } else { None } }) .collect() }) .unwrap(); assert_eq!(leader_vote_stake.len(), 1); let (leader_vote_account, leader_stake) = leader_vote_stake.pop().unwrap(); assert!(leader_stake > 0); let leader_stake = Stake { delegation: Delegation { stake: leader_lamports, activation_epoch: std::u64::MAX, // bootstrap ..Delegation::default() }, ..Stake::default() }; let mut epoch = 1; loop { if epoch > LEADER_SCHEDULE_SLOT_OFFSET / SLOTS_PER_EPOCH { break; } let vote_accounts = parent.epoch_vote_accounts(epoch); assert!(vote_accounts.is_some()); // epoch_stakes are a snapshot at the leader_schedule_slot_offset boundary // in the prior epoch (0 in this case) assert_eq!( leader_stake.stake(0, None), vote_accounts.unwrap().get(&leader_vote_account).unwrap().0 ); epoch += 1; } // child crosses epoch boundary and is the first slot in the epoch let child = Bank::new_from_parent( &parent, &leader_pubkey, SLOTS_PER_EPOCH - (LEADER_SCHEDULE_SLOT_OFFSET % SLOTS_PER_EPOCH), ); assert!(child.epoch_vote_accounts(epoch).is_some()); assert_eq!( leader_stake.stake(child.epoch(), None), child .epoch_vote_accounts(epoch) .unwrap() .get(&leader_vote_account) .unwrap() .0 ); // child crosses epoch boundary but isn't the first slot in the epoch, still // makes an epoch stakes snapshot at 1 let child = Bank::new_from_parent( &parent, &leader_pubkey, SLOTS_PER_EPOCH - (LEADER_SCHEDULE_SLOT_OFFSET % SLOTS_PER_EPOCH) + 1, ); assert!(child.epoch_vote_accounts(epoch).is_some()); assert_eq!( leader_stake.stake(child.epoch(), None), child .epoch_vote_accounts(epoch) .unwrap() .get(&leader_vote_account) .unwrap() .0 ); } #[test] fn test_zero_signatures() { solana_logger::setup(); let (genesis_config, mint_keypair) = create_genesis_config(500); let mut bank = Bank::new(&genesis_config); bank.fee_calculator.lamports_per_signature = 2; let key = Keypair::new(); let mut transfer_instruction = system_instruction::transfer(&mint_keypair.pubkey(), &key.pubkey(), 0); transfer_instruction.accounts[0].is_signer = false; let tx = Transaction::new_signed_instructions( &Vec::<&Keypair>::new(), &[transfer_instruction], bank.last_blockhash(), ); assert_eq!(bank.process_transaction(&tx), Ok(())); assert_eq!(bank.get_balance(&key.pubkey()), 0); } #[test] fn test_bank_get_slots_in_epoch() { let (genesis_config, _) = create_genesis_config(500); let bank = Bank::new(&genesis_config); assert_eq!(bank.get_slots_in_epoch(0), MINIMUM_SLOTS_PER_EPOCH as u64); assert_eq!( bank.get_slots_in_epoch(2), (MINIMUM_SLOTS_PER_EPOCH * 4) as u64 ); assert_eq!( bank.get_slots_in_epoch(5000), genesis_config.epoch_schedule.slots_per_epoch ); } #[test] fn test_bank_entered_epoch_callback() { let (genesis_config, _) = create_genesis_config(500); let bank0 = Arc::new(Bank::new(&genesis_config)); let callback_count = Arc::new(AtomicU64::new(0)); bank0.set_entered_epoch_callback({ let callback_count = callback_count.clone(); //Box::new(move |_bank: &mut Bank| { Box::new(move |_| { callback_count.fetch_add(1, Ordering::SeqCst); }) }); let _bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), bank0.get_slots_in_epoch(0) - 1); // No callback called while within epoch 0 assert_eq!(callback_count.load(Ordering::SeqCst), 0); let _bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), bank0.get_slots_in_epoch(0)); // Callback called as bank1 is in epoch 1 assert_eq!(callback_count.load(Ordering::SeqCst), 1); callback_count.store(0, Ordering::SeqCst); let _bank1 = Bank::new_from_parent( &bank0, &Pubkey::default(), std::u64::MAX / bank0.ticks_per_slot - 1, ); // If the new bank jumps ahead multiple epochs the callback is still only called once. // This was done to keep the callback implementation simpler as new bank will never jump // cross multiple epochs in a real deployment. assert_eq!(callback_count.load(Ordering::SeqCst), 1); } #[test] fn test_is_delta_true() { let (genesis_config, mint_keypair) = create_genesis_config(500); let bank = Arc::new(Bank::new(&genesis_config)); let key1 = Keypair::new(); let tx_transfer_mint_to_1 = system_transaction::transfer(&mint_keypair, &key1.pubkey(), 1, genesis_config.hash()); assert_eq!(bank.process_transaction(&tx_transfer_mint_to_1), Ok(())); assert_eq!(bank.is_delta.load(Ordering::Relaxed), true); let bank1 = new_from_parent(&bank); let hash1 = bank1.hash_internal_state(); assert_eq!(bank1.is_delta.load(Ordering::Relaxed), false); assert_ne!(hash1, bank.hash()); // ticks don't make a bank into a delta or change its state unless a block boundary is crossed bank1.register_tick(&Hash::default()); assert_eq!(bank1.is_delta.load(Ordering::Relaxed), false); assert_eq!(bank1.hash_internal_state(), hash1); } #[test] fn test_is_empty() { let (genesis_config, mint_keypair) = create_genesis_config(500); let bank0 = Arc::new(Bank::new(&genesis_config)); let key1 = Keypair::new(); // The zeroth bank is empty becasue there are no transactions assert_eq!(bank0.is_empty(), true); // Set is_delta to true, bank is no longer empty let tx_transfer_mint_to_1 = system_transaction::transfer(&mint_keypair, &key1.pubkey(), 1, genesis_config.hash()); assert_eq!(bank0.process_transaction(&tx_transfer_mint_to_1), Ok(())); assert_eq!(bank0.is_empty(), false); } #[test] fn test_bank_inherit_tx_count() { let (genesis_config, mint_keypair) = create_genesis_config(500); let bank0 = Arc::new(Bank::new(&genesis_config)); // Bank 1 let bank1 = Arc::new(Bank::new_from_parent(&bank0, &Pubkey::new_rand(), 1)); // Bank 2 let bank2 = Bank::new_from_parent(&bank0, &Pubkey::new_rand(), 2); // transfer a token assert_eq!( bank1.process_transaction(&system_transaction::transfer( &mint_keypair, &Keypair::new().pubkey(), 1, genesis_config.hash(), )), Ok(()) ); assert_eq!(bank0.transaction_count(), 0); assert_eq!(bank2.transaction_count(), 0); assert_eq!(bank1.transaction_count(), 1); bank1.squash(); assert_eq!(bank0.transaction_count(), 0); assert_eq!(bank2.transaction_count(), 0); assert_eq!(bank1.transaction_count(), 1); let bank6 = Bank::new_from_parent(&bank1, &Pubkey::new_rand(), 3); assert_eq!(bank1.transaction_count(), 1); assert_eq!(bank6.transaction_count(), 1); bank6.squash(); assert_eq!(bank6.transaction_count(), 1); } #[test] fn test_bank_inherit_fee_rate_governor() { let (mut genesis_config, _mint_keypair) = create_genesis_config(500); genesis_config .fee_rate_governor .target_lamports_per_signature = 123; let bank0 = Arc::new(Bank::new(&genesis_config)); let bank1 = Arc::new(new_from_parent(&bank0)); assert_eq!( bank0.fee_rate_governor.target_lamports_per_signature / 2, bank1 .fee_rate_governor .create_fee_calculator() .lamports_per_signature ); } #[test] fn test_bank_vote_accounts() { let GenesisConfigInfo { genesis_config, mint_keypair, .. } = create_genesis_config_with_leader(500, &Pubkey::new_rand(), 1); let bank = Arc::new(Bank::new(&genesis_config)); let vote_accounts = bank.vote_accounts(); assert_eq!(vote_accounts.len(), 1); // bootstrap validator has // to have a vote account let vote_keypair = Keypair::new(); let instructions = vote_instruction::create_account( &mint_keypair.pubkey(), &vote_keypair.pubkey(), &VoteInit { node_pubkey: mint_keypair.pubkey(), authorized_voter: vote_keypair.pubkey(), authorized_withdrawer: vote_keypair.pubkey(), commission: 0, }, 10, ); let transaction = Transaction::new_signed_instructions( &[&mint_keypair, &vote_keypair], &instructions, bank.last_blockhash(), ); bank.process_transaction(&transaction).unwrap(); let vote_accounts = bank.vote_accounts(); assert_eq!(vote_accounts.len(), 2); assert!(vote_accounts.get(&vote_keypair.pubkey()).is_some()); assert!(bank.withdraw(&vote_keypair.pubkey(), 10).is_ok()); let vote_accounts = bank.vote_accounts(); assert_eq!(vote_accounts.len(), 1); } #[test] fn test_bank_stake_delegations() { let GenesisConfigInfo { genesis_config, mint_keypair, .. } = create_genesis_config_with_leader(500, &Pubkey::new_rand(), 1); let bank = Arc::new(Bank::new(&genesis_config)); let stake_delegations = bank.stake_delegations(); assert_eq!(stake_delegations.len(), 1); // bootstrap validator has // to have a stake delegation let vote_keypair = Keypair::new(); let mut instructions = vote_instruction::create_account( &mint_keypair.pubkey(), &vote_keypair.pubkey(), &VoteInit { node_pubkey: mint_keypair.pubkey(), authorized_voter: vote_keypair.pubkey(), authorized_withdrawer: vote_keypair.pubkey(), commission: 0, }, 10, ); let stake_keypair = Keypair::new(); instructions.extend(stake_instruction::create_account_and_delegate_stake( &mint_keypair.pubkey(), &stake_keypair.pubkey(), &vote_keypair.pubkey(), &Authorized::auto(&stake_keypair.pubkey()), &Lockup::default(), 10, )); let transaction = Transaction::new_signed_instructions( &[&mint_keypair, &vote_keypair, &stake_keypair], &instructions, bank.last_blockhash(), ); bank.process_transaction(&transaction).unwrap(); let stake_delegations = bank.stake_delegations(); assert_eq!(stake_delegations.len(), 2); assert!(stake_delegations.get(&stake_keypair.pubkey()).is_some()); } #[test] fn test_bank_fees_account() { let (mut genesis_config, _) = create_genesis_config(500); genesis_config.fee_rate_governor = FeeRateGovernor::new(12345, 0); let bank = Arc::new(Bank::new(&genesis_config)); let fees_account = bank.get_account(&sysvar::fees::id()).unwrap(); let fees = Fees::from_account(&fees_account).unwrap(); assert_eq!( bank.fee_calculator.lamports_per_signature, fees.fee_calculator.lamports_per_signature ); assert_eq!(fees.fee_calculator.lamports_per_signature, 12345); } #[test] fn test_is_delta_with_no_committables() { let (genesis_config, mint_keypair) = create_genesis_config(8000); let bank = Bank::new(&genesis_config); bank.is_delta.store(false, Ordering::Relaxed); let keypair1 = Keypair::new(); let keypair2 = Keypair::new(); let fail_tx = system_transaction::transfer(&keypair1, &keypair2.pubkey(), 1, bank.last_blockhash()); // Should fail with TransactionError::AccountNotFound, which means // the account which this tx operated on will not be committed. Thus // the bank is_delta should still be false assert_eq!( bank.process_transaction(&fail_tx), Err(TransactionError::AccountNotFound) ); // Check the bank is_delta is still false assert!(!bank.is_delta.load(Ordering::Relaxed)); // Should fail with InstructionError, but InstructionErrors are committable, // so is_delta should be true assert_eq!( bank.transfer(10_001, &mint_keypair, &Pubkey::new_rand()), Err(TransactionError::InstructionError( 0, InstructionError::new_result_with_negative_lamports(), )) ); assert!(bank.is_delta.load(Ordering::Relaxed)); } #[test] fn test_bank_serialize() { solana_logger::setup(); let (genesis_config, _) = create_genesis_config(500); let bank0 = Arc::new(Bank::new(&genesis_config)); let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1); bank0.squash(); // Create an account on a non-root fork let key1 = Keypair::new(); bank1.deposit(&key1.pubkey(), 5); let bank2 = Bank::new_from_parent(&bank0, &Pubkey::default(), 2); // Test new account let key2 = Keypair::new(); bank2.deposit(&key2.pubkey(), 10); assert_eq!(bank2.get_balance(&key2.pubkey()), 10); let key3 = Keypair::new(); bank2.deposit(&key3.pubkey(), 0); bank2.squash(); let snapshot_storages = bank2.get_snapshot_storages(); let rc_serialize = BankRcSerialize { bank_rc: &bank2.rc, snapshot_storages: &snapshot_storages, }; let len = serialized_size(&bank2).unwrap() + serialized_size(&rc_serialize).unwrap(); let mut buf = vec![0u8; len as usize]; let mut writer = Cursor::new(&mut buf[..]); serialize_into(&mut writer, &bank2).unwrap(); serialize_into(&mut writer, &rc_serialize).unwrap(); let mut rdr = Cursor::new(&buf[..]); let mut dbank: Bank = deserialize_from_snapshot(&mut rdr).unwrap(); let mut reader = BufReader::new(&buf[rdr.position() as usize..]); // Create a new set of directories for this bank's accounts let (_accounts_dir, dbank_paths) = get_temp_accounts_paths(4).unwrap(); let ref_sc = StatusCacheRc::default(); ref_sc.status_cache.write().unwrap().add_root(2); // Create a directory to simulate AppendVecs unpackaged from a snapshot tar let copied_accounts = TempDir::new().unwrap(); copy_append_vecs(&bank2.rc.accounts.accounts_db, copied_accounts.path()).unwrap(); dbank.set_bank_rc( BankRc::from_stream( &dbank_paths, dbank.slot(), &dbank.ancestors, &[], &mut reader, copied_accounts.path(), ) .unwrap(), ref_sc, ); assert_eq!(dbank.get_balance(&key1.pubkey()), 0); assert_eq!(dbank.get_balance(&key2.pubkey()), 10); assert_eq!(dbank.get_balance(&key3.pubkey()), 0); bank2.compare_bank(&dbank); } #[test] fn test_check_point_values() { let (genesis_config, _) = create_genesis_config(500); let bank = Arc::new(Bank::new(&genesis_config)); // check that point values are 0 if no previous value was known and current values are not normal assert_eq!( bank.check_point_values(std::f64::INFINITY, std::f64::NAN), (0.0, 0.0) ); bank.store_account( &sysvar::rewards::id(), &sysvar::rewards::create_account(1, 1.0, 1.0), ); // check that point values are the previous value if current values are not normal assert_eq!( bank.check_point_values(std::f64::INFINITY, std::f64::NAN), (1.0, 1.0) ); } #[test] fn test_bank_get_program_accounts() { let (genesis_config, mint_keypair) = create_genesis_config(500); let parent = Arc::new(Bank::new(&genesis_config)); let genesis_accounts: Vec<_> = parent.get_program_accounts(None); assert!( genesis_accounts .iter() .any(|(pubkey, _)| *pubkey == mint_keypair.pubkey()), "mint pubkey not found" ); assert!( genesis_accounts .iter() .any(|(pubkey, _)| solana_sdk::sysvar::is_sysvar_id(pubkey)), "no sysvars found" ); let bank0 = Arc::new(new_from_parent(&parent)); let pubkey0 = Pubkey::new_rand(); let program_id = Pubkey::new(&[2; 32]); let account0 = Account::new(1, 0, &program_id); bank0.store_account(&pubkey0, &account0); assert_eq!( bank0.get_program_accounts_modified_since_parent(&program_id), vec![(pubkey0, account0.clone())] ); let bank1 = Arc::new(new_from_parent(&bank0)); bank1.squash(); assert_eq!( bank0.get_program_accounts(Some(&program_id)), vec![(pubkey0, account0.clone())] ); assert_eq!( bank1.get_program_accounts(Some(&program_id)), vec![(pubkey0, account0.clone())] ); assert_eq!( bank1.get_program_accounts_modified_since_parent(&program_id), vec![] ); let bank2 = Arc::new(new_from_parent(&bank1)); let pubkey1 = Pubkey::new_rand(); let account1 = Account::new(3, 0, &program_id); bank2.store_account(&pubkey1, &account1); // Accounts with 0 lamports should be filtered out by Accounts::load_by_program() let pubkey2 = Pubkey::new_rand(); let account2 = Account::new(0, 0, &program_id); bank2.store_account(&pubkey2, &account2); let bank3 = Arc::new(new_from_parent(&bank2)); bank3.squash(); assert_eq!(bank1.get_program_accounts(Some(&program_id)).len(), 2); assert_eq!(bank3.get_program_accounts(Some(&program_id)).len(), 2); } #[test] fn test_status_cache_ancestors() { let (genesis_config, _mint_keypair) = create_genesis_config(500); let parent = Arc::new(Bank::new(&genesis_config)); let bank1 = Arc::new(new_from_parent(&parent)); let mut bank = bank1; for _ in 0..MAX_CACHE_ENTRIES * 2 { bank = Arc::new(new_from_parent(&bank)); bank.squash(); } let bank = new_from_parent(&bank); assert_eq!( bank.status_cache_ancestors(), (bank.slot() - MAX_CACHE_ENTRIES as u64..=bank.slot()).collect::>() ); } #[test] fn test_add_instruction_processor() { let (genesis_config, mint_keypair) = create_genesis_config(500); let mut bank = Bank::new(&genesis_config); fn mock_vote_processor( program_id: &Pubkey, _keyed_accounts: &[KeyedAccount], _instruction_data: &[u8], ) -> std::result::Result<(), InstructionError> { if !solana_vote_program::check_id(program_id) { return Err(InstructionError::IncorrectProgramId); } Err(InstructionError::Custom(42)) } assert!(bank.get_account(&solana_vote_program::id()).is_none()); bank.add_instruction_processor(solana_vote_program::id(), mock_vote_processor); assert!(bank.get_account(&solana_vote_program::id()).is_some()); let mock_account = Keypair::new(); let mock_validator_identity = Keypair::new(); let instructions = vote_instruction::create_account( &mint_keypair.pubkey(), &mock_account.pubkey(), &VoteInit { node_pubkey: mock_validator_identity.pubkey(), ..VoteInit::default() }, 1, ); let transaction = Transaction::new_signed_instructions( &[&mint_keypair, &mock_account, &mock_validator_identity], &instructions, bank.last_blockhash(), ); assert_eq!( bank.process_transaction(&transaction), Err(TransactionError::InstructionError( 1, InstructionError::Custom(42) )) ); } #[test] fn test_add_instruction_processor_for_existing_program() { let GenesisConfigInfo { genesis_config, mint_keypair, .. } = create_genesis_config_with_leader(500, &Pubkey::new_rand(), 0); let mut bank = Bank::new(&genesis_config); fn mock_vote_processor( _pubkey: &Pubkey, _ka: &[KeyedAccount], _data: &[u8], ) -> std::result::Result<(), InstructionError> { Err(InstructionError::Custom(42)) } let mock_account = Keypair::new(); let mock_validator_identity = Keypair::new(); let instructions = vote_instruction::create_account( &mint_keypair.pubkey(), &mock_account.pubkey(), &VoteInit { node_pubkey: mock_validator_identity.pubkey(), ..VoteInit::default() }, 1, ); let transaction = Transaction::new_signed_instructions( &[&mint_keypair, &mock_account, &mock_validator_identity], &instructions, bank.last_blockhash(), ); let vote_loader_account = bank.get_account(&solana_vote_program::id()).unwrap(); bank.add_instruction_processor(solana_vote_program::id(), mock_vote_processor); let new_vote_loader_account = bank.get_account(&solana_vote_program::id()).unwrap(); // Vote loader account should not be updated since it was included in the genesis config. assert_eq!(vote_loader_account.data, new_vote_loader_account.data); assert_eq!( bank.process_transaction(&transaction), Err(TransactionError::InstructionError( 1, InstructionError::Custom(42) )) ); } #[test] #[should_panic] fn test_add_instruction_processor_for_invalid_account() { let (genesis_config, mint_keypair) = create_genesis_config(500); let mut bank = Bank::new(&genesis_config); fn mock_ix_processor( _pubkey: &Pubkey, _ka: &[KeyedAccount], _data: &[u8], ) -> std::result::Result<(), InstructionError> { Err(InstructionError::Custom(42)) } // Non-native loader accounts can not be used for instruction processing bank.add_instruction_processor(mint_keypair.pubkey(), mock_ix_processor); } #[test] fn test_recent_blockhashes_sysvar() { let (genesis_config, _mint_keypair) = create_genesis_config(500); let mut bank = Arc::new(Bank::new(&genesis_config)); for i in 1..5 { let bhq_account = bank.get_account(&sysvar::recent_blockhashes::id()).unwrap(); let recent_blockhashes = sysvar::recent_blockhashes::RecentBlockhashes::from_account(&bhq_account).unwrap(); // Check length assert_eq!(recent_blockhashes.len(), i); let most_recent_hash = recent_blockhashes.iter().nth(0).unwrap().blockhash; // Check order assert_eq!(Some(true), bank.check_hash_age(&most_recent_hash, 0)); goto_end_of_slot(Arc::get_mut(&mut bank).unwrap()); bank = Arc::new(new_from_parent(&bank)); } } #[test] fn test_bank_inherit_last_vote_sync() { let (genesis_config, _) = create_genesis_config(500); let bank0 = Arc::new(Bank::new(&genesis_config)); let last_ts = bank0.last_vote_sync.load(Ordering::Relaxed); assert_eq!(last_ts, 0); bank0.last_vote_sync.store(1, Ordering::Relaxed); let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), bank0.get_slots_in_epoch(0) - 1); let last_ts = bank1.last_vote_sync.load(Ordering::Relaxed); assert_eq!(last_ts, 1); } #[test] fn test_hash_internal_state_unchanged() { let (genesis_config, _) = create_genesis_config(500); let bank0 = Arc::new(Bank::new(&genesis_config)); bank0.freeze(); let bank0_hash = bank0.hash(); let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1); bank1.freeze(); let bank1_hash = bank1.hash(); // Checkpointing should always result in a new state assert_ne!(bank0_hash, bank1_hash); } #[test] fn test_ticks_change_state() { let (genesis_config, _) = create_genesis_config(500); let bank = Arc::new(Bank::new(&genesis_config)); let bank1 = new_from_parent(&bank); let hash1 = bank1.hash_internal_state(); // ticks don't change its state unless a block boundary is crossed for _ in 0..genesis_config.ticks_per_slot { assert_eq!(bank1.hash_internal_state(), hash1); bank1.register_tick(&Hash::default()); } assert_ne!(bank1.hash_internal_state(), hash1); } #[ignore] #[test] fn test_banks_leak() { fn add_lotsa_stake_accounts(genesis_config: &mut GenesisConfig) { const LOTSA: usize = 4_096; (0..LOTSA).for_each(|_| { let pubkey = Pubkey::new_rand(); genesis_config.add_account( pubkey, solana_stake_program::stake_state::create_lockup_stake_account( &Authorized::auto(&pubkey), &Lockup::default(), &Rent::default(), 50_000_000, ), ); }); } solana_logger::setup(); let (mut genesis_config, _) = create_genesis_config(100_000_000_000_000); add_lotsa_stake_accounts(&mut genesis_config); let mut bank = std::sync::Arc::new(Bank::new(&genesis_config)); let mut num_banks = 0; let pid = std::process::id(); #[cfg(not(target_os = "linux"))] error!( "\nYou can run this to watch RAM:\n while read -p 'banks: '; do echo $(( $(ps -o vsize= -p {})/$REPLY));done", pid ); loop { num_banks += 1; bank = std::sync::Arc::new(new_from_parent(&bank)); if num_banks % 100 == 0 { #[cfg(target_os = "linux")] { let pages_consumed = std::fs::read_to_string(format!("/proc/{}/statm", pid)) .unwrap() .split_whitespace() .next() .unwrap() .parse::() .unwrap(); error!( "at {} banks: {} mem or {}kB/bank", num_banks, pages_consumed * 4096, (pages_consumed * 4) / num_banks ); } #[cfg(not(target_os = "linux"))] { error!("{} banks, sleeping for 5 sec", num_banks); std::thread::sleep(Duration::new(5, 0)); } } } } fn get_nonce_account(bank: &Bank, nonce_pubkey: &Pubkey) -> Option { bank.get_account(&nonce_pubkey).and_then(|acc| { let state = StateMut::::state(&acc).map(|v| v.convert_to_current()); match state { Ok(nonce::State::Initialized(ref data)) => Some(data.blockhash), _ => None, } }) } fn nonce_setup( bank: &mut Arc, mint_keypair: &Keypair, custodian_lamports: u64, nonce_lamports: u64, nonce_authority: Option, ) -> Result<(Keypair, Keypair)> { let custodian_keypair = Keypair::new(); let nonce_keypair = Keypair::new(); /* Setup accounts */ let mut setup_ixs = vec![system_instruction::transfer( &mint_keypair.pubkey(), &custodian_keypair.pubkey(), custodian_lamports, )]; let nonce_authority = nonce_authority.unwrap_or(nonce_keypair.pubkey()); setup_ixs.extend_from_slice(&system_instruction::create_nonce_account( &custodian_keypair.pubkey(), &nonce_keypair.pubkey(), &nonce_authority, nonce_lamports, )); let setup_tx = Transaction::new_signed_instructions( &[mint_keypair, &custodian_keypair, &nonce_keypair], &setup_ixs, bank.last_blockhash(), ); bank.process_transaction(&setup_tx)?; Ok((custodian_keypair, nonce_keypair)) } fn setup_nonce_with_bank( supply_lamports: u64, mut genesis_cfg_fn: F, custodian_lamports: u64, nonce_lamports: u64, nonce_authority: Option, ) -> Result<(Arc, Keypair, Keypair, Keypair)> where F: FnMut(&mut GenesisConfig), { let (mut genesis_config, mint_keypair) = create_genesis_config(supply_lamports); genesis_config.rent.lamports_per_byte_year = 0; genesis_cfg_fn(&mut genesis_config); let mut bank = Arc::new(Bank::new(&genesis_config)); // Banks 0 and 1 have no fees, wait two blocks before // initializing our nonce accounts for _ in 0..2 { goto_end_of_slot(Arc::get_mut(&mut bank).unwrap()); bank = Arc::new(new_from_parent(&bank)); } let (custodian_keypair, nonce_keypair) = nonce_setup( &mut bank, &mint_keypair, custodian_lamports, nonce_lamports, nonce_authority, )?; Ok((bank, mint_keypair, custodian_keypair, nonce_keypair)) } #[test] fn test_check_tx_durable_nonce_ok() { let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(10_000_000, |_| {}, 5_000_000, 250_000, None).unwrap(); let custodian_pubkey = custodian_keypair.pubkey(); let nonce_pubkey = nonce_keypair.pubkey(); let nonce_hash = get_nonce_account(&bank, &nonce_pubkey).unwrap(); let tx = Transaction::new_signed_with_payer( &[ system_instruction::advance_nonce_account(&nonce_pubkey, &nonce_pubkey), system_instruction::transfer(&custodian_pubkey, &nonce_pubkey, 100_000), ], Some(&custodian_pubkey), &[&custodian_keypair, &nonce_keypair], nonce_hash, ); let nonce_account = bank.get_account(&nonce_pubkey).unwrap(); assert_eq!( bank.check_tx_durable_nonce(&tx), Some((nonce_pubkey, nonce_account)) ); } #[test] fn test_check_tx_durable_nonce_not_durable_nonce_fail() { let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(10_000_000, |_| {}, 5_000_000, 250_000, None).unwrap(); let custodian_pubkey = custodian_keypair.pubkey(); let nonce_pubkey = nonce_keypair.pubkey(); let nonce_hash = get_nonce_account(&bank, &nonce_pubkey).unwrap(); let tx = Transaction::new_signed_with_payer( &[ system_instruction::transfer(&custodian_pubkey, &nonce_pubkey, 100_000), system_instruction::advance_nonce_account(&nonce_pubkey, &nonce_pubkey), ], Some(&custodian_pubkey), &[&custodian_keypair, &nonce_keypair], nonce_hash, ); assert!(bank.check_tx_durable_nonce(&tx).is_none()); } #[test] fn test_check_tx_durable_nonce_missing_ix_pubkey_fail() { let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(10_000_000, |_| {}, 5_000_000, 250_000, None).unwrap(); let custodian_pubkey = custodian_keypair.pubkey(); let nonce_pubkey = nonce_keypair.pubkey(); let nonce_hash = get_nonce_account(&bank, &nonce_pubkey).unwrap(); let mut tx = Transaction::new_signed_with_payer( &[ system_instruction::advance_nonce_account(&nonce_pubkey, &nonce_pubkey), system_instruction::transfer(&custodian_pubkey, &nonce_pubkey, 100_000), ], Some(&custodian_pubkey), &[&custodian_keypair, &nonce_keypair], nonce_hash, ); tx.message.instructions[0].accounts.clear(); assert!(bank.check_tx_durable_nonce(&tx).is_none()); } #[test] fn test_check_tx_durable_nonce_nonce_acc_does_not_exist_fail() { let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(10_000_000, |_| {}, 5_000_000, 250_000, None).unwrap(); let custodian_pubkey = custodian_keypair.pubkey(); let nonce_pubkey = nonce_keypair.pubkey(); let missing_keypair = Keypair::new(); let missing_pubkey = missing_keypair.pubkey(); let nonce_hash = get_nonce_account(&bank, &nonce_pubkey).unwrap(); let tx = Transaction::new_signed_with_payer( &[ system_instruction::advance_nonce_account(&missing_pubkey, &nonce_pubkey), system_instruction::transfer(&custodian_pubkey, &nonce_pubkey, 100_000), ], Some(&custodian_pubkey), &[&custodian_keypair, &nonce_keypair], nonce_hash, ); assert!(bank.check_tx_durable_nonce(&tx).is_none()); } #[test] fn test_check_tx_durable_nonce_bad_tx_hash_fail() { let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(10_000_000, |_| {}, 5_000_000, 250_000, None).unwrap(); let custodian_pubkey = custodian_keypair.pubkey(); let nonce_pubkey = nonce_keypair.pubkey(); let tx = Transaction::new_signed_with_payer( &[ system_instruction::advance_nonce_account(&nonce_pubkey, &nonce_pubkey), system_instruction::transfer(&custodian_pubkey, &nonce_pubkey, 100_000), ], Some(&custodian_pubkey), &[&custodian_keypair, &nonce_keypair], Hash::default(), ); assert!(bank.check_tx_durable_nonce(&tx).is_none()); } #[test] fn test_assign_from_nonce_account_fail() { let (genesis_config, _mint_keypair) = create_genesis_config(100_000_000); let bank = Arc::new(Bank::new(&genesis_config)); let nonce = Keypair::new(); let nonce_account = Account::new_data( 42424242, &nonce::state::Versions::new_current(nonce::State::Initialized( nonce::state::Data::default(), )), &system_program::id(), ) .unwrap(); let blockhash = bank.last_blockhash(); bank.store_account(&nonce.pubkey(), &nonce_account); let tx = Transaction::new_signed_instructions( &[&nonce], &[system_instruction::assign( &nonce.pubkey(), &Pubkey::new(&[9u8; 32]), )], blockhash, ); let expect = Err(TransactionError::InstructionError( 0, InstructionError::ModifiedProgramId, )); assert_eq!(bank.process_transaction(&tx), expect); } #[test] fn test_durable_nonce_transaction() { let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank( 10_000_000, |gc| { gc.rent.lamports_per_byte_year; }, 5_000_000, 250_000, None, ) .unwrap(); let alice_keypair = Keypair::new(); let alice_pubkey = alice_keypair.pubkey(); let custodian_pubkey = custodian_keypair.pubkey(); let nonce_pubkey = nonce_keypair.pubkey(); assert_eq!(bank.get_balance(&custodian_pubkey), 4_750_000); assert_eq!(bank.get_balance(&nonce_pubkey), 250_000); /* Grab the hash stored in the nonce account */ let nonce_hash = get_nonce_account(&bank, &nonce_pubkey).unwrap(); /* Kick nonce hash off the blockhash_queue */ for _ in 0..MAX_RECENT_BLOCKHASHES + 1 { goto_end_of_slot(Arc::get_mut(&mut bank).unwrap()); bank = Arc::new(new_from_parent(&bank)); } /* Expect a non-Durable Nonce transfer to fail */ assert_eq!( bank.process_transaction(&system_transaction::transfer( &custodian_keypair, &alice_pubkey, 100_000, nonce_hash ),), Err(TransactionError::BlockhashNotFound), ); /* Check fee not charged */ assert_eq!(bank.get_balance(&custodian_pubkey), 4_750_000); /* Durable Nonce transfer */ let durable_tx = Transaction::new_signed_with_payer( &[ system_instruction::advance_nonce_account(&nonce_pubkey, &nonce_pubkey), system_instruction::transfer(&custodian_pubkey, &alice_pubkey, 100_000), ], Some(&custodian_pubkey), &[&custodian_keypair, &nonce_keypair], nonce_hash, ); assert_eq!(bank.process_transaction(&durable_tx), Ok(())); /* Check balances */ assert_eq!(bank.get_balance(&custodian_pubkey), 4_640_000); assert_eq!(bank.get_balance(&nonce_pubkey), 250_000); assert_eq!(bank.get_balance(&alice_pubkey), 100_000); /* Confirm stored nonce has advanced */ let new_nonce = get_nonce_account(&bank, &nonce_pubkey).unwrap(); assert_ne!(nonce_hash, new_nonce); /* Durable Nonce re-use fails */ let durable_tx = Transaction::new_signed_with_payer( &[ system_instruction::advance_nonce_account(&nonce_pubkey, &nonce_pubkey), system_instruction::transfer(&custodian_pubkey, &alice_pubkey, 100_000), ], Some(&custodian_pubkey), &[&custodian_keypair, &nonce_keypair], nonce_hash, ); assert_eq!( bank.process_transaction(&durable_tx), Err(TransactionError::BlockhashNotFound) ); /* Check fee not charged and nonce not advanced */ assert_eq!(bank.get_balance(&custodian_pubkey), 4_640_000); assert_eq!(new_nonce, get_nonce_account(&bank, &nonce_pubkey).unwrap()); let nonce_hash = new_nonce; /* Kick nonce hash off the blockhash_queue */ for _ in 0..MAX_RECENT_BLOCKHASHES + 1 { goto_end_of_slot(Arc::get_mut(&mut bank).unwrap()); bank = Arc::new(new_from_parent(&bank)); } let durable_tx = Transaction::new_signed_with_payer( &[ system_instruction::advance_nonce_account(&nonce_pubkey, &nonce_pubkey), system_instruction::transfer(&custodian_pubkey, &alice_pubkey, 100_000_000), ], Some(&custodian_pubkey), &[&custodian_keypair, &nonce_keypair], nonce_hash, ); assert_eq!( bank.process_transaction(&durable_tx), Err(TransactionError::InstructionError( 1, system_instruction::SystemError::ResultWithNegativeLamports.into() )) ); /* Check fee charged and nonce has advanced */ assert_eq!(bank.get_balance(&custodian_pubkey), 4_630_000); assert_ne!(nonce_hash, get_nonce_account(&bank, &nonce_pubkey).unwrap()); /* Confirm replaying a TX that failed with InstructionError::* now * fails with TransactionError::BlockhashNotFound */ assert_eq!( bank.process_transaction(&durable_tx), Err(TransactionError::BlockhashNotFound), ); } #[test] fn test_collect_balances() { let (genesis_config, _mint_keypair) = create_genesis_config(500); let parent = Arc::new(Bank::new(&genesis_config)); let bank0 = Arc::new(new_from_parent(&parent)); let keypair = Keypair::new(); let pubkey0 = Pubkey::new_rand(); let pubkey1 = Pubkey::new_rand(); let program_id = Pubkey::new(&[2; 32]); let keypair_account = Account::new(8, 0, &program_id); let account0 = Account::new(11, 0, &program_id); let program_account = Account::new(1, 10, &Pubkey::default()); bank0.store_account(&keypair.pubkey(), &keypair_account); bank0.store_account(&pubkey0, &account0); bank0.store_account(&program_id, &program_account); let instructions = vec![CompiledInstruction::new(1, &(), vec![0])]; let tx0 = Transaction::new_with_compiled_instructions( &[&keypair], &[pubkey0], Hash::default(), vec![program_id], instructions, ); let instructions = vec![CompiledInstruction::new(1, &(), vec![0])]; let tx1 = Transaction::new_with_compiled_instructions( &[&keypair], &[pubkey1], Hash::default(), vec![program_id], instructions, ); let balances = bank0.collect_balances(&[tx0, tx1]); assert_eq!(balances.len(), 2); assert_eq!(balances[0], vec![8, 11, 1]); assert_eq!(balances[1], vec![8, 0, 1]); } #[test] fn test_pre_post_transaction_balances() { let (mut genesis_config, _mint_keypair) = create_genesis_config(500); let fee_rate_governor = FeeRateGovernor::new(1, 0); genesis_config.fee_rate_governor = fee_rate_governor; let parent = Arc::new(Bank::new(&genesis_config)); let bank0 = Arc::new(new_from_parent(&parent)); let keypair0 = Keypair::new(); let keypair1 = Keypair::new(); let pubkey0 = Pubkey::new_rand(); let pubkey1 = Pubkey::new_rand(); let pubkey2 = Pubkey::new_rand(); let keypair0_account = Account::new(8, 0, &Pubkey::default()); let keypair1_account = Account::new(9, 0, &Pubkey::default()); let account0 = Account::new(11, 0, &&Pubkey::default()); bank0.store_account(&keypair0.pubkey(), &keypair0_account); bank0.store_account(&keypair1.pubkey(), &keypair1_account); bank0.store_account(&pubkey0, &account0); let blockhash = bank0.last_blockhash(); let tx0 = system_transaction::transfer(&keypair0, &pubkey0, 2, blockhash.clone()); let tx1 = system_transaction::transfer(&Keypair::new(), &pubkey1, 2, blockhash.clone()); let tx2 = system_transaction::transfer(&keypair1, &pubkey2, 12, blockhash.clone()); let txs = vec![tx0, tx1, tx2]; let lock_result = bank0.prepare_batch(&txs, None); let (transaction_results, transaction_balances_set) = bank0.load_execute_and_commit_transactions(&lock_result, MAX_PROCESSING_AGE, true); assert_eq!(transaction_balances_set.pre_balances.len(), 3); assert_eq!(transaction_balances_set.post_balances.len(), 3); assert!(transaction_results.processing_results[0].0.is_ok()); assert_eq!(transaction_balances_set.pre_balances[0], vec![8, 11, 1]); assert_eq!(transaction_balances_set.post_balances[0], vec![5, 13, 1]); // Failed transactions still produce balance sets // This is a TransactionError - not possible to charge fees assert!(transaction_results.processing_results[1].0.is_err()); assert_eq!(transaction_balances_set.pre_balances[1], vec![0, 0, 1]); assert_eq!(transaction_balances_set.post_balances[1], vec![0, 0, 1]); // Failed transactions still produce balance sets // This is an InstructionError - fees charged assert!(transaction_results.processing_results[2].0.is_err()); assert_eq!(transaction_balances_set.pre_balances[2], vec![9, 0, 1]); assert_eq!(transaction_balances_set.post_balances[2], vec![8, 0, 1]); } #[test] fn test_transaction_with_duplicate_accounts_in_instruction() { let (genesis_config, mint_keypair) = create_genesis_config(500); let mut bank = Bank::new(&genesis_config); fn mock_process_instruction( _program_id: &Pubkey, keyed_accounts: &[KeyedAccount], data: &[u8], ) -> result::Result<(), InstructionError> { let lamports = data[0] as u64; { let mut to_account = keyed_accounts[1].try_account_ref_mut()?; let mut dup_account = keyed_accounts[2].try_account_ref_mut()?; dup_account.lamports -= lamports; to_account.lamports += lamports; } keyed_accounts[0].try_account_ref_mut()?.lamports -= lamports; keyed_accounts[1].try_account_ref_mut()?.lamports += lamports; Ok(()) } let mock_program_id = Pubkey::new(&[2u8; 32]); bank.add_instruction_processor(mock_program_id, mock_process_instruction); let from_pubkey = Pubkey::new_rand(); let to_pubkey = Pubkey::new_rand(); let dup_pubkey = from_pubkey.clone(); let from_account = Account::new(100, 1, &mock_program_id); let to_account = Account::new(0, 1, &mock_program_id); bank.store_account(&from_pubkey, &from_account); bank.store_account(&to_pubkey, &to_account); let account_metas = vec![ AccountMeta::new(from_pubkey, false), AccountMeta::new(to_pubkey, false), AccountMeta::new(dup_pubkey, false), ]; let instruction = Instruction::new(mock_program_id, &10, account_metas); let tx = Transaction::new_signed_with_payer( &[instruction], Some(&mint_keypair.pubkey()), &[&mint_keypair], bank.last_blockhash(), ); let result = bank.process_transaction(&tx); assert_eq!(result, Ok(())); assert_eq!(bank.get_balance(&from_pubkey), 80); assert_eq!(bank.get_balance(&to_pubkey), 20); } #[test] fn test_transaction_with_program_ids_passed_to_programs() { let (genesis_config, mint_keypair) = create_genesis_config(500); let mut bank = Bank::new(&genesis_config); fn mock_process_instruction( _program_id: &Pubkey, _keyed_accounts: &[KeyedAccount], _data: &[u8], ) -> result::Result<(), InstructionError> { Ok(()) } let mock_program_id = Pubkey::new(&[2u8; 32]); bank.add_instruction_processor(mock_program_id, mock_process_instruction); let from_pubkey = Pubkey::new_rand(); let to_pubkey = Pubkey::new_rand(); let dup_pubkey = from_pubkey.clone(); let from_account = Account::new(100, 1, &mock_program_id); let to_account = Account::new(0, 1, &mock_program_id); bank.store_account(&from_pubkey, &from_account); bank.store_account(&to_pubkey, &to_account); let account_metas = vec![ AccountMeta::new(from_pubkey, false), AccountMeta::new(to_pubkey, false), AccountMeta::new(dup_pubkey, false), AccountMeta::new(mock_program_id, false), ]; let instruction = Instruction::new(mock_program_id, &10, account_metas); let tx = Transaction::new_signed_with_payer( &[instruction], Some(&mint_keypair.pubkey()), &[&mint_keypair], bank.last_blockhash(), ); let result = bank.process_transaction(&tx); assert_eq!(result, Ok(())); } }