From 2bfad87a5f50bf8bf3351e7158e1afc7d6c5e41e Mon Sep 17 00:00:00 2001 From: Michael Vines Date: Sat, 2 Mar 2019 10:05:31 -0800 Subject: [PATCH] Rename Bank.last_id() to Bank.last_block_hash() --- benches/banking_stage.rs | 2 +- core/src/banking_stage.rs | 12 +++--- core/src/blocktree_processor.rs | 48 ++++++++++++------------ core/src/fullnode.rs | 4 +- core/src/leader_confirmation_service.rs | 2 +- core/src/poh_recorder.rs | 14 +++---- core/src/poh_service.rs | 4 +- core/src/replay_stage.rs | 16 ++++---- core/src/rpc.rs | 8 ++-- core/src/rpc_pubsub.rs | 6 +-- core/src/rpc_subscriptions.rs | 4 +- core/src/voting_keypair.rs | 4 +- programs/native/rewards/tests/rewards.rs | 8 ++-- programs/native/vote/tests/vote.rs | 6 +-- programs/tests/programs.rs | 16 ++++---- runtime/benches/bank.rs | 6 +-- runtime/src/bank.rs | 10 ++--- tests/tvu.rs | 2 +- 18 files changed, 86 insertions(+), 86 deletions(-) diff --git a/benches/banking_stage.rs b/benches/banking_stage.rs index 905ad6663e..4185ee04db 100644 --- a/benches/banking_stage.rs +++ b/benches/banking_stage.rs @@ -45,7 +45,7 @@ fn create_test_recorder(bank: &Arc) -> (Arc>, PohServic let exit = Arc::new(AtomicBool::new(false)); let poh_recorder = Arc::new(Mutex::new(PohRecorder::new( bank.tick_height(), - bank.last_id(), + bank.last_block_hash(), ))); let poh_service = PohService::new( poh_recorder.clone(), diff --git a/core/src/banking_stage.rs b/core/src/banking_stage.rs index b23fd4cb4a..f4f2f726b4 100644 --- a/core/src/banking_stage.rs +++ b/core/src/banking_stage.rs @@ -361,7 +361,7 @@ mod tests { let exit = Arc::new(AtomicBool::new(false)); let poh_recorder = Arc::new(Mutex::new(PohRecorder::new( bank.tick_height(), - bank.last_id(), + bank.last_block_hash(), ))); let poh_service = PohService::new( poh_recorder.clone(), @@ -394,7 +394,7 @@ mod tests { let (mut genesis_block, _mint_keypair) = GenesisBlock::new(2); genesis_block.ticks_per_slot = 4; let bank = Arc::new(Bank::new(&genesis_block)); - let start_hash = bank.last_id(); + let start_hash = bank.last_block_hash(); let (verified_sender, verified_receiver) = channel(); let (poh_recorder, poh_service) = create_test_recorder(&bank); let (banking_stage, entry_receiver) = BankingStage::new( @@ -413,7 +413,7 @@ mod tests { .collect(); assert_eq!(entries.len(), genesis_block.ticks_per_slot as usize - 1); assert!(entries.verify(&start_hash)); - assert_eq!(entries[entries.len() - 1].hash, bank.last_id()); + assert_eq!(entries[entries.len() - 1].hash, bank.last_block_hash()); banking_stage.join().unwrap(); poh_service.close().unwrap(); } @@ -422,7 +422,7 @@ mod tests { fn test_banking_stage_entries_only() { let (genesis_block, mint_keypair) = GenesisBlock::new(2); let bank = Arc::new(Bank::new(&genesis_block)); - let start_hash = bank.last_id(); + let start_hash = bank.last_block_hash(); let (verified_sender, verified_receiver) = channel(); let (poh_recorder, poh_service) = create_test_recorder(&bank); let (banking_stage, entry_receiver) = BankingStage::new( @@ -636,7 +636,7 @@ mod tests { let poh_recorder = Arc::new(Mutex::new(PohRecorder::new( bank.tick_height(), - bank.last_id(), + bank.last_block_hash(), ))); poh_recorder.lock().unwrap().set_working_bank(working_bank); let pubkey = Keypair::new().pubkey(); @@ -691,7 +691,7 @@ mod tests { }; let poh_recorder = Arc::new(Mutex::new(PohRecorder::new( bank.tick_height(), - bank.last_id(), + bank.last_block_hash(), ))); poh_recorder.lock().unwrap().set_working_bank(working_bank); diff --git a/core/src/blocktree_processor.rs b/core/src/blocktree_processor.rs index 93333c4ece..aa1a82a0a3 100644 --- a/core/src/blocktree_processor.rs +++ b/core/src/blocktree_processor.rs @@ -115,7 +115,7 @@ pub fn process_blocktree( let slot = 0; let bank = Arc::new(Bank::new_with_paths(&genesis_block, account_paths)); let entry_height = 0; - let last_entry_hash = bank.last_id(); + let last_entry_hash = bank.last_block_hash(); vec![(slot, bank, entry_height, last_entry_hash)] }; @@ -500,7 +500,7 @@ mod tests { let bank = bank_forks[1].clone(); assert_eq!(bank.get_balance(&mint_keypair.pubkey()), 50 - 3); assert_eq!(bank.tick_height(), 2 * genesis_block.ticks_per_slot - 1); - assert_eq!(bank.last_id(), entries.last().unwrap().hash); + assert_eq!(bank.last_block_hash(), entries.last().unwrap().hash); } #[test] @@ -544,19 +544,19 @@ mod tests { let keypair1 = Keypair::new(); let keypair2 = Keypair::new(); - let last_id = bank.last_id(); + let last_id = bank.last_block_hash(); // ensure bank can process 2 entries that have a common account and no tick is registered let tx = - SystemTransaction::new_account(&mint_keypair, keypair1.pubkey(), 2, bank.last_id(), 0); + SystemTransaction::new_account(&mint_keypair, keypair1.pubkey(), 2, bank.last_block_hash(), 0); let entry_1 = next_entry(&last_id, 1, vec![tx]); let tx = - SystemTransaction::new_account(&mint_keypair, keypair2.pubkey(), 2, bank.last_id(), 0); + SystemTransaction::new_account(&mint_keypair, keypair2.pubkey(), 2, bank.last_block_hash(), 0); let entry_2 = next_entry(&entry_1.hash, 1, vec![tx]); assert_eq!(par_process_entries(&bank, &[entry_1, entry_2]), Ok(())); assert_eq!(bank.get_balance(&keypair1.pubkey()), 2); assert_eq!(bank.get_balance(&keypair2.pubkey()), 2); - assert_eq!(bank.last_id(), last_id); + assert_eq!(bank.last_block_hash(), last_id); } #[test] @@ -569,23 +569,23 @@ mod tests { // fund: put 4 in each of 1 and 2 assert_matches!( - bank.transfer(4, &mint_keypair, keypair1.pubkey(), bank.last_id()), + bank.transfer(4, &mint_keypair, keypair1.pubkey(), bank.last_block_hash()), Ok(_) ); assert_matches!( - bank.transfer(4, &mint_keypair, keypair2.pubkey(), bank.last_id()), + bank.transfer(4, &mint_keypair, keypair2.pubkey(), bank.last_block_hash()), Ok(_) ); // construct an Entry whose 2nd transaction would cause a lock conflict with previous entry let entry_1_to_mint = next_entry( - &bank.last_id(), + &bank.last_block_hash(), 1, vec![SystemTransaction::new_account( &keypair1, mint_keypair.pubkey(), 1, - bank.last_id(), + bank.last_block_hash(), 0, )], ); @@ -594,12 +594,12 @@ mod tests { &entry_1_to_mint.hash, 1, vec![ - SystemTransaction::new_account(&keypair2, keypair3.pubkey(), 2, bank.last_id(), 0), // should be fine + SystemTransaction::new_account(&keypair2, keypair3.pubkey(), 2, bank.last_block_hash(), 0), // should be fine SystemTransaction::new_account( &keypair1, mint_keypair.pubkey(), 2, - bank.last_id(), + bank.last_block_hash(), 0, ), // will collide ], @@ -626,22 +626,22 @@ mod tests { //load accounts let tx = - SystemTransaction::new_account(&mint_keypair, keypair1.pubkey(), 1, bank.last_id(), 0); + SystemTransaction::new_account(&mint_keypair, keypair1.pubkey(), 1, bank.last_block_hash(), 0); assert_eq!(bank.process_transaction(&tx), Ok(())); let tx = - SystemTransaction::new_account(&mint_keypair, keypair2.pubkey(), 1, bank.last_id(), 0); + SystemTransaction::new_account(&mint_keypair, keypair2.pubkey(), 1, bank.last_block_hash(), 0); assert_eq!(bank.process_transaction(&tx), Ok(())); // ensure bank can process 2 entries that do not have a common account and no tick is registered - let last_id = bank.last_id(); - let tx = SystemTransaction::new_account(&keypair1, keypair3.pubkey(), 1, bank.last_id(), 0); + let last_id = bank.last_block_hash(); + let tx = SystemTransaction::new_account(&keypair1, keypair3.pubkey(), 1, bank.last_block_hash(), 0); let entry_1 = next_entry(&last_id, 1, vec![tx]); - let tx = SystemTransaction::new_account(&keypair2, keypair4.pubkey(), 1, bank.last_id(), 0); + let tx = SystemTransaction::new_account(&keypair2, keypair4.pubkey(), 1, bank.last_block_hash(), 0); let entry_2 = next_entry(&entry_1.hash, 1, vec![tx]); assert_eq!(par_process_entries(&bank, &[entry_1, entry_2]), Ok(())); assert_eq!(bank.get_balance(&keypair3.pubkey()), 1); assert_eq!(bank.get_balance(&keypair4.pubkey()), 1); - assert_eq!(bank.last_id(), last_id); + assert_eq!(bank.last_block_hash(), last_id); } #[test] @@ -655,14 +655,14 @@ mod tests { //load accounts let tx = - SystemTransaction::new_account(&mint_keypair, keypair1.pubkey(), 1, bank.last_id(), 0); + SystemTransaction::new_account(&mint_keypair, keypair1.pubkey(), 1, bank.last_block_hash(), 0); assert_eq!(bank.process_transaction(&tx), Ok(())); let tx = - SystemTransaction::new_account(&mint_keypair, keypair2.pubkey(), 1, bank.last_id(), 0); + SystemTransaction::new_account(&mint_keypair, keypair2.pubkey(), 1, bank.last_block_hash(), 0); assert_eq!(bank.process_transaction(&tx), Ok(())); - let last_id = bank.last_id(); - while last_id == bank.last_id() { + let last_id = bank.last_block_hash(); + while last_id == bank.last_block_hash() { bank.register_tick(&Hash::default()); } @@ -670,7 +670,7 @@ mod tests { let tx = SystemTransaction::new_account(&keypair2, keypair3.pubkey(), 1, last_id, 0); let entry_1 = next_entry(&last_id, 1, vec![tx]); let tick = next_entry(&entry_1.hash, 1, vec![]); - let tx = SystemTransaction::new_account(&keypair1, keypair4.pubkey(), 1, bank.last_id(), 0); + let tx = SystemTransaction::new_account(&keypair1, keypair4.pubkey(), 1, bank.last_block_hash(), 0); let entry_2 = next_entry(&tick.hash, 1, vec![tx]); assert_eq!( par_process_entries(&bank, &[entry_1.clone(), tick.clone(), entry_2.clone()]), @@ -680,7 +680,7 @@ mod tests { assert_eq!(bank.get_balance(&keypair4.pubkey()), 1); // ensure that an error is returned for an empty account (keypair2) - let tx = SystemTransaction::new_account(&keypair2, keypair3.pubkey(), 1, bank.last_id(), 0); + let tx = SystemTransaction::new_account(&keypair2, keypair3.pubkey(), 1, bank.last_block_hash(), 0); let entry_3 = next_entry(&entry_2.hash, 1, vec![tx]); assert_eq!( par_process_entries(&bank, &[entry_3]), diff --git a/core/src/fullnode.rs b/core/src/fullnode.rs index 9d9801ff02..a310f1a1a9 100644 --- a/core/src/fullnode.rs +++ b/core/src/fullnode.rs @@ -124,10 +124,10 @@ impl Fullnode { let bank_info = &bank_forks_info[0]; let bank = bank_forks[bank_info.bank_id].clone(); - info!("starting PoH... {} {}", bank.tick_height(), bank.last_id(),); + info!("starting PoH... {} {}", bank.tick_height(), bank.last_block_hash(),); let poh_recorder = Arc::new(Mutex::new(PohRecorder::new( bank.tick_height(), - bank.last_id(), + bank.last_block_hash(), ))); let poh_service = PohService::new(poh_recorder.clone(), &config.tick_config, exit.clone()); diff --git a/core/src/leader_confirmation_service.rs b/core/src/leader_confirmation_service.rs index 6cff3f8025..1ccb6695eb 100644 --- a/core/src/leader_confirmation_service.rs +++ b/core/src/leader_confirmation_service.rs @@ -154,7 +154,7 @@ mod tests { tick_hash = hash(&serialize(&tick_hash).unwrap()); bank.register_tick(&tick_hash); } - let last_id = bank.last_id(); + let last_id = bank.last_block_hash(); // Create a total of 10 vote accounts, each will have a balance of 1 (after giving 1 to // their vote account), for a total staking pool of 10 tokens. diff --git a/core/src/poh_recorder.rs b/core/src/poh_recorder.rs index d42a6c1407..24ca79c151 100644 --- a/core/src/poh_recorder.rs +++ b/core/src/poh_recorder.rs @@ -223,7 +223,7 @@ mod tests { fn test_poh_recorder_clear() { let (genesis_block, _mint_keypair) = GenesisBlock::new(2); let bank = Arc::new(Bank::new(&genesis_block)); - let prev_hash = bank.last_id(); + let prev_hash = bank.last_block_hash(); let (entry_sender, _) = channel(); let mut poh_recorder = PohRecorder::new(0, prev_hash); @@ -243,7 +243,7 @@ mod tests { fn test_poh_recorder_tick_sent_after_min() { let (genesis_block, _mint_keypair) = GenesisBlock::new(2); let bank = Arc::new(Bank::new(&genesis_block)); - let prev_hash = bank.last_id(); + let prev_hash = bank.last_block_hash(); let (entry_sender, entry_receiver) = channel(); let mut poh_recorder = PohRecorder::new(0, prev_hash); @@ -274,7 +274,7 @@ mod tests { fn test_poh_recorder_tick_sent_upto_and_including_max() { let (genesis_block, _mint_keypair) = GenesisBlock::new(2); let bank = Arc::new(Bank::new(&genesis_block)); - let prev_hash = bank.last_id(); + let prev_hash = bank.last_block_hash(); let (entry_sender, entry_receiver) = channel(); let mut poh_recorder = PohRecorder::new(0, prev_hash); @@ -304,7 +304,7 @@ mod tests { fn test_poh_recorder_record_to_early() { let (genesis_block, _mint_keypair) = GenesisBlock::new(2); let bank = Arc::new(Bank::new(&genesis_block)); - let prev_hash = bank.last_id(); + let prev_hash = bank.last_block_hash(); let (entry_sender, entry_receiver) = channel(); let mut poh_recorder = PohRecorder::new(0, prev_hash); @@ -326,7 +326,7 @@ mod tests { fn test_poh_recorder_record_at_min_passes() { let (genesis_block, _mint_keypair) = GenesisBlock::new(2); let bank = Arc::new(Bank::new(&genesis_block)); - let prev_hash = bank.last_id(); + let prev_hash = bank.last_block_hash(); let (entry_sender, entry_receiver) = channel(); let mut poh_recorder = PohRecorder::new(0, prev_hash); @@ -357,7 +357,7 @@ mod tests { fn test_poh_recorder_record_at_max_fails() { let (genesis_block, _mint_keypair) = GenesisBlock::new(2); let bank = Arc::new(Bank::new(&genesis_block)); - let prev_hash = bank.last_id(); + let prev_hash = bank.last_block_hash(); let (entry_sender, entry_receiver) = channel(); let mut poh_recorder = PohRecorder::new(0, prev_hash); @@ -385,7 +385,7 @@ mod tests { fn test_poh_cache_on_disconnect() { let (genesis_block, _mint_keypair) = GenesisBlock::new(2); let bank = Arc::new(Bank::new(&genesis_block)); - let prev_hash = bank.last_id(); + let prev_hash = bank.last_block_hash(); let (entry_sender, entry_receiver) = channel(); let mut poh_recorder = PohRecorder::new(0, prev_hash); diff --git a/core/src/poh_service.rs b/core/src/poh_service.rs index a871226f05..adf2b743d5 100644 --- a/core/src/poh_service.rs +++ b/core/src/poh_service.rs @@ -124,7 +124,7 @@ mod tests { fn test_poh_service() { let (genesis_block, _mint_keypair) = GenesisBlock::new(2); let bank = Arc::new(Bank::new(&genesis_block)); - let prev_hash = bank.last_id(); + let prev_hash = bank.last_block_hash(); let (entry_sender, entry_receiver) = channel(); let poh_recorder = Arc::new(Mutex::new(PohRecorder::new(bank.tick_height(), prev_hash))); let exit = Arc::new(AtomicBool::new(false)); @@ -204,7 +204,7 @@ mod tests { fn test_poh_service_drops_working_bank() { let (genesis_block, _mint_keypair) = GenesisBlock::new(2); let bank = Arc::new(Bank::new(&genesis_block)); - let prev_hash = bank.last_id(); + let prev_hash = bank.last_block_hash(); let (entry_sender, entry_receiver) = channel(); let poh_recorder = Arc::new(Mutex::new(PohRecorder::new(bank.tick_height(), prev_hash))); let exit = Arc::new(AtomicBool::new(false)); diff --git a/core/src/replay_stage.rs b/core/src/replay_stage.rs index e874a8b650..e0e1b53c0e 100644 --- a/core/src/replay_stage.rs +++ b/core/src/replay_stage.rs @@ -137,7 +137,7 @@ impl ReplayStage { let vote = VoteTransaction::new_vote( keypair, *latest_slot_vote, - parent.last_id(), + parent.last_block_hash(), 0, ); cluster_info.write().unwrap().push_vote(vote); @@ -152,7 +152,7 @@ impl ReplayStage { ); to_leader_sender.send(TvuRotationInfo { tick_height: parent.tick_height(), - last_id: parent.last_id(), + last_id: parent.last_block_hash(), slot: next_slot, leader_id: next_leader, })?; @@ -206,7 +206,7 @@ impl ReplayStage { progress: &mut HashMap, ) -> result::Result<(Vec, usize)> { let bank_id = bank.slot(); - let bank_progress = &mut progress.entry(bank_id).or_insert((bank.last_id(), 0)); + let bank_progress = &mut progress.entry(bank_id).or_insert((bank.last_block_hash(), 0)); blocktree.get_slot_entries_with_blob_count(bank_id, bank_progress.1 as u64, None) } @@ -217,7 +217,7 @@ impl ReplayStage { forward_entry_sender: &EntrySender, num: usize, ) -> result::Result<()> { - let bank_progress = &mut progress.entry(bank.slot()).or_insert((bank.last_id(), 0)); + let bank_progress = &mut progress.entry(bank.slot()).or_insert((bank.last_block_hash(), 0)); let result = Self::verify_and_process_entries(&bank, &entries, &bank_progress.0); bank_progress.1 += num; if let Some(last_entry) = entries.last() { @@ -253,7 +253,7 @@ impl ReplayStage { entries.len(), bank.tick_height(), last_entry, - bank.last_id() + bank.last_block_hash() ); return Err(result::Error::BlobError(BlobError::VerificationFailed)); } @@ -358,11 +358,11 @@ mod test { ); let keypair = voting_keypair.as_ref(); - let vote = VoteTransaction::new_vote(keypair, 0, bank.last_id(), 0); + let vote = VoteTransaction::new_vote(keypair, 0, bank.last_block_hash(), 0); cluster_info_me.write().unwrap().push_vote(vote); info!("Send ReplayStage an entry, should see it on the ledger writer receiver"); - let next_tick = create_ticks(1, bank.last_id()); + let next_tick = create_ticks(1, bank.last_block_hash()); blocktree.write_entries(1, 0, 0, next_tick.clone()).unwrap(); let received_tick = ledger_writer_recv @@ -383,7 +383,7 @@ mod test { let (forward_entry_sender, forward_entry_receiver) = channel(); let genesis_block = GenesisBlock::new(10_000).0; let bank = Arc::new(Bank::new(&genesis_block)); - let mut last_id = bank.last_id(); + let mut last_id = bank.last_block_hash(); let mut entries = Vec::new(); for _ in 0..5 { let entry = next_entry_mut(&mut last_id, 1, vec![]); //just ticks diff --git a/core/src/rpc.rs b/core/src/rpc.rs index e222e49a44..fcf24c79c3 100644 --- a/core/src/rpc.rs +++ b/core/src/rpc.rs @@ -58,7 +58,7 @@ impl JsonRpcRequestProcessor { } fn get_recent_block_hash(&self) -> Result { - let id = self.bank()?.last_id(); + let id = self.bank()?.last_block_hash(); Ok(bs58::encode(id).into_string()) } @@ -255,7 +255,7 @@ impl RpcSol for RpcSolImpl { trace!("request_airdrop id={} tokens={}", id, tokens); let pubkey = verify_pubkey(id)?; - let last_id = meta.request_processor.read().unwrap().bank()?.last_id(); + let last_id = meta.request_processor.read().unwrap().bank()?.last_block_hash(); let transaction = request_airdrop_transaction(&meta.drone_addr, &pubkey, tokens, last_id) .map_err(|err| { info!("request_airdrop_transaction failed: {:?}", err); @@ -370,7 +370,7 @@ mod tests { let (genesis_block, alice) = GenesisBlock::new(10_000); let bank = Arc::new(Bank::new(&genesis_block)); - let last_id = bank.last_id(); + let last_id = bank.last_block_hash(); let tx = SystemTransaction::new_move(&alice, pubkey, 20, last_id, 0); bank.process_transaction(&tx).expect("process transaction"); @@ -406,7 +406,7 @@ mod tests { let mut request_processor = JsonRpcRequestProcessor::new(StorageState::default()); request_processor.set_bank(&bank); thread::spawn(move || { - let last_id = bank.last_id(); + let last_id = bank.last_block_hash(); let tx = SystemTransaction::new_move(&alice, bob_pubkey, 20, last_id, 0); bank.process_transaction(&tx).expect("process transaction"); }) diff --git a/core/src/rpc_pubsub.rs b/core/src/rpc_pubsub.rs index ac4d615035..716409483a 100644 --- a/core/src/rpc_pubsub.rs +++ b/core/src/rpc_pubsub.rs @@ -203,7 +203,7 @@ mod tests { let bob_pubkey = bob.pubkey(); let bank = Bank::new(&genesis_block); let arc_bank = Arc::new(bank); - let last_id = arc_bank.last_id(); + let last_id = arc_bank.last_block_hash(); let rpc = RpcSolPubSubImpl::default(); @@ -232,7 +232,7 @@ mod tests { let bob_pubkey = Keypair::new().pubkey(); let bank = Bank::new(&genesis_block); let arc_bank = Arc::new(bank); - let last_id = arc_bank.last_id(); + let last_id = arc_bank.last_block_hash(); let session = create_session(); @@ -279,7 +279,7 @@ mod tests { let executable = false; // TODO let bank = Bank::new(&genesis_block); let arc_bank = Arc::new(bank); - let last_id = arc_bank.last_id(); + let last_id = arc_bank.last_block_hash(); let rpc = RpcSolPubSubImpl::default(); let session = create_session(); diff --git a/core/src/rpc_subscriptions.rs b/core/src/rpc_subscriptions.rs index 680704336b..5d61c6c626 100644 --- a/core/src/rpc_subscriptions.rs +++ b/core/src/rpc_subscriptions.rs @@ -156,7 +156,7 @@ mod tests { let (genesis_block, mint_keypair) = GenesisBlock::new(100); let bank = Bank::new(&genesis_block); let alice = Keypair::new(); - let last_id = bank.last_id(); + let last_id = bank.last_block_hash(); let tx = SystemTransaction::new_program_account( &mint_keypair, alice.pubkey(), @@ -201,7 +201,7 @@ mod tests { let (genesis_block, mint_keypair) = GenesisBlock::new(100); let bank = Bank::new(&genesis_block); let alice = Keypair::new(); - let last_id = bank.last_id(); + let last_id = bank.last_block_hash(); let tx = SystemTransaction::new_move(&mint_keypair, alice.pubkey(), 20, last_id, 0); let signature = tx.signatures[0]; bank.process_transaction(&tx).unwrap(); diff --git a/core/src/voting_keypair.rs b/core/src/voting_keypair.rs index c839b7f5f3..8857ea07e3 100644 --- a/core/src/voting_keypair.rs +++ b/core/src/voting_keypair.rs @@ -109,7 +109,7 @@ pub mod tests { bank: &Bank, num_tokens: u64, ) { - let last_id = bank.last_id(); + let last_id = bank.last_block_hash(); let tx = VoteTransaction::fund_staking_account( from_keypair, *voting_pubkey, @@ -121,7 +121,7 @@ pub mod tests { } pub fn push_vote(voting_keypair: &T, bank: &Bank, slot_height: u64) { - let last_id = bank.last_id(); + let last_id = bank.last_block_hash(); let tx = VoteTransaction::new_vote(voting_keypair, slot_height, last_id, 0); bank.process_transaction(&tx).unwrap(); } diff --git a/programs/native/rewards/tests/rewards.rs b/programs/native/rewards/tests/rewards.rs index a5d848ea32..016015720f 100644 --- a/programs/native/rewards/tests/rewards.rs +++ b/programs/native/rewards/tests/rewards.rs @@ -24,7 +24,7 @@ impl<'a> RewardsBank<'a> { rewards_id: Pubkey, lamports: u64, ) -> Result<()> { - let last_id = self.bank.last_id(); + let last_id = self.bank.last_block_hash(); let tx = RewardsTransaction::new_account(from_keypair, rewards_id, last_id, lamports, 0); self.bank.process_transaction(&tx) } @@ -35,13 +35,13 @@ impl<'a> RewardsBank<'a> { vote_id: Pubkey, lamports: u64, ) -> Result<()> { - let last_id = self.bank.last_id(); + let last_id = self.bank.last_block_hash(); let tx = VoteTransaction::fund_staking_account(from_keypair, vote_id, last_id, lamports, 0); self.bank.process_transaction(&tx) } fn submit_vote(&self, vote_keypair: &Keypair, tick_height: u64) -> Result { - let last_id = self.bank.last_id(); + let last_id = self.bank.last_block_hash(); let tx = VoteTransaction::new_vote(vote_keypair, tick_height, last_id, 0); self.bank.process_transaction(&tx)?; self.bank.register_tick(&hash(last_id.as_ref())); @@ -51,7 +51,7 @@ impl<'a> RewardsBank<'a> { } fn redeem_credits(&self, rewards_id: Pubkey, vote_keypair: &Keypair) -> Result { - let last_id = self.bank.last_id(); + let last_id = self.bank.last_block_hash(); let tx = RewardsTransaction::new_redeem_credits(&vote_keypair, rewards_id, last_id, 0); self.bank.process_transaction(&tx)?; let vote_account = self.bank.get_account(&vote_keypair.pubkey()).unwrap(); diff --git a/programs/native/vote/tests/vote.rs b/programs/native/vote/tests/vote.rs index be8232f61d..b7ddac4b53 100644 --- a/programs/native/vote/tests/vote.rs +++ b/programs/native/vote/tests/vote.rs @@ -26,13 +26,13 @@ impl<'a> VoteBank<'a> { vote_id: Pubkey, lamports: u64, ) -> Result<()> { - let last_id = self.bank.last_id(); + let last_id = self.bank.last_block_hash(); let tx = VoteTransaction::fund_staking_account(from_keypair, vote_id, last_id, lamports, 0); self.bank.process_transaction(&tx) } fn submit_vote(&self, vote_keypair: &Keypair, tick_height: u64) -> Result { - let last_id = self.bank.last_id(); + let last_id = self.bank.last_block_hash(); let tx = VoteTransaction::new_vote(vote_keypair, tick_height, last_id, 0); self.bank.process_transaction(&tx)?; self.bank.register_tick(&hash(last_id.as_ref())); @@ -71,7 +71,7 @@ fn test_vote_via_bank_with_no_signature() { .unwrap(); let mallory_id = mallory_keypair.pubkey(); - let last_id = bank.last_id(); + let last_id = bank.last_block_hash(); let vote_ix = BuilderInstruction::new( vote_program::id(), &VoteInstruction::Vote(Vote::new(0)), diff --git a/programs/tests/programs.rs b/programs/tests/programs.rs index eaadf76b20..cd128df88b 100644 --- a/programs/tests/programs.rs +++ b/programs/tests/programs.rs @@ -15,7 +15,7 @@ fn load_program(bank: &Bank, from: &Keypair, loader_id: Pubkey, program: Vec let tx = SystemTransaction::new_program_account( from, program_account.pubkey(), - bank.last_id(), + bank.last_block_hash(), 1, program.len() as u64, loader_id, @@ -32,14 +32,14 @@ fn load_program(bank: &Bank, from: &Keypair, loader_id: Pubkey, program: Vec loader_id, offset, chunk.to_vec(), - bank.last_id(), + bank.last_block_hash(), 0, ); bank.process_transaction(&tx).unwrap(); offset += chunk_size as u32; } - let tx = LoaderTransaction::new_finalize(&program_account, loader_id, bank.last_id(), 0); + let tx = LoaderTransaction::new_finalize(&program_account, loader_id, bank.last_block_hash(), 0); bank.process_transaction(&tx).unwrap(); assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(()))); @@ -57,7 +57,7 @@ fn test_program_native_noop() { let program_id = load_program(&bank, &mint_keypair, native_loader::id(), program); // Call user program - let tx = Transaction::new(&mint_keypair, &[], program_id, &1u8, bank.last_id(), 0); + let tx = Transaction::new(&mint_keypair, &[], program_id, &1u8, bank.last_block_hash(), 0); bank.process_transaction(&tx).unwrap(); assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(()))); } @@ -73,7 +73,7 @@ fn test_program_native_failure() { let program_id = load_program(&bank, &mint_keypair, native_loader::id(), program); // Call user program - let tx = Transaction::new(&mint_keypair, &[], program_id, &1u8, bank.last_id(), 0); + let tx = Transaction::new(&mint_keypair, &[], program_id, &1u8, bank.last_block_hash(), 0); assert_eq!( bank.process_transaction(&tx), Err(BankError::ProgramError(0, ProgramError::GenericError)) @@ -126,7 +126,7 @@ fn test_program_bpf_c_noop() { &[], program_id, &vec![1u8], - bank.last_id(), + bank.last_block_hash(), 0, ); bank.process_transaction(&tx).unwrap(); @@ -170,7 +170,7 @@ fn test_program_bpf_c() { &[], program_id, &vec![1u8], - bank.last_id(), + bank.last_block_hash(), 0, ); bank.process_transaction(&tx).unwrap(); @@ -210,7 +210,7 @@ fn test_program_bpf_rust() { &[], program_id, &vec![1u8], - bank.last_id(), + bank.last_block_hash(), 0, ); bank.process_transaction(&tx).unwrap(); diff --git a/runtime/benches/bank.rs b/runtime/benches/bank.rs index dfa306a4ec..d8469e5d42 100644 --- a/runtime/benches/bank.rs +++ b/runtime/benches/bank.rs @@ -25,14 +25,14 @@ fn bench_process_transaction(bencher: &mut Bencher) { &mint_keypair, rando0.pubkey(), 10_000, - bank.last_id(), + bank.last_block_hash(), 0, ); assert_eq!(bank.process_transaction(&tx), Ok(())); // Seed the 'to' account and a cell for its signature. let rando1 = Keypair::new(); - let tx = SystemTransaction::new_move(&rando0, rando1.pubkey(), 1, bank.last_id(), 0); + let tx = SystemTransaction::new_move(&rando0, rando1.pubkey(), 1, bank.last_block_hash(), 0); assert_eq!(bank.process_transaction(&tx), Ok(())); // Finally, return the transaction to the benchmark. @@ -40,7 +40,7 @@ fn bench_process_transaction(bencher: &mut Bencher) { }) .collect(); - let mut id = bank.last_id(); + let mut id = bank.last_block_hash(); for _ in 0..(MAX_RECENT_TICK_HASHES - 1) { bank.register_tick(&id); diff --git a/runtime/src/bank.rs b/runtime/src/bank.rs index efa2e18d62..c81545156b 100644 --- a/runtime/src/bank.rs +++ b/runtime/src/bank.rs @@ -298,7 +298,7 @@ impl Bank { } /// Return the last block hash registered. - pub fn last_id(&self) -> Hash { + pub fn last_block_hash(&self) -> Hash { self.block_hash_queue.read().unwrap().last_hash() } @@ -881,7 +881,7 @@ mod tests { let (genesis_block, mint_keypair) = GenesisBlock::new(10_000); let pubkey = Keypair::new().pubkey(); let bank = Bank::new(&genesis_block); - assert_eq!(bank.last_id(), genesis_block.hash()); + assert_eq!(bank.last_block_hash(), genesis_block.hash()); bank.transfer(1_000, &mint_keypair, pubkey, genesis_block.hash()) .unwrap(); @@ -899,7 +899,7 @@ mod tests { let key1 = Keypair::new().pubkey(); let key2 = Keypair::new().pubkey(); let bank = Bank::new(&genesis_block); - assert_eq!(bank.last_id(), genesis_block.hash()); + assert_eq!(bank.last_block_hash(), genesis_block.hash()); let t1 = SystemTransaction::new_move(&mint_keypair, key1, 1, genesis_block.hash(), 0); let t2 = SystemTransaction::new_move(&mint_keypair, key2, 1, genesis_block.hash(), 0); @@ -1394,11 +1394,11 @@ mod tests { let pubkey = Keypair::new().pubkey(); bank0 - .transfer(1_000, &mint_keypair, pubkey, bank0.last_id()) + .transfer(1_000, &mint_keypair, pubkey, bank0.last_block_hash()) .unwrap(); assert_ne!(bank0.hash_internal_state(), initial_state); bank1 - .transfer(1_000, &mint_keypair, pubkey, bank1.last_id()) + .transfer(1_000, &mint_keypair, pubkey, bank1.last_block_hash()) .unwrap(); assert_eq!(bank0.hash_internal_state(), bank1.hash_internal_state()); diff --git a/tests/tvu.rs b/tests/tvu.rs index f930316182..7d3046ceb6 100644 --- a/tests/tvu.rs +++ b/tests/tvu.rs @@ -86,7 +86,7 @@ fn test_replay() { let tvu_addr = target1.info.tvu; let bank = Bank::new(&genesis_block); - let last_id = bank.last_id(); + let last_id = bank.last_block_hash(); let bank_forks = BankForks::new(0, bank); let bank_forks_info = vec![BankForksInfo { bank_id: 0,