Rename prev_id to prev_hash

book/src/blocktree.md

@@ -75,13 +75,13 @@ Note: Cumulatively, this means that the replay stage will now have to know when
 
 The bank exposes to replay stage:
 
- 1. `prev_id`: which PoH chain it's working on as indicated by the id of the last
+ 1. `prev_hash`: which PoH chain it's working on as indicated by the hash of the last
     entry it processed
  2. `tick_height`: the ticks in the PoH chain currently being verified by this
     bank
  3. `votes`: a stack of records that contain:
 
-    1. `prev_ids`: what anything after this vote must chain to in PoH
+    1. `prev_hashes`: what anything after this vote must chain to in PoH
     2. `tick_height`: the tick height at which this vote was cast
     3. `lockout period`: how long a chain must be observed to be in the ledger to
        be able to be chained below this vote

src/entry.rs

@@ -55,18 +55,18 @@ pub struct Entry {
 
 impl Entry {
     /// Creates the next Entry `num_hashes` after `start_hash`.
-    pub fn new(prev_id: &Hash, num_hashes: u64, transactions: Vec<Transaction>) -> Self {
+    pub fn new(prev_hash: &Hash, num_hashes: u64, transactions: Vec<Transaction>) -> Self {
         let entry = {
             if num_hashes == 0 && transactions.is_empty() {
                 Entry {
                     num_hashes: 0,
-                    id: *prev_id,
+                    id: *prev_hash,
                     transactions,
                 }
             } else if num_hashes == 0 {
                 // If you passed in transactions, but passed in num_hashes == 0, then
                 // next_hash will generate the next hash and set num_hashes == 1
-                let id = next_hash(prev_id, 1, &transactions);
+                let id = next_hash(prev_hash, 1, &transactions);
                 Entry {
                     num_hashes: 1,
                     id,
@@ -76,7 +76,7 @@ impl Entry {
                 // Otherwise, the next Entry `num_hashes` after `start_hash`.
                 // If you wanted a tick for instance, then pass in num_hashes = 1
                 // and transactions = empty
-                let id = next_hash(prev_id, num_hashes, &transactions);
+                let id = next_hash(prev_hash, num_hashes, &transactions);
                 Entry {
                     num_hashes,
                     id,
@@ -461,11 +461,11 @@ pub fn make_consecutive_blobs(
 
 #[cfg(test)]
 /// Creates the next Tick or Transaction Entry `num_hashes` after `start_hash`.
-pub fn next_entry(prev_id: &Hash, num_hashes: u64, transactions: Vec<Transaction>) -> Entry {
+pub fn next_entry(prev_hash: &Hash, num_hashes: u64, transactions: Vec<Transaction>) -> Entry {
     assert!(num_hashes > 0 || transactions.is_empty());
     Entry {
         num_hashes,
-        id: next_hash(prev_id, num_hashes, &transactions),
+        id: next_hash(prev_hash, num_hashes, &transactions),
         transactions,
     }
 }
@@ -641,11 +641,11 @@ mod tests {
     fn test_next_entries() {
         solana_logger::setup();
         let id = Hash::default();
-        let next_id = hash(&id.as_ref());
+        let next_hash = hash(&id.as_ref());
         let keypair = Keypair::new();
         let vote_account = Keypair::new();
-        let tx_small = VoteTransaction::new_vote(&vote_account, 1, next_id, 2);
+        let tx_small = VoteTransaction::new_vote(&vote_account, 1, next_hash, 2);
-        let tx_large = BudgetTransaction::new(&keypair, keypair.pubkey(), 1, next_id);
+        let tx_large = BudgetTransaction::new(&keypair, keypair.pubkey(), 1, next_hash);
 
         let tx_small_size = tx_small.serialized_size().unwrap() as usize;
         let tx_large_size = tx_large.serialized_size().unwrap() as usize;

src/poh_recorder.rs

@@ -197,8 +197,8 @@ mod tests {
 
     #[test]
     fn test_poh_recorder_no_zero_tick() {
-        let prev_id = Hash::default();
+        let prev_hash = Hash::default();
-        let mut poh_recorder = PohRecorder::new(0, prev_id);
+        let mut poh_recorder = PohRecorder::new(0, prev_hash);
         poh_recorder.tick();
         assert_eq!(poh_recorder.tick_cache.len(), 1);
         assert_eq!(poh_recorder.tick_cache[0].1, 1);
@@ -207,8 +207,8 @@ mod tests {
 
     #[test]
     fn test_poh_recorder_tick_height_is_last_tick() {
-        let prev_id = Hash::default();
+        let prev_hash = Hash::default();
-        let mut poh_recorder = PohRecorder::new(0, prev_id);
+        let mut poh_recorder = PohRecorder::new(0, prev_hash);
         poh_recorder.tick();
         poh_recorder.tick();
         assert_eq!(poh_recorder.tick_cache.len(), 2);
@@ -229,9 +229,9 @@ 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_id = bank.last_id();
+        let prev_hash = bank.last_id();
         let (entry_sender, _) = channel();
-        let mut poh_recorder = PohRecorder::new(0, prev_id);
+        let mut poh_recorder = PohRecorder::new(0, prev_hash);
 
         let working_bank = WorkingBank {
             bank,
@@ -249,9 +249,9 @@ 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_id = bank.last_id();
+        let prev_hash = bank.last_id();
         let (entry_sender, entry_receiver) = channel();
-        let mut poh_recorder = PohRecorder::new(0, prev_id);
+        let mut poh_recorder = PohRecorder::new(0, prev_hash);
 
         let working_bank = WorkingBank {
             bank,
@@ -280,9 +280,9 @@ 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_id = bank.last_id();
+        let prev_hash = bank.last_id();
         let (entry_sender, entry_receiver) = channel();
-        let mut poh_recorder = PohRecorder::new(0, prev_id);
+        let mut poh_recorder = PohRecorder::new(0, prev_hash);
 
         poh_recorder.tick();
         poh_recorder.tick();
@@ -310,9 +310,9 @@ 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_id = bank.last_id();
+        let prev_hash = bank.last_id();
         let (entry_sender, entry_receiver) = channel();
-        let mut poh_recorder = PohRecorder::new(0, prev_id);
+        let mut poh_recorder = PohRecorder::new(0, prev_hash);
 
         let working_bank = WorkingBank {
             bank,
@@ -332,9 +332,9 @@ 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_id = bank.last_id();
+        let prev_hash = bank.last_id();
         let (entry_sender, entry_receiver) = channel();
-        let mut poh_recorder = PohRecorder::new(0, prev_id);
+        let mut poh_recorder = PohRecorder::new(0, prev_hash);
 
         let working_bank = WorkingBank {
             bank,
@@ -363,9 +363,9 @@ 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_id = bank.last_id();
+        let prev_hash = bank.last_id();
         let (entry_sender, entry_receiver) = channel();
-        let mut poh_recorder = PohRecorder::new(0, prev_id);
+        let mut poh_recorder = PohRecorder::new(0, prev_hash);
 
         let working_bank = WorkingBank {
             bank,
@@ -391,9 +391,9 @@ 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_id = bank.last_id();
+        let prev_hash = bank.last_id();
         let (entry_sender, entry_receiver) = channel();
-        let mut poh_recorder = PohRecorder::new(0, prev_id);
+        let mut poh_recorder = PohRecorder::new(0, prev_hash);
 
         let working_bank = WorkingBank {
             bank,

src/poh_service.rs

@@ -124,9 +124,9 @@ mod tests {
     fn test_poh_service() {
         let (genesis_block, _mint_keypair) = GenesisBlock::new(2);
         let bank = Arc::new(Bank::new(&genesis_block));
-        let prev_id = bank.last_id();
+        let prev_hash = bank.last_id();
         let (entry_sender, entry_receiver) = channel();
-        let poh_recorder = Arc::new(Mutex::new(PohRecorder::new(bank.tick_height(), prev_id)));
+        let poh_recorder = Arc::new(Mutex::new(PohRecorder::new(bank.tick_height(), prev_hash)));
         let exit = Arc::new(AtomicBool::new(false));
         let working_bank = WorkingBank {
             bank: bank.clone(),
@@ -204,9 +204,9 @@ 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_id = bank.last_id();
+        let prev_hash = bank.last_id();
         let (entry_sender, entry_receiver) = channel();
-        let poh_recorder = Arc::new(Mutex::new(PohRecorder::new(bank.tick_height(), prev_id)));
+        let poh_recorder = Arc::new(Mutex::new(PohRecorder::new(bank.tick_height(), prev_hash)));
         let exit = Arc::new(AtomicBool::new(false));
         let working_bank = WorkingBank {
             bank: bank.clone(),