blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove old feature: simple_capitalization (#15763) 

* Remove old feature: simple_capitalization

* Fix another failing test in core

* Finish up test cleanup

* Further clean up a bit
This commit is contained in:
Ryo Onodera 2021-03-12 11:12:40 +09:00 committed by GitHub
parent 209dbb6f7c
commit 4bbeb9c033
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 115 additions and 502 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
accounts-bench/src/main.rs
View File

@ -103,9 +103,7 @@ fn main() {
} else { } else {
let mut pubkeys: Vec<Pubkey> = vec![]; let mut pubkeys: Vec<Pubkey> = vec![];
let mut time = Measure::start("hash"); let mut time = Measure::start("hash");
let results = accounts let results = accounts.accounts_db.update_accounts_hash(0, &ancestors);
.accounts_db
.update_accounts_hash(0, &ancestors, true);
time.stop(); time.stop();
let mut time_store = Measure::start("hash using store"); let mut time_store = Measure::start("hash using store");
let results_store = accounts.accounts_db.update_accounts_hash_with_index_option( let results_store = accounts.accounts_db.update_accounts_hash_with_index_option(
@ -113,7 +111,6 @@ fn main() {
false, false,
solana_sdk::clock::Slot::default(), solana_sdk::clock::Slot::default(),
&ancestors, &ancestors,
true,
None, None,
); );
time_store.stop(); time_store.stop();

2
core/src/non_circulating_supply.rs
View File

@ -195,9 +195,11 @@ mod tests {
..GenesisConfig::default() ..GenesisConfig::default()
}; };
let mut bank = Arc::new(Bank::new(&genesis_config)); let mut bank = Arc::new(Bank::new(&genesis_config));
let sysvar_and_native_program_delta = 10;
assert_eq!( assert_eq!(
bank.capitalization(), bank.capitalization(),
(num_genesis_accounts + num_non_circulating_accounts + num_stake_accounts) * balance (num_genesis_accounts + num_non_circulating_accounts + num_stake_accounts) * balance
+ sysvar_and_native_program_delta,
); );
let non_circulating_supply = calculate_non_circulating_supply(&bank); let non_circulating_supply = calculate_non_circulating_supply(&bank);

31
ledger-tool/src/main.rs
View File

@ -1238,13 +1238,6 @@ fn main() {
.help("Enable stake program v2 (several inflation-related staking \ .help("Enable stake program v2 (several inflation-related staking \
bugs are feature-gated behind this)"), bugs are feature-gated behind this)"),
) )
.arg(
Arg::with_name("enable_simple_capitalization")
.required(false)
.long("enable-simple-capitalization")
.takes_value(false)
.help("Enable simple capitalization to test hardcoded cap adjustments"),
)
.arg( .arg(
Arg::with_name("recalculate_capitalization") Arg::with_name("recalculate_capitalization")
.required(false) .required(false)
@ -2194,30 +2187,6 @@ fn main() {
genesis_config.rent.minimum_balance(Feature::size_of()), genesis_config.rent.minimum_balance(Feature::size_of()),
1, 1,
); );
if arg_matches.is_present("enable_simple_capitalization") {
if base_bank
.get_account(&feature_set::simple_capitalization::id())
.is_none()
{
base_bank.store_account(
&feature_set::simple_capitalization::id(),
&feature::create_account(
&Feature { activated_at: None },
feature_account_balance,
),
);
let old_cap = base_bank.set_capitalization();
let new_cap = base_bank.capitalization();
warn!(
"Skewing capitalization a bit to enable simple capitalization as \
requested: increasing {} from {} to {}",
feature_account_balance, old_cap, new_cap,
);
assert_eq!(old_cap + feature_account_balance, new_cap);
} else {
warn!("Already simple_capitalization is activated (or scheduled)");
}
}
if arg_matches.is_present("enable_stake_program_v2") { if arg_matches.is_present("enable_stake_program_v2") {
let mut force_enabled_count = 0; let mut force_enabled_count = 0;
if base_bank if base_bank

12
runtime/benches/accounts.rs
View File

@ -105,12 +105,8 @@ fn test_accounts_hash_bank_hash(bencher: &mut Bencher) {
let slot = 0; let slot = 0;
create_test_accounts(&accounts, &mut pubkeys, num_accounts, slot); create_test_accounts(&accounts, &mut pubkeys, num_accounts, slot);
let ancestors = vec![(0, 0)].into_iter().collect(); let ancestors = vec![(0, 0)].into_iter().collect();
let (_, total_lamports) = accounts let (_, total_lamports) = accounts.accounts_db.update_accounts_hash(0, &ancestors);
.accounts_db bencher.iter(|| assert!(accounts.verify_bank_hash_and_lamports(0, &ancestors, total_lamports)));
.update_accounts_hash(0, &ancestors, true);
bencher.iter(|| {
assert!(accounts.verify_bank_hash_and_lamports(0, &ancestors, total_lamports, true))
});
} }
#[bench] #[bench]
@ -126,9 +122,7 @@ fn test_update_accounts_hash(bencher: &mut Bencher) {
create_test_accounts(&accounts, &mut pubkeys, 50_000, 0); create_test_accounts(&accounts, &mut pubkeys, 50_000, 0);
let ancestors = vec![(0, 0)].into_iter().collect(); let ancestors = vec![(0, 0)].into_iter().collect();
bencher.iter(|| { bencher.iter(|| {
accounts accounts.accounts_db.update_accounts_hash(0, &ancestors);
.accounts_db
.update_accounts_hash(0, &ancestors, true);
}); });
} }

18
runtime/src/accounts.rs
View File

@ -577,11 +577,7 @@ impl Accounts {
.collect() .collect()
} }
pub fn calculate_capitalization( pub fn calculate_capitalization(&self, ancestors: &Ancestors) -> u64 {
&self,
ancestors: &Ancestors,
simple_capitalization_enabled: bool,
) -> u64 {
self.accounts_db.unchecked_scan_accounts( self.accounts_db.unchecked_scan_accounts(
"calculate_capitalization_scan_elapsed", "calculate_capitalization_scan_elapsed",
ancestors, ancestors,
@ -592,7 +588,6 @@ impl Accounts {
lamports, lamports,
&loaded_account.owner(), &loaded_account.owner(),
loaded_account.executable(), loaded_account.executable(),
simple_capitalization_enabled,
); );
*total_capitalization = AccountsDb::checked_iterative_sum_for_capitalization( *total_capitalization = AccountsDb::checked_iterative_sum_for_capitalization(
@ -610,14 +605,11 @@ impl Accounts {
slot: Slot, slot: Slot,
ancestors: &Ancestors, ancestors: &Ancestors,
total_lamports: u64, total_lamports: u64,
simple_capitalization_enabled: bool,
) -> bool { ) -> bool {
if let Err(err) = self.accounts_db.verify_bank_hash_and_lamports( if let Err(err) =
slot, self.accounts_db
ancestors, .verify_bank_hash_and_lamports(slot, ancestors, total_lamports)
total_lamports, {
simple_capitalization_enabled,
) {
warn!("verify_bank_hash failed: {:?}", err); warn!("verify_bank_hash failed: {:?}", err);
false false
} else { } else {

208
runtime/src/accounts_db.rs
View File

@ -3487,27 +3487,13 @@ impl AccountsDb {
AccountsHash::checked_cast_for_capitalization(balances.map(|b| b as u128).sum::<u128>()) AccountsHash::checked_cast_for_capitalization(balances.map(|b| b as u128).sum::<u128>())
} }
// remove this by inlining and remove extra unused params upto all callchain
pub fn account_balance_for_capitalization( pub fn account_balance_for_capitalization(
lamports: u64, lamports: u64,
owner: &Pubkey, _owner: &Pubkey,
executable: bool, _executable: bool,
simple_capitalization_enabled: bool,
) -> u64 { ) -> u64 {
if simple_capitalization_enabled { lamports
return lamports;
}
let is_specially_retained = (solana_sdk::native_loader::check_id(owner) && executable)
|| solana_sdk::sysvar::check_id(owner);
if is_specially_retained {
// specially retained accounts always have an initial 1 lamport
// balance, but could be modified by transfers which increase
// the balance but don't affect the capitalization.
lamports - 1
} else {
lamports
}
} }
fn calculate_accounts_hash( fn calculate_accounts_hash(
@ -3515,7 +3501,6 @@ impl AccountsDb {
slot: Slot, slot: Slot,
ancestors: &Ancestors, ancestors: &Ancestors,
check_hash: bool, check_hash: bool,
simple_capitalization_enabled: bool,
) -> Result<(Hash, u64), BankHashVerificationError> { ) -> Result<(Hash, u64), BankHashVerificationError> {
use BankHashVerificationError::*; use BankHashVerificationError::*;
let mut scan = Measure::start("scan"); let mut scan = Measure::start("scan");
@ -3560,7 +3545,6 @@ impl AccountsDb {
account_info.lamports, account_info.lamports,
loaded_account.owner(), loaded_account.owner(),
loaded_account.executable(), loaded_account.executable(),
simple_capitalization_enabled,
); );
if check_hash { if check_hash {
@ -3626,36 +3610,12 @@ impl AccountsDb {
bank_hash_info.snapshot_hash bank_hash_info.snapshot_hash
} }
pub fn update_accounts_hash( pub fn update_accounts_hash(&self, slot: Slot, ancestors: &Ancestors) -> (Hash, u64) {
&self, self.update_accounts_hash_with_index_option(true, false, slot, ancestors, None)
slot: Slot,
ancestors: &Ancestors,
simple_capitalization_enabled: bool,
) -> (Hash, u64) {
self.update_accounts_hash_with_index_option(
true,
false,
slot,
ancestors,
simple_capitalization_enabled,
None,
)
} }
pub fn update_accounts_hash_test( pub fn update_accounts_hash_test(&self, slot: Slot, ancestors: &Ancestors) -> (Hash, u64) {
&self, self.update_accounts_hash_with_index_option(true, true, slot, ancestors, None)
slot: Slot,
ancestors: &Ancestors,
simple_capitalization_enabled: bool,
) -> (Hash, u64) {
self.update_accounts_hash_with_index_option(
true,
true,
slot,
ancestors,
simple_capitalization_enabled,
None,
)
} }
/// Scan through all the account storage in parallel /// Scan through all the account storage in parallel
@ -3701,18 +3661,16 @@ impl AccountsDb {
use_index: bool, use_index: bool,
slot: Slot, slot: Slot,
ancestors: &Ancestors, ancestors: &Ancestors,
simple_capitalization_enabled: bool,
) -> (Hash, u64) { ) -> (Hash, u64) {
if !use_index { if !use_index {
let combined_maps = self.get_snapshot_storages(slot); let combined_maps = self.get_snapshot_storages(slot);
Self::calculate_accounts_hash_without_index( Self::calculate_accounts_hash_without_index(
&combined_maps, &combined_maps,
simple_capitalization_enabled,
Some(&self.thread_pool_clean), Some(&self.thread_pool_clean),
) )
} else { } else {
self.calculate_accounts_hash(slot, ancestors, false, simple_capitalization_enabled) self.calculate_accounts_hash(slot, ancestors, false)
.unwrap() .unwrap()
} }
} }
@ -3723,23 +3681,14 @@ impl AccountsDb {
debug_verify: bool, debug_verify: bool,
slot: Slot, slot: Slot,
ancestors: &Ancestors, ancestors: &Ancestors,
simple_capitalization_enabled: bool,
expected_capitalization: Option<u64>, expected_capitalization: Option<u64>,
) -> (Hash, u64) { ) -> (Hash, u64) {
let (hash, total_lamports) = self.calculate_accounts_hash_helper( let (hash, total_lamports) =
use_index, self.calculate_accounts_hash_helper(use_index, slot, ancestors);
slot,
ancestors,
simple_capitalization_enabled,
);
if debug_verify { if debug_verify {
// calculate the other way (store or non-store) and verify results match. // calculate the other way (store or non-store) and verify results match.
let (hash_other, total_lamports_other) = self.calculate_accounts_hash_helper( let (hash_other, total_lamports_other) =
!use_index, self.calculate_accounts_hash_helper(!use_index, slot, ancestors);
slot,
ancestors,
simple_capitalization_enabled,
);
let success = hash == hash_other let success = hash == hash_other
&& total_lamports == total_lamports_other && total_lamports == total_lamports_other
@ -3754,7 +3703,6 @@ impl AccountsDb {
fn scan_snapshot_stores( fn scan_snapshot_stores(
storage: &[SnapshotStorage], storage: &[SnapshotStorage],
simple_capitalization_enabled: bool,
mut stats: &mut crate::accounts_hash::HashStats, mut stats: &mut crate::accounts_hash::HashStats,
bins: usize, bins: usize,
) -> Vec<Vec<Vec<CalculateHashIntermediate>>> { ) -> Vec<Vec<Vec<CalculateHashIntermediate>>> {
@ -3778,7 +3726,6 @@ impl AccountsDb {
raw_lamports, raw_lamports,
loaded_account.owner(), loaded_account.owner(),
loaded_account.executable(), loaded_account.executable(),
simple_capitalization_enabled,
) )
}; };
@ -3807,7 +3754,6 @@ impl AccountsDb {
// intended to be faster than calculate_accounts_hash // intended to be faster than calculate_accounts_hash
pub fn calculate_accounts_hash_without_index( pub fn calculate_accounts_hash_without_index(
storages: &[SnapshotStorage], storages: &[SnapshotStorage],
simple_capitalization_enabled: bool,
thread_pool: Option<&ThreadPool>, thread_pool: Option<&ThreadPool>,
) -> (Hash, u64) { ) -> (Hash, u64) {
let scan_and_hash = || { let scan_and_hash = || {
@ -3816,7 +3762,6 @@ impl AccountsDb {
const PUBKEY_BINS_FOR_CALCULATING_HASHES: usize = 64; const PUBKEY_BINS_FOR_CALCULATING_HASHES: usize = 64;
let result = Self::scan_snapshot_stores( let result = Self::scan_snapshot_stores(
storages, storages,
simple_capitalization_enabled,
&mut stats, &mut stats,
PUBKEY_BINS_FOR_CALCULATING_HASHES, PUBKEY_BINS_FOR_CALCULATING_HASHES,
); );
@ -3835,12 +3780,11 @@ impl AccountsDb {
slot: Slot, slot: Slot,
ancestors: &Ancestors, ancestors: &Ancestors,
total_lamports: u64, total_lamports: u64,
simple_capitalization_enabled: bool,
) -> Result<(), BankHashVerificationError> { ) -> Result<(), BankHashVerificationError> {
use BankHashVerificationError::*; use BankHashVerificationError::*;
let (calculated_hash, calculated_lamports) = let (calculated_hash, calculated_lamports) =
self.calculate_accounts_hash(slot, ancestors, true, simple_capitalization_enabled)?; self.calculate_accounts_hash(slot, ancestors, true)?;
if calculated_lamports != total_lamports { if calculated_lamports != total_lamports {
warn!( warn!(
@ -5071,13 +5015,13 @@ pub mod tests {
#[should_panic(expected = "assertion failed: bins <= max_plus_1 && bins > 0")] #[should_panic(expected = "assertion failed: bins <= max_plus_1 && bins > 0")]
fn test_accountsdb_scan_snapshot_stores_illegal_bins2() { fn test_accountsdb_scan_snapshot_stores_illegal_bins2() {
let mut stats = HashStats::default(); let mut stats = HashStats::default();
AccountsDb::scan_snapshot_stores(&[], true, &mut stats, 257); AccountsDb::scan_snapshot_stores(&[], &mut stats, 257);
} }
#[test] #[test]
#[should_panic(expected = "assertion failed: bins <= max_plus_1 && bins > 0")] #[should_panic(expected = "assertion failed: bins <= max_plus_1 && bins > 0")]
fn test_accountsdb_scan_snapshot_stores_illegal_bins() { fn test_accountsdb_scan_snapshot_stores_illegal_bins() {
let mut stats = HashStats::default(); let mut stats = HashStats::default();
AccountsDb::scan_snapshot_stores(&[], true, &mut stats, 0); AccountsDb::scan_snapshot_stores(&[], &mut stats, 0);
} }
fn sample_storages_and_accounts() -> (SnapshotStorages, Vec<CalculateHashIntermediate>) { fn sample_storages_and_accounts() -> (SnapshotStorages, Vec<CalculateHashIntermediate>) {
@ -5164,11 +5108,11 @@ pub mod tests {
let bins = 1; let bins = 1;
let mut stats = HashStats::default(); let mut stats = HashStats::default();
let result = AccountsDb::scan_snapshot_stores(&storages, true, &mut stats, bins); let result = AccountsDb::scan_snapshot_stores(&storages, &mut stats, bins);
assert_eq!(result, vec![vec![raw_expected.clone()]]); assert_eq!(result, vec![vec![raw_expected.clone()]]);
let bins = 2; let bins = 2;
let result = AccountsDb::scan_snapshot_stores(&storages, true, &mut stats, bins); let result = AccountsDb::scan_snapshot_stores(&storages, &mut stats, bins);
let mut expected = vec![Vec::new(); bins]; let mut expected = vec![Vec::new(); bins];
expected[0].push(raw_expected[0].clone()); expected[0].push(raw_expected[0].clone());
expected[0].push(raw_expected[1].clone()); expected[0].push(raw_expected[1].clone());
@ -5177,7 +5121,7 @@ pub mod tests {
assert_eq!(result, vec![expected]); assert_eq!(result, vec![expected]);
let bins = 4; let bins = 4;
let result = AccountsDb::scan_snapshot_stores(&storages, true, &mut stats, bins); let result = AccountsDb::scan_snapshot_stores(&storages, &mut stats, bins);
let mut expected = vec![Vec::new(); bins]; let mut expected = vec![Vec::new(); bins];
expected[0].push(raw_expected[0].clone()); expected[0].push(raw_expected[0].clone());
expected[1].push(raw_expected[1].clone()); expected[1].push(raw_expected[1].clone());
@ -5186,7 +5130,7 @@ pub mod tests {
assert_eq!(result, vec![expected]); assert_eq!(result, vec![expected]);
let bins = 256; let bins = 256;
let result = AccountsDb::scan_snapshot_stores(&storages, true, &mut stats, bins); let result = AccountsDb::scan_snapshot_stores(&storages, &mut stats, bins);
let mut expected = vec![Vec::new(); bins]; let mut expected = vec![Vec::new(); bins];
expected[0].push(raw_expected[0].clone()); expected[0].push(raw_expected[0].clone());
expected[127].push(raw_expected[1].clone()); expected[127].push(raw_expected[1].clone());
@ -5207,7 +5151,7 @@ pub mod tests {
storages[0].splice(0..0, vec![arc; MAX_ITEMS_PER_CHUNK]); storages[0].splice(0..0, vec![arc; MAX_ITEMS_PER_CHUNK]);
let mut stats = HashStats::default(); let mut stats = HashStats::default();
let result = AccountsDb::scan_snapshot_stores(&storages, true, &mut stats, bins); let result = AccountsDb::scan_snapshot_stores(&storages, &mut stats, bins);
assert_eq!(result.len(), 2); // 2 chunks assert_eq!(result.len(), 2); // 2 chunks
assert_eq!(result[0].len(), 0); // nothing found in first slots assert_eq!(result[0].len(), 0); // nothing found in first slots
assert_eq!(result[1].len(), bins); assert_eq!(result[1].len(), bins);
@ -5219,7 +5163,7 @@ pub mod tests {
solana_logger::setup(); solana_logger::setup();
let (storages, _size, _slot_expected) = sample_storage(); let (storages, _size, _slot_expected) = sample_storage();
let result = AccountsDb::calculate_accounts_hash_without_index(&storages, true, None); let result = AccountsDb::calculate_accounts_hash_without_index(&storages, None);
let expected_hash = Hash::from_str("GKot5hBsd81kMupNCXHaqbhv3huEbxAFMLnpcX2hniwn").unwrap(); let expected_hash = Hash::from_str("GKot5hBsd81kMupNCXHaqbhv3huEbxAFMLnpcX2hniwn").unwrap();
assert_eq!(result, (expected_hash, 0)); assert_eq!(result, (expected_hash, 0));
} }
@ -5234,7 +5178,7 @@ pub mod tests {
item.hash item.hash
}); });
let sum = raw_expected.iter().map(|item| item.lamports).sum(); let sum = raw_expected.iter().map(|item| item.lamports).sum();
let result = AccountsDb::calculate_accounts_hash_without_index(&storages, true, None); let result = AccountsDb::calculate_accounts_hash_without_index(&storages, None);
assert_eq!(result, (expected_hash, sum)); assert_eq!(result, (expected_hash, sum));
} }
@ -6319,8 +6263,8 @@ pub mod tests {
let ancestors = linear_ancestors(latest_slot); let ancestors = linear_ancestors(latest_slot);
assert_eq!( assert_eq!(
daccounts.update_accounts_hash(latest_slot, &ancestors, true), daccounts.update_accounts_hash(latest_slot, &ancestors),
accounts.update_accounts_hash(latest_slot, &ancestors, true) accounts.update_accounts_hash(latest_slot, &ancestors)
); );
} }
@ -6473,12 +6417,12 @@ pub mod tests {
let ancestors = linear_ancestors(current_slot); let ancestors = linear_ancestors(current_slot);
info!("ancestors: {:?}", ancestors); info!("ancestors: {:?}", ancestors);
let hash = accounts.update_accounts_hash_test(current_slot, &ancestors, true); let hash = accounts.update_accounts_hash_test(current_slot, &ancestors);
accounts.clean_accounts(None); accounts.clean_accounts(None);
assert_eq!( assert_eq!(
accounts.update_accounts_hash_test(current_slot, &ancestors, true), accounts.update_accounts_hash_test(current_slot, &ancestors),
hash hash
); );
@ -6595,7 +6539,7 @@ pub mod tests {
accounts.add_root(current_slot); accounts.add_root(current_slot);
accounts.print_accounts_stats("pre_f"); accounts.print_accounts_stats("pre_f");
accounts.update_accounts_hash(4, &HashMap::default(), true); accounts.update_accounts_hash(4, &HashMap::default());
let accounts = f(accounts, current_slot); let accounts = f(accounts, current_slot);
@ -6607,7 +6551,7 @@ pub mod tests {
assert_load_account(&accounts, current_slot, dummy_pubkey, dummy_lamport); assert_load_account(&accounts, current_slot, dummy_pubkey, dummy_lamport);
accounts accounts
.verify_bank_hash_and_lamports(4, &HashMap::default(), 1222, true) .verify_bank_hash_and_lamports(4, &HashMap::default(), 1222)
.unwrap(); .unwrap();
} }
@ -6987,15 +6931,15 @@ pub mod tests {
db.store_uncached(some_slot, &[(&key, &account)]); db.store_uncached(some_slot, &[(&key, &account)]);
db.add_root(some_slot); db.add_root(some_slot);
db.update_accounts_hash_test(some_slot, &ancestors, true); db.update_accounts_hash_test(some_slot, &ancestors);
assert_matches!( assert_matches!(
db.verify_bank_hash_and_lamports(some_slot, &ancestors, 1, true), db.verify_bank_hash_and_lamports(some_slot, &ancestors, 1),
Ok(_) Ok(_)
); );
db.bank_hashes.write().unwrap().remove(&some_slot).unwrap(); db.bank_hashes.write().unwrap().remove(&some_slot).unwrap();
assert_matches!( assert_matches!(
db.verify_bank_hash_and_lamports(some_slot, &ancestors, 1, true), db.verify_bank_hash_and_lamports(some_slot, &ancestors, 1),
Err(MissingBankHash) Err(MissingBankHash)
); );
@ -7010,7 +6954,7 @@ pub mod tests {
.unwrap() .unwrap()
.insert(some_slot, bank_hash_info); .insert(some_slot, bank_hash_info);
assert_matches!( assert_matches!(
db.verify_bank_hash_and_lamports(some_slot, &ancestors, 1, true), db.verify_bank_hash_and_lamports(some_slot, &ancestors, 1),
Err(MismatchedBankHash) Err(MismatchedBankHash)
); );
} }
@ -7029,9 +6973,9 @@ pub mod tests {
db.store_uncached(some_slot, &[(&key, &account)]); db.store_uncached(some_slot, &[(&key, &account)]);
db.add_root(some_slot); db.add_root(some_slot);
db.update_accounts_hash_test(some_slot, &ancestors, true); db.update_accounts_hash_test(some_slot, &ancestors);
assert_matches!( assert_matches!(
db.verify_bank_hash_and_lamports(some_slot, &ancestors, 1, true), db.verify_bank_hash_and_lamports(some_slot, &ancestors, 1),
Ok(_) Ok(_)
); );
@ -7043,18 +6987,14 @@ pub mod tests {
&solana_sdk::native_loader::create_loadable_account("foo", 1), &solana_sdk::native_loader::create_loadable_account("foo", 1),
)], )],
); );
db.update_accounts_hash_test(some_slot, &ancestors, true); db.update_accounts_hash_test(some_slot, &ancestors);
assert_matches!( assert_matches!(
db.verify_bank_hash_and_lamports(some_slot, &ancestors, 1, false), db.verify_bank_hash_and_lamports(some_slot, &ancestors, 2),
Ok(_)
);
assert_matches!(
db.verify_bank_hash_and_lamports(some_slot, &ancestors, 2, true),
Ok(_) Ok(_)
); );
assert_matches!( assert_matches!(
db.verify_bank_hash_and_lamports(some_slot, &ancestors, 10, true), db.verify_bank_hash_and_lamports(some_slot, &ancestors, 10),
Err(MismatchedTotalLamports(expected, actual)) if expected == 2 && actual == 10 Err(MismatchedTotalLamports(expected, actual)) if expected == 2 && actual == 10
); );
} }
@ -7072,9 +7012,9 @@ pub mod tests {
.unwrap() .unwrap()
.insert(some_slot, BankHashInfo::default()); .insert(some_slot, BankHashInfo::default());
db.add_root(some_slot); db.add_root(some_slot);
db.update_accounts_hash_test(some_slot, &ancestors, true); db.update_accounts_hash_test(some_slot, &ancestors);
assert_matches!( assert_matches!(
db.verify_bank_hash_and_lamports(some_slot, &ancestors, 0, true), db.verify_bank_hash_and_lamports(some_slot, &ancestors, 0),
Ok(_) Ok(_)
); );
} }
@ -7099,7 +7039,7 @@ pub mod tests {
db.store_accounts_unfrozen(some_slot, accounts, &[some_hash], false); db.store_accounts_unfrozen(some_slot, accounts, &[some_hash], false);
db.add_root(some_slot); db.add_root(some_slot);
assert_matches!( assert_matches!(
db.verify_bank_hash_and_lamports(some_slot, &ancestors, 1, true), db.verify_bank_hash_and_lamports(some_slot, &ancestors, 1),
Err(MismatchedAccountHash) Err(MismatchedAccountHash)
); );
} }
@ -7663,14 +7603,14 @@ pub mod tests {
); );
let no_ancestors = HashMap::default(); let no_ancestors = HashMap::default();
accounts.update_accounts_hash(current_slot, &no_ancestors, true); accounts.update_accounts_hash(current_slot, &no_ancestors);
accounts accounts
.verify_bank_hash_and_lamports(current_slot, &no_ancestors, 22300, true) .verify_bank_hash_and_lamports(current_slot, &no_ancestors, 22300)
.unwrap(); .unwrap();
let accounts = reconstruct_accounts_db_via_serialization(&accounts, current_slot); let accounts = reconstruct_accounts_db_via_serialization(&accounts, current_slot);
accounts accounts
.verify_bank_hash_and_lamports(current_slot, &no_ancestors, 22300, true) .verify_bank_hash_and_lamports(current_slot, &no_ancestors, 22300)
.unwrap(); .unwrap();
// repeating should be no-op // repeating should be no-op
@ -7928,7 +7868,7 @@ pub mod tests {
fn test_account_balance_for_capitalization_normal() { fn test_account_balance_for_capitalization_normal() {
// system accounts // system accounts
assert_eq!( assert_eq!(
AccountsDb::account_balance_for_capitalization(10, &Pubkey::default(), false, true), AccountsDb::account_balance_for_capitalization(10, &Pubkey::default(), false),
10 10
); );
// any random program data accounts // any random program data accounts
@ -7937,16 +7877,6 @@ pub mod tests {
10, 10,
&solana_sdk::pubkey::new_rand(), &solana_sdk::pubkey::new_rand(),
false, false,
true,
),
10
);
assert_eq!(
AccountsDb::account_balance_for_capitalization(
10,
&solana_sdk::pubkey::new_rand(),
false,
false,
), ),
10 10
); );
@ -7963,37 +7893,13 @@ pub mod tests {
normal_sysvar.lamports, normal_sysvar.lamports,
&normal_sysvar.owner, &normal_sysvar.owner,
normal_sysvar.executable, normal_sysvar.executable,
false,
),
0
);
assert_eq!(
AccountsDb::account_balance_for_capitalization(
normal_sysvar.lamports,
&normal_sysvar.owner,
normal_sysvar.executable,
true,
), ),
1 1
); );
// currently transactions can send any lamports to sysvars although this is not sensible. // transactions can send any lamports to sysvars although this is not sensible.
assert_eq!( assert_eq!(
AccountsDb::account_balance_for_capitalization( AccountsDb::account_balance_for_capitalization(10, &solana_sdk::sysvar::id(), false),
10,
&solana_sdk::sysvar::id(),
false,
false
),
9
);
assert_eq!(
AccountsDb::account_balance_for_capitalization(
10,
&solana_sdk::sysvar::id(),
false,
true
),
10 10
); );
} }
@ -8006,16 +7912,6 @@ pub mod tests {
normal_native_program.lamports, normal_native_program.lamports,
&normal_native_program.owner, &normal_native_program.owner,
normal_native_program.executable, normal_native_program.executable,
false,
),
0
);
assert_eq!(
AccountsDb::account_balance_for_capitalization(
normal_native_program.lamports,
&normal_native_program.owner,
normal_native_program.executable,
true,
), ),
1 1
); );
@ -8026,16 +7922,6 @@ pub mod tests {
1, 1,
&solana_sdk::native_loader::id(), &solana_sdk::native_loader::id(),
false, false,
false,
),
1
);
assert_eq!(
AccountsDb::account_balance_for_capitalization(
1,
&solana_sdk::native_loader::id(),
false,
true,
), ),
1 1
); );

326
runtime/src/bank.rs
View File

@ -1336,11 +1336,7 @@ impl Bank {
let old_account = self.get_sysvar_account(pubkey); let old_account = self.get_sysvar_account(pubkey);
let new_account = updater(&old_account); let new_account = updater(&old_account);
if !self.simple_capitalization_enabled() { self.store_account_and_update_capitalization(pubkey, &new_account);
self.store_account(pubkey, &new_account);
} else {
self.store_account_and_update_capitalization(pubkey, &new_account);
}
} }
fn inherit_specially_retained_account_balance( fn inherit_specially_retained_account_balance(
@ -2232,11 +2228,7 @@ impl Bank {
name, name,
self.inherit_specially_retained_account_balance(&existing_genuine_program), self.inherit_specially_retained_account_balance(&existing_genuine_program),
); );
if !self.simple_capitalization_enabled() { self.store_account_and_update_capitalization(&program_id, &account);
self.store_account(&program_id, &account);
} else {
self.store_account_and_update_capitalization(&program_id, &account);
}
debug!("Added native program {} under {:?}", name, program_id); debug!("Added native program {} under {:?}", name, program_id);
} }
@ -4195,7 +4187,6 @@ impl Bank {
self.slot(), self.slot(),
&self.ancestors, &self.ancestors,
self.capitalization(), self.capitalization(),
self.simple_capitalization_enabled(),
) )
} }
@ -4226,9 +4217,7 @@ impl Bank {
} }
pub fn calculate_capitalization(&self) -> u64 { pub fn calculate_capitalization(&self) -> u64 {
self.rc self.rc.accounts.calculate_capitalization(&self.ancestors)
.accounts
.calculate_capitalization(&self.ancestors, self.simple_capitalization_enabled())
} }
pub fn calculate_and_verify_capitalization(&self) -> bool { pub fn calculate_and_verify_capitalization(&self) -> bool {
@ -4276,7 +4265,6 @@ impl Bank {
debug_verify, debug_verify,
self.slot(), self.slot(),
&self.ancestors, &self.ancestors,
self.simple_capitalization_enabled(),
Some(self.capitalization()), Some(self.capitalization()),
); );
assert_eq!(total_lamports, self.capitalization()); assert_eq!(total_lamports, self.capitalization());
@ -4613,28 +4601,6 @@ impl Bank {
.is_active(&feature_set::check_init_vote_data::id()) .is_active(&feature_set::check_init_vote_data::id())
} }
pub fn simple_capitalization_enabled(&self) -> bool {
self.simple_capitalization_enabled_at_genesis()
|| self
.feature_set
.is_active(&feature_set::simple_capitalization::id())
}
fn simple_capitalization_enabled_at_genesis(&self) -> bool {
// genesis builtin initialization codepath is called even before the initial
// feature activation, so we need to peek this flag at very early bank
// initialization phase for the development genesis case
if let Some(account) = self.get_account(&feature_set::simple_capitalization::id()) {
if let Some(feature) = feature::from_account(&account) {
if feature.activated_at == Some(0) {
return true;
}
}
}
false
}
pub fn deactivate_feature(&mut self, id: &Pubkey) { pub fn deactivate_feature(&mut self, id: &Pubkey) {
let mut feature_set = Arc::make_mut(&mut self.feature_set).clone(); let mut feature_set = Arc::make_mut(&mut self.feature_set).clone();
feature_set.active.remove(&id); feature_set.active.remove(&id);
@ -4681,10 +4647,6 @@ impl Bank {
self.rewrite_stakes(); self.rewrite_stakes();
} }
if new_feature_activations.contains(&feature_set::simple_capitalization::id()) {
self.adjust_capitalization_for_existing_specially_retained_accounts();
}
self.ensure_feature_builtins(init_finish_or_warp, &new_feature_activations); self.ensure_feature_builtins(init_finish_or_warp, &new_feature_activations);
self.reconfigure_token2_native_mint(); self.reconfigure_token2_native_mint();
self.ensure_no_storage_rewards_pool(); self.ensure_no_storage_rewards_pool();
@ -4786,40 +4748,6 @@ impl Bank {
} }
} }
} }
fn adjust_capitalization_for_existing_specially_retained_accounts(&self) {
use solana_sdk::{bpf_loader, bpf_loader_deprecated, secp256k1_program};
let mut existing_sysvar_account_count = 8;
let mut existing_native_program_account_count = 4;
if self.get_account(&sysvar::rewards::id()).is_some() {
existing_sysvar_account_count += 1;
}
if self.get_account(&bpf_loader::id()).is_some() {
existing_native_program_account_count += 1;
}
if self.get_account(&bpf_loader_deprecated::id()).is_some() {
existing_native_program_account_count += 1;
}
if self.get_account(&secp256k1_program::id()).is_some() {
existing_native_program_account_count += 1;
}
info!(
"Adjusted capitalization for existing {} sysvars and {} native programs from {}",
existing_sysvar_account_count,
existing_native_program_account_count,
self.capitalization()
);
self.capitalization.fetch_add(
existing_sysvar_account_count + existing_native_program_account_count,
Relaxed,
);
}
fn reconfigure_token2_native_mint(&mut self) { fn reconfigure_token2_native_mint(&mut self) {
let reconfigure_token2_native_mint = match self.cluster_type() { let reconfigure_token2_native_mint = match self.cluster_type() {
ClusterType::Development => true, ClusterType::Development => true,
@ -5193,7 +5121,7 @@ pub(crate) mod tests {
#[test] #[test]
fn test_bank_capitalization() { fn test_bank_capitalization() {
let bank = Arc::new(Bank::new(&GenesisConfig { let bank0 = Arc::new(Bank::new(&GenesisConfig {
accounts: (0..42) accounts: (0..42)
.map(|_| { .map(|_| {
( (
@ -5205,9 +5133,17 @@ pub(crate) mod tests {
cluster_type: ClusterType::MainnetBeta, cluster_type: ClusterType::MainnetBeta,
..GenesisConfig::default() ..GenesisConfig::default()
})); }));
assert_eq!(bank.capitalization(), 42 * 42); let sysvar_and_native_proram_delta0 = 10;
let bank1 = Bank::new_from_parent(&bank, &Pubkey::default(), 1); assert_eq!(
assert_eq!(bank1.capitalization(), 42 * 42); bank0.capitalization(),
42 * 42 + sysvar_and_native_proram_delta0
);
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
let sysvar_and_native_proram_delta1 = 2;
assert_eq!(
bank1.capitalization(),
42 * 42 + sysvar_and_native_proram_delta0 + sysvar_and_native_proram_delta1,
);
} }
#[test] #[test]
@ -5493,19 +5429,6 @@ pub(crate) mod tests {
assert_eq!(bank.capitalization(), bank.calculate_capitalization()); assert_eq!(bank.capitalization(), bank.calculate_capitalization());
} }
fn assert_capitalization_diff_with_new_bank(
bank: &Bank,
updater: impl Fn() -> Bank,
asserter: impl Fn(u64, u64),
) -> Bank {
let old = bank.capitalization();
let bank = updater();
let new = bank.capitalization();
asserter(old, new);
assert_eq!(bank.capitalization(), bank.calculate_capitalization());
bank
}
#[test] #[test]
fn test_store_account_and_update_capitalization_missing() { fn test_store_account_and_update_capitalization_missing() {
let (genesis_config, _mint_keypair) = create_genesis_config(0); let (genesis_config, _mint_keypair) = create_genesis_config(0);
@ -5708,7 +5631,6 @@ pub(crate) mod tests {
burn_percent: 10, burn_percent: 10,
}; };
genesis_config.disable_cap_altering_features_for_preciseness();
let mut bank = Bank::new(&genesis_config); let mut bank = Bank::new(&genesis_config);
// Enable rent collection // Enable rent collection
bank.rent_collector.epoch = 5; bank.rent_collector.epoch = 5;
@ -5794,8 +5716,9 @@ pub(crate) mod tests {
let current_capitalization = bank.capitalization.load(Relaxed); let current_capitalization = bank.capitalization.load(Relaxed);
let sysvar_and_native_proram_delta = 1;
assert_eq!( assert_eq!(
previous_capitalization - current_capitalization, previous_capitalization - current_capitalization + sysvar_and_native_proram_delta,
burned_portion burned_portion
); );
@ -6701,11 +6624,6 @@ pub(crate) mod tests {
.map(|(slot, _)| *slot) .map(|(slot, _)| *slot)
.collect::<Vec<Slot>>() .collect::<Vec<Slot>>()
} }
fn first_slot_in_next_epoch(&self) -> Slot {
self.epoch_schedule()
.get_first_slot_in_epoch(self.epoch() + 1)
}
} }
#[test] #[test]
@ -6855,7 +6773,7 @@ pub(crate) mod tests {
solana_logger::setup(); solana_logger::setup();
// create a bank that ticks really slowly... // create a bank that ticks really slowly...
let bank = Arc::new(Bank::new(&GenesisConfig { let bank0 = Arc::new(Bank::new(&GenesisConfig {
accounts: (0..42) accounts: (0..42)
.map(|_| { .map(|_| {
( (
@ -6881,16 +6799,20 @@ pub(crate) mod tests {
// enable lazy rent collection because this test depends on rent-due accounts // enable lazy rent collection because this test depends on rent-due accounts
// not being eagerly-collected for exact rewards calculation // not being eagerly-collected for exact rewards calculation
bank.restore_old_behavior_for_fragile_tests(); bank0.restore_old_behavior_for_fragile_tests();
assert_eq!(bank.capitalization(), 42 * 1_000_000_000); let sysvar_and_native_proram_delta0 = 10;
assert!(bank.rewards.read().unwrap().is_empty()); assert_eq!(
bank0.capitalization(),
42 * 1_000_000_000 + sysvar_and_native_proram_delta0
);
assert!(bank0.rewards.read().unwrap().is_empty());
let ((vote_id, mut vote_account), (stake_id, stake_account)) = let ((vote_id, mut vote_account), (stake_id, stake_account)) =
crate::stakes::tests::create_staked_node_accounts(1_0000); crate::stakes::tests::create_staked_node_accounts(1_0000);
// set up accounts // set up accounts
bank.store_account_and_update_capitalization(&stake_id, &stake_account); bank0.store_account_and_update_capitalization(&stake_id, &stake_account);
// generate some rewards // generate some rewards
let mut vote_state = Some(VoteState::from(&vote_account).unwrap()); let mut vote_state = Some(VoteState::from(&vote_account).unwrap());
@ -6900,7 +6822,7 @@ pub(crate) mod tests {
} }
let versioned = VoteStateVersions::Current(Box::new(vote_state.take().unwrap())); let versioned = VoteStateVersions::Current(Box::new(vote_state.take().unwrap()));
VoteState::to(&versioned, &mut vote_account).unwrap(); VoteState::to(&versioned, &mut vote_account).unwrap();
bank.store_account_and_update_capitalization(&vote_id, &vote_account); bank0.store_account_and_update_capitalization(&vote_id, &vote_account);
match versioned { match versioned {
VoteStateVersions::Current(v) => { VoteStateVersions::Current(v) => {
vote_state = Some(*v); vote_state = Some(*v);
@ -6908,9 +6830,9 @@ pub(crate) mod tests {
_ => panic!("Has to be of type Current"), _ => panic!("Has to be of type Current"),
}; };
} }
bank.store_account_and_update_capitalization(&vote_id, &vote_account); bank0.store_account_and_update_capitalization(&vote_id, &vote_account);
let validator_points: u128 = bank let validator_points: u128 = bank0
.stake_delegation_accounts(&mut null_tracer()) .stake_delegation_accounts(&mut null_tracer())
.iter() .iter()
.flat_map(|(_vote_pubkey, (stake_group, vote_account))| { .flat_map(|(_vote_pubkey, (stake_group, vote_account))| {
@ -6926,15 +6848,17 @@ pub(crate) mod tests {
// put a child bank in epoch 1, which calls update_rewards()... // put a child bank in epoch 1, which calls update_rewards()...
let bank1 = Bank::new_from_parent( let bank1 = Bank::new_from_parent(
&bank, &bank0,
&Pubkey::default(), &Pubkey::default(),
bank.get_slots_in_epoch(bank.epoch()) + 1, bank0.get_slots_in_epoch(bank0.epoch()) + 1,
); );
// verify that there's inflation // verify that there's inflation
assert_ne!(bank1.capitalization(), bank.capitalization()); assert_ne!(bank1.capitalization(), bank0.capitalization());
// verify the inflation is represented in validator_points * // verify the inflation is represented in validator_points *
let inflation = bank1.capitalization() - bank.capitalization(); let sysvar_and_native_proram_delta1 = 2;
let paid_rewards =
bank1.capitalization() - bank0.capitalization() - sysvar_and_native_proram_delta1;
let rewards = bank1 let rewards = bank1
.get_account(&sysvar::rewards::id()) .get_account(&sysvar::rewards::id())
@ -6951,10 +6875,8 @@ pub(crate) mod tests {
); );
// verify the rewards are the right size // verify the rewards are the right size
assert!( let allocated_rewards = rewards.validator_point_value * validator_points as f64;
((rewards.validator_point_value * validator_points as f64) - inflation as f64).abs() assert!((allocated_rewards - paid_rewards as f64).abs() < 1.0); // rounding, truncating
< 1.0 // rounding, truncating
);
// verify validator rewards show up in bank1.rewards vector // verify validator rewards show up in bank1.rewards vector
assert_eq!( assert_eq!(
@ -7002,7 +6924,11 @@ pub(crate) mod tests {
// not being eagerly-collected for exact rewards calculation // not being eagerly-collected for exact rewards calculation
bank.restore_old_behavior_for_fragile_tests(); bank.restore_old_behavior_for_fragile_tests();
assert_eq!(bank.capitalization(), 42 * 1_000_000_000); let sysvar_and_native_proram_delta = 10;
assert_eq!(
bank.capitalization(),
42 * 1_000_000_000 + sysvar_and_native_proram_delta
);
assert!(bank.rewards.read().unwrap().is_empty()); assert!(bank.rewards.read().unwrap().is_empty());
let vote_id = solana_sdk::pubkey::new_rand(); let vote_id = solana_sdk::pubkey::new_rand();
@ -7418,7 +7344,6 @@ pub(crate) mod tests {
let (expected_fee_collected, expected_fee_burned) = let (expected_fee_collected, expected_fee_burned) =
genesis_config.fee_rate_governor.burn(expected_fee_paid); genesis_config.fee_rate_governor.burn(expected_fee_paid);
genesis_config.disable_cap_altering_features_for_preciseness();
let mut bank = Bank::new(&genesis_config); let mut bank = Bank::new(&genesis_config);
let capitalization = bank.capitalization(); let capitalization = bank.capitalization();
@ -7448,7 +7373,11 @@ pub(crate) mod tests {
); // Leader collects fee after the bank is frozen ); // Leader collects fee after the bank is frozen
// verify capitalization // verify capitalization
assert_eq!(capitalization - expected_fee_burned, bank.capitalization()); let sysvar_and_native_proram_delta = 1;
assert_eq!(
capitalization - expected_fee_burned + sysvar_and_native_proram_delta,
bank.capitalization()
);
assert_eq!( assert_eq!(
*bank.rewards.read().unwrap(), *bank.rewards.read().unwrap(),
@ -8219,7 +8148,8 @@ pub(crate) mod tests {
assert_eq!(None, bank3.get_account_modified_since_parent(&pubkey)); assert_eq!(None, bank3.get_account_modified_since_parent(&pubkey));
} }
fn do_test_bank_update_sysvar_account(simple_capitalization_enabled: bool) { #[test]
fn test_bank_update_sysvar_account() {
use sysvar::clock::Clock; use sysvar::clock::Clock;
let dummy_clock_id = solana_sdk::pubkey::new_rand(); let dummy_clock_id = solana_sdk::pubkey::new_rand();
@ -8229,9 +8159,7 @@ pub(crate) mod tests {
let expected_next_slot = expected_previous_slot + 1; let expected_next_slot = expected_previous_slot + 1;
// First, initialize the clock sysvar // First, initialize the clock sysvar
if simple_capitalization_enabled { activate_all_features(&mut genesis_config);
activate_all_features(&mut genesis_config);
}
let bank1 = Arc::new(Bank::new(&genesis_config)); let bank1 = Arc::new(Bank::new(&genesis_config));
assert_eq!(bank1.calculate_capitalization(), bank1.capitalization()); assert_eq!(bank1.calculate_capitalization(), bank1.capitalization());
@ -8256,12 +8184,7 @@ pub(crate) mod tests {
); );
}, },
|old, new| { |old, new| {
// only if simple_capitalization_enabled, cap should increment assert_eq!(old + 1, new);
if simple_capitalization_enabled {
assert_eq!(old + 1, new);
} else {
assert_eq!(old, new);
}
}, },
); );
@ -8349,16 +8272,6 @@ pub(crate) mod tests {
); );
} }
#[test]
fn test_bank_update_sysvar_account_with_simple_capitalization_disabled() {
do_test_bank_update_sysvar_account(false)
}
#[test]
fn test_bank_update_sysvar_account_with_simple_capitalization_enabled() {
do_test_bank_update_sysvar_account(true);
}
#[test] #[test]
fn test_bank_epoch_vote_accounts() { fn test_bank_epoch_vote_accounts() {
let leader_pubkey = solana_sdk::pubkey::new_rand(); let leader_pubkey = solana_sdk::pubkey::new_rand();
@ -10577,11 +10490,10 @@ pub(crate) mod tests {
assert_eq!(bank.get_account_modified_slot(&loader_id).unwrap().1, slot); assert_eq!(bank.get_account_modified_slot(&loader_id).unwrap().1, slot);
} }
fn do_test_add_native_program(simple_capitalization_enabled: bool) { #[test]
fn test_add_native_program() {
let (mut genesis_config, _mint_keypair) = create_genesis_config(100_000); let (mut genesis_config, _mint_keypair) = create_genesis_config(100_000);
if simple_capitalization_enabled { activate_all_features(&mut genesis_config);
activate_all_features(&mut genesis_config);
}
let slot = 123; let slot = 123;
let program_id = solana_sdk::pubkey::new_rand(); let program_id = solana_sdk::pubkey::new_rand();
@ -10597,11 +10509,7 @@ pub(crate) mod tests {
&bank, &bank,
|| bank.add_native_program("mock_program", &program_id, false), || bank.add_native_program("mock_program", &program_id, false),
|old, new| { |old, new| {
if simple_capitalization_enabled { assert_eq!(old + 1, new);
assert_eq!(old + 1, new);
} else {
assert_eq!(old, new);
}
}, },
); );
@ -10644,16 +10552,6 @@ pub(crate) mod tests {
); );
} }
#[test]
fn test_add_native_program_with_simple_capitalization_disabled() {
do_test_add_native_program(false);
}
#[test]
fn test_add_native_program_with_simple_capitalization_enabled() {
do_test_add_native_program(true);
}
#[test] #[test]
fn test_add_native_program_inherited_cap_while_replacing() { fn test_add_native_program_inherited_cap_while_replacing() {
let (genesis_config, mint_keypair) = create_genesis_config(100_000); let (genesis_config, mint_keypair) = create_genesis_config(100_000);
@ -10815,7 +10713,6 @@ pub(crate) mod tests {
reward_pubkey, reward_pubkey,
Account::new(u64::MAX, 0, &solana_sdk::pubkey::new_rand()), Account::new(u64::MAX, 0, &solana_sdk::pubkey::new_rand()),
); );
genesis_config.disable_cap_altering_features_for_preciseness();
let bank0 = Bank::new(&genesis_config); let bank0 = Bank::new(&genesis_config);
// because capitalization has been reset with bogus capitalization calculation allowing overflows, // because capitalization has been reset with bogus capitalization calculation allowing overflows,
// deliberately substract 1 lamport to simulate it // deliberately substract 1 lamport to simulate it
@ -10831,8 +10728,9 @@ pub(crate) mod tests {
// assert that everything gets in order.... // assert that everything gets in order....
assert!(bank1.get_account(&reward_pubkey).is_none()); assert!(bank1.get_account(&reward_pubkey).is_none());
let sysvar_and_native_proram_delta = 1;
assert_eq!( assert_eq!(
bank0.capitalization() + 1 + 1_000_000_000, bank0.capitalization() + 1 + 1_000_000_000 + sysvar_and_native_proram_delta,
bank1.capitalization() bank1.capitalization()
); );
assert_eq!(bank1.capitalization(), bank1.calculate_capitalization()); assert_eq!(bank1.capitalization(), bank1.calculate_capitalization());
@ -11148,116 +11046,6 @@ pub(crate) mod tests {
bank.store_account(vote_pubkey, &vote_account); bank.store_account(vote_pubkey, &vote_account);
} }
#[test]
fn test_simple_capitalization_adjustment_minimum_genesis_set() {
solana_logger::setup();
let (mut genesis_config, _mint_keypair) = create_genesis_config(0);
let feature_balance =
std::cmp::max(genesis_config.rent.minimum_balance(Feature::size_of()), 1);
// inhibit deprecated rewards sysvar creation altogether
genesis_config.accounts.insert(
feature_set::deprecate_rewards_sysvar::id(),
Account::from(feature::create_account(
&Feature {
activated_at: Some(0),
},
feature_balance,
)),
);
let bank0 = Bank::new(&genesis_config);
let bank1 = Arc::new(new_from_parent(&Arc::new(bank0)));
// schedule activation of simple capitalization
bank1.store_account_and_update_capitalization(
&feature_set::simple_capitalization::id(),
&feature::create_account(&Feature { activated_at: None }, feature_balance),
);
// 12 is minimum adjusted cap increase in adjust_capitalization_for_existing_specially_retained_accounts
assert_capitalization_diff_with_new_bank(
&bank1,
|| Bank::new_from_parent(&bank1, &Pubkey::default(), bank1.first_slot_in_next_epoch()),
|old, new| assert_eq!(old + 12, new),
);
}
#[test]
fn test_simple_capitalization_adjustment_full_set() {
solana_logger::setup();
let (mut genesis_config, _mint_keypair) = create_genesis_config(0);
let feature_balance =
std::cmp::max(genesis_config.rent.minimum_balance(Feature::size_of()), 1);
// activate all features but simple capitalization
activate_all_features(&mut genesis_config);
genesis_config
.accounts
.remove(&feature_set::simple_capitalization::id());
// intentionally create deprecated rewards sysvar creation
genesis_config
.accounts
.remove(&feature_set::deprecate_rewards_sysvar::id());
// intentionally create bogus native programs
#[allow(clippy::unnecessary_wraps)]
fn mock_process_instruction(
_program_id: &Pubkey,
_keyed_accounts: &[KeyedAccount],
_data: &[u8],
_invoke_context: &mut dyn InvokeContext,
) -> std::result::Result<(), solana_sdk::instruction::InstructionError> {
Ok(())
}
let builtins = Builtins {
genesis_builtins: vec![
Builtin::new(
"mock bpf",
solana_sdk::bpf_loader::id(),
mock_process_instruction,
),
Builtin::new(
"mock bpf",
solana_sdk::bpf_loader_deprecated::id(),
mock_process_instruction,
),
],
feature_builtins: (vec![]),
};
let bank0 = Arc::new(Bank::new_with_paths(
&genesis_config,
Vec::new(),
&[],
None,
Some(&builtins),
HashSet::new(),
false,
));
// move to next epoch to create now deprecated rewards sysvar intentionally
let bank1 = Arc::new(Bank::new_from_parent(
&bank0,
&Pubkey::default(),
bank0.first_slot_in_next_epoch(),
));
// schedule activation of simple capitalization
bank1.store_account_and_update_capitalization(
&feature_set::simple_capitalization::id(),
&feature::create_account(&Feature { activated_at: None }, feature_balance),
);
// 16 is maximum adjusted cap increase in adjust_capitalization_for_existing_specially_retained_accounts
assert_capitalization_diff_with_new_bank(
&bank1,
|| Bank::new_from_parent(&bank1, &Pubkey::default(), bank1.first_slot_in_next_epoch()),
|old, new| assert_eq!(old + 16, new),
);
}
#[test] #[test]
fn test_update_clock_timestamp() { fn test_update_clock_timestamp() {
let leader_pubkey = solana_sdk::pubkey::new_rand(); let leader_pubkey = solana_sdk::pubkey::new_rand();

3
runtime/src/snapshot_package.rs
View File

@ -26,7 +26,6 @@ pub struct AccountsPackagePre {
pub snapshot_output_dir: PathBuf, pub snapshot_output_dir: PathBuf,
pub expected_capitalization: u64, pub expected_capitalization: u64,
pub hash_for_testing: Option<Hash>, pub hash_for_testing: Option<Hash>,
pub simple_capitalization_testing: bool,
} }
impl AccountsPackagePre { impl AccountsPackagePre {
@ -43,7 +42,6 @@ impl AccountsPackagePre {
snapshot_output_dir: PathBuf, snapshot_output_dir: PathBuf,
expected_capitalization: u64, expected_capitalization: u64,
hash_for_testing: Option<Hash>, hash_for_testing: Option<Hash>,
simple_capitalization_testing: bool,
) -> Self { ) -> Self {
Self { Self {
slot, slot,
@ -57,7 +55,6 @@ impl AccountsPackagePre {
snapshot_output_dir, snapshot_output_dir,
expected_capitalization, expected_capitalization,
hash_for_testing, hash_for_testing,
simple_capitalization_testing,
} }
} }
} }

2
runtime/src/snapshot_utils.rs
View File

@ -187,7 +187,6 @@ pub fn package_snapshot<P: AsRef<Path>, Q: AsRef<Path>>(
snapshot_package_output_path.as_ref().to_path_buf(), snapshot_package_output_path.as_ref().to_path_buf(),
bank.capitalization(), bank.capitalization(),
hash_for_testing, hash_for_testing,
bank.simple_capitalization_enabled(),
); );
Ok(package) Ok(package)
@ -978,7 +977,6 @@ pub fn process_accounts_package_pre(
if let Some(expected_hash) = accounts_package.hash_for_testing { if let Some(expected_hash) = accounts_package.hash_for_testing {
let (hash, lamports) = AccountsDb::calculate_accounts_hash_without_index( let (hash, lamports) = AccountsDb::calculate_accounts_hash_without_index(
&accounts_package.storages, &accounts_package.storages,
accounts_package.simple_capitalization_testing,
thread_pool, thread_pool,
); );

5
sdk/src/feature_set.rs
View File

@ -71,10 +71,6 @@ pub mod filter_stake_delegation_accounts {
solana_sdk::declare_id!("GE7fRxmW46K6EmCD9AMZSbnaJ2e3LfqCZzdHi9hmYAgi"); solana_sdk::declare_id!("GE7fRxmW46K6EmCD9AMZSbnaJ2e3LfqCZzdHi9hmYAgi");
} }
pub mod simple_capitalization {
solana_sdk::declare_id!("9r69RnnxABmpcPFfj1yhg4n9YFR2MNaLdKJCC6v3Speb");
}
pub mod bpf_loader_upgradeable_program { pub mod bpf_loader_upgradeable_program {
solana_sdk::declare_id!("FbhK8HN9qvNHvJcoFVHAEUCNkagHvu7DTWzdnLuVQ5u4"); solana_sdk::declare_id!("FbhK8HN9qvNHvJcoFVHAEUCNkagHvu7DTWzdnLuVQ5u4");
} }
@ -127,7 +123,6 @@ lazy_static! {
(stake_program_v2::id(), "solana_stake_program v2"), (stake_program_v2::id(), "solana_stake_program v2"),
(rewrite_stake::id(), "rewrite stake"), (rewrite_stake::id(), "rewrite stake"),
(filter_stake_delegation_accounts::id(), "filter stake_delegation_accounts #14062"), (filter_stake_delegation_accounts::id(), "filter stake_delegation_accounts #14062"),
(simple_capitalization::id(), "simple capitalization"),
(bpf_loader_upgradeable_program::id(), "upgradeable bpf loader"), (bpf_loader_upgradeable_program::id(), "upgradeable bpf loader"),
(stake_program_v3::id(), "solana_stake_program v3"), (stake_program_v3::id(), "solana_stake_program v3"),
(turbine_retransmit_peers_patch::id(), "turbine retransmit peers patch #14631"), (turbine_retransmit_peers_patch::id(), "turbine retransmit peers patch #14631"),

5
sdk/src/genesis_config.rs
View File

@ -151,11 +151,6 @@ impl GenesisConfig {
hash(&serialized) hash(&serialized)
} }
pub fn disable_cap_altering_features_for_preciseness(&mut self) {
self.accounts
.remove(&crate::feature_set::simple_capitalization::id());
}
fn genesis_filename(ledger_path: &Path) -> PathBuf { fn genesis_filename(ledger_path: &Path) -> PathBuf {
Path::new(ledger_path).join("genesis.bin") Path::new(ledger_path).join("genesis.bin")
} }