Rename Bank.last_id() to Bank.last_block_hash()

benches/banking_stage.rs

@@ -45,7 +45,7 @@ fn create_test_recorder(bank: &Arc<Bank>) -> (Arc<Mutex<PohRecorder>>, 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(),

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);
 

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 last_id = bank.last_block_hash();
-        let tx = SystemTransaction::new_account(&keypair1, keypair3.pubkey(), 1, bank.last_id(), 0);
+        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();
+        let last_id = bank.last_block_hash();
-        while last_id == bank.last_id() {
+        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]),

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());
 

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.

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);
 

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));

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<u64, (Hash, usize)>,
     ) -> result::Result<(Vec<Entry>, 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

core/src/rpc.rs

@@ -58,7 +58,7 @@ impl JsonRpcRequestProcessor {
     }
 
     fn get_recent_block_hash(&self) -> Result<String> {
-        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");
         })

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();

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();

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<T: KeypairUtil>(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();
     }

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<VoteState> {
-        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<VoteState> {
-        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();

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<VoteState> {
-        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)),

programs/tests/programs.rs

@@ -15,7 +15,7 @@ fn load_program(bank: &Bank, from: &Keypair, loader_id: Pubkey, program: Vec<u8>
     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<u8>
             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();

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);

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());
 

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,