Remove improper uses of &Arc<Bank> (#32802)
In most cases, either a &Bank or an Arc<Bank> is more proper. - &Bank is used if the function only needs a momentary reference - Arc<Bank> is used if the function needs its' own copy This PR leaves several instances of &Arc<Bank> around; these instances are situations where a clone may only happen conditionally.
This commit is contained in:
parent
3cda810358
commit
a4c8cc3ce0
|
@ -416,8 +416,12 @@ fn main() {
|
|||
Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"),
|
||||
);
|
||||
let leader_schedule_cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank));
|
||||
let (exit, poh_recorder, poh_service, signal_receiver) =
|
||||
create_test_recorder(&bank, blockstore.clone(), None, Some(leader_schedule_cache));
|
||||
let (exit, poh_recorder, poh_service, signal_receiver) = create_test_recorder(
|
||||
bank.clone(),
|
||||
blockstore.clone(),
|
||||
None,
|
||||
Some(leader_schedule_cache),
|
||||
);
|
||||
let (banking_tracer, tracer_thread) =
|
||||
BankingTracer::new(matches.is_present("trace_banking").then_some((
|
||||
&blockstore.banking_trace_path(),
|
||||
|
@ -528,7 +532,8 @@ fn main() {
|
|||
poh_time.stop();
|
||||
|
||||
let mut new_bank_time = Measure::start("new_bank");
|
||||
let new_bank = Bank::new_from_parent(&bank, &collector, bank.slot() + 1);
|
||||
let new_slot = bank.slot() + 1;
|
||||
let new_bank = Bank::new_from_parent(bank, &collector, new_slot);
|
||||
new_bank_time.stop();
|
||||
|
||||
let mut insert_time = Measure::start("insert_time");
|
||||
|
|
|
@ -136,7 +136,7 @@ fn test_account_subscription() {
|
|||
let blockhash = bank.last_blockhash();
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let bob = Keypair::new();
|
||||
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
|
||||
|
@ -342,7 +342,7 @@ fn test_program_subscription() {
|
|||
let blockhash = bank.last_blockhash();
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let bob = Keypair::new();
|
||||
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
|
||||
|
@ -429,7 +429,7 @@ fn test_root_subscription() {
|
|||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
|
||||
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
|
||||
|
|
|
@ -86,7 +86,7 @@ fn bench_consume_buffered(bencher: &mut Bencher) {
|
|||
Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"),
|
||||
);
|
||||
let (exit, poh_recorder, poh_service, _signal_receiver) =
|
||||
create_test_recorder(&bank, blockstore, None, None);
|
||||
create_test_recorder(bank, blockstore, None, None);
|
||||
|
||||
let recorder = poh_recorder.read().unwrap().new_recorder();
|
||||
let bank_start = poh_recorder.read().unwrap().bank_start().unwrap();
|
||||
|
@ -282,7 +282,7 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
|
|||
Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"),
|
||||
);
|
||||
let (exit, poh_recorder, poh_service, signal_receiver) =
|
||||
create_test_recorder(&bank, blockstore, None, None);
|
||||
create_test_recorder(bank.clone(), blockstore, None, None);
|
||||
let cluster_info = {
|
||||
let keypair = Arc::new(Keypair::new());
|
||||
let node = Node::new_localhost_with_pubkey(&keypair.pubkey());
|
||||
|
|
|
@ -122,7 +122,7 @@ fn setup(apply_cost_tracker_during_replay: bool) -> BenchFrame {
|
|||
Blockstore::open(ledger_path.path()).expect("Expected to be able to open database ledger"),
|
||||
);
|
||||
let (exit, poh_recorder, poh_service, signal_receiver) =
|
||||
create_test_recorder(&bank, blockstore, None, None);
|
||||
create_test_recorder(bank.clone(), blockstore, None, None);
|
||||
|
||||
BenchFrame {
|
||||
bank,
|
||||
|
|
|
@ -650,7 +650,7 @@ mod tests {
|
|||
let genesis_config = create_genesis_config(2).genesis_config;
|
||||
let bank = Bank::new_no_wallclock_throttle_for_tests(&genesis_config);
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank = Arc::new(bank_forks.read().unwrap().get(0).unwrap());
|
||||
let bank = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let banking_tracer = BankingTracer::new_disabled();
|
||||
let (non_vote_sender, non_vote_receiver) = banking_tracer.create_channel_non_vote();
|
||||
let (tpu_vote_sender, tpu_vote_receiver) = banking_tracer.create_channel_tpu_vote();
|
||||
|
@ -663,7 +663,7 @@ mod tests {
|
|||
.expect("Expected to be able to open database ledger"),
|
||||
);
|
||||
let (exit, poh_recorder, poh_service, _entry_receiever) =
|
||||
create_test_recorder(&bank, blockstore, None, None);
|
||||
create_test_recorder(bank, blockstore, None, None);
|
||||
let (_, cluster_info) = new_test_cluster_info(/*keypair:*/ None);
|
||||
let cluster_info = Arc::new(cluster_info);
|
||||
let (replay_vote_sender, _replay_vote_receiver) = unbounded();
|
||||
|
@ -701,7 +701,7 @@ mod tests {
|
|||
let num_extra_ticks = 2;
|
||||
let bank = Bank::new_no_wallclock_throttle_for_tests(&genesis_config);
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank = Arc::new(bank_forks.read().unwrap().get(0).unwrap());
|
||||
let bank = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let start_hash = bank.last_blockhash();
|
||||
let banking_tracer = BankingTracer::new_disabled();
|
||||
let (non_vote_sender, non_vote_receiver) = banking_tracer.create_channel_non_vote();
|
||||
|
@ -719,7 +719,7 @@ mod tests {
|
|||
..PohConfig::default()
|
||||
};
|
||||
let (exit, poh_recorder, poh_service, entry_receiver) =
|
||||
create_test_recorder(&bank, blockstore, Some(poh_config), None);
|
||||
create_test_recorder(bank.clone(), blockstore, Some(poh_config), None);
|
||||
let (_, cluster_info) = new_test_cluster_info(/*keypair:*/ None);
|
||||
let cluster_info = Arc::new(cluster_info);
|
||||
let (replay_vote_sender, _replay_vote_receiver) = unbounded();
|
||||
|
@ -780,7 +780,7 @@ mod tests {
|
|||
} = create_slow_genesis_config(10);
|
||||
let bank = Bank::new_no_wallclock_throttle_for_tests(&genesis_config);
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank = Arc::new(bank_forks.read().unwrap().get(0).unwrap());
|
||||
let bank = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let start_hash = bank.last_blockhash();
|
||||
let banking_tracer = BankingTracer::new_disabled();
|
||||
let (non_vote_sender, non_vote_receiver) = banking_tracer.create_channel_non_vote();
|
||||
|
@ -800,7 +800,7 @@ mod tests {
|
|||
..PohConfig::default()
|
||||
};
|
||||
let (exit, poh_recorder, poh_service, entry_receiver) =
|
||||
create_test_recorder(&bank, blockstore, Some(poh_config), None);
|
||||
create_test_recorder(bank.clone(), blockstore, Some(poh_config), None);
|
||||
let (_, cluster_info) = new_test_cluster_info(/*keypair:*/ None);
|
||||
let cluster_info = Arc::new(cluster_info);
|
||||
let (replay_vote_sender, _replay_vote_receiver) = unbounded();
|
||||
|
@ -951,7 +951,7 @@ mod tests {
|
|||
// start a banking_stage to eat verified receiver
|
||||
let bank = Bank::new_no_wallclock_throttle_for_tests(&genesis_config);
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank = Arc::new(bank_forks.read().unwrap().get(0).unwrap());
|
||||
let bank = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let blockstore = Arc::new(
|
||||
Blockstore::open(ledger_path.path())
|
||||
.expect("Expected to be able to open database ledger"),
|
||||
|
@ -963,7 +963,7 @@ mod tests {
|
|||
..PohConfig::default()
|
||||
};
|
||||
let (exit, poh_recorder, poh_service, entry_receiver) =
|
||||
create_test_recorder(&bank, blockstore, Some(poh_config), None);
|
||||
create_test_recorder(bank.clone(), blockstore, Some(poh_config), None);
|
||||
let (_, cluster_info) = new_test_cluster_info(/*keypair:*/ None);
|
||||
let cluster_info = Arc::new(cluster_info);
|
||||
let _banking_stage = BankingStage::new_num_threads(
|
||||
|
@ -1136,7 +1136,7 @@ mod tests {
|
|||
);
|
||||
let bank = Bank::new_no_wallclock_throttle_for_tests(&genesis_config);
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank = Arc::new(bank_forks.read().unwrap().get(0).unwrap());
|
||||
let bank = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let start_hash = bank.last_blockhash();
|
||||
let banking_tracer = BankingTracer::new_disabled();
|
||||
let (non_vote_sender, non_vote_receiver) = banking_tracer.create_channel_non_vote();
|
||||
|
@ -1156,7 +1156,7 @@ mod tests {
|
|||
..PohConfig::default()
|
||||
};
|
||||
let (exit, poh_recorder, poh_service, _entry_receiver) =
|
||||
create_test_recorder(&bank, blockstore, Some(poh_config), None);
|
||||
create_test_recorder(bank.clone(), blockstore, Some(poh_config), None);
|
||||
let (_, cluster_info) = new_test_cluster_info(/*keypair:*/ None);
|
||||
let cluster_info = Arc::new(cluster_info);
|
||||
let (replay_vote_sender, _replay_vote_receiver) = unbounded();
|
||||
|
|
|
@ -688,7 +688,7 @@ impl Consumer {
|
|||
/// * `transactions` - a batch of transactions deserialized from packets
|
||||
/// * `pending_indexes` - identifies which indexes in the `transactions` list are still pending
|
||||
fn filter_pending_packets_from_pending_txs(
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
transactions: &[SanitizedTransaction],
|
||||
pending_indexes: &[usize],
|
||||
) -> Vec<usize> {
|
||||
|
@ -1701,7 +1701,7 @@ mod tests {
|
|||
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 bank = Arc::new(Bank::new_from_parent(bank, &Pubkey::new_unique(), 1));
|
||||
let message = VersionedMessage::V0(v0::Message {
|
||||
header: MessageHeader {
|
||||
num_required_signatures: 1,
|
||||
|
|
|
@ -151,12 +151,13 @@ mod tests {
|
|||
let ledger_path = temp_dir();
|
||||
let blockstore = Arc::new(Blockstore::open(ledger_path.as_path()).unwrap());
|
||||
let (exit, poh_recorder, poh_service, _entry_receiver) =
|
||||
create_test_recorder(&bank, blockstore, None, None);
|
||||
create_test_recorder(bank.clone(), blockstore, None, None);
|
||||
|
||||
let my_pubkey = Pubkey::new_unique();
|
||||
let decision_maker = DecisionMaker::new(my_pubkey, poh_recorder.clone());
|
||||
poh_recorder.write().unwrap().reset(bank.clone(), None);
|
||||
let bank = Arc::new(Bank::new_from_parent(&bank, &my_pubkey, bank.slot() + 1));
|
||||
let slot = bank.slot() + 1;
|
||||
let bank = Arc::new(Bank::new_from_parent(bank, &my_pubkey, slot));
|
||||
|
||||
// Currently Leader - Consume
|
||||
{
|
||||
|
|
|
@ -323,7 +323,7 @@ mod tests {
|
|||
};
|
||||
|
||||
let (exit, poh_recorder, poh_service, _entry_receiver) =
|
||||
create_test_recorder(&bank, blockstore, Some(poh_config), None);
|
||||
create_test_recorder(bank, blockstore, Some(poh_config), None);
|
||||
|
||||
let (local_node, cluster_info) = new_test_cluster_info(Some(validator_keypair));
|
||||
let cluster_info = Arc::new(cluster_info);
|
||||
|
|
|
@ -116,7 +116,7 @@ impl LatestValidatorVotePacket {
|
|||
// This requires updating dependencies of ed25519-dalek as rand_core is not compatible cross
|
||||
// version https://github.com/dalek-cryptography/ed25519-dalek/pull/214
|
||||
pub(crate) fn weighted_random_order_by_stake<'a>(
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
pubkeys: impl Iterator<Item = &'a Pubkey>,
|
||||
) -> impl Iterator<Item = Pubkey> {
|
||||
// Efraimidis and Spirakis algo for weighted random sample without replacement
|
||||
|
|
|
@ -868,7 +868,7 @@ mod tests {
|
|||
|
||||
// Create a child descended from the first bank
|
||||
let next_bank = Arc::new(Bank::new_from_parent(
|
||||
&first_bank,
|
||||
first_bank.clone(),
|
||||
&Pubkey::new_unique(),
|
||||
first_bank.slot() + 1,
|
||||
));
|
||||
|
|
|
@ -14,10 +14,7 @@ use {
|
|||
saturating_add_assign,
|
||||
transaction::{self, SanitizedTransaction, TransactionError},
|
||||
},
|
||||
std::sync::{
|
||||
atomic::{AtomicU64, Ordering},
|
||||
Arc,
|
||||
},
|
||||
std::sync::atomic::{AtomicU64, Ordering},
|
||||
};
|
||||
|
||||
// QosService is local to each banking thread, each instance of QosService provides services to
|
||||
|
@ -137,7 +134,7 @@ impl QosService {
|
|||
pub fn update_costs<'a>(
|
||||
transaction_cost_results: impl Iterator<Item = &'a transaction::Result<TransactionCost>>,
|
||||
transaction_committed_status: Option<&Vec<CommitTransactionDetails>>,
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
) {
|
||||
if let Some(transaction_committed_status) = transaction_committed_status {
|
||||
Self::update_committed_transaction_costs(
|
||||
|
@ -152,7 +149,7 @@ impl QosService {
|
|||
pub fn remove_costs<'a>(
|
||||
transaction_cost_results: impl Iterator<Item = &'a transaction::Result<TransactionCost>>,
|
||||
transaction_committed_status: Option<&Vec<CommitTransactionDetails>>,
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
) {
|
||||
match transaction_committed_status {
|
||||
Some(transaction_committed_status) => Self::remove_uncommitted_transaction_costs(
|
||||
|
@ -167,7 +164,7 @@ impl QosService {
|
|||
fn remove_uncommitted_transaction_costs<'a>(
|
||||
transaction_cost_results: impl Iterator<Item = &'a transaction::Result<TransactionCost>>,
|
||||
transaction_committed_status: &Vec<CommitTransactionDetails>,
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
) {
|
||||
let mut cost_tracker = bank.write_cost_tracker().unwrap();
|
||||
transaction_cost_results
|
||||
|
@ -186,7 +183,7 @@ impl QosService {
|
|||
fn update_committed_transaction_costs<'a>(
|
||||
transaction_cost_results: impl Iterator<Item = &'a transaction::Result<TransactionCost>>,
|
||||
transaction_committed_status: &Vec<CommitTransactionDetails>,
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
) {
|
||||
let mut cost_tracker = bank.write_cost_tracker().unwrap();
|
||||
transaction_cost_results
|
||||
|
@ -206,7 +203,7 @@ impl QosService {
|
|||
|
||||
fn remove_transaction_costs<'a>(
|
||||
transaction_cost_results: impl Iterator<Item = &'a transaction::Result<TransactionCost>>,
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
) {
|
||||
let mut cost_tracker = bank.write_cost_tracker().unwrap();
|
||||
transaction_cost_results.for_each(|tx_cost| {
|
||||
|
@ -599,6 +596,7 @@ mod tests {
|
|||
system_transaction,
|
||||
},
|
||||
solana_vote_program::vote_transaction,
|
||||
std::sync::Arc,
|
||||
};
|
||||
|
||||
#[test]
|
||||
|
|
|
@ -182,12 +182,9 @@ mod tests {
|
|||
account.set_data(data);
|
||||
bank.store_account(&address_table_key, &account);
|
||||
|
||||
let slot = bank.slot() + 1;
|
||||
(
|
||||
Arc::new(Bank::new_from_parent(
|
||||
&bank,
|
||||
&Pubkey::new_unique(),
|
||||
bank.slot() + 1,
|
||||
)),
|
||||
Arc::new(Bank::new_from_parent(bank, &Pubkey::new_unique(), slot)),
|
||||
address_table_key,
|
||||
)
|
||||
}
|
||||
|
|
|
@ -711,7 +711,7 @@ impl ThreadLocalUnprocessedPackets {
|
|||
fn sanitize_unforwarded_packets(
|
||||
&mut self,
|
||||
packets_to_process: &[Arc<ImmutableDeserializedPacket>],
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
total_dropped_packets: &mut usize,
|
||||
) -> (Vec<SanitizedTransaction>, Vec<usize>) {
|
||||
// Get ref of ImmutableDeserializedPacket
|
||||
|
@ -721,11 +721,7 @@ impl ThreadLocalUnprocessedPackets {
|
|||
.enumerate()
|
||||
.filter_map(|(packet_index, deserialized_packet)| {
|
||||
deserialized_packet
|
||||
.build_sanitized_transaction(
|
||||
&bank.feature_set,
|
||||
bank.vote_only_bank(),
|
||||
bank.as_ref(),
|
||||
)
|
||||
.build_sanitized_transaction(&bank.feature_set, bank.vote_only_bank(), bank)
|
||||
.map(|transaction| (transaction, packet_index))
|
||||
})
|
||||
.unzip();
|
||||
|
@ -740,7 +736,7 @@ impl ThreadLocalUnprocessedPackets {
|
|||
/// Checks sanitized transactions against bank, returns valid transaction indexes
|
||||
fn filter_invalid_transactions(
|
||||
transactions: &[SanitizedTransaction],
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
total_dropped_packets: &mut usize,
|
||||
) -> Vec<usize> {
|
||||
let filter = vec![Ok(()); transactions.len()];
|
||||
|
|
|
@ -958,7 +958,7 @@ mod tests {
|
|||
.read()
|
||||
.unwrap()
|
||||
.contains_key(&bank.slot()));
|
||||
let bank1 = Bank::new_from_parent(&bank, &Pubkey::default(), bank.slot() + 1);
|
||||
let bank1 = Bank::new_from_parent(bank.clone(), &Pubkey::default(), bank.slot() + 1);
|
||||
vote_tracker.progress_with_new_root_bank(&bank1);
|
||||
assert!(!vote_tracker
|
||||
.slot_vote_trackers
|
||||
|
@ -969,12 +969,10 @@ mod tests {
|
|||
// Check `keys` and `epoch_authorized_voters` are purged when new
|
||||
// root bank moves to the next epoch
|
||||
let current_epoch = bank.epoch();
|
||||
let new_epoch_bank = Bank::new_from_parent(
|
||||
&bank,
|
||||
&Pubkey::default(),
|
||||
bank.epoch_schedule()
|
||||
.get_first_slot_in_epoch(current_epoch + 1),
|
||||
);
|
||||
let new_epoch_slot = bank
|
||||
.epoch_schedule()
|
||||
.get_first_slot_in_epoch(current_epoch + 1);
|
||||
let new_epoch_bank = Bank::new_from_parent(bank, &Pubkey::default(), new_epoch_slot);
|
||||
vote_tracker.progress_with_new_root_bank(&new_epoch_bank);
|
||||
}
|
||||
|
||||
|
@ -1020,7 +1018,7 @@ mod tests {
|
|||
let bank0 = Bank::new_for_tests(&genesis_config);
|
||||
// Votes for slots less than the provided root bank's slot should not be processed
|
||||
let bank3 = Arc::new(Bank::new_from_parent(
|
||||
&Arc::new(bank0),
|
||||
Arc::new(bank0),
|
||||
&Pubkey::default(),
|
||||
3,
|
||||
));
|
||||
|
@ -1541,7 +1539,7 @@ mod tests {
|
|||
.collect();
|
||||
|
||||
let new_root_bank =
|
||||
Bank::new_from_parent(&bank, &Pubkey::default(), first_slot_in_new_epoch - 2);
|
||||
Bank::new_from_parent(bank, &Pubkey::default(), first_slot_in_new_epoch - 2);
|
||||
ClusterInfoVoteListener::filter_and_confirm_with_new_votes(
|
||||
&vote_tracker,
|
||||
vote_txs,
|
||||
|
@ -1757,10 +1755,11 @@ mod tests {
|
|||
1
|
||||
);
|
||||
|
||||
let slot = current_leader_bank.slot() + 1;
|
||||
let current_leader_bank = Arc::new(Bank::new_from_parent(
|
||||
¤t_leader_bank,
|
||||
current_leader_bank,
|
||||
&Pubkey::default(),
|
||||
current_leader_bank.slot() + 1,
|
||||
slot,
|
||||
));
|
||||
ClusterInfoVoteListener::check_for_leader_bank_and_send_votes(
|
||||
&mut bank_vote_sender_state_option,
|
||||
|
|
|
@ -487,7 +487,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn test_highest_super_majority_root_advance() {
|
||||
fn get_vote_account_root_slot(vote_pubkey: Pubkey, bank: &Arc<Bank>) -> Slot {
|
||||
fn get_vote_account_root_slot(vote_pubkey: Pubkey, bank: &Bank) -> Slot {
|
||||
let vote_account = bank.get_vote_account(&vote_pubkey).unwrap();
|
||||
let slot = vote_account
|
||||
.vote_state()
|
||||
|
@ -515,7 +515,7 @@ mod tests {
|
|||
// Create enough banks such that vote account will root slots 0 and 1
|
||||
for x in 0..33 {
|
||||
let previous_bank = bank_forks.get(x).unwrap();
|
||||
let bank = Bank::new_from_parent(&previous_bank, &Pubkey::default(), x + 1);
|
||||
let bank = Bank::new_from_parent(previous_bank.clone(), &Pubkey::default(), x + 1);
|
||||
let vote = vote_transaction::new_vote_transaction(
|
||||
vec![x],
|
||||
previous_bank.hash(),
|
||||
|
@ -540,7 +540,7 @@ mod tests {
|
|||
|
||||
// Add an additional bank/vote that will root slot 2
|
||||
let bank33 = bank_forks.get(33).unwrap();
|
||||
let bank34 = Bank::new_from_parent(&bank33, &Pubkey::default(), 34);
|
||||
let bank34 = Bank::new_from_parent(bank33.clone(), &Pubkey::default(), 34);
|
||||
let vote33 = vote_transaction::new_vote_transaction(
|
||||
vec![33],
|
||||
bank33.hash(),
|
||||
|
@ -583,7 +583,7 @@ 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.get(33).unwrap();
|
||||
let bank35 = Bank::new_from_parent(&bank33, &Pubkey::default(), 35);
|
||||
let bank35 = Bank::new_from_parent(bank33, &Pubkey::default(), 35);
|
||||
bank_forks.insert(bank35);
|
||||
|
||||
let working_bank = bank_forks.working_bank();
|
||||
|
@ -608,7 +608,7 @@ mod tests {
|
|||
// continues normally
|
||||
for x in 35..=37 {
|
||||
let previous_bank = bank_forks.get(x).unwrap();
|
||||
let bank = Bank::new_from_parent(&previous_bank, &Pubkey::default(), x + 1);
|
||||
let bank = Bank::new_from_parent(previous_bank.clone(), &Pubkey::default(), x + 1);
|
||||
let vote = vote_transaction::new_vote_transaction(
|
||||
vec![x],
|
||||
previous_bank.hash(),
|
||||
|
|
|
@ -288,7 +288,7 @@ mod test {
|
|||
.bank_forks
|
||||
.write()
|
||||
.unwrap()
|
||||
.insert(Bank::new_from_parent(&bank6, &Pubkey::default(), 7));
|
||||
.insert(Bank::new_from_parent(bank6, &Pubkey::default(), 7));
|
||||
let bank7 = vote_simulator.bank_forks.read().unwrap().get(7).unwrap();
|
||||
assert!(!bank7.ancestors.contains_key(&3));
|
||||
|
||||
|
|
|
@ -1812,7 +1812,7 @@ mod test {
|
|||
let bank_forks = &repair_info.bank_forks;
|
||||
let root_bank = bank_forks.read().unwrap().root_bank();
|
||||
let new_root_slot = dead_duplicate_confirmed_slot_2 + 1;
|
||||
let new_root_bank = Bank::new_from_parent(&root_bank, &Pubkey::default(), new_root_slot);
|
||||
let new_root_bank = Bank::new_from_parent(root_bank, &Pubkey::default(), new_root_slot);
|
||||
new_root_bank.freeze();
|
||||
{
|
||||
let mut w_bank_forks = bank_forks.write().unwrap();
|
||||
|
|
|
@ -1950,7 +1950,7 @@ impl ReplayStage {
|
|||
};
|
||||
|
||||
let tpu_bank = Self::new_bank_from_parent_with_notify(
|
||||
&parent,
|
||||
parent.clone(),
|
||||
poh_slot,
|
||||
root_slot,
|
||||
my_pubkey,
|
||||
|
@ -2563,7 +2563,7 @@ impl ReplayStage {
|
|||
return replay_result;
|
||||
}
|
||||
|
||||
let bank = &bank_forks.read().unwrap().get(bank_slot).unwrap();
|
||||
let bank = bank_forks.read().unwrap().get(bank_slot).unwrap();
|
||||
let parent_slot = bank.parent_slot();
|
||||
let (num_blocks_on_fork, num_dropped_blocks_on_fork) = {
|
||||
let stats = progress_lock
|
||||
|
@ -2575,11 +2575,11 @@ impl ReplayStage {
|
|||
stats.num_dropped_blocks_on_fork + new_dropped_blocks;
|
||||
(num_blocks_on_fork, num_dropped_blocks_on_fork)
|
||||
};
|
||||
let prev_leader_slot = progress_lock.get_bank_prev_leader_slot(bank);
|
||||
let prev_leader_slot = progress_lock.get_bank_prev_leader_slot(&bank);
|
||||
|
||||
let bank_progress = progress_lock.entry(bank.slot()).or_insert_with(|| {
|
||||
ForkProgress::new_from_bank(
|
||||
bank,
|
||||
&bank,
|
||||
my_pubkey,
|
||||
&vote_account.clone(),
|
||||
prev_leader_slot,
|
||||
|
@ -2596,7 +2596,7 @@ impl ReplayStage {
|
|||
let mut replay_blockstore_time =
|
||||
Measure::start("replay_blockstore_into_bank");
|
||||
let blockstore_result = Self::replay_blockstore_into_bank(
|
||||
bank,
|
||||
&bank,
|
||||
blockstore,
|
||||
&replay_stats,
|
||||
&replay_progress,
|
||||
|
@ -2651,9 +2651,9 @@ impl ReplayStage {
|
|||
debug!("bank_slot {:?} is marked dead", bank_slot);
|
||||
replay_result.is_slot_dead = true;
|
||||
} else {
|
||||
let bank = &bank_forks.read().unwrap().get(bank_slot).unwrap();
|
||||
let bank = bank_forks.read().unwrap().get(bank_slot).unwrap();
|
||||
let parent_slot = bank.parent_slot();
|
||||
let prev_leader_slot = progress.get_bank_prev_leader_slot(bank);
|
||||
let prev_leader_slot = progress.get_bank_prev_leader_slot(&bank);
|
||||
let (num_blocks_on_fork, num_dropped_blocks_on_fork) = {
|
||||
let stats = progress
|
||||
.get(&parent_slot)
|
||||
|
@ -2667,7 +2667,7 @@ impl ReplayStage {
|
|||
|
||||
let bank_progress = progress.entry(bank.slot()).or_insert_with(|| {
|
||||
ForkProgress::new_from_bank(
|
||||
bank,
|
||||
&bank,
|
||||
my_pubkey,
|
||||
&vote_account.clone(),
|
||||
prev_leader_slot,
|
||||
|
@ -2679,7 +2679,7 @@ impl ReplayStage {
|
|||
if bank.collector_id() != my_pubkey {
|
||||
let mut replay_blockstore_time = Measure::start("replay_blockstore_into_bank");
|
||||
let blockstore_result = Self::replay_blockstore_into_bank(
|
||||
bank,
|
||||
&bank,
|
||||
blockstore,
|
||||
&bank_progress.replay_stats,
|
||||
&bank_progress.replay_progress,
|
||||
|
@ -3200,7 +3200,7 @@ impl ReplayStage {
|
|||
}
|
||||
|
||||
fn select_forks_failed_switch_threshold(
|
||||
reset_bank: Option<&Arc<Bank>>,
|
||||
reset_bank: Option<&Bank>,
|
||||
progress: &ProgressMap,
|
||||
tower: &mut Tower,
|
||||
heaviest_bank_slot: Slot,
|
||||
|
@ -3345,7 +3345,7 @@ impl ReplayStage {
|
|||
SwitchForkDecision::FailedSwitchThreshold(switch_proof_stake, total_stake) => {
|
||||
let reset_bank = heaviest_bank_on_same_voted_fork;
|
||||
let final_switch_fork_decision = Self::select_forks_failed_switch_threshold(
|
||||
reset_bank,
|
||||
reset_bank.map(|bank| bank.as_ref()),
|
||||
progress,
|
||||
tower,
|
||||
heaviest_bank.slot(),
|
||||
|
@ -3785,15 +3785,14 @@ impl ReplayStage {
|
|||
for (parent_slot, children) in next_slots {
|
||||
let parent_bank = frozen_banks
|
||||
.get(&parent_slot)
|
||||
.expect("missing parent in bank forks")
|
||||
.clone();
|
||||
.expect("missing parent in bank forks");
|
||||
for child_slot in children {
|
||||
if forks.get(child_slot).is_some() || new_banks.get(&child_slot).is_some() {
|
||||
trace!("child already active or frozen {}", child_slot);
|
||||
continue;
|
||||
}
|
||||
let leader = leader_schedule_cache
|
||||
.slot_leader_at(child_slot, Some(&parent_bank))
|
||||
.slot_leader_at(child_slot, Some(parent_bank))
|
||||
.unwrap();
|
||||
info!(
|
||||
"new fork:{} parent:{} root:{}",
|
||||
|
@ -3802,7 +3801,7 @@ impl ReplayStage {
|
|||
forks.root()
|
||||
);
|
||||
let child_bank = Self::new_bank_from_parent_with_notify(
|
||||
&parent_bank,
|
||||
parent_bank.clone(),
|
||||
child_slot,
|
||||
forks.root(),
|
||||
&leader,
|
||||
|
@ -3849,7 +3848,7 @@ impl ReplayStage {
|
|||
}
|
||||
|
||||
fn new_bank_from_parent_with_notify(
|
||||
parent: &Arc<Bank>,
|
||||
parent: Arc<Bank>,
|
||||
slot: u64,
|
||||
root_slot: u64,
|
||||
leader: &Pubkey,
|
||||
|
@ -4094,7 +4093,7 @@ pub(crate) mod tests {
|
|||
// Insert a non-root bank so that the propagation logic will update this
|
||||
// bank
|
||||
let bank1 = Bank::new_from_parent(
|
||||
&bank_forks.read().unwrap().get(0).unwrap(),
|
||||
bank_forks.read().unwrap().get(0).unwrap(),
|
||||
&leader_schedule_cache.slot_leader_at(1, None).unwrap(),
|
||||
1,
|
||||
);
|
||||
|
@ -4204,7 +4203,7 @@ pub(crate) mod tests {
|
|||
|
||||
let root = 3;
|
||||
let root_bank = Bank::new_from_parent(
|
||||
&bank_forks.read().unwrap().get(0).unwrap(),
|
||||
bank_forks.read().unwrap().get(0).unwrap(),
|
||||
&Pubkey::default(),
|
||||
root,
|
||||
);
|
||||
|
@ -4290,20 +4289,20 @@ pub(crate) mod tests {
|
|||
let confirmed_root = 1;
|
||||
let fork = 2;
|
||||
let bank1 = Bank::new_from_parent(
|
||||
&bank_forks.read().unwrap().get(0).unwrap(),
|
||||
bank_forks.read().unwrap().get(0).unwrap(),
|
||||
&Pubkey::default(),
|
||||
confirmed_root,
|
||||
);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let bank2 = Bank::new_from_parent(
|
||||
&bank_forks.read().unwrap().get(confirmed_root).unwrap(),
|
||||
bank_forks.read().unwrap().get(confirmed_root).unwrap(),
|
||||
&Pubkey::default(),
|
||||
fork,
|
||||
);
|
||||
bank_forks.write().unwrap().insert(bank2);
|
||||
let root = 3;
|
||||
let root_bank = Bank::new_from_parent(
|
||||
&bank_forks.read().unwrap().get(confirmed_root).unwrap(),
|
||||
bank_forks.read().unwrap().get(confirmed_root).unwrap(),
|
||||
&Pubkey::default(),
|
||||
root,
|
||||
);
|
||||
|
@ -4595,7 +4594,7 @@ pub(crate) mod tests {
|
|||
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
|
||||
assert!(bank0.is_frozen());
|
||||
assert_eq!(bank0.tick_height(), bank0.max_tick_height());
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let bank1 = bank_forks.read().unwrap().get(1).unwrap();
|
||||
let bank1_progress = progress
|
||||
|
@ -4666,7 +4665,7 @@ pub(crate) mod tests {
|
|||
|
||||
#[test]
|
||||
fn test_replay_commitment_cache() {
|
||||
fn leader_vote(vote_slot: Slot, bank: &Arc<Bank>, pubkey: &Pubkey) {
|
||||
fn leader_vote(vote_slot: Slot, bank: &Bank, pubkey: &Pubkey) {
|
||||
let mut leader_vote_account = bank.get_account(pubkey).unwrap();
|
||||
let mut vote_state = vote_state::from(&leader_vote_account).unwrap();
|
||||
vote_state::process_slot_vote_unchecked(&mut vote_state, vote_slot);
|
||||
|
@ -4722,7 +4721,8 @@ pub(crate) mod tests {
|
|||
|
||||
for i in 1..=3 {
|
||||
let prev_bank = bank_forks.read().unwrap().get(i - 1).unwrap();
|
||||
let bank = Bank::new_from_parent(&prev_bank, &Pubkey::default(), prev_bank.slot() + 1);
|
||||
let slot = prev_bank.slot() + 1;
|
||||
let bank = Bank::new_from_parent(prev_bank, &Pubkey::default(), slot);
|
||||
let _res = bank.transfer(
|
||||
10,
|
||||
&genesis_config_info.mint_keypair,
|
||||
|
@ -4817,7 +4817,7 @@ pub(crate) mod tests {
|
|||
)
|
||||
.unwrap();
|
||||
|
||||
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &Pubkey::default(), 1));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank0, &Pubkey::default(), 1));
|
||||
let slot = bank1.slot();
|
||||
|
||||
let (entries, test_signatures) = create_test_transaction_entries(
|
||||
|
@ -4880,7 +4880,7 @@ pub(crate) mod tests {
|
|||
);
|
||||
|
||||
let bank_forks = RwLock::new(bank_forks);
|
||||
let bank1 = Bank::new_from_parent(&bank0, &my_node_pubkey, 1);
|
||||
let bank1 = Bank::new_from_parent(bank0.clone(), &my_node_pubkey, 1);
|
||||
bank1.process_transaction(&vote_tx).unwrap();
|
||||
bank1.freeze();
|
||||
|
||||
|
@ -5330,9 +5330,9 @@ pub(crate) mod tests {
|
|||
vote_simulator::initialize_state(&keypairs, stake);
|
||||
|
||||
let bank0 = bank_forks.get(0).unwrap();
|
||||
bank_forks.insert(Bank::new_from_parent(&bank0, &Pubkey::default(), 9));
|
||||
bank_forks.insert(Bank::new_from_parent(bank0.clone(), &Pubkey::default(), 9));
|
||||
let bank9 = bank_forks.get(9).unwrap();
|
||||
bank_forks.insert(Bank::new_from_parent(&bank9, &Pubkey::default(), 10));
|
||||
bank_forks.insert(Bank::new_from_parent(bank9, &Pubkey::default(), 10));
|
||||
bank_forks.set_root(9, &AbsRequestSender::default(), None);
|
||||
let total_epoch_stake = bank0.total_epoch_stake();
|
||||
|
||||
|
@ -5432,7 +5432,7 @@ pub(crate) mod tests {
|
|||
for i in 1..=10 {
|
||||
let parent_bank = bank_forks.get(i - 1).unwrap().clone();
|
||||
let prev_leader_slot = ((i - 1) / 2) * 2;
|
||||
bank_forks.insert(Bank::new_from_parent(&parent_bank, &Pubkey::default(), i));
|
||||
bank_forks.insert(Bank::new_from_parent(parent_bank, &Pubkey::default(), i));
|
||||
progress_map.insert(
|
||||
i,
|
||||
ForkProgress::new(
|
||||
|
@ -5513,7 +5513,7 @@ pub(crate) mod tests {
|
|||
for i in 1..=10 {
|
||||
let parent_bank = bank_forks.get(i - 1).unwrap().clone();
|
||||
let prev_leader_slot = i - 1;
|
||||
bank_forks.insert(Bank::new_from_parent(&parent_bank, &Pubkey::default(), i));
|
||||
bank_forks.insert(Bank::new_from_parent(parent_bank, &Pubkey::default(), i));
|
||||
let mut fork_progress = ForkProgress::new(
|
||||
Hash::default(),
|
||||
Some(prev_leader_slot),
|
||||
|
@ -5655,10 +5655,10 @@ pub(crate) mod tests {
|
|||
// which implies confirmation
|
||||
let bank0 = Bank::new_for_tests(&genesis_config::create_genesis_config(10000).0);
|
||||
let parent_slot_bank =
|
||||
Bank::new_from_parent(&Arc::new(bank0), &Pubkey::default(), parent_slot);
|
||||
Bank::new_from_parent(Arc::new(bank0), &Pubkey::default(), parent_slot);
|
||||
let mut bank_forks = BankForks::new(parent_slot_bank);
|
||||
let bank5 =
|
||||
Bank::new_from_parent(&bank_forks.get(parent_slot).unwrap(), &Pubkey::default(), 5);
|
||||
Bank::new_from_parent(bank_forks.get(parent_slot).unwrap(), &Pubkey::default(), 5);
|
||||
bank_forks.insert(bank5);
|
||||
|
||||
// Should purge only `previous_leader_slot` from the progress map
|
||||
|
@ -5769,7 +5769,7 @@ pub(crate) mod tests {
|
|||
// Create bank 7
|
||||
let root_bank = bank_forks.read().unwrap().root_bank();
|
||||
let bank7 = Bank::new_from_parent(
|
||||
&bank_forks.read().unwrap().get(6).unwrap(),
|
||||
bank_forks.read().unwrap().get(6).unwrap(),
|
||||
&Pubkey::default(),
|
||||
7,
|
||||
);
|
||||
|
@ -5932,7 +5932,7 @@ pub(crate) mod tests {
|
|||
// Create bank 7 and insert to blockstore and bank forks
|
||||
let root_bank = bank_forks.read().unwrap().root_bank();
|
||||
let bank7 = Bank::new_from_parent(
|
||||
&bank_forks.read().unwrap().get(6).unwrap(),
|
||||
bank_forks.read().unwrap().get(6).unwrap(),
|
||||
&Pubkey::default(),
|
||||
7,
|
||||
);
|
||||
|
@ -7031,7 +7031,7 @@ 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, &Pubkey::default(), 1));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank0.clone(), &Pubkey::default(), 1));
|
||||
bank1.fill_bank_with_ticks_for_tests();
|
||||
tower.record_bank_vote(&bank0, &my_vote_pubkey);
|
||||
ReplayStage::push_vote(
|
||||
|
@ -7072,7 +7072,7 @@ 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, &Pubkey::default(), 2));
|
||||
let bank2 = Arc::new(Bank::new_from_parent(bank1.clone(), &Pubkey::default(), 2));
|
||||
bank2.fill_bank_with_ticks_for_tests();
|
||||
bank2.freeze();
|
||||
for refresh_bank in &[&bank1, &bank2] {
|
||||
|
@ -7165,11 +7165,9 @@ pub(crate) mod tests {
|
|||
let expired_bank = {
|
||||
let mut parent_bank = bank2.clone();
|
||||
for _ in 0..MAX_PROCESSING_AGE {
|
||||
parent_bank = Arc::new(Bank::new_from_parent(
|
||||
&parent_bank,
|
||||
&Pubkey::default(),
|
||||
parent_bank.slot() + 1,
|
||||
));
|
||||
let slot = parent_bank.slot() + 1;
|
||||
parent_bank =
|
||||
Arc::new(Bank::new_from_parent(parent_bank, &Pubkey::default(), slot));
|
||||
parent_bank.fill_bank_with_ticks_for_tests();
|
||||
parent_bank.freeze();
|
||||
}
|
||||
|
@ -7223,10 +7221,11 @@ pub(crate) mod tests {
|
|||
assert_eq!(tower.last_voted_slot().unwrap(), 1);
|
||||
|
||||
// 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(
|
||||
&expired_bank,
|
||||
expired_bank.clone(),
|
||||
&Pubkey::default(),
|
||||
expired_bank.slot() + 1,
|
||||
expired_bank_child_slot,
|
||||
));
|
||||
expired_bank_child.process_transaction(vote_tx).unwrap();
|
||||
let vote_account = expired_bank_child
|
||||
|
@ -7244,7 +7243,7 @@ pub(crate) mod tests {
|
|||
// 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(
|
||||
&bank2,
|
||||
bank2,
|
||||
&Pubkey::default(),
|
||||
expired_bank_child.slot() + 1,
|
||||
));
|
||||
|
@ -7281,7 +7280,7 @@ pub(crate) mod tests {
|
|||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn send_vote_in_new_bank(
|
||||
parent_bank: &Arc<Bank>,
|
||||
parent_bank: Arc<Bank>,
|
||||
my_slot: Slot,
|
||||
my_vote_keypair: &[Arc<Keypair>],
|
||||
tower: &mut Tower,
|
||||
|
@ -7299,9 +7298,9 @@ pub(crate) mod tests {
|
|||
progress: &mut ProgressMap,
|
||||
) -> Arc<Bank> {
|
||||
let my_vote_pubkey = &my_vote_keypair[0].pubkey();
|
||||
tower.record_bank_vote(parent_bank, my_vote_pubkey);
|
||||
tower.record_bank_vote(&parent_bank, my_vote_pubkey);
|
||||
ReplayStage::push_vote(
|
||||
parent_bank,
|
||||
&parent_bank,
|
||||
my_vote_pubkey,
|
||||
identity_keypair,
|
||||
my_vote_keypair,
|
||||
|
@ -7392,7 +7391,8 @@ 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, &Pubkey::default(), other_fork_slot);
|
||||
let other_fork_bank =
|
||||
Bank::new_from_parent(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(|| {
|
||||
|
@ -7411,7 +7411,7 @@ pub(crate) mod tests {
|
|||
let mut cursor = Cursor::default();
|
||||
|
||||
let mut new_bank = send_vote_in_new_bank(
|
||||
&bank0,
|
||||
bank0,
|
||||
2,
|
||||
&my_vote_keypair,
|
||||
&mut tower,
|
||||
|
@ -7429,7 +7429,7 @@ pub(crate) mod tests {
|
|||
&mut progress,
|
||||
);
|
||||
new_bank = send_vote_in_new_bank(
|
||||
&new_bank,
|
||||
new_bank.clone(),
|
||||
new_bank.slot() + 1,
|
||||
&my_vote_keypair,
|
||||
&mut tower,
|
||||
|
@ -7451,7 +7451,7 @@ 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 = Bank::new_from_parent(new_bank, &Pubkey::default(), new_slot);
|
||||
bank.fill_bank_with_ticks_for_tests();
|
||||
bank.freeze();
|
||||
progress.entry(new_slot).or_insert_with(|| {
|
||||
|
@ -7576,7 +7576,7 @@ pub(crate) mod tests {
|
|||
let (retransmit_slots_sender, retransmit_slots_receiver) = unbounded();
|
||||
|
||||
let bank1 = Bank::new_from_parent(
|
||||
&bank_forks.read().unwrap().get(0).unwrap(),
|
||||
bank_forks.read().unwrap().get(0).unwrap(),
|
||||
&leader_schedule_cache.slot_leader_at(1, None).unwrap(),
|
||||
1,
|
||||
);
|
||||
|
@ -7757,7 +7757,7 @@ pub(crate) mod tests {
|
|||
let mut prev_index = 0;
|
||||
for i in (1..10).chain(11..15) {
|
||||
let bank = Bank::new_from_parent(
|
||||
&bank_forks.read().unwrap().get(prev_index).unwrap(),
|
||||
bank_forks.read().unwrap().get(prev_index).unwrap(),
|
||||
&leader_schedule_cache.slot_leader_at(i, None).unwrap(),
|
||||
i,
|
||||
);
|
||||
|
|
|
@ -417,7 +417,7 @@ pub mod tests {
|
|||
let blockstore = Arc::new(blockstore);
|
||||
let bank = bank_forks.working_bank();
|
||||
let (exit, poh_recorder, poh_service, _entry_receiver) =
|
||||
create_test_recorder(&bank, blockstore.clone(), None, None);
|
||||
create_test_recorder(bank.clone(), blockstore.clone(), None, None);
|
||||
let vote_keypair = Keypair::new();
|
||||
let leader_schedule_cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank));
|
||||
let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
|
||||
|
|
|
@ -1444,7 +1444,7 @@ impl Validator {
|
|||
}
|
||||
}
|
||||
|
||||
fn active_vote_account_exists_in_bank(bank: &Arc<Bank>, vote_account: &Pubkey) -> bool {
|
||||
fn active_vote_account_exists_in_bank(bank: &Bank, vote_account: &Pubkey) -> bool {
|
||||
if let Some(account) = &bank.get_account(vote_account) {
|
||||
if let Some(vote_state) = vote_state::from(account) {
|
||||
return !vote_state.votes.is_empty();
|
||||
|
@ -1922,7 +1922,7 @@ fn maybe_warp_slot(
|
|||
root_bank.force_flush_accounts_cache();
|
||||
|
||||
bank_forks.insert(Bank::warp_from_parent(
|
||||
&root_bank,
|
||||
root_bank,
|
||||
&Pubkey::default(),
|
||||
warp_slot,
|
||||
solana_accounts_db::accounts_db::CalcAccountsHashDataSource::Storages,
|
||||
|
@ -2554,7 +2554,7 @@ mod tests {
|
|||
|
||||
// bank=1, wait=0, should pass, bank is past the wait slot
|
||||
let bank_forks = RwLock::new(BankForks::new(Bank::new_from_parent(
|
||||
&bank_forks.read().unwrap().root_bank(),
|
||||
bank_forks.read().unwrap().root_bank(),
|
||||
&Pubkey::default(),
|
||||
1,
|
||||
)));
|
||||
|
|
|
@ -510,10 +510,11 @@ mod tests {
|
|||
|
||||
// Create a set of valid ancestor hashes for this fork
|
||||
for _ in 0..MAX_ENTRIES {
|
||||
let slot = my_leader_bank.slot() + 1;
|
||||
my_leader_bank = Arc::new(Bank::new_from_parent(
|
||||
&my_leader_bank,
|
||||
my_leader_bank,
|
||||
&Pubkey::default(),
|
||||
my_leader_bank.slot() + 1,
|
||||
slot,
|
||||
));
|
||||
}
|
||||
let slot_hashes_account = my_leader_bank
|
||||
|
@ -585,10 +586,11 @@ mod tests {
|
|||
my_leader_bank.freeze();
|
||||
let vote_slot = my_leader_bank.slot();
|
||||
let vote_hash = my_leader_bank.hash();
|
||||
let new_leader_slot = my_leader_bank.slot() + 1;
|
||||
let my_leader_bank = Arc::new(Bank::new_from_parent(
|
||||
&my_leader_bank,
|
||||
my_leader_bank,
|
||||
&Pubkey::default(),
|
||||
my_leader_bank.slot() + 1,
|
||||
new_leader_slot,
|
||||
));
|
||||
let vote_account_key = vote_simulator.vote_pubkeys[1];
|
||||
let vote = VoteTransaction::from(Vote::new(vec![vote_slot], vote_hash));
|
||||
|
|
|
@ -82,7 +82,7 @@ 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, &Pubkey::default(), slot);
|
||||
let new_bank = Bank::new_from_parent(parent_bank.clone(), &Pubkey::default(), slot);
|
||||
self.progress
|
||||
.entry(slot)
|
||||
.or_insert_with(|| ForkProgress::new(Hash::default(), None, None, 0, 0));
|
||||
|
|
|
@ -273,10 +273,11 @@ fn test_epoch_accounts_hash_basic(test_environment: TestEnvironment) {
|
|||
for _ in 0..slots_per_epoch.checked_mul(NUM_EPOCHS_TO_TEST).unwrap() {
|
||||
let bank = {
|
||||
let parent = bank_forks.read().unwrap().working_bank();
|
||||
let slot = parent.slot().checked_add(1).unwrap();
|
||||
let bank = bank_forks.write().unwrap().insert(Bank::new_from_parent(
|
||||
&parent,
|
||||
parent,
|
||||
&Pubkey::default(),
|
||||
parent.slot().checked_add(1).unwrap(),
|
||||
slot,
|
||||
));
|
||||
|
||||
let transaction = system_transaction::transfer(
|
||||
|
@ -385,10 +386,11 @@ fn test_snapshots_have_expected_epoch_accounts_hash() {
|
|||
for _ in 0..slots_per_epoch.checked_mul(NUM_EPOCHS_TO_TEST).unwrap() {
|
||||
let bank = {
|
||||
let parent = bank_forks.read().unwrap().working_bank();
|
||||
let slot = parent.slot().checked_add(1).unwrap();
|
||||
let bank = bank_forks.write().unwrap().insert(Bank::new_from_parent(
|
||||
&parent,
|
||||
parent,
|
||||
&Pubkey::default(),
|
||||
parent.slot() + 1,
|
||||
slot,
|
||||
));
|
||||
|
||||
let transaction = system_transaction::transfer(
|
||||
|
@ -501,10 +503,11 @@ fn test_background_services_request_handling_for_epoch_accounts_hash() {
|
|||
for _ in 0..slots_per_epoch.checked_mul(NUM_EPOCHS_TO_TEST).unwrap() {
|
||||
let bank = {
|
||||
let parent = bank_forks.read().unwrap().working_bank();
|
||||
let slot = parent.slot().checked_add(1).unwrap();
|
||||
let bank = bank_forks.write().unwrap().insert(Bank::new_from_parent(
|
||||
&parent,
|
||||
parent,
|
||||
&Pubkey::default(),
|
||||
parent.slot() + 1,
|
||||
slot,
|
||||
));
|
||||
|
||||
let transaction = system_transaction::transfer(
|
||||
|
@ -593,16 +596,17 @@ fn test_epoch_accounts_hash_and_warping() {
|
|||
// flush the write cache so warping can calculate the accounts hash from storages
|
||||
bank.force_flush_accounts_cache();
|
||||
let bank = bank_forks.write().unwrap().insert(Bank::warp_from_parent(
|
||||
&bank,
|
||||
bank,
|
||||
&Pubkey::default(),
|
||||
eah_stop_slot_in_next_epoch,
|
||||
CalcAccountsHashDataSource::Storages,
|
||||
));
|
||||
let bank = bank_forks.write().unwrap().insert(Bank::new_from_parent(
|
||||
&bank,
|
||||
&Pubkey::default(),
|
||||
bank.slot() + 1,
|
||||
));
|
||||
let slot = bank.slot().checked_add(1).unwrap();
|
||||
let bank =
|
||||
bank_forks
|
||||
.write()
|
||||
.unwrap()
|
||||
.insert(Bank::new_from_parent(bank, &Pubkey::default(), slot));
|
||||
bank_forks.write().unwrap().set_root(
|
||||
bank.slot(),
|
||||
&test_environment
|
||||
|
@ -627,16 +631,17 @@ fn test_epoch_accounts_hash_and_warping() {
|
|||
// flush the write cache so warping can calculate the accounts hash from storages
|
||||
bank.force_flush_accounts_cache();
|
||||
let bank = bank_forks.write().unwrap().insert(Bank::warp_from_parent(
|
||||
&bank,
|
||||
bank,
|
||||
&Pubkey::default(),
|
||||
eah_start_slot_in_next_epoch,
|
||||
CalcAccountsHashDataSource::Storages,
|
||||
));
|
||||
let bank = bank_forks.write().unwrap().insert(Bank::new_from_parent(
|
||||
&bank,
|
||||
&Pubkey::default(),
|
||||
bank.slot() + 1,
|
||||
));
|
||||
let slot = bank.slot().checked_add(1).unwrap();
|
||||
let bank =
|
||||
bank_forks
|
||||
.write()
|
||||
.unwrap()
|
||||
.insert(Bank::new_from_parent(bank, &Pubkey::default(), slot));
|
||||
bank_forks.write().unwrap().set_root(
|
||||
bank.slot(),
|
||||
&test_environment
|
||||
|
|
|
@ -218,7 +218,8 @@ fn run_bank_forks_snapshot_n<F>(
|
|||
accounts_package_sender,
|
||||
};
|
||||
for slot in 1..=last_slot {
|
||||
let mut bank = Bank::new_from_parent(&bank_forks[slot - 1], &Pubkey::default(), slot);
|
||||
let mut bank =
|
||||
Bank::new_from_parent(bank_forks[slot - 1].clone(), &Pubkey::default(), slot);
|
||||
f(&mut bank, mint_keypair);
|
||||
let bank = bank_forks.insert(bank);
|
||||
// Set root to make sure we don't end up with too many account storage entries
|
||||
|
@ -376,11 +377,12 @@ fn test_concurrent_snapshot_packaging(
|
|||
let saved_slot = 4;
|
||||
let mut saved_archive_path = None;
|
||||
|
||||
for forks in 0..MAX_BANK_SNAPSHOTS_TO_RETAIN + 2 {
|
||||
for i in 0..MAX_BANK_SNAPSHOTS_TO_RETAIN + 2 {
|
||||
let parent_slot = i as Slot;
|
||||
let bank = Bank::new_from_parent(
|
||||
&bank_forks[forks as u64],
|
||||
bank_forks[parent_slot].clone(),
|
||||
&Pubkey::default(),
|
||||
(forks + 1) as u64,
|
||||
parent_slot + 1,
|
||||
);
|
||||
let slot = bank.slot();
|
||||
let key1 = Keypair::new().pubkey();
|
||||
|
@ -595,7 +597,7 @@ fn test_slots_to_snapshot(snapshot_version: SnapshotVersion, cluster_type: Clust
|
|||
for _ in 0..num_set_roots {
|
||||
for _ in 0..*add_root_interval {
|
||||
let new_slot = current_bank.slot() + 1;
|
||||
let new_bank = Bank::new_from_parent(¤t_bank, &Pubkey::default(), new_slot);
|
||||
let new_bank = Bank::new_from_parent(current_bank, &Pubkey::default(), new_slot);
|
||||
snapshot_test_config.bank_forks.insert(new_bank);
|
||||
current_bank = snapshot_test_config.bank_forks[new_slot].clone();
|
||||
}
|
||||
|
@ -728,7 +730,8 @@ fn test_bank_forks_incremental_snapshot(
|
|||
for slot in 1..=LAST_SLOT {
|
||||
// Make a new bank and perform some transactions
|
||||
let bank = {
|
||||
let bank = Bank::new_from_parent(&bank_forks[slot - 1], &Pubkey::default(), slot);
|
||||
let bank =
|
||||
Bank::new_from_parent(bank_forks[slot - 1].clone(), &Pubkey::default(), slot);
|
||||
|
||||
let key = solana_sdk::pubkey::new_rand();
|
||||
let tx = system_transaction::transfer(mint_keypair, &key, 1, bank.last_blockhash());
|
||||
|
@ -1024,7 +1027,7 @@ fn test_snapshots_with_background_services(
|
|||
// Make a new bank and process some transactions
|
||||
{
|
||||
let bank = Bank::new_from_parent(
|
||||
&bank_forks.read().unwrap().get(slot - 1).unwrap(),
|
||||
bank_forks.read().unwrap().get(slot - 1).unwrap(),
|
||||
&Pubkey::default(),
|
||||
slot,
|
||||
);
|
||||
|
|
|
@ -2930,8 +2930,11 @@ fn main() {
|
|||
|| bootstrap_validator_pubkeys.is_some();
|
||||
|
||||
if child_bank_required {
|
||||
let mut child_bank =
|
||||
Bank::new_from_parent(&bank, bank.collector_id(), bank.slot() + 1);
|
||||
let mut child_bank = Bank::new_from_parent(
|
||||
bank.clone(),
|
||||
bank.collector_id(),
|
||||
bank.slot() + 1,
|
||||
);
|
||||
|
||||
if let Ok(rent_burn_percentage) = rent_burn_percentage {
|
||||
child_bank.set_rent_burn_percentage(rent_burn_percentage);
|
||||
|
@ -3137,7 +3140,7 @@ fn main() {
|
|||
bank.rc.accounts.accounts_db.add_root(bank.slot());
|
||||
bank.force_flush_accounts_cache();
|
||||
Arc::new(Bank::warp_from_parent(
|
||||
&bank,
|
||||
bank.clone(),
|
||||
bank.collector_id(),
|
||||
warp_slot,
|
||||
CalcAccountsHashDataSource::Storages,
|
||||
|
@ -3606,7 +3609,7 @@ fn main() {
|
|||
}
|
||||
};
|
||||
let warped_bank = Bank::new_from_parent_with_tracer(
|
||||
&base_bank,
|
||||
base_bank.clone(),
|
||||
base_bank.collector_id(),
|
||||
next_epoch,
|
||||
tracer,
|
||||
|
|
|
@ -1372,7 +1372,7 @@ fn process_next_slots(
|
|||
// handles any partials
|
||||
if next_meta.is_full() {
|
||||
let next_bank = Bank::new_from_parent(
|
||||
bank,
|
||||
bank.clone(),
|
||||
&leader_schedule_cache
|
||||
.slot_leader_at(*next_slot, Some(bank))
|
||||
.unwrap(),
|
||||
|
@ -3592,13 +3592,14 @@ pub mod tests {
|
|||
};
|
||||
let recyclers = VerifyRecyclers::default();
|
||||
process_bank_0(&bank0, &blockstore, &opts, &recyclers, None, None);
|
||||
let bank1 = bank_forks.insert(Bank::new_from_parent(&bank0, &Pubkey::default(), 1));
|
||||
let bank0_last_blockhash = bank0.last_blockhash();
|
||||
let bank1 = bank_forks.insert(Bank::new_from_parent(bank0, &Pubkey::default(), 1));
|
||||
confirm_full_slot(
|
||||
&blockstore,
|
||||
&bank1,
|
||||
&opts,
|
||||
&recyclers,
|
||||
&mut ConfirmationProgress::new(bank0.last_blockhash()),
|
||||
&mut ConfirmationProgress::new(bank0_last_blockhash),
|
||||
None,
|
||||
None,
|
||||
None,
|
||||
|
@ -3752,11 +3753,8 @@ pub mod tests {
|
|||
}
|
||||
i += 1;
|
||||
|
||||
bank = Arc::new(Bank::new_from_parent(
|
||||
&bank,
|
||||
&Pubkey::default(),
|
||||
bank.slot() + thread_rng().gen_range(1, 3),
|
||||
));
|
||||
let slot = bank.slot() + thread_rng().gen_range(1, 3);
|
||||
bank = Arc::new(Bank::new_from_parent(bank, &Pubkey::default(), slot));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -3893,7 +3891,7 @@ pub mod tests {
|
|||
bank0.freeze();
|
||||
|
||||
let bank1 = Arc::new(Bank::new_from_parent(
|
||||
&bank0,
|
||||
bank0.clone(),
|
||||
&solana_sdk::pubkey::new_rand(),
|
||||
1,
|
||||
));
|
||||
|
@ -4465,7 +4463,7 @@ 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 slot_2_bank = Arc::new(Bank::new_from_parent(slot_0_bank, &collector_id, 2));
|
||||
assert_eq!(slot_2_bank.slot(), 2);
|
||||
assert_eq!(slot_2_bank.tick_height(), 2);
|
||||
assert_eq!(slot_2_bank.max_tick_height(), 6);
|
||||
|
|
|
@ -531,7 +531,7 @@ mod tests {
|
|||
target_slot += 1;
|
||||
}
|
||||
|
||||
let bank = Bank::new_from_parent(&Arc::new(bank), &Pubkey::default(), target_slot);
|
||||
let bank = Bank::new_from_parent(Arc::new(bank), &Pubkey::default(), target_slot);
|
||||
let mut expected_slot = 0;
|
||||
let epoch = bank.get_leader_schedule_epoch(target_slot);
|
||||
for i in 0..epoch {
|
||||
|
@ -591,7 +591,7 @@ mod tests {
|
|||
assert_eq!(bank.get_epoch_and_slot_index(96).0, 2);
|
||||
assert!(cache.slot_leader_at(96, Some(&bank)).is_none());
|
||||
|
||||
let bank2 = Bank::new_from_parent(&bank, &solana_sdk::pubkey::new_rand(), 95);
|
||||
let bank2 = Bank::new_from_parent(bank, &solana_sdk::pubkey::new_rand(), 95);
|
||||
assert!(bank2.epoch_vote_accounts(2).is_some());
|
||||
|
||||
// Set root for a slot in epoch 1, so that epoch 2 is now confirmed
|
||||
|
|
|
@ -71,7 +71,7 @@ pub struct BankStart {
|
|||
}
|
||||
|
||||
impl BankStart {
|
||||
fn get_working_bank_if_not_expired(&self) -> Option<&Arc<Bank>> {
|
||||
fn get_working_bank_if_not_expired(&self) -> Option<&Bank> {
|
||||
if self.should_working_bank_still_be_processing_txs() {
|
||||
Some(&self.working_bank)
|
||||
} else {
|
||||
|
@ -249,7 +249,7 @@ pub enum PohRecorderBank {
|
|||
}
|
||||
|
||||
impl PohRecorderBank {
|
||||
pub fn bank(&self) -> &Arc<Bank> {
|
||||
pub fn bank(&self) -> &Bank {
|
||||
match self {
|
||||
PohRecorderBank::WorkingBank(bank_start) => &bank_start.working_bank,
|
||||
PohRecorderBank::LastResetBank(last_reset_bank) => last_reset_bank,
|
||||
|
@ -1024,7 +1024,7 @@ impl PohRecorder {
|
|||
// if it's still processing transactions
|
||||
pub fn get_working_bank_if_not_expired<'a>(
|
||||
bank_start: &Option<&'a BankStart>,
|
||||
) -> Option<&'a Arc<Bank>> {
|
||||
) -> Option<&'a Bank> {
|
||||
bank_start
|
||||
.as_ref()
|
||||
.and_then(|bank_start| bank_start.get_working_bank_if_not_expired())
|
||||
|
@ -1039,7 +1039,7 @@ impl PohRecorder {
|
|||
}
|
||||
|
||||
pub fn create_test_recorder(
|
||||
bank: &Arc<Bank>,
|
||||
bank: Arc<Bank>,
|
||||
blockstore: Arc<Blockstore>,
|
||||
poh_config: Option<PohConfig>,
|
||||
leader_schedule_cache: Option<Arc<LeaderScheduleCache>>,
|
||||
|
@ -1051,7 +1051,7 @@ pub fn create_test_recorder(
|
|||
) {
|
||||
let leader_schedule_cache = match leader_schedule_cache {
|
||||
Some(provided_cache) => provided_cache,
|
||||
None => Arc::new(LeaderScheduleCache::new_from_bank(bank)),
|
||||
None => Arc::new(LeaderScheduleCache::new_from_bank(&bank)),
|
||||
};
|
||||
let exit = Arc::new(AtomicBool::new(false));
|
||||
let poh_config = poh_config.unwrap_or_default();
|
||||
|
@ -1067,14 +1067,15 @@ pub fn create_test_recorder(
|
|||
&poh_config,
|
||||
exit.clone(),
|
||||
);
|
||||
poh_recorder.set_bank(bank.clone(), false);
|
||||
let ticks_per_slot = bank.ticks_per_slot();
|
||||
|
||||
poh_recorder.set_bank(bank, false);
|
||||
let poh_recorder = Arc::new(RwLock::new(poh_recorder));
|
||||
let poh_service = PohService::new(
|
||||
poh_recorder.clone(),
|
||||
&poh_config,
|
||||
exit.clone(),
|
||||
bank.ticks_per_slot(),
|
||||
ticks_per_slot,
|
||||
crate::poh_service::DEFAULT_PINNED_CPU_CORE,
|
||||
crate::poh_service::DEFAULT_HASHES_PER_BATCH,
|
||||
record_receiver,
|
||||
|
@ -1236,7 +1237,7 @@ mod tests {
|
|||
);
|
||||
|
||||
bank0.fill_bank_with_ticks_for_tests();
|
||||
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &Pubkey::default(), 1));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank0, &Pubkey::default(), 1));
|
||||
|
||||
// Set a working bank
|
||||
poh_recorder.set_bank(bank1.clone(), false);
|
||||
|
@ -1348,7 +1349,7 @@ mod tests {
|
|||
);
|
||||
|
||||
bank0.fill_bank_with_ticks_for_tests();
|
||||
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &Pubkey::default(), 1));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank0, &Pubkey::default(), 1));
|
||||
poh_recorder.set_bank(bank1.clone(), false);
|
||||
// Let poh_recorder tick up to bank1.tick_height() - 1
|
||||
for _ in 0..bank1.tick_height() - 1 {
|
||||
|
@ -1433,7 +1434,7 @@ mod tests {
|
|||
);
|
||||
|
||||
bank0.fill_bank_with_ticks_for_tests();
|
||||
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &Pubkey::default(), 1));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank0, &Pubkey::default(), 1));
|
||||
poh_recorder.set_bank(bank1.clone(), false);
|
||||
|
||||
// Record up to exactly min tick height
|
||||
|
@ -1601,7 +1602,7 @@ mod tests {
|
|||
);
|
||||
|
||||
bank0.fill_bank_with_ticks_for_tests();
|
||||
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &Pubkey::default(), 1));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank0, &Pubkey::default(), 1));
|
||||
poh_recorder.set_bank(bank1, false);
|
||||
|
||||
// Check we can make two ticks without hitting min_tick_height
|
||||
|
@ -1974,7 +1975,7 @@ mod tests {
|
|||
);
|
||||
|
||||
// reset poh now. we should immediately be leader
|
||||
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &Pubkey::default(), 1));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank0, &Pubkey::default(), 1));
|
||||
assert_eq!(bank1.slot(), 1);
|
||||
poh_recorder.reset(bank1.clone(), Some((2, 2)));
|
||||
assert_eq!(
|
||||
|
@ -2017,7 +2018,7 @@ mod tests {
|
|||
|
||||
// Let's test that correct grace ticks are reported
|
||||
// Set the leader slot one slot down
|
||||
let bank2 = Arc::new(Bank::new_from_parent(&bank1, &Pubkey::default(), 2));
|
||||
let bank2 = Arc::new(Bank::new_from_parent(bank1.clone(), &Pubkey::default(), 2));
|
||||
poh_recorder.reset(bank2.clone(), Some((4, 4)));
|
||||
|
||||
// send ticks for a slot
|
||||
|
@ -2030,7 +2031,7 @@ mod tests {
|
|||
poh_recorder.reached_leader_slot(),
|
||||
PohLeaderStatus::NotReached
|
||||
);
|
||||
let bank3 = Arc::new(Bank::new_from_parent(&bank2, &Pubkey::default(), 3));
|
||||
let bank3 = Arc::new(Bank::new_from_parent(bank2, &Pubkey::default(), 3));
|
||||
assert_eq!(bank3.slot(), 3);
|
||||
poh_recorder.reset(bank3.clone(), Some((4, 4)));
|
||||
|
||||
|
@ -2046,7 +2047,7 @@ mod tests {
|
|||
// Let's test that if a node overshoots the ticks for its target
|
||||
// leader slot, reached_leader_slot() will return true, because it's overdue
|
||||
// Set the leader slot one slot down
|
||||
let bank4 = Arc::new(Bank::new_from_parent(&bank3, &Pubkey::default(), 4));
|
||||
let bank4 = Arc::new(Bank::new_from_parent(bank3, &Pubkey::default(), 4));
|
||||
poh_recorder.reset(bank4.clone(), Some((5, 5)));
|
||||
|
||||
// Overshoot ticks for the slot
|
||||
|
@ -2110,7 +2111,7 @@ mod tests {
|
|||
assert!(!poh_recorder.would_be_leader(2 * bank.ticks_per_slot()));
|
||||
|
||||
// Move the bank up a slot (so that max_tick_height > slot 0's tick_height)
|
||||
let bank = Arc::new(Bank::new_from_parent(&bank, &Pubkey::default(), 1));
|
||||
let bank = Arc::new(Bank::new_from_parent(bank, &Pubkey::default(), 1));
|
||||
// If we set the working bank, the node should be leader within next 2 slots
|
||||
poh_recorder.set_bank(bank.clone(), false);
|
||||
assert!(poh_recorder.would_be_leader(2 * bank.ticks_per_slot()));
|
||||
|
@ -2141,7 +2142,7 @@ mod tests {
|
|||
Arc::new(AtomicBool::default()),
|
||||
);
|
||||
//create a new bank
|
||||
let bank = Arc::new(Bank::new_from_parent(&bank, &Pubkey::default(), 2));
|
||||
let bank = Arc::new(Bank::new_from_parent(bank, &Pubkey::default(), 2));
|
||||
// add virtual ticks into poh for slots 0, 1, and 2
|
||||
for _ in 0..(bank.ticks_per_slot() * 3) {
|
||||
poh_recorder.tick();
|
||||
|
|
|
@ -828,7 +828,7 @@ impl ProgramTest {
|
|||
let bank = {
|
||||
let bank = Arc::new(bank);
|
||||
bank.fill_bank_with_ticks_for_tests();
|
||||
let bank = Bank::new_from_parent(&bank, bank.collector_id(), bank.slot() + 1);
|
||||
let bank = Bank::new_from_parent(bank.clone(), bank.collector_id(), bank.slot() + 1);
|
||||
debug!("Bank slot: {}", bank.slot());
|
||||
bank
|
||||
};
|
||||
|
@ -1118,7 +1118,7 @@ impl ProgramTestContext {
|
|||
bank
|
||||
} else {
|
||||
bank_forks.insert(Bank::warp_from_parent(
|
||||
&bank,
|
||||
bank,
|
||||
&Pubkey::default(),
|
||||
pre_warp_slot,
|
||||
// some warping tests cannot use the append vecs because of the sequence of adding roots and flushing
|
||||
|
@ -1154,7 +1154,7 @@ impl ProgramTestContext {
|
|||
|
||||
// warp_bank is frozen so go forward to get unfrozen bank at warp_slot
|
||||
bank_forks.insert(Bank::new_from_parent(
|
||||
&warp_bank,
|
||||
warp_bank,
|
||||
&Pubkey::default(),
|
||||
warp_slot,
|
||||
));
|
||||
|
@ -1191,7 +1191,7 @@ impl ProgramTestContext {
|
|||
|
||||
// warp_bank is frozen so go forward to get unfrozen bank at warp_slot
|
||||
let warp_slot = pre_warp_slot + 1;
|
||||
let mut warp_bank = Bank::new_from_parent(&bank, &Pubkey::default(), warp_slot);
|
||||
let mut warp_bank = Bank::new_from_parent(bank, &Pubkey::default(), warp_slot);
|
||||
|
||||
warp_bank.force_reward_interval_end_for_tests();
|
||||
bank_forks.insert(warp_bank);
|
||||
|
|
|
@ -201,7 +201,7 @@ 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 mut bank_client = BankClient::new_shared(&bank);
|
||||
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
|
||||
|
|
|
@ -457,7 +457,7 @@ fn test_sol_alloc_free_no_longer_deployable() {
|
|||
// 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 mut bank = Bank::new_from_parent(Arc::new(bank), &Pubkey::default(), new_slot);
|
||||
|
||||
// invoke the program
|
||||
assert!(bank.process_transaction(&invoke_tx).is_ok());
|
||||
|
@ -501,7 +501,7 @@ fn test_program_sbf_duplicate_accounts() {
|
|||
} = create_genesis_config(50);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
let (bank, program_id) = load_program_and_advance_slot(
|
||||
&mut bank_client,
|
||||
&bpf_loader::id(),
|
||||
|
@ -710,7 +710,7 @@ fn test_return_data_and_log_data_syscall() {
|
|||
} = create_genesis_config(50);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let (bank, program_id) = load_program_and_advance_slot(
|
||||
&mut bank_client,
|
||||
|
@ -778,7 +778,7 @@ fn test_program_sbf_invoke_sanity() {
|
|||
} = create_genesis_config(50);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let invoke_program_id =
|
||||
load_program(&bank_client, &bpf_loader::id(), &mint_keypair, program.1);
|
||||
|
@ -1175,7 +1175,7 @@ fn test_program_sbf_program_id_spoofing() {
|
|||
} = create_genesis_config(50);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let malicious_swap_pubkey = load_program(
|
||||
&bank_client,
|
||||
|
@ -1226,7 +1226,7 @@ fn test_program_sbf_caller_has_access_to_cpi_program() {
|
|||
} = create_genesis_config(50);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let caller_pubkey = load_program(
|
||||
&bank_client,
|
||||
|
@ -1264,7 +1264,7 @@ fn test_program_sbf_ro_modify() {
|
|||
} = create_genesis_config(50);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let (bank, program_pubkey) = load_program_and_advance_slot(
|
||||
&mut bank_client,
|
||||
|
@ -1479,7 +1479,7 @@ fn test_program_sbf_instruction_introspection() {
|
|||
} = create_genesis_config(50_000);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let (bank, program_id) = load_program_and_advance_slot(
|
||||
&mut bank_client,
|
||||
|
@ -1753,7 +1753,7 @@ fn test_program_sbf_invoke_stable_genesis_and_bank() {
|
|||
} = get_stable_genesis_config();
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let bank_client = BankClient::new_shared(&bank);
|
||||
let bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
// Deploy upgradeable program
|
||||
let buffer_keypair = Keypair::from_base58_string(
|
||||
|
@ -1927,7 +1927,7 @@ fn test_program_sbf_invoke_in_same_tx_as_deployment() {
|
|||
} = create_genesis_config(50);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
// Deploy upgradeable program
|
||||
let buffer_keypair = Keypair::new();
|
||||
|
@ -2025,7 +2025,7 @@ fn test_program_sbf_invoke_in_same_tx_as_redeployment() {
|
|||
} = create_genesis_config(50);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
// Deploy upgradeable program
|
||||
let buffer_keypair = Keypair::new();
|
||||
|
@ -2133,7 +2133,7 @@ fn test_program_sbf_invoke_in_same_tx_as_undeployment() {
|
|||
} = create_genesis_config(50);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
// Deploy upgradeable program
|
||||
let buffer_keypair = Keypair::new();
|
||||
|
@ -2643,7 +2643,7 @@ fn test_program_upgradeable_locks() {
|
|||
} = create_genesis_config(2_000_000_000);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
load_upgradeable_program(
|
||||
&bank_client,
|
||||
|
@ -2766,7 +2766,7 @@ fn test_program_sbf_finalize() {
|
|||
} = create_genesis_config(50);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let (_, program_pubkey) = load_program_and_advance_slot(
|
||||
&mut bank_client,
|
||||
|
@ -2814,7 +2814,7 @@ fn test_program_sbf_ro_account_modify() {
|
|||
} = create_genesis_config(50);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let (bank, program_id) = load_program_and_advance_slot(
|
||||
&mut bank_client,
|
||||
|
@ -2885,7 +2885,7 @@ fn test_program_sbf_realloc() {
|
|||
feature_set.deactivate(&feature_set::bpf_account_data_direct_mapping::id());
|
||||
}
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let (bank, program_id) = load_program_and_advance_slot(
|
||||
&mut bank_client,
|
||||
|
@ -3213,7 +3213,7 @@ fn test_program_sbf_realloc_invoke() {
|
|||
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let realloc_program_id = load_program(
|
||||
&bank_client,
|
||||
|
@ -3729,7 +3729,7 @@ fn test_program_sbf_processed_inner_instruction() {
|
|||
} = create_genesis_config(50);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let sibling_program_id = load_program(
|
||||
&bank_client,
|
||||
|
@ -3887,7 +3887,7 @@ fn test_get_minimum_delegation() {
|
|||
let mut bank = Bank::new_for_tests(&genesis_config);
|
||||
bank.feature_set = Arc::new(FeatureSet::all_enabled());
|
||||
let bank = Arc::new(bank);
|
||||
let mut bank_client = BankClient::new_shared(&bank);
|
||||
let mut bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let (_, program_id) = load_program_and_advance_slot(
|
||||
&mut bank_client,
|
||||
|
|
|
@ -177,7 +177,7 @@ impl OptimisticallyConfirmedBankTracker {
|
|||
fn notify_or_defer(
|
||||
subscriptions: &RpcSubscriptions,
|
||||
bank_forks: &RwLock<BankForks>,
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
last_notified_confirmed_slot: &mut Slot,
|
||||
pending_optimistically_confirmed_banks: &mut HashSet<Slot>,
|
||||
slot_notification_subscribers: &Option<Arc<RwLock<Vec<SlotNotificationSender>>>>,
|
||||
|
@ -204,13 +204,13 @@ impl OptimisticallyConfirmedBankTracker {
|
|||
fn notify_or_defer_confirmed_banks(
|
||||
subscriptions: &RpcSubscriptions,
|
||||
bank_forks: &RwLock<BankForks>,
|
||||
bank: &Arc<Bank>,
|
||||
bank: Arc<Bank>,
|
||||
slot_threshold: Slot,
|
||||
last_notified_confirmed_slot: &mut Slot,
|
||||
pending_optimistically_confirmed_banks: &mut HashSet<Slot>,
|
||||
slot_notification_subscribers: &Option<Arc<RwLock<Vec<SlotNotificationSender>>>>,
|
||||
) {
|
||||
for confirmed_bank in bank.clone().parents_inclusive().iter().rev() {
|
||||
for confirmed_bank in bank.parents_inclusive().iter().rev() {
|
||||
if confirmed_bank.slot() > slot_threshold {
|
||||
debug!(
|
||||
"Calling notify_or_defer for confirmed_bank {:?}",
|
||||
|
@ -286,7 +286,7 @@ impl OptimisticallyConfirmedBankTracker {
|
|||
Self::notify_or_defer_confirmed_banks(
|
||||
subscriptions,
|
||||
bank_forks,
|
||||
&bank,
|
||||
bank,
|
||||
*highest_confirmed_slot,
|
||||
last_notified_confirmed_slot,
|
||||
pending_optimistically_confirmed_banks,
|
||||
|
@ -343,7 +343,7 @@ impl OptimisticallyConfirmedBankTracker {
|
|||
Self::notify_or_defer_confirmed_banks(
|
||||
subscriptions,
|
||||
bank_forks,
|
||||
&bank,
|
||||
bank.clone(),
|
||||
*last_notified_confirmed_slot,
|
||||
last_notified_confirmed_slot,
|
||||
pending_optimistically_confirmed_banks,
|
||||
|
@ -418,13 +418,13 @@ mod tests {
|
|||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let bank1 = bank_forks.read().unwrap().get(1).unwrap();
|
||||
let bank2 = Bank::new_from_parent(&bank1, &Pubkey::default(), 2);
|
||||
let bank2 = Bank::new_from_parent(bank1, &Pubkey::default(), 2);
|
||||
bank_forks.write().unwrap().insert(bank2);
|
||||
let bank2 = bank_forks.read().unwrap().get(2).unwrap();
|
||||
let bank3 = Bank::new_from_parent(&bank2, &Pubkey::default(), 3);
|
||||
let bank3 = Bank::new_from_parent(bank2, &Pubkey::default(), 3);
|
||||
bank_forks.write().unwrap().insert(bank3);
|
||||
|
||||
let optimistically_confirmed_bank =
|
||||
|
@ -520,7 +520,7 @@ mod tests {
|
|||
|
||||
// Test higher root will be cached and clear pending_optimistically_confirmed_banks
|
||||
let bank3 = bank_forks.read().unwrap().get(3).unwrap();
|
||||
let bank4 = Bank::new_from_parent(&bank3, &Pubkey::default(), 4);
|
||||
let bank4 = Bank::new_from_parent(bank3, &Pubkey::default(), 4);
|
||||
bank_forks.write().unwrap().insert(bank4);
|
||||
OptimisticallyConfirmedBankTracker::process_notification(
|
||||
BankNotification::OptimisticallyConfirmed(4),
|
||||
|
@ -540,7 +540,7 @@ mod tests {
|
|||
assert_eq!(highest_confirmed_slot, 4);
|
||||
|
||||
let bank4 = bank_forks.read().unwrap().get(4).unwrap();
|
||||
let bank5 = Bank::new_from_parent(&bank4, &Pubkey::default(), 5);
|
||||
let bank5 = Bank::new_from_parent(bank4, &Pubkey::default(), 5);
|
||||
bank_forks.write().unwrap().insert(bank5);
|
||||
let bank5 = bank_forks.read().unwrap().get(5).unwrap();
|
||||
|
||||
|
@ -550,6 +550,7 @@ mod tests {
|
|||
|
||||
let subscribers = Some(Arc::new(RwLock::new(bank_notification_senders)));
|
||||
let parent_roots = bank5.ancestors.keys();
|
||||
|
||||
OptimisticallyConfirmedBankTracker::process_notification(
|
||||
BankNotification::NewRootBank(bank5),
|
||||
&bank_forks,
|
||||
|
@ -590,10 +591,10 @@ mod tests {
|
|||
|
||||
// Banks <= root do not get added to pending list, even if not frozen
|
||||
let bank5 = bank_forks.read().unwrap().get(5).unwrap();
|
||||
let bank6 = Bank::new_from_parent(&bank5, &Pubkey::default(), 6);
|
||||
let bank6 = Bank::new_from_parent(bank5, &Pubkey::default(), 6);
|
||||
bank_forks.write().unwrap().insert(bank6);
|
||||
let bank5 = bank_forks.read().unwrap().get(5).unwrap();
|
||||
let bank7 = Bank::new_from_parent(&bank5, &Pubkey::default(), 7);
|
||||
let bank7 = Bank::new_from_parent(bank5, &Pubkey::default(), 7);
|
||||
bank_forks.write().unwrap().insert(bank7);
|
||||
bank_forks
|
||||
.write()
|
||||
|
|
|
@ -15,12 +15,12 @@ use {
|
|||
};
|
||||
|
||||
pub fn get_parsed_token_account(
|
||||
bank: Arc<Bank>,
|
||||
bank: &Bank,
|
||||
pubkey: &Pubkey,
|
||||
account: AccountSharedData,
|
||||
) -> UiAccount {
|
||||
let additional_data = get_token_account_mint(account.data())
|
||||
.and_then(|mint_pubkey| get_mint_owner_and_decimals(&bank, &mint_pubkey).ok())
|
||||
.and_then(|mint_pubkey| get_mint_owner_and_decimals(bank, &mint_pubkey).ok())
|
||||
.map(|(_, decimals)| AccountAdditionalData {
|
||||
spl_token_decimals: Some(decimals),
|
||||
});
|
||||
|
@ -72,7 +72,7 @@ where
|
|||
|
||||
/// Analyze a mint Pubkey that may be the native_mint and get the mint-account owner (token
|
||||
/// program_id) and decimals
|
||||
pub fn get_mint_owner_and_decimals(bank: &Arc<Bank>, mint: &Pubkey) -> Result<(Pubkey, u8)> {
|
||||
pub fn get_mint_owner_and_decimals(bank: &Bank, mint: &Pubkey) -> Result<(Pubkey, u8)> {
|
||||
if mint == &spl_token::native_mint::id() {
|
||||
Ok((spl_token::id(), spl_token::native_mint::DECIMALS))
|
||||
} else {
|
||||
|
|
|
@ -338,7 +338,7 @@ impl JsonRpcRequestProcessor {
|
|||
|
||||
// Useful for unit testing
|
||||
pub fn new_from_bank(
|
||||
bank: &Arc<Bank>,
|
||||
bank: Arc<Bank>,
|
||||
socket_addr_space: SocketAddrSpace,
|
||||
connection_cache: Arc<ConnectionCache>,
|
||||
) -> Self {
|
||||
|
@ -373,6 +373,7 @@ impl JsonRpcRequestProcessor {
|
|||
exit.clone(),
|
||||
);
|
||||
|
||||
let leader_schedule_cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank));
|
||||
Self {
|
||||
config: JsonRpcConfig::default(),
|
||||
snapshot_config: None,
|
||||
|
@ -396,11 +397,11 @@ impl JsonRpcRequestProcessor {
|
|||
transaction_sender: Arc::new(Mutex::new(sender)),
|
||||
bigtable_ledger_storage: None,
|
||||
optimistically_confirmed_bank: Arc::new(RwLock::new(OptimisticallyConfirmedBank {
|
||||
bank: bank.clone(),
|
||||
bank,
|
||||
})),
|
||||
largest_accounts_cache: Arc::new(RwLock::new(LargestAccountsCache::new(30))),
|
||||
max_slots: Arc::new(MaxSlots::default()),
|
||||
leader_schedule_cache: Arc::new(LeaderScheduleCache::new_from_bank(bank)),
|
||||
leader_schedule_cache,
|
||||
max_complete_transaction_status_slot: Arc::new(AtomicU64::default()),
|
||||
max_complete_rewards_slot: Arc::new(AtomicU64::default()),
|
||||
prioritization_fee_cache: Arc::new(PrioritizationFeeCache::default()),
|
||||
|
@ -1433,7 +1434,7 @@ impl JsonRpcRequestProcessor {
|
|||
fn get_transaction_status(
|
||||
&self,
|
||||
signature: Signature,
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
) -> Option<TransactionStatus> {
|
||||
let (slot, status) = bank.get_signature_status_slot(&signature)?;
|
||||
|
||||
|
@ -1987,7 +1988,7 @@ impl JsonRpcRequestProcessor {
|
|||
/// Use a set of filters to get an iterator of keyed program accounts from a bank
|
||||
fn get_filtered_program_accounts(
|
||||
&self,
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
program_id: &Pubkey,
|
||||
mut filters: Vec<RpcFilterType>,
|
||||
) -> RpcCustomResult<Vec<(Pubkey, AccountSharedData)>> {
|
||||
|
@ -2037,7 +2038,7 @@ impl JsonRpcRequestProcessor {
|
|||
/// Get an iterator of spl-token accounts by owner address
|
||||
fn get_filtered_spl_token_accounts_by_owner(
|
||||
&self,
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
program_id: &Pubkey,
|
||||
owner_key: &Pubkey,
|
||||
mut filters: Vec<RpcFilterType>,
|
||||
|
@ -2088,7 +2089,7 @@ impl JsonRpcRequestProcessor {
|
|||
/// Get an iterator of spl-token accounts by mint address
|
||||
fn get_filtered_spl_token_accounts_by_mint(
|
||||
&self,
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
program_id: &Pubkey,
|
||||
mint_key: &Pubkey,
|
||||
mut filters: Vec<RpcFilterType>,
|
||||
|
@ -2280,7 +2281,7 @@ pub(crate) fn check_is_at_least_confirmed(commitment: CommitmentConfig) -> Resul
|
|||
}
|
||||
|
||||
fn get_encoded_account(
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
pubkey: &Pubkey,
|
||||
encoding: UiAccountEncoding,
|
||||
data_slice: Option<UiDataSliceConfig>,
|
||||
|
@ -2290,7 +2291,7 @@ fn get_encoded_account(
|
|||
let response = if is_known_spl_token_id(account.owner())
|
||||
&& encoding == UiAccountEncoding::JsonParsed
|
||||
{
|
||||
get_parsed_token_account(bank.clone(), pubkey, account)
|
||||
get_parsed_token_account(bank, pubkey, account)
|
||||
} else {
|
||||
encode_account(&account, pubkey, encoding, data_slice)?
|
||||
};
|
||||
|
@ -2441,7 +2442,7 @@ fn get_spl_token_mint_filter(program_id: &Pubkey, filters: &[RpcFilterType]) ->
|
|||
/// Analyze a passed Pubkey that may be a Token program id or Mint address to determine the program
|
||||
/// id and optional Mint
|
||||
fn get_token_program_id_and_mint(
|
||||
bank: &Arc<Bank>,
|
||||
bank: &Bank,
|
||||
token_account_filter: TokenAccountsFilter,
|
||||
) -> Result<(Pubkey, Option<Pubkey>)> {
|
||||
match token_account_filter {
|
||||
|
@ -4955,7 +4956,7 @@ pub mod tests {
|
|||
let mut parent_bank = self.bank_forks.read().unwrap().working_bank();
|
||||
for (i, root) in roots.iter().enumerate() {
|
||||
let new_bank =
|
||||
Bank::new_from_parent(&parent_bank, parent_bank.collector_id(), *root);
|
||||
Bank::new_from_parent(parent_bank.clone(), parent_bank.collector_id(), *root);
|
||||
parent_bank = self.bank_forks.write().unwrap().insert(new_bank);
|
||||
let parent = if i > 0 { roots[i - 1] } else { 0 };
|
||||
fill_blockstore_slot_with_ticks(
|
||||
|
@ -4968,7 +4969,7 @@ pub mod tests {
|
|||
}
|
||||
self.blockstore.set_roots(roots.iter()).unwrap();
|
||||
let new_bank = Bank::new_from_parent(
|
||||
&parent_bank,
|
||||
parent_bank.clone(),
|
||||
parent_bank.collector_id(),
|
||||
roots.iter().max().unwrap() + 1,
|
||||
);
|
||||
|
@ -4998,11 +4999,7 @@ pub mod tests {
|
|||
.bank_forks
|
||||
.write()
|
||||
.unwrap()
|
||||
.insert(Bank::new_from_parent(
|
||||
&parent_bank,
|
||||
&Pubkey::default(),
|
||||
slot,
|
||||
));
|
||||
.insert(Bank::new_from_parent(parent_bank, &Pubkey::default(), slot));
|
||||
|
||||
let new_block_commitment = BlockCommitmentCache::new(
|
||||
HashMap::new(),
|
||||
|
@ -5056,7 +5053,7 @@ pub mod tests {
|
|||
.unwrap();
|
||||
let connection_cache = Arc::new(ConnectionCache::new("connection_cache_test"));
|
||||
let request_processor = JsonRpcRequestProcessor::new_from_bank(
|
||||
&bank,
|
||||
bank,
|
||||
SocketAddrSpace::Unspecified,
|
||||
connection_cache,
|
||||
);
|
||||
|
@ -5075,7 +5072,7 @@ pub mod tests {
|
|||
let bank = Arc::new(Bank::new_for_tests(&genesis.genesis_config));
|
||||
let connection_cache = Arc::new(ConnectionCache::new("connection_cache_test"));
|
||||
let meta = JsonRpcRequestProcessor::new_from_bank(
|
||||
&bank,
|
||||
bank,
|
||||
SocketAddrSpace::Unspecified,
|
||||
connection_cache,
|
||||
);
|
||||
|
@ -5107,7 +5104,7 @@ pub mod tests {
|
|||
let bank = Arc::new(Bank::new_for_tests(&genesis.genesis_config));
|
||||
let connection_cache = Arc::new(ConnectionCache::new("connection_cache_test"));
|
||||
let meta = JsonRpcRequestProcessor::new_from_bank(
|
||||
&bank,
|
||||
bank,
|
||||
SocketAddrSpace::Unspecified,
|
||||
connection_cache,
|
||||
);
|
||||
|
@ -5234,7 +5231,7 @@ pub mod tests {
|
|||
|
||||
let connection_cache = Arc::new(ConnectionCache::new("connection_cache_test"));
|
||||
let meta = JsonRpcRequestProcessor::new_from_bank(
|
||||
&bank,
|
||||
bank,
|
||||
SocketAddrSpace::Unspecified,
|
||||
connection_cache,
|
||||
);
|
||||
|
@ -6380,7 +6377,7 @@ pub mod tests {
|
|||
let bank = Arc::new(Bank::new_for_tests(&genesis.genesis_config));
|
||||
let connection_cache = Arc::new(ConnectionCache::new("connection_cache_test"));
|
||||
let meta = JsonRpcRequestProcessor::new_from_bank(
|
||||
&bank,
|
||||
bank,
|
||||
SocketAddrSpace::Unspecified,
|
||||
connection_cache,
|
||||
);
|
||||
|
@ -8294,13 +8291,13 @@ pub mod tests {
|
|||
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let bank1 = bank_forks.read().unwrap().get(1).unwrap();
|
||||
let bank2 = Bank::new_from_parent(&bank1, &Pubkey::default(), 2);
|
||||
let bank2 = Bank::new_from_parent(bank1, &Pubkey::default(), 2);
|
||||
bank_forks.write().unwrap().insert(bank2);
|
||||
let bank2 = bank_forks.read().unwrap().get(2).unwrap();
|
||||
let bank3 = Bank::new_from_parent(&bank2, &Pubkey::default(), 3);
|
||||
let bank3 = Bank::new_from_parent(bank2, &Pubkey::default(), 3);
|
||||
bank_forks.write().unwrap().insert(bank3);
|
||||
|
||||
let optimistically_confirmed_bank =
|
||||
|
|
|
@ -873,7 +873,7 @@ mod tests {
|
|||
let blockhash = bank.last_blockhash();
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
|
||||
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
|
||||
|
@ -1001,7 +1001,7 @@ mod tests {
|
|||
let blockhash = bank.last_blockhash();
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
|
||||
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
|
||||
|
@ -1192,7 +1192,7 @@ mod tests {
|
|||
let blockhash = bank.last_blockhash();
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let bob = Keypair::new();
|
||||
|
||||
|
|
|
@ -383,7 +383,7 @@ fn filter_account_result(
|
|||
if is_known_spl_token_id(account.owner())
|
||||
&& params.encoding == UiAccountEncoding::JsonParsed
|
||||
{
|
||||
get_parsed_token_account(bank, ¶ms.pubkey, account)
|
||||
get_parsed_token_account(&bank, ¶ms.pubkey, account)
|
||||
} else {
|
||||
UiAccount::encode(¶ms.pubkey, &account, params.encoding, None, None)
|
||||
}
|
||||
|
@ -1326,7 +1326,7 @@ pub(crate) mod tests {
|
|||
let blockhash = bank.last_blockhash();
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let alice = Keypair::new();
|
||||
|
||||
|
@ -1941,7 +1941,7 @@ pub(crate) mod tests {
|
|||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
|
||||
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let bank1 = bank_forks.read().unwrap().get(1).unwrap();
|
||||
|
||||
|
@ -1958,7 +1958,7 @@ pub(crate) mod tests {
|
|||
|
||||
bank1.process_transaction(&tx).unwrap();
|
||||
|
||||
let bank2 = Bank::new_from_parent(&bank1, &Pubkey::default(), 2);
|
||||
let bank2 = Bank::new_from_parent(bank1, &Pubkey::default(), 2);
|
||||
bank_forks.write().unwrap().insert(bank2);
|
||||
|
||||
// add account for bob and process the transaction at bank2
|
||||
|
@ -1975,7 +1975,7 @@ pub(crate) mod tests {
|
|||
|
||||
bank2.process_transaction(&tx).unwrap();
|
||||
|
||||
let bank3 = Bank::new_from_parent(&bank2, &Pubkey::default(), 3);
|
||||
let bank3 = Bank::new_from_parent(bank2, &Pubkey::default(), 3);
|
||||
bank_forks.write().unwrap().insert(bank3);
|
||||
|
||||
// add account for joe and process the transaction at bank3
|
||||
|
@ -2136,7 +2136,7 @@ pub(crate) mod tests {
|
|||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
|
||||
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let bank1 = bank_forks.read().unwrap().get(1).unwrap();
|
||||
|
||||
|
@ -2153,7 +2153,7 @@ pub(crate) mod tests {
|
|||
|
||||
bank1.process_transaction(&tx).unwrap();
|
||||
|
||||
let bank2 = Bank::new_from_parent(&bank1, &Pubkey::default(), 2);
|
||||
let bank2 = Bank::new_from_parent(bank1, &Pubkey::default(), 2);
|
||||
bank_forks.write().unwrap().insert(bank2);
|
||||
|
||||
// add account for bob and process the transaction at bank2
|
||||
|
@ -2252,7 +2252,7 @@ pub(crate) mod tests {
|
|||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
|
||||
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let bank1 = bank_forks.read().unwrap().get(1).unwrap();
|
||||
|
||||
|
@ -2269,7 +2269,7 @@ pub(crate) mod tests {
|
|||
|
||||
bank1.process_transaction(&tx).unwrap();
|
||||
|
||||
let bank2 = Bank::new_from_parent(&bank1, &Pubkey::default(), 2);
|
||||
let bank2 = Bank::new_from_parent(bank1, &Pubkey::default(), 2);
|
||||
bank_forks.write().unwrap().insert(bank2);
|
||||
|
||||
// add account for bob and process the transaction at bank2
|
||||
|
@ -2372,7 +2372,7 @@ pub(crate) mod tests {
|
|||
})
|
||||
};
|
||||
|
||||
let bank3 = Bank::new_from_parent(&bank2, &Pubkey::default(), 3);
|
||||
let bank3 = Bank::new_from_parent(bank2, &Pubkey::default(), 3);
|
||||
bank_forks.write().unwrap().insert(bank3);
|
||||
|
||||
// add account for joe and process the transaction at bank3
|
||||
|
@ -2452,7 +2452,7 @@ pub(crate) mod tests {
|
|||
.unwrap();
|
||||
|
||||
let next_bank = Bank::new_from_parent(
|
||||
&bank_forks.get(0).unwrap(),
|
||||
bank_forks.get(0).unwrap(),
|
||||
&solana_sdk::pubkey::new_rand(),
|
||||
1,
|
||||
);
|
||||
|
@ -2757,9 +2757,9 @@ pub(crate) mod tests {
|
|||
let blockhash = bank.last_blockhash();
|
||||
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
|
||||
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0.clone(), &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(bank1);
|
||||
let bank2 = Bank::new_from_parent(&bank0, &Pubkey::default(), 2);
|
||||
let bank2 = Bank::new_from_parent(bank0, &Pubkey::default(), 2);
|
||||
bank_forks.write().unwrap().insert(bank2);
|
||||
|
||||
// we need a pubkey that will pass its rent collection slot so rent_epoch gets updated to max since this account is exempt
|
||||
|
|
|
@ -75,7 +75,11 @@ fn test_accounts_squash(bencher: &mut Bencher) {
|
|||
// merkle hash of the account state and distribution of fees and rent
|
||||
let mut slot = 1u64;
|
||||
bencher.iter(|| {
|
||||
let next_bank = Arc::new(Bank::new_from_parent(&prev_bank, &Pubkey::default(), slot));
|
||||
let next_bank = Arc::new(Bank::new_from_parent(
|
||||
prev_bank.clone(),
|
||||
&Pubkey::default(),
|
||||
slot,
|
||||
));
|
||||
next_bank.deposit(&pubkeys[0], 1).unwrap();
|
||||
next_bank.squash();
|
||||
slot += 1;
|
||||
|
|
|
@ -78,12 +78,12 @@ pub fn create_native_loader_transactions(
|
|||
.collect()
|
||||
}
|
||||
|
||||
fn sync_bencher(bank: &Arc<Bank>, _bank_client: &BankClient, transactions: &[Transaction]) {
|
||||
fn sync_bencher(bank: &Bank, _bank_client: &BankClient, transactions: &[Transaction]) {
|
||||
let results = bank.process_transactions(transactions.iter());
|
||||
assert!(results.iter().all(Result::is_ok));
|
||||
}
|
||||
|
||||
fn async_bencher(bank: &Arc<Bank>, bank_client: &BankClient, transactions: &[Transaction]) {
|
||||
fn async_bencher(bank: &Bank, bank_client: &BankClient, transactions: &[Transaction]) {
|
||||
for transaction in transactions.iter().cloned() {
|
||||
bank_client.async_send_transaction(transaction).unwrap();
|
||||
}
|
||||
|
@ -113,7 +113,7 @@ fn async_bencher(bank: &Arc<Bank>, bank_client: &BankClient, transactions: &[Tra
|
|||
#[allow(clippy::type_complexity)]
|
||||
fn do_bench_transactions(
|
||||
bencher: &mut Bencher,
|
||||
bench_work: &dyn Fn(&Arc<Bank>, &BankClient, &[Transaction]),
|
||||
bench_work: &dyn Fn(&Bank, &BankClient, &[Transaction]),
|
||||
create_transactions: &dyn Fn(&BankClient, &Keypair) -> Vec<Transaction>,
|
||||
) {
|
||||
solana_logger::setup();
|
||||
|
@ -130,11 +130,11 @@ fn do_bench_transactions(
|
|||
Ok(())
|
||||
});
|
||||
|
||||
let mut bank = Bank::new_from_parent(&Arc::new(bank), &Pubkey::default(), 1);
|
||||
let mut bank = Bank::new_from_parent(Arc::new(bank), &Pubkey::default(), 1);
|
||||
bank.add_mockup_builtin(Pubkey::from(BUILTIN_PROGRAM_ID), process_instruction);
|
||||
bank.add_builtin_account("solana_noop_program", &Pubkey::from(NOOP_PROGRAM_ID), false);
|
||||
let bank = Arc::new(bank);
|
||||
let bank_client = BankClient::new_shared(&bank);
|
||||
let bank_client = BankClient::new_shared(bank.clone());
|
||||
let transactions = create_transactions(&bank_client, &mint_keypair);
|
||||
|
||||
// Do once to fund accounts, load modules, etc...
|
||||
|
@ -189,7 +189,7 @@ fn bench_bank_update_recent_blockhashes(bencher: &mut Bencher) {
|
|||
// Prime blockhash_queue
|
||||
for i in 0..(MAX_RECENT_BLOCKHASHES + 1) {
|
||||
bank = Arc::new(Bank::new_from_parent(
|
||||
&bank,
|
||||
bank,
|
||||
&Pubkey::default(),
|
||||
(i + 1) as u64,
|
||||
));
|
||||
|
|
|
@ -104,7 +104,7 @@ fn bench_process_transactions_multiple_slots(bencher: &mut Bencher) {
|
|||
let bank = bank_forks.working_bank();
|
||||
let collector = solana_sdk::pubkey::new_rand();
|
||||
let banks = (1..=NUM_SLOTS)
|
||||
.map(|n| Arc::new(Bank::new_from_parent(&bank, &collector, n as u64)))
|
||||
.map(|n| Arc::new(Bank::new_from_parent(bank.clone(), &collector, n as u64)))
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
bencher.iter(|| {
|
||||
|
|
|
@ -907,10 +907,11 @@ mod test {
|
|||
// fine; but maybe unexpected for a reader/debugger without this additional context.
|
||||
let mut make_banks = |num_banks| {
|
||||
for _ in 0..num_banks {
|
||||
let slot = bank.slot() + 1;
|
||||
bank = Arc::new(Bank::new_from_parent(
|
||||
&bank,
|
||||
bank.clone(),
|
||||
&Pubkey::new_unique(),
|
||||
bank.slot() + 1,
|
||||
slot,
|
||||
));
|
||||
|
||||
// Since we're not using `BankForks::set_root()`, we have to handle sending the
|
||||
|
|
|
@ -1172,7 +1172,7 @@ impl Bank {
|
|||
}
|
||||
|
||||
/// Create a new bank that points to an immutable checkpoint of another bank.
|
||||
pub fn new_from_parent(parent: &Arc<Bank>, collector_id: &Pubkey, slot: Slot) -> Self {
|
||||
pub fn new_from_parent(parent: Arc<Bank>, collector_id: &Pubkey, slot: Slot) -> Self {
|
||||
Self::_new_from_parent(
|
||||
parent,
|
||||
collector_id,
|
||||
|
@ -1183,7 +1183,7 @@ impl Bank {
|
|||
}
|
||||
|
||||
pub fn new_from_parent_with_options(
|
||||
parent: &Arc<Bank>,
|
||||
parent: Arc<Bank>,
|
||||
collector_id: &Pubkey,
|
||||
slot: Slot,
|
||||
new_bank_options: NewBankOptions,
|
||||
|
@ -1192,7 +1192,7 @@ impl Bank {
|
|||
}
|
||||
|
||||
pub fn new_from_parent_with_tracer(
|
||||
parent: &Arc<Bank>,
|
||||
parent: Arc<Bank>,
|
||||
collector_id: &Pubkey,
|
||||
slot: Slot,
|
||||
reward_calc_tracer: impl RewardCalcTracer,
|
||||
|
@ -1281,7 +1281,7 @@ impl Bank {
|
|||
}
|
||||
|
||||
fn _new_from_parent(
|
||||
parent: &Arc<Bank>,
|
||||
parent: Arc<Bank>,
|
||||
collector_id: &Pubkey,
|
||||
slot: Slot,
|
||||
reward_calc_tracer: Option<impl RewardCalcTracer>,
|
||||
|
@ -1301,7 +1301,7 @@ impl Bank {
|
|||
accounts_db.insert_default_bank_hash_stats(slot, parent.slot());
|
||||
BankRc {
|
||||
accounts: Arc::new(Accounts::new(accounts_db)),
|
||||
parent: RwLock::new(Some(Arc::clone(parent))),
|
||||
parent: RwLock::new(Some(Arc::clone(&parent))),
|
||||
slot,
|
||||
bank_id_generator: Arc::clone(&parent.rc.bank_id_generator),
|
||||
}
|
||||
|
@ -1721,7 +1721,7 @@ impl Bank {
|
|||
/// * Freezes the new bank, assuming that the user will `Bank::new_from_parent` from this bank
|
||||
/// * Calculates and sets the epoch accounts hash from the parent
|
||||
pub fn warp_from_parent(
|
||||
parent: &Arc<Bank>,
|
||||
parent: Arc<Bank>,
|
||||
collector_id: &Pubkey,
|
||||
slot: Slot,
|
||||
data_source: CalcAccountsHashDataSource,
|
||||
|
|
|
@ -103,7 +103,7 @@ mod tests {
|
|||
genesis_config.epoch_schedule = EpochSchedule::custom(400, 400, false);
|
||||
let bank0 = Arc::new(Bank::new_for_tests(&genesis_config));
|
||||
let eah_start_slot = epoch_accounts_hash_utils::calculation_start(&bank0);
|
||||
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank1 = Bank::new_from_parent(bank0.clone(), &Pubkey::default(), 1);
|
||||
bank0.squash();
|
||||
|
||||
// Create an account on a non-root fork
|
||||
|
@ -118,7 +118,7 @@ mod tests {
|
|||
} else {
|
||||
0
|
||||
} + 2;
|
||||
let bank2 = Bank::new_from_parent(&bank0, &Pubkey::default(), bank2_slot);
|
||||
let bank2 = Bank::new_from_parent(bank0, &Pubkey::default(), bank2_slot);
|
||||
|
||||
// Test new account
|
||||
let key2 = Keypair::new();
|
||||
|
@ -346,7 +346,7 @@ mod tests {
|
|||
BankTestConfig::default(),
|
||||
));
|
||||
bank0.squash();
|
||||
let mut bank = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let mut bank = Bank::new_from_parent(bank0.clone(), &Pubkey::default(), 1);
|
||||
|
||||
add_root_and_flush_write_cache(&bank0);
|
||||
bank.rc
|
||||
|
@ -448,7 +448,7 @@ mod tests {
|
|||
activate_all_features(&mut genesis_config);
|
||||
|
||||
let bank0 = Arc::new(Bank::new_for_tests(&genesis_config));
|
||||
let mut bank = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let mut bank = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
while !bank.is_complete() {
|
||||
bank.fill_bank_with_ticks_for_tests();
|
||||
}
|
||||
|
@ -538,7 +538,7 @@ mod tests {
|
|||
BankTestConfig::default(),
|
||||
));
|
||||
bank0.squash();
|
||||
let mut bank = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let mut bank = Bank::new_from_parent(bank0.clone(), &Pubkey::default(), 1);
|
||||
add_root_and_flush_write_cache(&bank0);
|
||||
bank.rc
|
||||
.accounts
|
||||
|
|
|
@ -53,10 +53,11 @@ mod tests {
|
|||
assert!(bank0_sysvar_cache.get_slot_hashes().is_err());
|
||||
assert!(bank0_sysvar_cache.get_epoch_rewards().is_err()); // partitioned epoch reward feature is not enabled
|
||||
|
||||
let bank1_slot = bank0.slot() + 1;
|
||||
let bank1 = Arc::new(Bank::new_from_parent(
|
||||
&bank0,
|
||||
bank0.clone(),
|
||||
&Pubkey::default(),
|
||||
bank0.slot() + 1,
|
||||
bank1_slot,
|
||||
));
|
||||
|
||||
let bank1_sysvar_cache = bank1.sysvar_cache.read().unwrap();
|
||||
|
@ -77,7 +78,8 @@ mod tests {
|
|||
assert_ne!(bank0_cached_fees, bank1_cached_fees);
|
||||
assert_eq!(bank0_cached_rent, bank1_cached_rent);
|
||||
|
||||
let bank2 = Bank::new_from_parent(&bank1, &Pubkey::default(), bank1.slot() + 1);
|
||||
let bank2_slot = bank1.slot() + 1;
|
||||
let bank2 = Bank::new_from_parent(bank1.clone(), &Pubkey::default(), bank2_slot);
|
||||
|
||||
let bank2_sysvar_cache = bank2.sysvar_cache.read().unwrap();
|
||||
let bank2_cached_clock = bank2_sysvar_cache.get_clock();
|
||||
|
@ -107,7 +109,8 @@ mod tests {
|
|||
fn test_reset_and_fill_sysvar_cache() {
|
||||
let (genesis_config, _mint_keypair) = create_genesis_config(100_000);
|
||||
let bank0 = Arc::new(Bank::new_for_tests(&genesis_config));
|
||||
let mut bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), bank0.slot() + 1);
|
||||
let bank1_slot = bank0.slot() + 1;
|
||||
let mut bank1 = Bank::new_from_parent(bank0, &Pubkey::default(), bank1_slot);
|
||||
|
||||
let bank1_sysvar_cache = bank1.sysvar_cache.read().unwrap();
|
||||
let bank1_cached_clock = bank1_sysvar_cache.get_clock();
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -308,11 +308,10 @@ impl BankClient {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn new_shared(bank: &Arc<Bank>) -> Self {
|
||||
pub fn new_shared(bank: Arc<Bank>) -> Self {
|
||||
let (transaction_sender, transaction_receiver) = unbounded();
|
||||
let transaction_sender = Mutex::new(transaction_sender);
|
||||
let thread_bank = bank.clone();
|
||||
let bank = bank.clone();
|
||||
Builder::new()
|
||||
.name("solBankClient".to_string())
|
||||
.spawn(move || Self::run(&thread_bank, transaction_receiver))
|
||||
|
@ -324,7 +323,7 @@ impl BankClient {
|
|||
}
|
||||
|
||||
pub fn new(bank: Bank) -> Self {
|
||||
Self::new_shared(&Arc::new(bank))
|
||||
Self::new_shared(Arc::new(bank))
|
||||
}
|
||||
|
||||
pub fn set_sysvar_for_tests<T: Sysvar + SysvarId>(&self, sysvar: &T) {
|
||||
|
@ -333,7 +332,7 @@ impl BankClient {
|
|||
|
||||
pub fn advance_slot(&mut self, by: u64, collector_id: &Pubkey) -> Option<Arc<Bank>> {
|
||||
self.bank = Arc::new(Bank::new_from_parent(
|
||||
&self.bank,
|
||||
self.bank.clone(),
|
||||
collector_id,
|
||||
self.bank.slot().checked_add(by)?,
|
||||
));
|
||||
|
|
|
@ -696,7 +696,7 @@ mod tests {
|
|||
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let mut bank_forks = BankForks::new(bank);
|
||||
let child_bank = Bank::new_from_parent(&bank_forks[0u64], &Pubkey::default(), 1);
|
||||
let child_bank = Bank::new_from_parent(bank_forks[0].clone(), &Pubkey::default(), 1);
|
||||
child_bank.register_tick(&Hash::default());
|
||||
bank_forks.insert(child_bank);
|
||||
assert_eq!(bank_forks[1u64].tick_height(), 1);
|
||||
|
@ -707,7 +707,7 @@ mod tests {
|
|||
fn test_bank_forks_new_from_banks() {
|
||||
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
|
||||
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
|
||||
let child_bank = Arc::new(Bank::new_from_parent(&bank, &Pubkey::default(), 1));
|
||||
let child_bank = Arc::new(Bank::new_from_parent(bank.clone(), &Pubkey::default(), 1));
|
||||
|
||||
let bank_forks = BankForks::new_from_banks(&[bank.clone(), child_bank.clone()], 0);
|
||||
assert_eq!(bank_forks.root(), 0);
|
||||
|
@ -724,9 +724,9 @@ mod tests {
|
|||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let mut bank_forks = BankForks::new(bank);
|
||||
let bank0 = bank_forks[0].clone();
|
||||
let bank = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank = Bank::new_from_parent(bank0.clone(), &Pubkey::default(), 1);
|
||||
bank_forks.insert(bank);
|
||||
let bank = Bank::new_from_parent(&bank0, &Pubkey::default(), 2);
|
||||
let bank = Bank::new_from_parent(bank0, &Pubkey::default(), 2);
|
||||
bank_forks.insert(bank);
|
||||
let descendants = bank_forks.descendants();
|
||||
let children: HashSet<u64> = [1u64, 2u64].iter().copied().collect();
|
||||
|
@ -741,9 +741,9 @@ mod tests {
|
|||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let mut bank_forks = BankForks::new(bank);
|
||||
let bank0 = bank_forks[0].clone();
|
||||
let bank = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
|
||||
let bank = Bank::new_from_parent(bank0.clone(), &Pubkey::default(), 1);
|
||||
bank_forks.insert(bank);
|
||||
let bank = Bank::new_from_parent(&bank0, &Pubkey::default(), 2);
|
||||
let bank = Bank::new_from_parent(bank0, &Pubkey::default(), 2);
|
||||
bank_forks.insert(bank);
|
||||
let ancestors = bank_forks.ancestors();
|
||||
assert!(ancestors[&0].is_empty());
|
||||
|
@ -758,7 +758,8 @@ mod tests {
|
|||
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let mut bank_forks = BankForks::new(bank);
|
||||
let child_bank = Bank::new_from_parent(&bank_forks[0u64], &Pubkey::default(), 1);
|
||||
let bank0 = bank_forks[0].clone();
|
||||
let child_bank = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.insert(child_bank);
|
||||
assert!(bank_forks.frozen_banks().get(&0).is_some());
|
||||
assert!(bank_forks.frozen_banks().get(&1).is_none());
|
||||
|
@ -769,7 +770,8 @@ mod tests {
|
|||
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
|
||||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let mut bank_forks = BankForks::new(bank);
|
||||
let child_bank = Bank::new_from_parent(&bank_forks[0u64], &Pubkey::default(), 1);
|
||||
let bank0 = bank_forks[0].clone();
|
||||
let child_bank = Bank::new_from_parent(bank0, &Pubkey::default(), 1);
|
||||
bank_forks.insert(child_bank);
|
||||
assert_eq!(bank_forks.active_bank_slots(), vec![1]);
|
||||
}
|
||||
|
@ -833,8 +835,10 @@ mod tests {
|
|||
// Clock::unix_timestamp from Bank::unix_timestamp_from_genesis()
|
||||
let update_timestamp_case = slot == slots_in_epoch;
|
||||
|
||||
let child1 = Bank::new_from_parent(&bank_forks0[slot - 1], &Pubkey::default(), slot);
|
||||
let child2 = Bank::new_from_parent(&bank_forks1[slot - 1], &Pubkey::default(), slot);
|
||||
let child1 =
|
||||
Bank::new_from_parent(bank_forks0[slot - 1].clone(), &Pubkey::default(), slot);
|
||||
let child2 =
|
||||
Bank::new_from_parent(bank_forks1[slot - 1].clone(), &Pubkey::default(), slot);
|
||||
|
||||
if update_timestamp_case {
|
||||
for child in &[&child1, &child2] {
|
||||
|
@ -880,7 +884,7 @@ mod tests {
|
|||
fn extend_bank_forks(bank_forks: &mut BankForks, parent_child_pairs: &[(Slot, Slot)]) {
|
||||
for (parent, child) in parent_child_pairs.iter() {
|
||||
bank_forks.insert(Bank::new_from_parent(
|
||||
&bank_forks[*parent],
|
||||
bank_forks[*parent].clone(),
|
||||
&Pubkey::default(),
|
||||
*child,
|
||||
));
|
||||
|
|
|
@ -8,7 +8,7 @@ use {
|
|||
stake::{self, state::StakeStateV2},
|
||||
},
|
||||
solana_stake_program::stake_state,
|
||||
std::{collections::HashSet, sync::Arc},
|
||||
std::collections::HashSet,
|
||||
};
|
||||
|
||||
pub struct NonCirculatingSupply {
|
||||
|
@ -16,7 +16,7 @@ pub struct NonCirculatingSupply {
|
|||
pub accounts: Vec<Pubkey>,
|
||||
}
|
||||
|
||||
pub fn calculate_non_circulating_supply(bank: &Arc<Bank>) -> ScanResult<NonCirculatingSupply> {
|
||||
pub fn calculate_non_circulating_supply(bank: &Bank) -> ScanResult<NonCirculatingSupply> {
|
||||
debug!("Updating Bank supply, epoch: {}", bank.epoch());
|
||||
let mut non_circulating_accounts_set: HashSet<Pubkey> = HashSet::new();
|
||||
|
||||
|
@ -228,8 +228,10 @@ mod tests {
|
|||
std::{collections::BTreeMap, sync::Arc},
|
||||
};
|
||||
|
||||
fn new_from_parent(parent: &Arc<Bank>) -> Bank {
|
||||
Bank::new_from_parent(parent, &Pubkey::default(), parent.slot() + 1)
|
||||
fn new_from_parent(parent: Arc<Bank>) -> Bank {
|
||||
let slot = parent.slot() + 1;
|
||||
let collector_id = Pubkey::default();
|
||||
Bank::new_from_parent(parent, &collector_id, slot)
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
@ -294,7 +296,7 @@ mod tests {
|
|||
num_non_circulating_accounts as usize + num_stake_accounts as usize
|
||||
);
|
||||
|
||||
bank = Arc::new(new_from_parent(&bank));
|
||||
bank = Arc::new(new_from_parent(bank));
|
||||
let new_balance = 11;
|
||||
for key in non_circulating_accounts {
|
||||
bank.store_account(
|
||||
|
@ -314,7 +316,7 @@ mod tests {
|
|||
|
||||
// Advance bank an epoch, which should unlock stakes
|
||||
for _ in 0..slots_per_epoch {
|
||||
bank = Arc::new(new_from_parent(&bank));
|
||||
bank = Arc::new(new_from_parent(bank));
|
||||
}
|
||||
assert_eq!(bank.epoch(), 1);
|
||||
let non_circulating_supply = calculate_non_circulating_supply(&bank).unwrap();
|
||||
|
|
|
@ -567,9 +567,9 @@ mod tests {
|
|||
let bank_forks = BankForks::new(bank0);
|
||||
let bank = bank_forks.working_bank();
|
||||
let collector = solana_sdk::pubkey::new_rand();
|
||||
let bank1 = Arc::new(Bank::new_from_parent(&bank, &collector, 1));
|
||||
let bank2 = Arc::new(Bank::new_from_parent(&bank, &collector, 2));
|
||||
let bank3 = Arc::new(Bank::new_from_parent(&bank, &collector, 3));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank.clone(), &collector, 1));
|
||||
let bank2 = Arc::new(Bank::new_from_parent(bank.clone(), &collector, 2));
|
||||
let bank3 = Arc::new(Bank::new_from_parent(bank, &collector, 3));
|
||||
|
||||
let mut prioritization_fee_cache = PrioritizationFeeCache::default();
|
||||
|
||||
|
|
|
@ -68,7 +68,7 @@ mod tests {
|
|||
assert_eq!(bank, root_bank_cache.root_bank());
|
||||
|
||||
{
|
||||
let child_bank = Bank::new_from_parent(&bank, &Pubkey::default(), 1);
|
||||
let child_bank = Bank::new_from_parent(bank.clone(), &Pubkey::default(), 1);
|
||||
bank_forks.write().unwrap().insert(child_bank);
|
||||
|
||||
// cached slot is still 0 since we have not set root
|
||||
|
|
|
@ -1214,7 +1214,8 @@ pub fn create_snapshot_dirs_for_tests(
|
|||
// loop to create the banks at slot 1 to num_total
|
||||
for _ in 0..num_total {
|
||||
// prepare the bank
|
||||
bank = Arc::new(Bank::new_from_parent(&bank, &collecter_id, bank.slot() + 1));
|
||||
let slot = bank.slot() + 1;
|
||||
bank = Arc::new(Bank::new_from_parent(bank, &collecter_id, slot));
|
||||
bank.fill_bank_with_ticks_for_tests();
|
||||
bank.squash();
|
||||
bank.force_flush_accounts_cache();
|
||||
|
@ -1362,7 +1363,7 @@ mod tests {
|
|||
}
|
||||
|
||||
let slot = 1;
|
||||
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &collector, slot));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank0, &collector, slot));
|
||||
bank1
|
||||
.transfer(sol_to_lamports(3.), &mint_keypair, &key3.pubkey())
|
||||
.unwrap();
|
||||
|
@ -1377,7 +1378,7 @@ mod tests {
|
|||
}
|
||||
|
||||
let slot = slot + 1;
|
||||
let bank2 = Arc::new(Bank::new_from_parent(&bank1, &collector, slot));
|
||||
let bank2 = Arc::new(Bank::new_from_parent(bank1, &collector, slot));
|
||||
bank2
|
||||
.transfer(sol_to_lamports(1.), &mint_keypair, &key1.pubkey())
|
||||
.unwrap();
|
||||
|
@ -1386,7 +1387,7 @@ mod tests {
|
|||
}
|
||||
|
||||
let slot = slot + 1;
|
||||
let bank3 = Arc::new(Bank::new_from_parent(&bank2, &collector, slot));
|
||||
let bank3 = Arc::new(Bank::new_from_parent(bank2, &collector, slot));
|
||||
bank3
|
||||
.transfer(sol_to_lamports(1.), &mint_keypair, &key1.pubkey())
|
||||
.unwrap();
|
||||
|
@ -1395,7 +1396,7 @@ mod tests {
|
|||
}
|
||||
|
||||
let slot = slot + 1;
|
||||
let bank4 = Arc::new(Bank::new_from_parent(&bank3, &collector, slot));
|
||||
let bank4 = Arc::new(Bank::new_from_parent(bank3, &collector, slot));
|
||||
bank4
|
||||
.transfer(sol_to_lamports(1.), &mint_keypair, &key1.pubkey())
|
||||
.unwrap();
|
||||
|
@ -1479,7 +1480,7 @@ mod tests {
|
|||
}
|
||||
|
||||
let slot = 1;
|
||||
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &collector, slot));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank0, &collector, slot));
|
||||
bank1
|
||||
.transfer(sol_to_lamports(3.), &mint_keypair, &key3.pubkey())
|
||||
.unwrap();
|
||||
|
@ -1513,7 +1514,7 @@ mod tests {
|
|||
.unwrap();
|
||||
|
||||
let slot = slot + 1;
|
||||
let bank2 = Arc::new(Bank::new_from_parent(&bank1, &collector, slot));
|
||||
let bank2 = Arc::new(Bank::new_from_parent(bank1, &collector, slot));
|
||||
bank2
|
||||
.transfer(sol_to_lamports(1.), &mint_keypair, &key1.pubkey())
|
||||
.unwrap();
|
||||
|
@ -1522,7 +1523,7 @@ mod tests {
|
|||
}
|
||||
|
||||
let slot = slot + 1;
|
||||
let bank3 = Arc::new(Bank::new_from_parent(&bank2, &collector, slot));
|
||||
let bank3 = Arc::new(Bank::new_from_parent(bank2, &collector, slot));
|
||||
bank3
|
||||
.transfer(sol_to_lamports(1.), &mint_keypair, &key1.pubkey())
|
||||
.unwrap();
|
||||
|
@ -1531,7 +1532,7 @@ mod tests {
|
|||
}
|
||||
|
||||
let slot = slot + 1;
|
||||
let bank4 = Arc::new(Bank::new_from_parent(&bank3, &collector, slot));
|
||||
let bank4 = Arc::new(Bank::new_from_parent(bank3, &collector, slot));
|
||||
bank4
|
||||
.transfer(sol_to_lamports(1.), &mint_keypair, &key1.pubkey())
|
||||
.unwrap();
|
||||
|
@ -1600,7 +1601,7 @@ mod tests {
|
|||
}
|
||||
|
||||
let slot = 1;
|
||||
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &collector, slot));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank0, &collector, slot));
|
||||
bank1
|
||||
.transfer(sol_to_lamports(1.), &mint_keypair, &key1.pubkey())
|
||||
.unwrap();
|
||||
|
@ -1634,7 +1635,7 @@ mod tests {
|
|||
.unwrap();
|
||||
|
||||
let slot = slot + 1;
|
||||
let bank2 = Arc::new(Bank::new_from_parent(&bank1, &collector, slot));
|
||||
let bank2 = Arc::new(Bank::new_from_parent(bank1, &collector, slot));
|
||||
bank2
|
||||
.transfer(sol_to_lamports(1.), &mint_keypair, &key1.pubkey())
|
||||
.unwrap();
|
||||
|
@ -1643,7 +1644,7 @@ mod tests {
|
|||
}
|
||||
|
||||
let slot = slot + 1;
|
||||
let bank3 = Arc::new(Bank::new_from_parent(&bank2, &collector, slot));
|
||||
let bank3 = Arc::new(Bank::new_from_parent(bank2, &collector, slot));
|
||||
bank3
|
||||
.transfer(sol_to_lamports(2.), &mint_keypair, &key2.pubkey())
|
||||
.unwrap();
|
||||
|
@ -1652,7 +1653,7 @@ mod tests {
|
|||
}
|
||||
|
||||
let slot = slot + 1;
|
||||
let bank4 = Arc::new(Bank::new_from_parent(&bank3, &collector, slot));
|
||||
let bank4 = Arc::new(Bank::new_from_parent(bank3, &collector, slot));
|
||||
bank4
|
||||
.transfer(sol_to_lamports(3.), &mint_keypair, &key3.pubkey())
|
||||
.unwrap();
|
||||
|
@ -1749,7 +1750,7 @@ mod tests {
|
|||
}
|
||||
|
||||
let slot = 1;
|
||||
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &collector, slot));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank0, &collector, slot));
|
||||
bank1
|
||||
.transfer(lamports_to_transfer, &key2, &key1.pubkey())
|
||||
.unwrap();
|
||||
|
@ -1771,7 +1772,7 @@ mod tests {
|
|||
.unwrap();
|
||||
|
||||
let slot = slot + 1;
|
||||
let bank2 = Arc::new(Bank::new_from_parent(&bank1, &collector, slot));
|
||||
let bank2 = Arc::new(Bank::new_from_parent(bank1, &collector, slot));
|
||||
let blockhash = bank2.last_blockhash();
|
||||
let tx = SanitizedTransaction::from_transaction_for_tests(system_transaction::transfer(
|
||||
&key1,
|
||||
|
@ -1837,7 +1838,7 @@ mod tests {
|
|||
);
|
||||
|
||||
let slot = slot + 1;
|
||||
let bank3 = Arc::new(Bank::new_from_parent(&bank2, &collector, slot));
|
||||
let bank3 = Arc::new(Bank::new_from_parent(bank2, &collector, slot));
|
||||
// Update Account2 so that it no longer holds a reference to slot2
|
||||
bank3
|
||||
.transfer(lamports_to_transfer, &mint_keypair, &key2.pubkey())
|
||||
|
@ -1847,7 +1848,7 @@ mod tests {
|
|||
}
|
||||
|
||||
let slot = slot + 1;
|
||||
let bank4 = Arc::new(Bank::new_from_parent(&bank3, &collector, slot));
|
||||
let bank4 = Arc::new(Bank::new_from_parent(bank3, &collector, slot));
|
||||
while !bank4.is_complete() {
|
||||
bank4.register_tick(&Hash::new_unique());
|
||||
}
|
||||
|
@ -1920,7 +1921,7 @@ mod tests {
|
|||
}
|
||||
|
||||
let slot = 1;
|
||||
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &collector, slot));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank0, &collector, slot));
|
||||
while !bank1.is_complete() {
|
||||
bank1.register_tick(&Hash::new_unique());
|
||||
}
|
||||
|
@ -1942,7 +1943,7 @@ mod tests {
|
|||
.unwrap();
|
||||
|
||||
let slot = slot + 1;
|
||||
let bank2 = Arc::new(Bank::new_from_parent(&bank1, &collector, slot));
|
||||
let bank2 = Arc::new(Bank::new_from_parent(bank1, &collector, slot));
|
||||
bank2
|
||||
.transfer(sol_to_lamports(1.), &mint_keypair, &key1.pubkey())
|
||||
.unwrap();
|
||||
|
@ -2185,11 +2186,8 @@ mod tests {
|
|||
|
||||
// make some banks, do some transactions, ensure there's some zero-lamport accounts
|
||||
for _ in 0..5 {
|
||||
bank = Arc::new(Bank::new_from_parent(
|
||||
&bank,
|
||||
&Pubkey::new_unique(),
|
||||
bank.slot() + 1,
|
||||
));
|
||||
let slot = bank.slot() + 1;
|
||||
bank = Arc::new(Bank::new_from_parent(bank, &Pubkey::new_unique(), slot));
|
||||
do_transfers(&bank);
|
||||
}
|
||||
|
||||
|
@ -2214,11 +2212,8 @@ mod tests {
|
|||
|
||||
// make more banks, do more transactions, ensure there's more zero-lamport accounts
|
||||
for _ in 0..5 {
|
||||
bank = Arc::new(Bank::new_from_parent(
|
||||
&bank,
|
||||
&Pubkey::new_unique(),
|
||||
bank.slot() + 1,
|
||||
));
|
||||
let slot = bank.slot() + 1;
|
||||
bank = Arc::new(Bank::new_from_parent(bank, &Pubkey::new_unique(), slot));
|
||||
do_transfers(&bank);
|
||||
}
|
||||
|
||||
|
|
|
@ -32,21 +32,15 @@ use {
|
|||
};
|
||||
|
||||
/// get bank at next epoch + `n` slots
|
||||
fn next_epoch_and_n_slots(bank: &Arc<Bank>, mut n: usize) -> Arc<Bank> {
|
||||
fn next_epoch_and_n_slots(bank: Arc<Bank>, mut n: usize) -> Arc<Bank> {
|
||||
bank.squash();
|
||||
let mut bank = Arc::new(Bank::new_from_parent(
|
||||
bank,
|
||||
&Pubkey::default(),
|
||||
bank.get_slots_in_epoch(bank.epoch()) + bank.slot(),
|
||||
));
|
||||
let slot = bank.get_slots_in_epoch(bank.epoch()) + bank.slot();
|
||||
let mut bank = Arc::new(Bank::new_from_parent(bank, &Pubkey::default(), slot));
|
||||
|
||||
while n > 0 {
|
||||
bank.squash();
|
||||
bank = Arc::new(Bank::new_from_parent(
|
||||
&bank,
|
||||
&Pubkey::default(),
|
||||
1 + bank.slot(),
|
||||
));
|
||||
let slot = bank.slot() + 1;
|
||||
bank = Arc::new(Bank::new_from_parent(bank, &Pubkey::default(), slot));
|
||||
n -= 1;
|
||||
}
|
||||
|
||||
|
@ -54,23 +48,19 @@ fn next_epoch_and_n_slots(bank: &Arc<Bank>, mut n: usize) -> Arc<Bank> {
|
|||
}
|
||||
|
||||
fn fill_epoch_with_votes(
|
||||
bank: &Arc<Bank>,
|
||||
mut bank: Arc<Bank>,
|
||||
vote_keypair: &Keypair,
|
||||
mint_keypair: &Keypair,
|
||||
) -> Arc<Bank> {
|
||||
let mint_pubkey = mint_keypair.pubkey();
|
||||
let vote_pubkey = vote_keypair.pubkey();
|
||||
let old_epoch = bank.epoch();
|
||||
let mut bank = bank.clone();
|
||||
while bank.epoch() != old_epoch + 1 {
|
||||
bank.squash();
|
||||
bank = Arc::new(Bank::new_from_parent(
|
||||
&bank,
|
||||
&Pubkey::default(),
|
||||
1 + bank.slot(),
|
||||
));
|
||||
let slot = bank.slot() + 1;
|
||||
bank = Arc::new(Bank::new_from_parent(bank, &Pubkey::default(), slot));
|
||||
|
||||
let bank_client = BankClient::new_shared(&bank);
|
||||
let bank_client = BankClient::new_shared(bank.clone());
|
||||
let parent = bank.parent().unwrap();
|
||||
|
||||
let message = Message::new(
|
||||
|
@ -136,7 +126,7 @@ fn test_stake_create_and_split_single_signature() {
|
|||
let staker_pubkey = staker_keypair.pubkey();
|
||||
|
||||
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
|
||||
let bank_client = BankClient::new_shared(&bank);
|
||||
let bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let stake_address =
|
||||
Pubkey::create_with_seed(&staker_pubkey, "stake", &stake::program::id()).unwrap();
|
||||
|
@ -212,7 +202,7 @@ fn test_stake_create_and_split_to_existing_system_account() {
|
|||
let staker_pubkey = staker_keypair.pubkey();
|
||||
|
||||
let bank = Arc::new(Bank::new_for_tests(&genesis_config));
|
||||
let bank_client = BankClient::new_shared(&bank);
|
||||
let bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let stake_address =
|
||||
Pubkey::create_with_seed(&staker_pubkey, "stake", &stake::program::id()).unwrap();
|
||||
|
@ -308,7 +298,7 @@ fn test_stake_account_lifetime() {
|
|||
.accounts_db
|
||||
.epoch_accounts_hash_manager
|
||||
.set_valid(EpochAccountsHash::new(Hash::new_unique()), bank.slot());
|
||||
let bank_client = BankClient::new_shared(&bank);
|
||||
let bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let (vote_balance, stake_rent_exempt_reserve, stake_minimum_delegation) = {
|
||||
let rent = &bank.rent_collector().rent;
|
||||
|
@ -402,12 +392,12 @@ fn test_stake_account_lifetime() {
|
|||
break;
|
||||
}
|
||||
// Cycle thru banks until we're fully warmed up
|
||||
bank = next_epoch_and_n_slots(&bank, 0);
|
||||
bank = next_epoch_and_n_slots(bank, 0);
|
||||
}
|
||||
|
||||
// Reward redemption
|
||||
// Submit enough votes to generate rewards
|
||||
bank = fill_epoch_with_votes(&bank, &vote_keypair, &mint_keypair);
|
||||
bank = fill_epoch_with_votes(bank, &vote_keypair, &mint_keypair);
|
||||
|
||||
// Test that votes and credits are there
|
||||
let account = bank.get_account(&vote_pubkey).expect("account not found");
|
||||
|
@ -420,13 +410,13 @@ fn test_stake_account_lifetime() {
|
|||
// one vote per slot, might be more slots than 32 in the epoch
|
||||
assert!(vote_state.credits() >= 1);
|
||||
|
||||
bank = fill_epoch_with_votes(&bank, &vote_keypair, &mint_keypair);
|
||||
bank = fill_epoch_with_votes(bank, &vote_keypair, &mint_keypair);
|
||||
|
||||
let pre_staked = get_staked(&bank, &stake_pubkey);
|
||||
let pre_balance = bank.get_balance(&stake_pubkey);
|
||||
|
||||
// next epoch bank plus one additional slot should pay rewards
|
||||
bank = next_epoch_and_n_slots(&bank, 1);
|
||||
bank = next_epoch_and_n_slots(bank, 1);
|
||||
|
||||
// Test that balance increased, and that the balance got staked
|
||||
let staked = get_staked(&bank, &stake_pubkey);
|
||||
|
@ -438,7 +428,7 @@ fn test_stake_account_lifetime() {
|
|||
let split_stake_keypair = Keypair::new();
|
||||
let split_stake_pubkey = split_stake_keypair.pubkey();
|
||||
|
||||
let bank_client = BankClient::new_shared(&bank);
|
||||
let bank_client = BankClient::new_shared(bank.clone());
|
||||
// Test split
|
||||
let split_starting_delegation = stake_minimum_delegation + bonus_delegation;
|
||||
let split_starting_balance = split_starting_delegation + stake_rent_exempt_reserve;
|
||||
|
@ -494,9 +484,9 @@ fn test_stake_account_lifetime() {
|
|||
.send_and_confirm_message(&[&mint_keypair, &stake_keypair], message)
|
||||
.is_err());
|
||||
|
||||
let mut bank = next_epoch_and_n_slots(&bank, 1);
|
||||
let mut bank = next_epoch_and_n_slots(bank, 1);
|
||||
|
||||
let bank_client = BankClient::new_shared(&bank);
|
||||
let bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
// assert we're still cooling down
|
||||
let split_staked = get_staked(&bank, &split_stake_pubkey);
|
||||
|
@ -540,9 +530,9 @@ fn test_stake_account_lifetime() {
|
|||
if get_staked(&bank, &split_stake_pubkey) == 0 {
|
||||
break;
|
||||
}
|
||||
bank = next_epoch_and_n_slots(&bank, 1);
|
||||
bank = next_epoch_and_n_slots(bank, 1);
|
||||
}
|
||||
let bank_client = BankClient::new_shared(&bank);
|
||||
let bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
// Test that we can withdraw everything else out of the split
|
||||
let split_remaining_balance = split_balance - split_unstaked;
|
||||
|
@ -584,7 +574,7 @@ fn test_create_stake_account_from_seed() {
|
|||
let bank = Bank::new_for_tests(&genesis_config);
|
||||
let mint_pubkey = mint_keypair.pubkey();
|
||||
let bank = Arc::new(bank);
|
||||
let bank_client = BankClient::new_shared(&bank);
|
||||
let bank_client = BankClient::new_shared(bank.clone());
|
||||
|
||||
let seed = "test-string";
|
||||
let stake_pubkey = Pubkey::create_with_seed(&mint_pubkey, seed, &stake::program::id()).unwrap();
|
||||
|
|
|
@ -584,8 +584,8 @@ impl SendTransactionService {
|
|||
|
||||
/// Retry transactions sent before.
|
||||
fn process_transactions<T: TpuInfo + std::marker::Send + 'static>(
|
||||
working_bank: &Arc<Bank>,
|
||||
root_bank: &Arc<Bank>,
|
||||
working_bank: &Bank,
|
||||
root_bank: &Bank,
|
||||
tpu_address: &SocketAddr,
|
||||
transactions: &mut HashMap<Signature, TransactionInfo>,
|
||||
leader_info_provider: &Arc<Mutex<CurrentLeaderInfo<T>>>,
|
||||
|
@ -880,7 +880,7 @@ mod test {
|
|||
};
|
||||
|
||||
let root_bank = Arc::new(Bank::new_from_parent(
|
||||
&bank_forks.read().unwrap().working_bank(),
|
||||
bank_forks.read().unwrap().working_bank(),
|
||||
&Pubkey::default(),
|
||||
1,
|
||||
));
|
||||
|
@ -888,7 +888,11 @@ mod test {
|
|||
.transfer(1, &mint_keypair, &mint_keypair.pubkey())
|
||||
.unwrap();
|
||||
|
||||
let working_bank = Arc::new(Bank::new_from_parent(&root_bank, &Pubkey::default(), 2));
|
||||
let working_bank = Arc::new(Bank::new_from_parent(
|
||||
root_bank.clone(),
|
||||
&Pubkey::default(),
|
||||
2,
|
||||
));
|
||||
|
||||
let non_rooted_signature = working_bank
|
||||
.transfer(2, &mint_keypair, &mint_keypair.pubkey())
|
||||
|
@ -1142,7 +1146,7 @@ mod test {
|
|||
};
|
||||
|
||||
let root_bank = Arc::new(Bank::new_from_parent(
|
||||
&bank_forks.read().unwrap().working_bank(),
|
||||
bank_forks.read().unwrap().working_bank(),
|
||||
&Pubkey::default(),
|
||||
1,
|
||||
));
|
||||
|
@ -1159,7 +1163,11 @@ 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, &Pubkey::default(), 2));
|
||||
let working_bank = Arc::new(Bank::new_from_parent(
|
||||
root_bank.clone(),
|
||||
&Pubkey::default(),
|
||||
2,
|
||||
));
|
||||
let non_rooted_signature = working_bank
|
||||
.transfer(2, &mint_keypair, &mint_keypair.pubkey())
|
||||
.unwrap();
|
||||
|
|
|
@ -129,7 +129,7 @@ mod tests {
|
|||
fn test_recv_slot_entries_1() {
|
||||
let (genesis_config, bank0, tx) = setup_test();
|
||||
|
||||
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &Pubkey::default(), 1));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank0, &Pubkey::default(), 1));
|
||||
let (s, r) = unbounded();
|
||||
let mut last_hash = genesis_config.hash();
|
||||
|
||||
|
@ -158,8 +158,8 @@ mod tests {
|
|||
fn test_recv_slot_entries_2() {
|
||||
let (genesis_config, bank0, tx) = setup_test();
|
||||
|
||||
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &Pubkey::default(), 1));
|
||||
let bank2 = Arc::new(Bank::new_from_parent(&bank1, &Pubkey::default(), 2));
|
||||
let bank1 = Arc::new(Bank::new_from_parent(bank0, &Pubkey::default(), 1));
|
||||
let bank2 = Arc::new(Bank::new_from_parent(bank1.clone(), &Pubkey::default(), 2));
|
||||
let (s, r) = unbounded();
|
||||
|
||||
let mut last_hash = genesis_config.hash();
|
||||
|
|
|
@ -685,7 +685,7 @@ mod test {
|
|||
|
||||
// Step 2: Make a transmission for another bank that interrupts the transmission for
|
||||
// slot 0
|
||||
let bank2 = Arc::new(Bank::new_from_parent(&bank0, &leader_keypair.pubkey(), 2));
|
||||
let bank2 = Arc::new(Bank::new_from_parent(bank0, &leader_keypair.pubkey(), 2));
|
||||
let interrupted_slot = unfinished_slot.slot;
|
||||
// Interrupting the slot should cause the unfinished_slot and stats to reset
|
||||
let num_shreds = 1;
|
||||
|
|
Loading…
Reference in New Issue