Add versioning (#8348)

automerge

runtime/src/bank.rs

@@ -2172,6 +2172,7 @@ mod tests {
         stake_instruction,
         stake_state::{self, Authorized, Delegation, Lockup, Stake},
     };
+    use solana_vote_program::vote_state::VoteStateVersions;
     use solana_vote_program::{
         vote_instruction,
         vote_state::{self, Vote, VoteInit, VoteState, MAX_LOCKOUT_HISTORY},
@@ -3069,11 +3070,20 @@ mod tests {
         bank.store_account(&archiver_id, &archiver_account);
 
         // generate some rewards
-        let mut vote_state = VoteState::from(&vote_account).unwrap();
+        let mut vote_state = Some(VoteState::from(&vote_account).unwrap());
         for i in 0..MAX_LOCKOUT_HISTORY + 42 {
-            vote_state.process_slot_vote_unchecked(i as u64);
-            vote_state.to(&mut vote_account).unwrap();
+            vote_state
+                .as_mut()
+                .map(|v| v.process_slot_vote_unchecked(i as u64));
+            let versioned = VoteStateVersions::Current(Box::new(vote_state.take().unwrap()));
+            VoteState::to(&versioned, &mut vote_account).unwrap();
             bank.store_account(&vote_id, &vote_account);
+            match versioned {
+                VoteStateVersions::Current(v) => {
+                    vote_state = Some(*v);
+                }
+                _ => panic!("Has to be of type Current"),
+            };
         }
         bank.store_account(&vote_id, &vote_account);
 

runtime/src/stakes.rs

@@ -195,7 +195,9 @@ pub mod tests {
     use super::*;
     use solana_sdk::{pubkey::Pubkey, rent::Rent};
     use solana_stake_program::stake_state;
-    use solana_vote_program::vote_state::{self, VoteState, MAX_LOCKOUT_HISTORY};
+    use solana_vote_program::vote_state::{
+        self, VoteState, VoteStateVersions, MAX_LOCKOUT_HISTORY,
+    };
 
     //  set up some dummies for a staked node     ((     vote      )  (     stake     ))
     pub fn create_staked_node_accounts(stake: u64) -> ((Pubkey, Account), (Pubkey, Account)) {
@@ -319,31 +321,55 @@ pub mod tests {
         assert_eq!(stakes.points(), 0);
         assert_eq!(stakes.claim_points(), 0);
 
-        let mut vote_state = VoteState::from(&vote_account).unwrap();
+        let mut vote_state = Some(VoteState::from(&vote_account).unwrap());
         for i in 0..MAX_LOCKOUT_HISTORY + 42 {
-            vote_state.process_slot_vote_unchecked(i as u64);
-            vote_state.to(&mut vote_account).unwrap();
+            vote_state
+                .as_mut()
+                .map(|v| v.process_slot_vote_unchecked(i as u64));
+            let versioned = VoteStateVersions::Current(Box::new(vote_state.take().unwrap()));
+            VoteState::to(&versioned, &mut vote_account).unwrap();
+            match versioned {
+                VoteStateVersions::Current(v) => {
+                    vote_state = Some(*v);
+                }
+                _ => panic!("Has to be of type Current"),
+            };
             stakes.store(&vote_pubkey, &vote_account);
-            assert_eq!(stakes.points(), vote_state.credits() * stake);
+            assert_eq!(
+                stakes.points(),
+                vote_state.as_ref().unwrap().credits() * stake
+            );
         }
         vote_account.lamports = 0;
         stakes.store(&vote_pubkey, &vote_account);
-        assert_eq!(stakes.points(), vote_state.credits() * stake);
+        assert_eq!(
+            stakes.points(),
+            vote_state.as_ref().unwrap().credits() * stake
+        );
 
-        assert_eq!(stakes.claim_points(), vote_state.credits() * stake);
+        assert_eq!(
+            stakes.claim_points(),
+            vote_state.as_ref().unwrap().credits() * stake
+        );
         assert_eq!(stakes.claim_points(), 0);
         assert_eq!(stakes.claim_points(), 0);
 
         // points come out of nowhere, but don't care here ;)
         vote_account.lamports = 1;
         stakes.store(&vote_pubkey, &vote_account);
-        assert_eq!(stakes.points(), vote_state.credits() * stake);
+        assert_eq!(
+            stakes.points(),
+            vote_state.as_ref().unwrap().credits() * stake
+        );
 
         // test going backwards, should never go backwards
         let old_vote_state = vote_state;
         let vote_account = vote_state::create_account(&vote_pubkey, &Pubkey::new_rand(), 0, 1);
         stakes.store(&vote_pubkey, &vote_account);
-        assert_eq!(stakes.points(), old_vote_state.credits() * stake);
+        assert_eq!(
+            stakes.points(),
+            old_vote_state.as_ref().unwrap().credits() * stake
+        );
     }
 
     #[test]

runtime/tests/stake.rs

@@ -18,7 +18,7 @@ use solana_stake_program::{
 };
 use solana_vote_program::{
     vote_instruction,
-    vote_state::{Vote, VoteInit, VoteState},
+    vote_state::{Vote, VoteInit, VoteState, VoteStateVersions},
 };
 use std::sync::Arc;
 
@@ -254,7 +254,9 @@ fn test_stake_account_lifetime() {
 
     // Test that votes and credits are there
     let account = bank.get_account(&vote_pubkey).expect("account not found");
-    let vote_state: VoteState = account.state().expect("couldn't unpack account data");
+    let vote_state: VoteState = StateMut::<VoteStateVersions>::state(&account)
+        .expect("couldn't unpack account data")
+        .convert_to_current();
 
     // 1 less vote, as the first vote should have cleared the lockout
     assert_eq!(vote_state.votes.len(), 31);