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

Use BankForks on tests - Part 4 (#34271) 

* Use BankForks on tests - Part 4

* Ensure the correct slot is set
This commit is contained in:
Lucas Steuernagel 2023-12-06 13:32:04 -03:00 committed by GitHub
parent fa251768b3
commit 1877fdb273
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 534 additions and 301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
bench-tps/src/bench.rs
View File

@ -1160,17 +1160,17 @@ mod tests {
},
};
fn bank_with_all_features(genesis_config: &GenesisConfig) -> Bank {
fn bank_with_all_features(genesis_config: &GenesisConfig) -> Arc<Bank> {
let mut bank = Bank::new_for_tests(genesis_config);
bank.feature_set = Arc::new(FeatureSet::all_enabled());
bank
bank.wrap_with_bank_forks_for_tests().0
}
#[test]
fn test_bench_tps_bank_client() {
let (genesis_config, id) = create_genesis_config(sol_to_lamports(10_000.0));
let bank = bank_with_all_features(&genesis_config);
let client = Arc::new(BankClient::new(bank));
let client = Arc::new(BankClient::new_shared(bank));
let config = Config {
id,
@ -1191,7 +1191,7 @@ mod tests {
fn test_bench_tps_fund_keys() {
let (genesis_config, id) = create_genesis_config(sol_to_lamports(10_000.0));
let bank = bank_with_all_features(&genesis_config);
let client = Arc::new(BankClient::new(bank));
let client = Arc::new(BankClient::new_shared(bank));
let keypair_count = 20;
let lamports = 20;
let rent = client.get_minimum_balance_for_rent_exemption(0).unwrap();
@ -1216,7 +1216,7 @@ mod tests {
let fee_rate_governor = FeeRateGovernor::new(11, 0);
genesis_config.fee_rate_governor = fee_rate_governor;
let bank = bank_with_all_features(&genesis_config);
let client = Arc::new(BankClient::new(bank));
let client = Arc::new(BankClient::new_shared(bank));
let keypair_count = 20;
let lamports = 20;
let rent = client.get_minimum_balance_for_rent_exemption(0).unwrap();
@ -1234,7 +1234,7 @@ mod tests {
fn test_bench_tps_create_durable_nonce() {
let (genesis_config, id) = create_genesis_config(sol_to_lamports(10_000.0));
let bank = bank_with_all_features(&genesis_config);
let client = Arc::new(BankClient::new(bank));
let client = Arc::new(BankClient::new_shared(bank));
let keypair_count = 10;
let lamports = 10_000_000;

9
core/src/banking_stage/consumer.rs
View File

@ -1724,14 +1724,19 @@ mod tests {
mint_keypair,
..
} = create_slow_genesis_config(10_000);
let bank = Bank::new_no_wallclock_throttle_for_tests(&genesis_config).0;
let (bank, bank_forks) = Bank::new_no_wallclock_throttle_for_tests(&genesis_config);
let keypair = Keypair::new();
let address_table_key = Pubkey::new_unique();
let address_table_state = generate_new_address_lookup_table(None, 2);
store_address_lookup_table(&bank, address_table_key, address_table_state);
let bank = Arc::new(Bank::new_from_parent(bank, &Pubkey::new_unique(), 1));
let new_bank = Bank::new_from_parent(bank, &Pubkey::new_unique(), 2);
let bank = bank_forks
.write()
.unwrap()
.insert(new_bank)
.clone_without_scheduler();
let message = VersionedMessage::V0(v0::Message {
header: MessageHeader {
num_required_signatures: 1,

49
core/src/commitment_service.rs
View File

@ -263,6 +263,20 @@ mod tests {
},
};
fn new_bank_from_parent_with_bank_forks(
bank_forks: &RwLock<BankForks>,
parent: Arc<Bank>,
collector_id: &Pubkey,
slot: Slot,
) -> Arc<Bank> {
let bank = Bank::new_from_parent(parent, collector_id, slot);
bank_forks
.write()
.unwrap()
.insert(bank)
.clone_without_scheduler()
}
#[test]
fn test_get_highest_super_majority_root() {
assert_eq!(get_highest_super_majority_root(vec![], 10), 0);
@ -508,14 +522,18 @@ mod tests {
vec![100; 1],
);
let bank0 = Bank::new_for_tests(&genesis_config);
let bank_forks = BankForks::new_rw_arc(bank0);
let (_bank0, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
// Fill bank_forks with banks with votes landing in the next slot
// Create enough banks such that vote account will root slots 0 and 1
for x in 0..33 {
let previous_bank = bank_forks.read().unwrap().get(x).unwrap();
let bank = Bank::new_from_parent(previous_bank.clone(), &Pubkey::default(), x + 1);
let bank = new_bank_from_parent_with_bank_forks(
bank_forks.as_ref(),
previous_bank.clone(),
&Pubkey::default(),
x + 1,
);
let vote = vote_transaction::new_vote_transaction(
vec![x],
previous_bank.hash(),
@ -526,7 +544,6 @@ mod tests {
None,
);
bank.process_transaction(&vote).unwrap();
bank_forks.write().unwrap().insert(bank);
}
let working_bank = bank_forks.read().unwrap().working_bank();
@ -543,7 +560,12 @@ mod tests {
// Add an additional bank/vote that will root slot 2
let bank33 = bank_forks.read().unwrap().get(33).unwrap();
let bank34 = Bank::new_from_parent(bank33.clone(), &Pubkey::default(), 34);
let bank34 = new_bank_from_parent_with_bank_forks(
bank_forks.as_ref(),
bank33.clone(),
&Pubkey::default(),
34,
);
let vote33 = vote_transaction::new_vote_transaction(
vec![33],
bank33.hash(),
@ -554,7 +576,6 @@ mod tests {
None,
);
bank34.process_transaction(&vote33).unwrap();
bank_forks.write().unwrap().insert(bank34);
let working_bank = bank_forks.read().unwrap().working_bank();
let root = get_vote_account_root_slot(
@ -587,8 +608,12 @@ mod tests {
// Add a forked bank. Because the vote for bank 33 landed in the non-ancestor, the vote
// account's root (and thus the highest_super_majority_root) rolls back to slot 1
let bank33 = bank_forks.read().unwrap().get(33).unwrap();
let bank35 = Bank::new_from_parent(bank33, &Pubkey::default(), 35);
bank_forks.write().unwrap().insert(bank35);
let _bank35 = new_bank_from_parent_with_bank_forks(
bank_forks.as_ref(),
bank33,
&Pubkey::default(),
35,
);
let working_bank = bank_forks.read().unwrap().working_bank();
let ancestors = working_bank.status_cache_ancestors();
@ -613,7 +638,12 @@ mod tests {
// continues normally
for x in 35..=37 {
let previous_bank = bank_forks.read().unwrap().get(x).unwrap();
let bank = Bank::new_from_parent(previous_bank.clone(), &Pubkey::default(), x + 1);
let bank = new_bank_from_parent_with_bank_forks(
bank_forks.as_ref(),
previous_bank.clone(),
&Pubkey::default(),
x + 1,
);
let vote = vote_transaction::new_vote_transaction(
vec![x],
previous_bank.hash(),
@ -624,7 +654,6 @@ mod tests {
None,
);
bank.process_transaction(&vote).unwrap();
bank_forks.write().unwrap().insert(bank);
}
let working_bank = bank_forks.read().unwrap().working_bank();

94
core/src/replay_stage.rs
View File

@ -4160,6 +4160,20 @@ pub(crate) mod tests {
trees::{tr, Tree},
};
fn new_bank_from_parent_with_bank_forks(
bank_forks: &RwLock<BankForks>,
parent: Arc<Bank>,
collector_id: &Pubkey,
slot: Slot,
) -> Arc<Bank> {
let bank = Bank::new_from_parent(parent, collector_id, slot);
bank_forks
.write()
.unwrap()
.insert(bank)
.clone_without_scheduler()
}
#[test]
fn test_is_partition_detected() {
let (VoteSimulator { bank_forks, .. }, _) = setup_default_forks(1, None::<GenerateVotes>);
@ -4933,7 +4947,12 @@ pub(crate) mod tests {
for i in 1..=3 {
let prev_bank = bank_forks.read().unwrap().get(i - 1).unwrap();
let slot = prev_bank.slot() + 1;
let bank = Bank::new_from_parent(prev_bank, &Pubkey::default(), slot);
let bank = new_bank_from_parent_with_bank_forks(
bank_forks.as_ref(),
prev_bank,
&Pubkey::default(),
slot,
);
let _res = bank.transfer(
10,
&genesis_config_info.mint_keypair,
@ -4942,7 +4961,7 @@ pub(crate) mod tests {
for _ in 0..genesis_config.ticks_per_slot {
bank.register_default_tick_for_test();
}
bank_forks.write().unwrap().insert(bank);
let arc_bank = bank_forks.read().unwrap().get(i).unwrap();
leader_vote(i - 1, &arc_bank, &leader_voting_pubkey);
ReplayStage::update_commitment_cache(
@ -5094,10 +5113,6 @@ pub(crate) mod tests {
None,
);
let bank1 = Bank::new_from_parent(bank0.clone(), &my_node_pubkey, 1);
bank1.process_transaction(&vote_tx).unwrap();
bank1.freeze();
// Test confirmations
let ancestors = bank_forks.read().unwrap().ancestors();
let mut frozen_banks: Vec<_> = bank_forks
@ -5138,8 +5153,16 @@ pub(crate) mod tests {
assert!(confirmed_forks.is_empty());
}
let bank1 = new_bank_from_parent_with_bank_forks(
bank_forks.as_ref(),
bank0.clone(),
&my_node_pubkey,
1,
);
bank1.process_transaction(&vote_tx).unwrap();
bank1.freeze();
// Insert the bank that contains a vote for slot 0, which confirms slot 0
bank_forks.write().unwrap().insert(bank1);
progress.insert(
1,
ForkProgress::new(bank0.last_blockhash(), None, None, 0, 0),
@ -7325,7 +7348,12 @@ pub(crate) mod tests {
let (voting_sender, voting_receiver) = unbounded();
// Simulate landing a vote for slot 0 landing in slot 1
let bank1 = Arc::new(Bank::new_from_parent(bank0.clone(), &Pubkey::default(), 1));
let bank1 = new_bank_from_parent_with_bank_forks(
bank_forks.as_ref(),
bank0.clone(),
&Pubkey::default(),
1,
);
bank1.fill_bank_with_ticks_for_tests();
tower.record_bank_vote(&bank0);
ReplayStage::push_vote(
@ -7366,7 +7394,12 @@ pub(crate) mod tests {
// Trying to refresh the vote for bank 0 in bank 1 or bank 2 won't succeed because
// the last vote has landed already
let bank2 = Arc::new(Bank::new_from_parent(bank1.clone(), &Pubkey::default(), 2));
let bank2 = new_bank_from_parent_with_bank_forks(
bank_forks.as_ref(),
bank1.clone(),
&Pubkey::default(),
2,
);
bank2.fill_bank_with_ticks_for_tests();
bank2.freeze();
for refresh_bank in &[&bank1, &bank2] {
@ -7460,8 +7493,12 @@ pub(crate) mod tests {
let mut parent_bank = bank2.clone();
for _ in 0..MAX_PROCESSING_AGE {
let slot = parent_bank.slot() + 1;
parent_bank =
Arc::new(Bank::new_from_parent(parent_bank, &Pubkey::default(), slot));
parent_bank = new_bank_from_parent_with_bank_forks(
bank_forks.as_ref(),
parent_bank,
&Pubkey::default(),
slot,
);
parent_bank.fill_bank_with_ticks_for_tests();
parent_bank.freeze();
}
@ -7516,11 +7553,12 @@ pub(crate) mod tests {
// Processing the vote transaction should be valid
let expired_bank_child_slot = expired_bank.slot() + 1;
let expired_bank_child = Arc::new(Bank::new_from_parent(
let expired_bank_child = new_bank_from_parent_with_bank_forks(
bank_forks.as_ref(),
expired_bank.clone(),
&Pubkey::default(),
expired_bank_child_slot,
));
);
expired_bank_child.process_transaction(vote_tx).unwrap();
let vote_account = expired_bank_child
.get_vote_account(&my_vote_pubkey)
@ -7536,11 +7574,12 @@ pub(crate) mod tests {
// 1) The vote for slot 1 hasn't landed
// 2) The latest refresh vote transaction's recent blockhash (the sibling's hash) doesn't exist
// This will still not refresh because `MAX_VOTE_REFRESH_INTERVAL_MILLIS` has not expired yet
let expired_bank_sibling = Arc::new(Bank::new_from_parent(
let expired_bank_sibling = new_bank_from_parent_with_bank_forks(
bank_forks.as_ref(),
bank2,
&Pubkey::default(),
expired_bank_child.slot() + 1,
));
);
expired_bank_sibling.fill_bank_with_ticks_for_tests();
expired_bank_sibling.freeze();
// Set the last refresh to now, shouldn't refresh because the last refresh just happened.
@ -7628,7 +7667,12 @@ pub(crate) mod tests {
parent_bank.last_blockhash()
);
assert_eq!(tower.last_voted_slot().unwrap(), parent_bank.slot());
let bank = Bank::new_from_parent(parent_bank, &Pubkey::default(), my_slot);
let bank = new_bank_from_parent_with_bank_forks(
bank_forks,
parent_bank,
&Pubkey::default(),
my_slot,
);
bank.fill_bank_with_ticks_for_tests();
if make_it_landing {
bank.process_transaction(vote_tx).unwrap();
@ -7644,7 +7688,6 @@ pub(crate) mod tests {
0,
)
});
bank_forks.write().unwrap().insert(bank);
bank_forks.read().unwrap().get(my_slot).unwrap()
}
@ -7685,8 +7728,12 @@ pub(crate) mod tests {
// Add a new fork starting from 0 with bigger slot number, we assume it has a bigger
// weight, but we cannot switch because of lockout.
let other_fork_slot = 1;
let other_fork_bank =
Bank::new_from_parent(bank0.clone(), &Pubkey::default(), other_fork_slot);
let other_fork_bank = new_bank_from_parent_with_bank_forks(
bank_forks.as_ref(),
bank0.clone(),
&Pubkey::default(),
other_fork_slot,
);
other_fork_bank.fill_bank_with_ticks_for_tests();
other_fork_bank.freeze();
progress.entry(other_fork_slot).or_insert_with(|| {
@ -7699,7 +7746,6 @@ pub(crate) mod tests {
0,
)
});
bank_forks.write().unwrap().insert(other_fork_bank);
let (voting_sender, voting_receiver) = unbounded();
let mut cursor = Cursor::default();
@ -7745,7 +7791,12 @@ pub(crate) mod tests {
let last_voted_slot = tower.last_voted_slot().unwrap();
while new_bank.is_in_slot_hashes_history(&last_voted_slot) {
let new_slot = new_bank.slot() + 1;
let bank = Bank::new_from_parent(new_bank, &Pubkey::default(), new_slot);
let bank = new_bank_from_parent_with_bank_forks(
bank_forks.as_ref(),
new_bank,
&Pubkey::default(),
new_slot,
);
bank.fill_bank_with_ticks_for_tests();
bank.freeze();
progress.entry(new_slot).or_insert_with(|| {
@ -7758,7 +7809,6 @@ pub(crate) mod tests {
0,
)
});
bank_forks.write().unwrap().insert(bank);
new_bank = bank_forks.read().unwrap().get(new_slot).unwrap();
}
let tip_of_voted_fork = new_bank.slot();

9
core/src/vote_simulator.rs
View File

@ -64,6 +64,8 @@ impl VoteSimulator {
latest_validator_votes_for_frozen_banks: LatestValidatorVotesForFrozenBanks::default(),
}
}
#[cfg(feature = "dev-context-only-utils")]
pub fn fill_bank_forks(
&mut self,
forks: Tree<u64>,
@ -84,6 +86,12 @@ impl VoteSimulator {
let parent = *walk.get_parent().unwrap().data();
let parent_bank = self.bank_forks.read().unwrap().get(parent).unwrap();
let new_bank = Bank::new_from_parent(parent_bank.clone(), &Pubkey::default(), slot);
let new_bank = self
.bank_forks
.write()
.unwrap()
.insert(new_bank)
.clone_without_scheduler();
self.progress
.entry(slot)
.or_insert_with(|| ForkProgress::new(Hash::default(), None, None, 0, 0));
@ -131,7 +139,6 @@ impl VoteSimulator {
Some((new_bank.parent_slot(), new_bank.parent_hash())),
);
}
self.bank_forks.write().unwrap().insert(new_bank);
walk.forward();
}

23
core/tests/snapshots.rs
View File

@ -196,7 +196,7 @@ fn run_bank_forks_snapshot_n<F>(
f: F,
set_root_interval: u64,
) where
F: Fn(&mut Bank, &Keypair),
F: Fn(&Bank, &Keypair),
{
solana_logger::setup();
// Set up snapshotting config
@ -221,13 +221,13 @@ fn run_bank_forks_snapshot_n<F>(
accounts_package_sender,
};
for slot in 1..=last_slot {
let mut bank = Bank::new_from_parent(
let bank = Bank::new_from_parent(
bank_forks.read().unwrap().get(slot - 1).unwrap().clone(),
&Pubkey::default(),
slot,
);
f(&mut bank, mint_keypair);
let bank = bank_forks.write().unwrap().insert(bank);
f(bank.clone_without_scheduler().as_ref(), mint_keypair);
// Set root to make sure we don't end up with too many account storage entries
// and to allow snapshotting of bank and the purging logic on status_cache to
// kick in
@ -399,6 +399,11 @@ fn test_concurrent_snapshot_packaging(
&Pubkey::default(),
parent_slot + 1,
);
let bank = bank_forks
.write()
.unwrap()
.insert(bank)
.clone_without_scheduler();
let slot = bank.slot();
let key1 = Keypair::new().pubkey();
let tx = system_transaction::transfer(mint_keypair, &key1, 1, genesis_config.hash());
@ -439,7 +444,6 @@ fn test_concurrent_snapshot_packaging(
);
accounts_package_sender.send(accounts_package).unwrap();
bank_forks.write().unwrap().insert(bank);
if slot == saved_slot {
// Find the relevant snapshot storages
let snapshot_storage_files: HashSet<_> = bank_forks
@ -758,6 +762,8 @@ fn test_bank_forks_incremental_snapshot(
let bank = {
let parent = bank_forks.read().unwrap().get(slot - 1).unwrap();
let bank = Bank::new_from_parent(parent, &Pubkey::default(), slot);
let bank_scheduler = bank_forks.write().unwrap().insert(bank);
let bank = bank_scheduler.clone_without_scheduler();
let key = solana_sdk::pubkey::new_rand();
let tx = system_transaction::transfer(mint_keypair, &key, 1, bank.last_blockhash());
@ -771,7 +777,7 @@ fn test_bank_forks_incremental_snapshot(
bank.register_unique_tick();
}
bank_forks.write().unwrap().insert(bank)
bank_scheduler
};
// Set root to make sure we don't end up with too many account storage entries
@ -1062,6 +1068,11 @@ fn test_snapshots_with_background_services(
&Pubkey::default(),
slot,
);
let bank = bank_forks
.write()
.unwrap()
.insert(bank)
.clone_without_scheduler();
let key = solana_sdk::pubkey::new_rand();
let tx = system_transaction::transfer(mint_keypair, &key, 1, bank.last_blockhash());
@ -1074,8 +1085,6 @@ fn test_snapshots_with_background_services(
while !bank.is_complete() {
bank.register_unique_tick();
}
bank_forks.write().unwrap().insert(bank);
}
// Call `BankForks::set_root()` to cause snapshots to be taken

74
ledger/src/blockstore_processor.rs
View File

@ -2693,7 +2693,7 @@ pub mod tests {
mint_keypair,
..
} = create_genesis_config(2);
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let keypair = Keypair::new();
let slot_entries = create_ticks(genesis_config.ticks_per_slot, 1, genesis_config.hash());
let tx = system_transaction::transfer(
@ -2858,7 +2858,7 @@ pub mod tests {
mint_keypair,
..
} = create_genesis_config(1000);
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let keypair1 = Keypair::new();
let keypair2 = Keypair::new();
@ -2895,7 +2895,7 @@ pub mod tests {
mint_keypair,
..
} = create_genesis_config(1000);
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let keypair1 = Keypair::new();
let keypair2 = Keypair::new();
let keypair3 = Keypair::new();
@ -2955,7 +2955,7 @@ pub mod tests {
mint_keypair,
..
} = create_genesis_config(1000);
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let keypair1 = Keypair::new();
let keypair2 = Keypair::new();
let keypair3 = Keypair::new();
@ -3105,8 +3105,12 @@ pub mod tests {
let mock_program_id = solana_sdk::pubkey::new_rand();
let mut bank = Bank::new_for_tests(&genesis_config);
bank.add_mockup_builtin(mock_program_id, MockBuiltinOk::vm);
let bank = Bank::new_with_mockup_builtin_for_tests(
&genesis_config,
mock_program_id,
MockBuiltinOk::vm,
)
.0;
let tx = Transaction::new_signed_with_payer(
&[Instruction::new_with_bincode(
@ -3120,7 +3124,6 @@ pub mod tests {
);
let entry = next_entry(&bank.last_blockhash(), 1, vec![tx]);
let bank = Arc::new(bank);
let result = process_entries_for_tests_without_scheduler(&bank, vec![entry]);
bank.freeze();
let blockhash_ok = bank.last_blockhash();
@ -3146,8 +3149,12 @@ pub mod tests {
let mut bankhash_err = None;
(0..get_instruction_errors().len()).for_each(|err| {
let mut bank = Bank::new_for_tests(&genesis_config);
bank.add_mockup_builtin(mock_program_id, MockBuiltinErr::vm);
let bank = Bank::new_with_mockup_builtin_for_tests(
&genesis_config,
mock_program_id,
MockBuiltinErr::vm,
)
.0;
let tx = Transaction::new_signed_with_payer(
&[Instruction::new_with_bincode(
@ -3183,7 +3190,7 @@ pub mod tests {
mint_keypair,
..
} = create_genesis_config(1000);
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let keypair1 = Keypair::new();
let keypair2 = Keypair::new();
let keypair3 = Keypair::new();
@ -3277,7 +3284,7 @@ pub mod tests {
mint_keypair,
..
} = create_genesis_config(1000);
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let keypair1 = Keypair::new();
let keypair2 = Keypair::new();
let keypair3 = Keypair::new();
@ -3323,7 +3330,7 @@ pub mod tests {
mint_keypair,
..
} = create_genesis_config(1_000_000_000);
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
const NUM_TRANSFERS_PER_ENTRY: usize = 8;
const NUM_TRANSFERS: usize = NUM_TRANSFERS_PER_ENTRY * 32;
@ -3390,7 +3397,7 @@ pub mod tests {
..
} = create_genesis_config((num_accounts + 1) as u64 * initial_lamports);
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let mut keypairs: Vec<Keypair> = vec![];
@ -3457,7 +3464,7 @@ pub mod tests {
mint_keypair,
..
} = create_genesis_config(1000);
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let keypair1 = Keypair::new();
let keypair2 = Keypair::new();
let keypair3 = Keypair::new();
@ -3519,7 +3526,7 @@ pub mod tests {
mint_keypair,
..
} = create_genesis_config(11_000);
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let pubkey = solana_sdk::pubkey::new_rand();
bank.transfer(1_000, &mint_keypair, &pubkey).unwrap();
assert_eq!(bank.transaction_count(), 1);
@ -3560,7 +3567,7 @@ pub mod tests {
mint_keypair,
..
} = create_genesis_config(11_000);
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let keypair1 = Keypair::new();
let keypair2 = Keypair::new();
let success_tx = system_transaction::transfer(
@ -3846,7 +3853,7 @@ pub mod tests {
mint_keypair,
..
} = create_genesis_config(100);
let bank0 = Arc::new(Bank::new_for_tests(&genesis_config));
let bank0 = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let genesis_hash = genesis_config.hash();
let keypair = Keypair::new();
@ -3910,7 +3917,7 @@ pub mod tests {
mint_keypair,
..
} = create_genesis_config(1_000_000_000);
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let present_account_key = Keypair::new();
let present_account = AccountSharedData::new(1, 10, &Pubkey::default());
@ -3968,14 +3975,18 @@ pub mod tests {
&validator_keypairs,
vec![100; validator_keypairs.len()],
);
let bank0 = Arc::new(Bank::new_for_tests(&genesis_config));
let (bank0, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
bank0.freeze();
let bank1 = Arc::new(Bank::new_from_parent(
bank0.clone(),
&solana_sdk::pubkey::new_rand(),
1,
));
let bank1 = bank_forks
.write()
.unwrap()
.insert(Bank::new_from_parent(
bank0.clone(),
&solana_sdk::pubkey::new_rand(),
1,
))
.clone_without_scheduler();
// The new blockhash is going to be the hash of the last tick in the block
let bank_1_blockhash = bank1.last_blockhash();
@ -4375,9 +4386,9 @@ pub mod tests {
..
} = create_genesis_config(100 * LAMPORTS_PER_SOL);
let genesis_hash = genesis_config.hash();
let bank = BankWithScheduler::new_without_scheduler(Arc::new(Bank::new_for_tests(
&genesis_config,
)));
let bank = BankWithScheduler::new_without_scheduler(
Bank::new_with_bank_forks_for_tests(&genesis_config).0,
);
let mut timing = ConfirmationTiming::default();
let mut progress = ConfirmationProgress::new(genesis_hash);
let amount = genesis_config.rent.minimum_balance(0);
@ -4593,7 +4604,7 @@ pub mod tests {
genesis_config.ticks_per_slot = TICKS_PER_SLOT;
let genesis_hash = genesis_config.hash();
let slot_0_bank = Arc::new(Bank::new_for_tests(&genesis_config));
let (slot_0_bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
assert_eq!(slot_0_bank.slot(), 0);
assert_eq!(slot_0_bank.tick_height(), 0);
assert_eq!(slot_0_bank.max_tick_height(), 2);
@ -4608,7 +4619,12 @@ pub mod tests {
assert_eq!(slot_0_bank.get_hash_age(&genesis_hash), Some(1));
assert_eq!(slot_0_bank.get_hash_age(&slot_0_hash), Some(0));
let slot_2_bank = Arc::new(Bank::new_from_parent(slot_0_bank, &collector_id, 2));
let new_bank = Bank::new_from_parent(slot_0_bank, &collector_id, 2);
let slot_2_bank = bank_forks
.write()
.unwrap()
.insert(new_bank)
.clone_without_scheduler();
assert_eq!(slot_2_bank.slot(), 2);
assert_eq!(slot_2_bank.tick_height(), 2);
assert_eq!(slot_2_bank.max_tick_height(), 6);

8
ledger/src/leader_schedule_cache.rs
View File

@ -509,7 +509,7 @@ mod tests {
} = create_genesis_config(10_000 * bootstrap_validator_stake_lamports());
genesis_config.epoch_schedule.warmup = false;
let bank = Bank::new_for_tests(&genesis_config);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank));
// Create new vote account
@ -533,7 +533,11 @@ mod tests {
target_slot += 1;
}
let bank = Bank::new_from_parent(Arc::new(bank), &Pubkey::default(), target_slot);
let bank = bank_forks
.write()
.unwrap()
.insert(Bank::new_from_parent(bank, &Pubkey::default(), target_slot))
.clone_without_scheduler();
let mut expected_slot = 0;
let epoch = bank.get_leader_schedule_epoch(target_slot);
for i in 0..epoch {

1
program-runtime/src/loaded_programs.rs
View File

@ -793,6 +793,7 @@ impl<FG: ForkGraph> LoadedPrograms<FG> {
working_slot: &S,
keys: impl Iterator<Item = (Pubkey, (LoadedProgramMatchCriteria, u64))>,
) -> Arc<Mutex<ExtractedPrograms>> {
debug_assert!(self.fork_graph.is_some());
let environments = self.get_environments_for_epoch(working_slot.current_epoch());
let current_slot = working_slot.current_slot();
let extracted = Arc::new(Mutex::new(ExtractedPrograms {

4
programs/sbf/benches/bpf_loader.rs
View File

@ -190,12 +190,12 @@ fn bench_program_execute_noop(bencher: &mut Bencher) {
..
} = create_genesis_config(50);
let bank = Bank::new_for_benches(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = bank.wrap_with_bank_forks_for_tests();
let mut bank_client = BankClient::new_shared(bank.clone());
let invoke_program_id = load_program(&bank_client, &bpf_loader::id(), &mint_keypair, "noop");
let bank = bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance the slot");
let mint_pubkey = mint_keypair.pubkey();

226
programs/sbf/tests/programs.rs
View File

@ -64,6 +64,7 @@ use {
solana_runtime::{
bank::Bank,
bank_client::BankClient,
bank_forks::BankForks,
genesis_utils::{
bootstrap_validator_stake_lamports, create_genesis_config,
create_genesis_config_with_leader_ex, GenesisConfigInfo,
@ -85,7 +86,12 @@ use {
system_program,
transaction::{SanitizedTransaction, Transaction, TransactionError},
},
std::{cell::RefCell, str::FromStr, sync::Arc, time::Duration},
std::{
cell::RefCell,
str::FromStr,
sync::{Arc, RwLock},
time::Duration,
},
};
#[cfg(feature = "sbf_rust")]
@ -258,6 +264,7 @@ fn execute_transactions(
fn load_program_and_advance_slot(
bank_client: &mut BankClient,
bank_forks: &RwLock<BankForks>,
loader_id: &Pubkey,
payer_keypair: &Keypair,
name: &str,
@ -265,7 +272,7 @@ fn load_program_and_advance_slot(
let pubkey = load_program(bank_client, loader_id, payer_keypair, name);
(
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks, &Pubkey::default())
.expect("Failed to advance the slot"),
pubkey,
)
@ -335,12 +342,13 @@ fn test_program_sbf_sanity() {
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let mut bank_client = BankClient::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank);
// Call user program
let (_, program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
program.0,
@ -386,12 +394,12 @@ fn test_program_sbf_loader_deprecated() {
.accounts
.remove(&solana_sdk::feature_set::disable_deploy_of_alloc_free_syscall::id())
.unwrap();
let bank = Bank::new_for_tests(&genesis_config);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let program_id = create_program(&bank, &bpf_loader_deprecated::id(), program);
let mut bank_client = BankClient::new(bank);
let mut bank_client = BankClient::new_shared(bank);
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance the slot");
let account_metas = vec![AccountMeta::new(mint_keypair.pubkey(), true)];
let instruction = Instruction::new_with_bytes(program_id, &[255], account_metas);
@ -413,7 +421,7 @@ fn test_sol_alloc_free_no_longer_deployable() {
mint_keypair,
..
} = create_genesis_config(50);
let mut bank = Bank::new_for_tests(&genesis_config);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
// Populate loader account with elf that depends on _sol_alloc_free syscall
let elf = load_program_from_file("solana_sbf_rust_deprecated_loader");
@ -457,21 +465,41 @@ fn test_sol_alloc_free_no_longer_deployable() {
);
// Enable _sol_alloc_free syscall
let slot = bank.slot();
drop(bank);
let mut bank = Arc::into_inner(bank_forks.write().unwrap().remove(slot).unwrap()).unwrap();
bank.deactivate_feature(&solana_sdk::feature_set::disable_deploy_of_alloc_free_syscall::id());
bank.clear_signatures();
bank.clear_program_cache();
let bank = bank_forks
.write()
.unwrap()
.insert(bank)
.clone_without_scheduler();
// Try and finalize the program now that sol_alloc_free is re-enabled
assert!(bank.process_transaction(&finalize_tx).is_ok());
let new_slot = bank.slot() + 1;
let mut bank = Bank::new_from_parent(Arc::new(bank), &Pubkey::default(), new_slot);
let bank = bank_forks
.write()
.unwrap()
.insert(Bank::new_from_parent(bank, &Pubkey::default(), new_slot))
.clone_without_scheduler();
// invoke the program
assert!(bank.process_transaction(&invoke_tx).is_ok());
// disable _sol_alloc_free
let slot = bank.slot();
drop(bank);
let mut bank = Arc::try_unwrap(bank_forks.write().unwrap().remove(slot).unwrap()).unwrap();
bank.activate_feature(&solana_sdk::feature_set::disable_deploy_of_alloc_free_syscall::id());
bank.clear_signatures();
let bank = bank_forks
.write()
.unwrap()
.insert(bank)
.clone_without_scheduler();
// invoke should still succeed because cached
assert!(bank.process_transaction(&invoke_tx).is_ok());
@ -506,11 +534,11 @@ fn test_program_sbf_duplicate_accounts() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
let (bank, program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
program,
@ -610,10 +638,11 @@ fn test_program_sbf_error_handling() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let mut bank_client = BankClient::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank);
let (_, program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
program,
@ -715,12 +744,12 @@ fn test_return_data_and_log_data_syscall() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
let (bank, program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
program,
@ -783,8 +812,7 @@ fn test_program_sbf_invoke_sanity() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
let invoke_program_id =
@ -793,6 +821,7 @@ fn test_program_sbf_invoke_sanity() {
load_program(&bank_client, &bpf_loader::id(), &mint_keypair, program.2);
let (bank, noop_program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
program.3,
@ -1180,8 +1209,7 @@ fn test_program_sbf_program_id_spoofing() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
let malicious_swap_pubkey = load_program(
@ -1192,6 +1220,7 @@ fn test_program_sbf_program_id_spoofing() {
);
let (bank, malicious_system_pubkey) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_spoof1_system",
@ -1231,8 +1260,7 @@ fn test_program_sbf_caller_has_access_to_cpi_program() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
let caller_pubkey = load_program(
@ -1243,6 +1271,7 @@ fn test_program_sbf_caller_has_access_to_cpi_program() {
);
let (_, caller2_pubkey) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_caller_access",
@ -1269,12 +1298,12 @@ fn test_program_sbf_ro_modify() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
let (bank, program_pubkey) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_ro_modify",
@ -1324,10 +1353,11 @@ fn test_program_sbf_call_depth() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let mut bank_client = BankClient::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank);
let (_, program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_call_depth",
@ -1357,10 +1387,11 @@ fn test_program_sbf_compute_budget() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let mut bank_client = BankClient::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank);
let (_, program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_noop",
@ -1484,12 +1515,12 @@ fn test_program_sbf_instruction_introspection() {
mint_keypair,
..
} = create_genesis_config(50_000);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
let (bank, program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_instruction_introspection",
@ -1542,8 +1573,8 @@ fn test_program_sbf_test_use_latest_executor() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let mut bank_client = BankClient::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank);
let panic_id = load_program(
&bank_client,
&bpf_loader::id(),
@ -1570,7 +1601,7 @@ fn test_program_sbf_test_use_latest_executor() {
);
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance the slot");
assert!(bank_client
.send_and_confirm_message(&[&mint_keypair, &program_keypair], message)
@ -1585,7 +1616,7 @@ fn test_program_sbf_test_use_latest_executor() {
"solana_sbf_rust_noop",
);
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance the slot");
let message = Message::new(&[instruction], Some(&mint_keypair.pubkey()));
bank_client
@ -1602,7 +1633,7 @@ fn test_program_sbf_test_use_latest_executor() {
Some(&mint_keypair.pubkey()),
);
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance the slot");
assert!(bank_client
.send_and_confirm_message(&[&mint_keypair], message)
@ -1619,8 +1650,8 @@ fn test_program_sbf_upgrade() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let mut bank_client = BankClient::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank);
// Deploy upgrade program
let buffer_keypair = Keypair::new();
@ -1636,7 +1667,7 @@ fn test_program_sbf_upgrade() {
"solana_sbf_rust_upgradeable",
);
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance the slot");
let mut instruction =
@ -1664,7 +1695,7 @@ fn test_program_sbf_upgrade() {
..clock::Clock::default()
});
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance the slot");
// Call upgraded program
@ -1697,7 +1728,7 @@ fn test_program_sbf_upgrade() {
);
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance the slot");
// Call original program
@ -1932,8 +1963,7 @@ fn test_program_sbf_invoke_in_same_tx_as_deployment() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
// Deploy upgradeable program
@ -1989,7 +2019,7 @@ fn test_program_sbf_invoke_in_same_tx_as_deployment() {
.unwrap();
let bank = bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance slot");
// Deployment is invisible to both top-level-instructions and CPI instructions
@ -2030,8 +2060,7 @@ fn test_program_sbf_invoke_in_same_tx_as_redeployment() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
// Deploy upgradeable program
@ -2084,7 +2113,7 @@ fn test_program_sbf_invoke_in_same_tx_as_redeployment() {
// load_upgradeable_program sets clock sysvar to 1, which causes the program to be effective
// after 2 slots. So we need to advance the bank client by 2 slots here.
let bank = bank_client
.advance_slot(2, &Pubkey::default())
.advance_slot(2, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance slot");
// Prepare redeployment
@ -2138,8 +2167,7 @@ fn test_program_sbf_invoke_in_same_tx_as_undeployment() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
// Deploy upgradeable program
@ -2181,7 +2209,7 @@ fn test_program_sbf_invoke_in_same_tx_as_undeployment() {
// load_upgradeable_program sets clock sysvar to 1, which causes the program to be effective
// after 2 slots. So we need to advance the bank client by 2 slots here.
let bank = bank_client
.advance_slot(2, &Pubkey::default())
.advance_slot(2, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance slot");
// Prepare undeployment
@ -2231,8 +2259,8 @@ fn test_program_sbf_invoke_upgradeable_via_cpi() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let mut bank_client = BankClient::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank);
let invoke_and_return = load_program(
&bank_client,
&bpf_loader::id(),
@ -2255,7 +2283,7 @@ fn test_program_sbf_invoke_upgradeable_via_cpi() {
);
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance slot");
let mut instruction = Instruction::new_with_bytes(
@ -2290,7 +2318,7 @@ fn test_program_sbf_invoke_upgradeable_via_cpi() {
..clock::Clock::default()
});
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance slot");
// Call the upgraded program
@ -2323,7 +2351,7 @@ fn test_program_sbf_invoke_upgradeable_via_cpi() {
);
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance slot");
// Call original program
@ -2366,7 +2394,8 @@ fn test_program_sbf_disguised_as_sbf_loader() {
bank.deactivate_feature(
&solana_sdk::feature_set::remove_bpf_loader_incorrect_program_id::id(),
);
let bank_client = BankClient::new(bank);
let bank = bank.wrap_with_bank_forks_for_tests().0;
let bank_client = BankClient::new_shared(bank);
let program_id = load_program(&bank_client, &bpf_loader::id(), &mint_keypair, program);
let account_metas = vec![AccountMeta::new_readonly(program_id, false)];
@ -2389,11 +2418,12 @@ fn test_program_reads_from_program_account() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let mut bank_client = BankClient::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank);
let (_, program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"read_program",
@ -2415,16 +2445,21 @@ fn test_program_sbf_c_dup() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let account_address = Pubkey::new_unique();
let account = AccountSharedData::new_data(42, &[1_u8, 2, 3], &system_program::id()).unwrap();
bank.store_account(&account_address, &account);
let mut bank_client = BankClient::new(bank);
let mut bank_client = BankClient::new_shared(bank);
let (_, program_id) =
load_program_and_advance_slot(&mut bank_client, &bpf_loader::id(), &mint_keypair, "ser");
let (_, program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"ser",
);
let account_metas = vec![
AccountMeta::new_readonly(account_address, false),
AccountMeta::new_readonly(account_address, false),
@ -2445,8 +2480,8 @@ fn test_program_sbf_upgrade_via_cpi() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let mut bank_client = BankClient::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank);
let invoke_and_return = load_program(
&bank_client,
&bpf_loader::id(),
@ -2468,7 +2503,7 @@ fn test_program_sbf_upgrade_via_cpi() {
"solana_sbf_rust_upgradeable",
);
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance the slot");
let program_account = bank_client.get_account(&program_id).unwrap().unwrap();
let Ok(bpf_loader_upgradeable::UpgradeableLoaderState::Program {
@ -2526,7 +2561,7 @@ fn test_program_sbf_upgrade_via_cpi() {
.unwrap();
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance the slot");
// Call the upgraded program
@ -2555,8 +2590,8 @@ fn test_program_sbf_set_upgrade_authority_via_cpi() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let mut bank_client = BankClient::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank);
// Deploy CPI invoker program
let invoke_and_return = load_program(
@ -2581,7 +2616,7 @@ fn test_program_sbf_set_upgrade_authority_via_cpi() {
);
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance the slot");
// Set program upgrade authority instruction to invoke via CPI
@ -2648,8 +2683,7 @@ fn test_program_upgradeable_locks() {
mint_keypair,
..
} = create_genesis_config(2_000_000_000);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
load_upgradeable_program(
@ -2671,7 +2705,7 @@ fn test_program_upgradeable_locks() {
);
let bank = bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance the slot");
bank_client
@ -2771,12 +2805,12 @@ fn test_program_sbf_finalize() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
let (_, program_pubkey) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_finalize",
@ -2792,7 +2826,7 @@ fn test_program_sbf_finalize() {
);
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance the slot");
let account_metas = vec![
@ -2819,12 +2853,12 @@ fn test_program_sbf_ro_account_modify() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
let (bank, program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_ro_account_modify",
@ -2891,11 +2925,12 @@ fn test_program_sbf_realloc() {
if !direct_mapping {
feature_set.deactivate(&feature_set::bpf_account_data_direct_mapping::id());
}
let bank = Arc::new(bank);
let (bank, bank_forks) = bank.wrap_with_bank_forks_for_tests();
let mut bank_client = BankClient::new_shared(bank.clone());
let (bank, program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_realloc",
@ -3218,8 +3253,7 @@ fn test_program_sbf_realloc_invoke() {
let mint_pubkey = mint_keypair.pubkey();
let signer = &[&mint_keypair];
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
let realloc_program_id = load_program(
@ -3231,6 +3265,7 @@ fn test_program_sbf_realloc_invoke() {
let (bank, realloc_invoke_program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_realloc_invoke",
@ -3734,8 +3769,7 @@ fn test_program_sbf_processed_inner_instruction() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Arc::new(bank);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let mut bank_client = BankClient::new_shared(bank.clone());
let sibling_program_id = load_program(
@ -3758,6 +3792,7 @@ fn test_program_sbf_processed_inner_instruction() {
);
let (_, invoke_and_return_program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_invoke_and_return",
@ -3816,10 +3851,12 @@ fn test_program_fees() {
FeeStructure::new(0.000005, 0.0, vec![(200, 0.0000005), (1400000, 0.000005)]);
bank.fee_structure = fee_structure.clone();
bank.feature_set = Arc::new(FeatureSet::all_enabled());
let mut bank_client = BankClient::new(bank);
let (bank, bank_forks) = bank.wrap_with_bank_forks_for_tests();
let mut bank_client = BankClient::new_shared(bank);
let (_, program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_noop",
@ -3895,11 +3932,12 @@ fn test_get_minimum_delegation() {
} = create_genesis_config(100_123_456_789);
let mut bank = Bank::new_for_tests(&genesis_config);
bank.feature_set = Arc::new(FeatureSet::all_enabled());
let bank = Arc::new(bank);
let (bank, bank_forks) = bank.wrap_with_bank_forks_for_tests();
let mut bank_client = BankClient::new_shared(bank.clone());
let (_, program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_get_minimum_delegation",
@ -3921,7 +3959,7 @@ fn test_program_sbf_inner_instruction_alignment_checks() {
mint_keypair,
..
} = create_genesis_config(50);
let bank = Bank::new_for_tests(&genesis_config);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let noop = create_program(&bank, &bpf_loader_deprecated::id(), "solana_sbf_rust_noop");
let inner_instruction_alignment_check = create_program(
&bank,
@ -3931,9 +3969,9 @@ fn test_program_sbf_inner_instruction_alignment_checks() {
// invoke unaligned program, which will call aligned program twice,
// unaligned should be allowed once invoke completes
let mut bank_client = BankClient::new(bank);
let mut bank_client = BankClient::new_shared(bank);
bank_client
.advance_slot(1, &Pubkey::default())
.advance_slot(1, bank_forks.as_ref(), &Pubkey::default())
.expect("Failed to advance the slot");
let mut instruction = Instruction::new_with_bytes(
inner_instruction_alignment_check,
@ -3966,7 +4004,7 @@ fn test_cpi_account_ownership_writability() {
feature_set.deactivate(&feature_set::bpf_account_data_direct_mapping::id());
}
bank.feature_set = Arc::new(feature_set);
let bank = Arc::new(bank);
let (bank, bank_forks) = bank.wrap_with_bank_forks_for_tests();
let mut bank_client = BankClient::new_shared(bank);
let invoke_program_id = load_program(
@ -3985,6 +4023,7 @@ fn test_cpi_account_ownership_writability() {
let (bank, realloc_program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_realloc",
@ -4147,7 +4186,7 @@ fn test_cpi_account_data_updates() {
feature_set.deactivate(&feature_set::bpf_account_data_direct_mapping::id());
}
bank.feature_set = Arc::new(feature_set);
let bank = Arc::new(bank);
let (bank, bank_forks) = bank.wrap_with_bank_forks_for_tests();
let mut bank_client = BankClient::new_shared(bank);
let invoke_program_id = load_program(
@ -4159,6 +4198,7 @@ fn test_cpi_account_data_updates() {
let (bank, realloc_program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_realloc",
@ -4294,7 +4334,7 @@ fn test_cpi_deprecated_loader_realloc() {
feature_set.deactivate(&feature_set::bpf_account_data_direct_mapping::id());
}
bank.feature_set = Arc::new(feature_set);
let bank = Arc::new(bank);
let (bank, bank_forks) = bank.wrap_with_bank_forks_for_tests();
let deprecated_program_id = create_program(
&bank,
@ -4306,6 +4346,7 @@ fn test_cpi_deprecated_loader_realloc() {
let (bank, invoke_program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_invoke",
@ -4444,11 +4485,12 @@ fn test_cpi_change_account_data_memory_allocation() {
LoadedProgram::new_builtin(0, 42, MockBuiltin::vm),
);
let bank = Arc::new(bank);
let (bank, bank_forks) = bank.wrap_with_bank_forks_for_tests();
let mut bank_client = BankClient::new_shared(bank);
let (bank, invoke_program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_invoke",
@ -4488,7 +4530,7 @@ fn test_cpi_invalid_account_info_pointers() {
let mut bank = Bank::new_for_tests(&genesis_config);
let feature_set = FeatureSet::all_enabled();
bank.feature_set = Arc::new(feature_set);
let bank = Arc::new(bank);
let (bank, bank_forks) = bank.wrap_with_bank_forks_for_tests();
let mut bank_client = BankClient::new_shared(bank);
let c_invoke_program_id =
@ -4496,6 +4538,7 @@ fn test_cpi_invalid_account_info_pointers() {
let (bank, invoke_program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_invoke",
@ -4556,11 +4599,12 @@ fn test_deny_executable_write() {
if !direct_mapping {
feature_set.deactivate(&feature_set::bpf_account_data_direct_mapping::id());
}
let bank = Arc::new(bank);
let (bank, bank_forks) = bank.wrap_with_bank_forks_for_tests();
let mut bank_client = BankClient::new_shared(bank);
let (_bank, invoke_program_id) = load_program_and_advance_slot(
&mut bank_client,
bank_forks.as_ref(),
&bpf_loader::id(),
&mint_keypair,
"solana_sbf_rust_invoke",

4
rpc/src/rpc.rs
View File

@ -5057,7 +5057,7 @@ pub mod tests {
fn test_rpc_request_processor_new() {
let bob_pubkey = solana_sdk::pubkey::new_rand();
let genesis = create_genesis_config(100);
let bank = Arc::new(Bank::new_for_tests(&genesis.genesis_config));
let bank = Bank::new_with_bank_forks_for_tests(&genesis.genesis_config).0;
bank.transfer(20, &genesis.mint_keypair, &bob_pubkey)
.unwrap();
let connection_cache = Arc::new(ConnectionCache::new("connection_cache_test"));
@ -5227,7 +5227,7 @@ pub mod tests {
fn test_rpc_get_tx_count() {
let bob_pubkey = solana_sdk::pubkey::new_rand();
let genesis = create_genesis_config(10);
let bank = Arc::new(Bank::new_for_tests(&genesis.genesis_config));
let bank = Bank::new_with_bank_forks_for_tests(&genesis.genesis_config).0;
// Add 4 transactions
bank.transfer(1, &genesis.mint_keypair, &bob_pubkey)
.unwrap();

232
runtime/src/bank/tests.rs
View File

@ -292,15 +292,14 @@ pub(crate) fn create_simple_test_bank(lamports: u64) -> Bank {
Bank::new_for_tests(&genesis_config)
}
fn create_simple_test_arc_bank(lamports: u64) -> Arc<Bank> {
fn create_simple_test_arc_bank(lamports: u64) -> (Arc<Bank>, Arc<RwLock<BankForks>>) {
let bank = create_simple_test_bank(lamports);
let (bank, _) = bank.wrap_with_bank_forks_for_tests();
bank
bank.wrap_with_bank_forks_for_tests()
}
#[test]
fn test_bank_block_height() {
let bank0 = create_simple_test_arc_bank(1);
let bank0 = create_simple_test_arc_bank(1).0;
assert_eq!(bank0.block_height(), 0);
let bank1 = Arc::new(new_from_parent(bank0));
assert_eq!(bank1.block_height(), 1);
@ -1276,7 +1275,7 @@ fn test_rent_collection_partitions(bank: &Bank) -> Vec<Partition> {
#[test]
fn test_rent_eager_across_epoch_without_gap() {
let mut bank = create_simple_test_arc_bank(1);
let mut bank = create_simple_test_arc_bank(1).0;
assert_eq!(bank.rent_collection_partitions(), vec![(0, 0, 32)]);
bank = Arc::new(new_from_parent(bank));
@ -1731,7 +1730,11 @@ fn test_rent_eager_collect_rent_in_partition(should_collect_rent: bool) {
);
}
fn new_from_parent_next_epoch(parent: Arc<Bank>, epochs: Epoch) -> Bank {
fn new_from_parent_next_epoch(
parent: Arc<Bank>,
bank_forks: &RwLock<BankForks>,
epochs: Epoch,
) -> Arc<Bank> {
let mut slot = parent.slot();
let mut epoch = parent.epoch();
for _ in 0..epochs {
@ -1739,7 +1742,7 @@ fn new_from_parent_next_epoch(parent: Arc<Bank>, epochs: Epoch) -> Bank {
epoch = parent.epoch_schedule().get_epoch(slot);
}
Bank::new_from_parent(parent, &Pubkey::default(), slot)
new_bank_from_parent_with_bank_forks(bank_forks, parent, &Pubkey::default(), slot)
}
#[test]
@ -1750,17 +1753,21 @@ fn test_collect_rent_from_accounts() {
for skip_rewrites in [false, true] {
let zero_lamport_pubkey = Pubkey::from([0; 32]);
let genesis_bank = create_simple_test_arc_bank(100000);
let (genesis_bank, bank_forks) = create_simple_test_arc_bank(100000);
let mut first_bank = new_from_parent(genesis_bank.clone());
if skip_rewrites {
first_bank.activate_feature(&feature_set::skip_rent_rewrites::id());
}
let first_bank = Arc::new(first_bank);
let first_bank = bank_forks
.write()
.unwrap()
.insert(first_bank)
.clone_without_scheduler();
let first_slot = 1;
assert_eq!(first_slot, first_bank.slot());
let epoch_delta = 4;
let later_bank = Arc::new(new_from_parent_next_epoch(first_bank, epoch_delta)); // a bank a few epochs in the future
let later_bank = new_from_parent_next_epoch(first_bank, bank_forks.as_ref(), epoch_delta); // a bank a few epochs in the future
let later_slot = later_bank.slot();
assert!(later_bank.epoch() == genesis_bank.epoch() + epoch_delta);
@ -2748,19 +2755,19 @@ fn test_bank_blockhash_fee_structure() {
.target_lamports_per_signature = 5000;
genesis_config.fee_rate_governor.target_signatures_per_slot = 0;
let (bank, _) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
goto_end_of_slot(bank.clone());
let cheap_blockhash = bank.last_blockhash();
let cheap_lamports_per_signature = bank.get_lamports_per_signature();
assert_eq!(cheap_lamports_per_signature, 0);
let bank = Arc::new(Bank::new_from_parent(bank, &leader, 1));
let bank = new_bank_from_parent_with_bank_forks(bank_forks.as_ref(), bank, &leader, 1);
goto_end_of_slot(bank.clone());
let expensive_blockhash = bank.last_blockhash();
let expensive_lamports_per_signature = bank.get_lamports_per_signature();
assert!(cheap_lamports_per_signature < expensive_lamports_per_signature);
let bank = Bank::new_from_parent(bank, &leader, 2);
let bank = new_bank_from_parent_with_bank_forks(bank_forks.as_ref(), bank, &leader, 2);
// Send a transfer using cheap_blockhash
let key = solana_sdk::pubkey::new_rand();
@ -4531,7 +4538,7 @@ fn test_get_filtered_indexed_accounts() {
#[test]
fn test_status_cache_ancestors() {
solana_logger::setup();
let parent = create_simple_test_arc_bank(500);
let parent = create_simple_test_arc_bank(500).0;
let bank1 = Arc::new(new_from_parent(parent));
let mut bank = bank1;
for _ in 0..MAX_CACHE_ENTRIES * 2 {
@ -4609,7 +4616,7 @@ fn test_add_duplicate_static_program() {
mint_keypair,
..
} = create_genesis_config_with_leader(500, &solana_sdk::pubkey::new_rand(), 0);
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
declare_process_instruction!(MockBuiltin, 1, |_invoke_context| {
Err(InstructionError::Custom(42))
@ -4640,9 +4647,14 @@ fn test_add_duplicate_static_program() {
let slot = bank.slot().saturating_add(1);
let mut bank = Bank::new_from_parent(bank, &Pubkey::default(), slot);
bank.add_mockup_builtin(solana_vote_program::id(), MockBuiltin::vm);
let bank = bank_forks
.write()
.unwrap()
.insert(bank)
.clone_without_scheduler();
let vote_loader_account = bank.get_account(&solana_vote_program::id()).unwrap();
bank.add_mockup_builtin(solana_vote_program::id(), MockBuiltin::vm);
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());
@ -4751,7 +4763,7 @@ fn test_add_instruction_processor_for_existing_unrelated_accounts() {
#[allow(deprecated)]
#[test]
fn test_recent_blockhashes_sysvar() {
let mut bank = create_simple_test_arc_bank(500);
let mut bank = create_simple_test_arc_bank(500).0;
for i in 1..5 {
let bhq_account = bank.get_account(&sysvar::recent_blockhashes::id()).unwrap();
let recent_blockhashes =
@ -4769,7 +4781,7 @@ fn test_recent_blockhashes_sysvar() {
#[allow(deprecated)]
#[test]
fn test_blockhash_queue_sysvar_consistency() {
let bank = create_simple_test_arc_bank(100_000);
let bank = create_simple_test_arc_bank(100_000).0;
goto_end_of_slot(bank.clone());
let bhq_account = bank.get_account(&sysvar::recent_blockhashes::id()).unwrap();
@ -4908,6 +4920,8 @@ fn nonce_setup(
Ok((custodian_keypair, nonce_keypair))
}
type NonceSetup = (Arc<Bank>, Keypair, Keypair, Keypair, Arc<RwLock<BankForks>>);
fn setup_nonce_with_bank<F>(
supply_lamports: u64,
mut genesis_cfg_fn: F,
@ -4915,7 +4929,7 @@ fn setup_nonce_with_bank<F>(
nonce_lamports: u64,
nonce_authority: Option<Pubkey>,
feature_set: FeatureSet,
) -> Result<(Arc<Bank>, Keypair, Keypair, Keypair)>
) -> Result<NonceSetup>
where
F: FnMut(&mut GenesisConfig),
{
@ -4946,7 +4960,13 @@ where
goto_end_of_slot(bank.clone());
bank = new_from_parent_with_fork_next_slot(bank, bank_forks.as_ref());
Ok((bank, mint_keypair, custodian_keypair, nonce_keypair))
Ok((
bank,
mint_keypair,
custodian_keypair,
nonce_keypair,
bank_forks,
))
}
impl Bank {
@ -4959,7 +4979,7 @@ impl Bank {
#[test]
fn test_check_transaction_for_nonce_ok() {
let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
let (bank, _mint_keypair, custodian_keypair, nonce_keypair, _) = setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
@ -4993,7 +5013,7 @@ fn test_check_transaction_for_nonce_ok() {
#[test]
fn test_check_transaction_for_nonce_not_nonce_fail() {
let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
let (bank, _mint_keypair, custodian_keypair, nonce_keypair, _) = setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
@ -5025,7 +5045,7 @@ fn test_check_transaction_for_nonce_not_nonce_fail() {
#[test]
fn test_check_transaction_for_nonce_missing_ix_pubkey_fail() {
let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
let (bank, _mint_keypair, custodian_keypair, nonce_keypair, _) = setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
@ -5058,7 +5078,7 @@ fn test_check_transaction_for_nonce_missing_ix_pubkey_fail() {
#[test]
fn test_check_transaction_for_nonce_nonce_acc_does_not_exist_fail() {
let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
let (bank, _mint_keypair, custodian_keypair, nonce_keypair, _) = setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
@ -5092,7 +5112,7 @@ fn test_check_transaction_for_nonce_nonce_acc_does_not_exist_fail() {
#[test]
fn test_check_transaction_for_nonce_bad_tx_hash_fail() {
let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
let (bank, _mint_keypair, custodian_keypair, nonce_keypair, _) = setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
@ -5123,7 +5143,7 @@ fn test_check_transaction_for_nonce_bad_tx_hash_fail() {
#[test]
fn test_assign_from_nonce_account_fail() {
let bank = create_simple_test_arc_bank(100_000_000);
let bank = create_simple_test_arc_bank(100_000_000).0;
let nonce = Keypair::new();
let nonce_account = AccountSharedData::new_data(
42_424_242,
@ -5176,15 +5196,16 @@ fn test_nonce_must_be_advanceable() {
#[test]
fn test_nonce_transaction() {
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
250_000,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair, bank_forks) =
setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
250_000,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let alice_keypair = Keypair::new();
let alice_pubkey = alice_keypair.pubkey();
let custodian_pubkey = custodian_keypair.pubkey();
@ -5199,7 +5220,7 @@ fn test_nonce_transaction() {
/* Kick nonce hash off the blockhash_queue */
for _ in 0..MAX_RECENT_BLOCKHASHES + 1 {
goto_end_of_slot(bank.clone());
bank = Arc::new(new_from_parent(bank));
bank = new_from_parent_with_fork_next_slot(bank, bank_forks.as_ref());
}
/* Expect a non-Nonce transfer to fail */
@ -5268,7 +5289,7 @@ fn test_nonce_transaction() {
/* Kick nonce hash off the blockhash_queue */
for _ in 0..MAX_RECENT_BLOCKHASHES + 1 {
goto_end_of_slot(bank.clone());
bank = Arc::new(new_from_parent(bank));
bank = new_from_parent_with_fork_next_slot(bank, bank_forks.as_ref());
}
let nonce_tx = Transaction::new_signed_with_payer(
@ -5310,7 +5331,7 @@ fn test_nonce_transaction() {
#[test]
fn test_nonce_transaction_with_tx_wide_caps() {
let feature_set = FeatureSet::all_enabled();
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) =
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair, bank_forks) =
setup_nonce_with_bank(10_000_000, |_| {}, 5_000_000, 250_000, None, feature_set).unwrap();
let alice_keypair = Keypair::new();
let alice_pubkey = alice_keypair.pubkey();
@ -5326,7 +5347,7 @@ fn test_nonce_transaction_with_tx_wide_caps() {
/* Kick nonce hash off the blockhash_queue */
for _ in 0..MAX_RECENT_BLOCKHASHES + 1 {
goto_end_of_slot(bank.clone());
bank = Arc::new(new_from_parent(bank));
bank = new_from_parent_with_fork_next_slot(bank, bank_forks.as_ref());
}
/* Expect a non-Nonce transfer to fail */
@ -5395,7 +5416,7 @@ fn test_nonce_transaction_with_tx_wide_caps() {
/* Kick nonce hash off the blockhash_queue */
for _ in 0..MAX_RECENT_BLOCKHASHES + 1 {
goto_end_of_slot(bank.clone());
bank = Arc::new(new_from_parent(bank));
bank = new_from_parent_with_fork_next_slot(bank, bank_forks.as_ref());
}
let nonce_tx = Transaction::new_signed_with_payer(
@ -5437,15 +5458,16 @@ fn test_nonce_transaction_with_tx_wide_caps() {
#[test]
fn test_nonce_authority() {
solana_logger::setup();
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
250_000,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair, bank_forks) =
setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
250_000,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let alice_keypair = Keypair::new();
let alice_pubkey = alice_keypair.pubkey();
let custodian_pubkey = custodian_keypair.pubkey();
@ -5463,7 +5485,7 @@ fn test_nonce_authority() {
for _ in 0..MAX_RECENT_BLOCKHASHES + 1 {
goto_end_of_slot(bank.clone());
bank = Arc::new(new_from_parent(bank));
bank = new_from_parent_with_fork_next_slot(bank, bank_forks.as_ref());
}
let nonce_tx = Transaction::new_signed_with_payer(
@ -5498,15 +5520,16 @@ fn test_nonce_authority() {
fn test_nonce_payer() {
solana_logger::setup();
let nonce_starting_balance = 250_000;
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
nonce_starting_balance,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair, bank_forks) =
setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
nonce_starting_balance,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let alice_keypair = Keypair::new();
let alice_pubkey = alice_keypair.pubkey();
let custodian_pubkey = custodian_keypair.pubkey();
@ -5521,7 +5544,7 @@ fn test_nonce_payer() {
for _ in 0..MAX_RECENT_BLOCKHASHES + 1 {
goto_end_of_slot(bank.clone());
bank = Arc::new(new_from_parent(bank));
bank = new_from_parent_with_fork_next_slot(bank, bank_forks.as_ref());
}
let nonce_tx = Transaction::new_signed_with_payer(
@ -5563,15 +5586,16 @@ fn test_nonce_payer_tx_wide_cap() {
let nonce_starting_balance =
250_000 + FeeStructure::default().compute_fee_bins.last().unwrap().fee;
let feature_set = FeatureSet::all_enabled();
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
nonce_starting_balance,
None,
feature_set,
)
.unwrap();
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair, bank_forks) =
setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
nonce_starting_balance,
None,
feature_set,
)
.unwrap();
let alice_keypair = Keypair::new();
let alice_pubkey = alice_keypair.pubkey();
let custodian_pubkey = custodian_keypair.pubkey();
@ -5586,7 +5610,7 @@ fn test_nonce_payer_tx_wide_cap() {
for _ in 0..MAX_RECENT_BLOCKHASHES + 1 {
goto_end_of_slot(bank.clone());
bank = Arc::new(new_from_parent(bank));
bank = new_from_parent_with_fork_next_slot(bank, bank_forks.as_ref());
}
let nonce_tx = Transaction::new_signed_with_payer(
@ -5761,15 +5785,16 @@ fn test_nonce_fee_calculator_updates_tx_wide_cap() {
#[test]
fn test_check_ro_durable_nonce_fails() {
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
250_000,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair, bank_forks) =
setup_nonce_with_bank(
10_000_000,
|_| {},
5_000_000,
250_000,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let custodian_pubkey = custodian_keypair.pubkey();
let nonce_pubkey = nonce_keypair.pubkey();
@ -5802,7 +5827,7 @@ fn test_check_ro_durable_nonce_fails() {
// Kick nonce hash off the blockhash_queue
for _ in 0..MAX_RECENT_BLOCKHASHES + 1 {
goto_end_of_slot(bank.clone());
bank = Arc::new(new_from_parent(bank));
bank = new_from_parent_with_fork_next_slot(bank, bank_forks.as_ref())
}
// Caught by the runtime because it is a nonce transaction
assert_eq!(
@ -5820,7 +5845,7 @@ fn test_check_ro_durable_nonce_fails() {
#[test]
fn test_collect_balances() {
let parent = create_simple_test_arc_bank(500);
let parent = create_simple_test_arc_bank(500).0;
let bank0 = Arc::new(new_from_parent(parent));
let keypair = Keypair::new();
@ -6048,7 +6073,7 @@ fn test_transaction_with_program_ids_passed_to_programs() {
fn test_account_ids_after_program_ids() {
solana_logger::setup();
let (genesis_config, mint_keypair) = create_genesis_config(500);
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let from_pubkey = solana_sdk::pubkey::new_rand();
let to_pubkey = solana_sdk::pubkey::new_rand();
@ -6070,8 +6095,13 @@ fn test_account_ids_after_program_ids() {
let slot = bank.slot().saturating_add(1);
let mut bank = Bank::new_from_parent(bank, &Pubkey::default(), slot);
bank.add_mockup_builtin(solana_vote_program::id(), MockBuiltin::vm);
let bank = bank_forks
.write()
.unwrap()
.insert(bank)
.clone_without_scheduler();
let result = bank.process_transaction(&tx);
assert_eq!(result, Ok(()));
let account = bank.get_account(&solana_vote_program::id()).unwrap();
@ -6690,7 +6720,7 @@ fn test_add_builtin_no_overwrite() {
let program_id = solana_sdk::pubkey::new_rand();
let mut bank = Arc::new(Bank::new_from_parent(
create_simple_test_arc_bank(100_000),
create_simple_test_arc_bank(100_000).0,
&Pubkey::default(),
slot,
));
@ -6714,7 +6744,7 @@ fn test_add_builtin_loader_no_overwrite() {
let loader_id = solana_sdk::pubkey::new_rand();
let mut bank = Arc::new(Bank::new_from_parent(
create_simple_test_arc_bank(100_000),
create_simple_test_arc_bank(100_000).0,
&Pubkey::default(),
slot,
));
@ -6901,7 +6931,7 @@ fn test_add_builtin_account_after_frozen() {
let program_id = Pubkey::from_str("CiXgo2KHKSDmDnV1F6B69eWFgNAPiSBjjYvfB4cvRNre").unwrap();
let bank = Bank::new_from_parent(
create_simple_test_arc_bank(100_000),
create_simple_test_arc_bank(100_000).0,
&Pubkey::default(),
slot,
);
@ -6920,7 +6950,7 @@ fn test_add_builtin_account_replace_none() {
let program_id = Pubkey::from_str("CiXgo2KHKSDmDnV1F6B69eWFgNAPiSBjjYvfB4cvRNre").unwrap();
let bank = Bank::new_from_parent(
create_simple_test_arc_bank(100_000),
create_simple_test_arc_bank(100_000).0,
&Pubkey::default(),
slot,
);
@ -7053,7 +7083,7 @@ fn test_add_precompiled_account_after_frozen() {
let program_id = Pubkey::from_str("CiXgo2KHKSDmDnV1F6B69eWFgNAPiSBjjYvfB4cvRNre").unwrap();
let bank = Bank::new_from_parent(
create_simple_test_arc_bank(100_000),
create_simple_test_arc_bank(100_000).0,
&Pubkey::default(),
slot,
);
@ -7132,7 +7162,7 @@ fn test_bpf_loader_upgradeable_deploy_with_max_len() {
let (genesis_config, mint_keypair) = create_genesis_config(1_000_000_000);
let mut bank = Bank::new_for_tests(&genesis_config);
bank.feature_set = Arc::new(FeatureSet::all_enabled());
let bank = bank.wrap_with_bank_forks_for_tests().0;
let (bank, bank_forks) = bank.wrap_with_bank_forks_for_tests();
let mut bank_client = BankClient::new_shared(bank.clone());
// Setup keypairs and addresses
@ -7302,7 +7332,9 @@ fn test_bpf_loader_upgradeable_deploy_with_max_len() {
// Test initialized program account
bank.clear_signatures();
bank.store_account(&buffer_address, &buffer_account);
let bank = bank_client.advance_slot(1, &mint_keypair.pubkey()).unwrap();
let bank = bank_client
.advance_slot(1, bank_forks.as_ref(), &mint_keypair.pubkey())
.unwrap();
let message = Message::new(
&[Instruction::new_with_bincode(
bpf_loader_upgradeable::id(),
@ -7849,7 +7881,7 @@ fn test_bpf_loader_upgradeable_deploy_with_max_len() {
#[test]
fn test_compute_active_feature_set() {
let bank0 = create_simple_test_arc_bank(100_000);
let bank0 = create_simple_test_arc_bank(100_000).0;
let mut bank = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
let test_feature = "TestFeature11111111111111111111111111111111"
@ -11698,7 +11730,7 @@ fn test_accounts_data_size_from_genesis() {
genesis_config.rent = Rent::default();
genesis_config.ticks_per_slot = 3;
let mut bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let (mut bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
assert_eq!(
bank.load_accounts_data_size() as usize,
bank.get_total_accounts_stats().unwrap().data_len
@ -11707,7 +11739,12 @@ fn test_accounts_data_size_from_genesis() {
// Create accounts over a number of banks and ensure the accounts data size remains correct
for _ in 0..10 {
let slot = bank.slot() + 1;
bank = Arc::new(Bank::new_from_parent(bank, &Pubkey::default(), slot));
bank = new_bank_from_parent_with_bank_forks(
bank_forks.as_ref(),
bank,
&Pubkey::default(),
slot,
);
// Store an account into the bank that is rent-exempt and has data
let data_size = rand::thread_rng().gen_range(3333..4444);
@ -12050,7 +12087,7 @@ fn test_calculate_fee_with_request_heap_frame_flag() {
fn test_is_in_slot_hashes_history() {
use solana_sdk::slot_hashes::MAX_ENTRIES;
let bank0 = create_simple_test_arc_bank(1);
let bank0 = create_simple_test_arc_bank(1).0;
assert!(!bank0.is_in_slot_hashes_history(&0));
assert!(!bank0.is_in_slot_hashes_history(&1));
let mut last_bank = bank0;
@ -12072,8 +12109,7 @@ fn test_feature_activation_loaded_programs_recompilation_phase() {
genesis_config
.accounts
.remove(&feature_set::reject_callx_r10::id());
let bank_forks = BankForks::new_rw_arc(Bank::new_for_tests(&genesis_config));
let root_bank = bank_forks.read().unwrap().root_bank();
let (root_bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
// Test a basic transfer
let amount = genesis_config.rent.minimum_balance(0);
@ -12103,7 +12139,7 @@ fn test_feature_activation_loaded_programs_recompilation_phase() {
// Advance the bank so the next transaction can be submitted.
goto_end_of_slot(root_bank.clone());
let bank = Arc::new(new_from_parent(root_bank));
let bank = new_from_parent_with_fork_next_slot(root_bank, bank_forks.as_ref());
// Compose second instruction using the same program with a different block hash
let instruction2 = Instruction::new_with_bytes(program_keypair.pubkey(), &[], Vec::new());
@ -12132,7 +12168,7 @@ fn test_feature_activation_loaded_programs_recompilation_phase() {
goto_end_of_slot(bank.clone());
// Advance to next epoch, which starts the recompilation phase
let bank = new_from_parent_next_epoch(bank, 1);
let bank = new_from_parent_next_epoch(bank, bank_forks.as_ref(), 1);
// Execute after feature is enabled to check it was filtered out and reverified.
let result_with_feature_enabled = bank.process_transaction(&transaction2);

21
runtime/src/bank_client.rs
View File

@ -4,7 +4,6 @@ use {
solana_sdk::{
account::Account,
client::{AsyncClient, Client, SyncClient},
clock,
commitment_config::CommitmentConfig,
epoch_info::EpochInfo,
fee_calculator::{FeeCalculator, FeeRateGovernor},
@ -27,6 +26,8 @@ use {
time::{Duration, Instant},
},
};
#[cfg(feature = "dev-context-only-utils")]
use {crate::bank_forks::BankForks, solana_sdk::clock, std::sync::RwLock};
pub struct BankClient {
bank: Arc<Bank>,
@ -330,12 +331,24 @@ impl BankClient {
self.bank.set_sysvar_for_tests(sysvar);
}
pub fn advance_slot(&mut self, by: u64, collector_id: &Pubkey) -> Option<Arc<Bank>> {
self.bank = Arc::new(Bank::new_from_parent(
#[cfg(feature = "dev-context-only-utils")]
pub fn advance_slot(
&mut self,
by: u64,
bank_forks: &RwLock<BankForks>,
collector_id: &Pubkey,
) -> Option<Arc<Bank>> {
let new_bank = Bank::new_from_parent(
self.bank.clone(),
collector_id,
self.bank.slot().checked_add(by)?,
));
);
self.bank = bank_forks
.write()
.unwrap()
.insert(new_bank)
.clone_without_scheduler();
self.set_sysvar_for_tests(&clock::Clock {
slot: self.bank.slot(),
..clock::Clock::default()

54
send-transaction-service/src/send_transaction_service.rs
View File

@ -892,28 +892,37 @@ mod test {
solana_logger::setup();
let (genesis_config, mint_keypair) = create_genesis_config(4);
let bank = Bank::new_for_tests(&genesis_config);
let bank_forks = BankForks::new_rw_arc(bank);
let (_, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let tpu_address = "127.0.0.1:0".parse().unwrap();
let config = Config {
leader_forward_count: 1,
..Config::default()
};
let root_bank = Arc::new(Bank::new_from_parent(
let root_bank = Bank::new_from_parent(
bank_forks.read().unwrap().working_bank(),
&Pubkey::default(),
1,
));
);
let root_bank = bank_forks
.write()
.unwrap()
.insert(root_bank)
.clone_without_scheduler();
let rooted_signature = root_bank
.transfer(1, &mint_keypair, &mint_keypair.pubkey())
.unwrap();
let working_bank = Arc::new(Bank::new_from_parent(
root_bank.clone(),
&Pubkey::default(),
2,
));
let working_bank = bank_forks
.write()
.unwrap()
.insert(Bank::new_from_parent(
root_bank.clone(),
&Pubkey::default(),
2,
))
.clone_without_scheduler();
let non_rooted_signature = working_bank
.transfer(2, &mint_keypair, &mint_keypair.pubkey())
@ -1158,19 +1167,24 @@ mod test {
solana_logger::setup();
let (genesis_config, mint_keypair) = create_genesis_config(4);
let bank = Bank::new_for_tests(&genesis_config);
let bank_forks = BankForks::new_rw_arc(bank);
let (_, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let tpu_address = "127.0.0.1:0".parse().unwrap();
let config = Config {
leader_forward_count: 1,
..Config::default()
};
let root_bank = Arc::new(Bank::new_from_parent(
let root_bank = Bank::new_from_parent(
bank_forks.read().unwrap().working_bank(),
&Pubkey::default(),
1,
));
);
let root_bank = bank_forks
.write()
.unwrap()
.insert(root_bank)
.clone_without_scheduler();
let rooted_signature = root_bank
.transfer(1, &mint_keypair, &mint_keypair.pubkey())
.unwrap();
@ -1184,11 +1198,15 @@ mod test {
AccountSharedData::new_data(43, &nonce_state, &system_program::id()).unwrap();
root_bank.store_account(&nonce_address, &nonce_account);
let working_bank = Arc::new(Bank::new_from_parent(
root_bank.clone(),
&Pubkey::default(),
2,
));
let working_bank = bank_forks
.write()
.unwrap()
.insert(Bank::new_from_parent(
root_bank.clone(),
&Pubkey::default(),
2,
))
.clone_without_scheduler();
let non_rooted_signature = working_bank
.transfer(2, &mint_keypair, &mint_keypair.pubkey())
.unwrap();

15
stake-accounts/src/stake_accounts.rs
View File

@ -292,11 +292,12 @@ mod tests {
stake::state::StakeStateV2,
},
solana_stake_program::stake_state,
std::sync::Arc,
};
fn create_bank(lamports: u64) -> (Bank, Keypair, u64, u64) {
fn create_bank(lamports: u64) -> (Arc<Bank>, Keypair, u64, u64) {
let (genesis_config, mint_keypair) = create_genesis_config(lamports);
let bank = Bank::new_for_tests(&genesis_config);
let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
let stake_rent = bank.get_minimum_balance_for_rent_exemption(StakeStateV2::size_of());
let system_rent = bank.get_minimum_balance_for_rent_exemption(0);
(bank, mint_keypair, stake_rent, system_rent)
@ -355,7 +356,7 @@ mod tests {
fn test_new_derived_stake_account() {
let (bank, funding_keypair, stake_rent, system_rent) = create_bank(10_000_000);
let funding_pubkey = funding_keypair.pubkey();
let bank_client = BankClient::new(bank);
let bank_client = BankClient::new_shared(bank);
let fee_payer_keypair = create_account(&bank_client, &funding_keypair, system_rent);
let fee_payer_pubkey = fee_payer_keypair.pubkey();
@ -392,7 +393,7 @@ mod tests {
fn test_authorize_stake_accounts() {
let (bank, funding_keypair, stake_rent, system_rent) = create_bank(10_000_000);
let funding_pubkey = funding_keypair.pubkey();
let bank_client = BankClient::new(bank);
let bank_client = BankClient::new_shared(bank);
let fee_payer_keypair = create_account(&bank_client, &funding_keypair, system_rent);
let fee_payer_pubkey = fee_payer_keypair.pubkey();
@ -454,7 +455,7 @@ mod tests {
fn test_lockup_stake_accounts() {
let (bank, funding_keypair, stake_rent, system_rent) = create_bank(10_000_000);
let funding_pubkey = funding_keypair.pubkey();
let bank_client = BankClient::new(bank);
let bank_client = BankClient::new_shared(bank);
let fee_payer_keypair = create_account(&bank_client, &funding_keypair, system_rent);
let fee_payer_pubkey = fee_payer_keypair.pubkey();
@ -545,7 +546,7 @@ mod tests {
fn test_rebase_stake_accounts() {
let (bank, funding_keypair, stake_rent, system_rent) = create_bank(10_000_000);
let funding_pubkey = funding_keypair.pubkey();
let bank_client = BankClient::new(bank);
let bank_client = BankClient::new_shared(bank);
let fee_payer_keypair = create_account(&bank_client, &funding_keypair, system_rent);
let fee_payer_pubkey = fee_payer_keypair.pubkey();
@ -608,7 +609,7 @@ mod tests {
fn test_move_stake_accounts() {
let (bank, funding_keypair, stake_rent, system_rent) = create_bank(10_000_000);
let funding_pubkey = funding_keypair.pubkey();
let bank_client = BankClient::new(bank);
let bank_client = BankClient::new_shared(bank);
let fee_payer_keypair = create_account(&bank_client, &funding_keypair, system_rent);
let fee_payer_pubkey = fee_payer_keypair.pubkey();