remove new_bank_from_parent_with_id() (#3039)

src/bank_forks.rs

@@ -69,13 +69,14 @@ mod tests {
     use super::*;
     use solana_sdk::genesis_block::GenesisBlock;
     use solana_sdk::hash::Hash;
+    use solana_sdk::pubkey::Pubkey;
 
     #[test]
     fn test_bank_forks() {
         let (genesis_block, _) = GenesisBlock::new(10_000);
         let bank = Bank::new(&genesis_block);
         let mut bank_forks = BankForks::new(0, bank);
-        let child_bank = Bank::new_from_parent(&bank_forks[0u64]);
+        let child_bank = Bank::new_from_parent(&bank_forks[0u64], Pubkey::default(), 1);
         child_bank.register_tick(&Hash::default());
         bank_forks.insert(1, child_bank);
         assert_eq!(bank_forks[1u64].tick_height(), 1);

src/blocktree_processor.rs

@@ -124,7 +124,7 @@ pub fn process_blocktree(
         let (slot, starting_bank, starting_entry_height, mut last_entry_hash) =
             pending_slots.pop().unwrap();
 
-        let bank = Arc::new(Bank::new_from_parent_and_id(
+        let bank = Arc::new(Bank::new_from_parent(
             &starting_bank,
             leader_schedule_utils::slot_leader_at(slot, &starting_bank),
             starting_bank.slot(),
@@ -213,7 +213,7 @@ pub fn process_blocktree(
 
         // This is a fork point, create a new child bank for each fork
         pending_slots.extend(meta.next_slots.iter().map(|next_slot| {
-            let child_bank = Arc::new(Bank::new_from_parent_and_id(
+            let child_bank = Arc::new(Bank::new_from_parent(
                 &bank,
                 leader_schedule_utils::slot_leader_at(*next_slot, &bank),
                 *next_slot,

src/replay_stage.rs

@@ -200,7 +200,7 @@ impl ReplayStage {
             // If the next slot is going to be a new slot and we're the leader for that slot,
             // make a new working bank, set it as the working bank.
             if tick_height + 1 == first_tick_in_slot && leader_id == my_id {
-                bank = Self::create_and_set_working_bank(slot, &bank_forks, &old_bank);
+                bank = Self::create_and_set_working_bank(&old_bank, leader_id, slot, &bank_forks);
             }
 
             // Send a rotation notification back to Fullnode to initialize the TPU to the right
@@ -254,9 +254,10 @@ impl ReplayStage {
                             trace!("{} replay_stage: new_slot found: {:?}", my_id, new_slot);
                             // Reset the state
                             bank = Self::create_and_set_working_bank(
+                                &bank,
+                                current_leader_id,
                                 new_slot.unwrap(),
                                 &bank_forks,
-                                &bank,
                             );
                             current_slot = new_slot;
                             Self::reset_state(
@@ -346,9 +347,10 @@ impl ReplayStage {
                         if my_id == leader_id {
                             // Create new bank for next slot if we are the leader for that slot
                             bank = Self::create_and_set_working_bank(
+                                &old_bank,
+                                leader_id,
                                 next_slot,
                                 &bank_forks,
-                                &old_bank,
                             );
                             current_slot = Some(next_slot);
                             Self::reset_state(
@@ -406,11 +408,12 @@ impl ReplayStage {
     }
 
     fn create_and_set_working_bank(
+        parent: &Arc<Bank>,
+        leader_id: Pubkey,
         slot: u64,
         bank_forks: &Arc<RwLock<BankForks>>,
-        parent: &Arc<Bank>,
     ) -> Arc<Bank> {
-        let new_bank = Bank::new_from_parent(&parent);
+        let new_bank = Bank::new_from_parent(&parent, leader_id, slot);
         new_bank.squash();
         let mut bank_forks = bank_forks.write().unwrap();
         bank_forks.insert(slot, new_bank);

src/rpc_pubsub.rs

@@ -168,6 +168,7 @@ mod tests {
     use solana_sdk::budget_program;
     use solana_sdk::budget_transaction::BudgetTransaction;
     use solana_sdk::genesis_block::GenesisBlock;
+    use solana_sdk::pubkey::Pubkey;
     use solana_sdk::signature::{Keypair, KeypairUtil};
     use solana_sdk::system_transaction::SystemTransaction;
     use solana_sdk::transaction::Transaction;
@@ -184,7 +185,11 @@ mod tests {
         subscriptions.notify_subscribers(&bank);
 
         // Simulate a block boundary
-        Ok(Arc::new(Bank::new_from_parent(&bank)))
+        Ok(Arc::new(Bank::new_from_parent(
+            &bank,
+            Pubkey::default(),
+            bank.slot() + 1,
+        )))
     }
 
     fn create_session() -> Arc<Session> {

src/staking_utils.rs

@@ -120,6 +120,7 @@ mod tests {
     use hashbrown::HashSet;
     use solana_sdk::genesis_block::GenesisBlock;
     use solana_sdk::hash::Hash;
+    use solana_sdk::pubkey::Pubkey;
     use solana_sdk::signature::{Keypair, KeypairUtil};
     use std::iter::FromIterator;
     use std::sync::Arc;
@@ -131,20 +132,24 @@ mod tests {
         (bank.tick_index(), bank.slot_index(), bank.epoch_height())
     }
 
+    fn new_from_parent(parent: &Arc<Bank>) -> Bank {
+        Bank::new_from_parent(parent, Pubkey::default(), parent.slot() + 1)
+    }
+
     #[test]
     fn test_bank_staked_nodes_at_epoch() {
         let pubkey = Keypair::new().pubkey();
         let bootstrap_tokens = 2;
         let (genesis_block, _) = GenesisBlock::new_with_leader(2, pubkey, bootstrap_tokens);
         let bank = Bank::new(&genesis_block);
-        let bank = Bank::new_from_parent(&Arc::new(bank));
+        let bank = new_from_parent(&Arc::new(bank));
         let ticks_per_offset = bank.stakers_slot_offset() * bank.ticks_per_slot();
         register_ticks(&bank, ticks_per_offset);
         assert_eq!(bank.slot_height(), bank.stakers_slot_offset());
 
         let mut expected = HashMap::new();
         expected.insert(pubkey, bootstrap_tokens - 1);
-        let bank = Bank::new_from_parent(&Arc::new(bank));
+        let bank = new_from_parent(&Arc::new(bank));
         assert_eq!(
             node_stakes_at_slot_extractor(&bank, bank.slot_height(), |s, _| s),
             expected