StakeLifecycle, Deactivate tests

Author: rustopian

program/tests/deactivate.rs

@@ -0,0 +1,128 @@
+#![allow(clippy::arithmetic_side_effects)]
+
+mod helpers;
+
+use {
+    helpers::{context::StakeTestContext, lifecycle::StakeLifecycle},
+    mollusk_svm::result::Check,
+    solana_account::ReadableAccount,
+    solana_program_error::ProgramError,
+    solana_pubkey::Pubkey,
+    solana_stake_client::instructions::{DeactivateBuilder, DelegateStakeBuilder},
+    solana_stake_interface::{error::StakeError, state::StakeStateV2},
+    solana_stake_program::id,
+    test_case::test_case,
+};
+
+#[test_case(false; "activating")]
+#[test_case(true; "active")]
+fn test_deactivate(activate: bool) {
+    let mut ctx = StakeTestContext::with_delegation();
+    let min_delegation = ctx.minimum_delegation.unwrap();
+    let rent_exempt_reserve = ctx.rent_exempt_reserve;
+    let staker = ctx.staker;
+    let withdrawer = ctx.withdrawer;
+
+    let (stake, mut stake_account) = ctx
+        .stake_account(StakeLifecycle::Initialized)
+        .staked_amount(min_delegation)
+        .build();
+
+    let (vote, vote_account_data) = ctx.vote_account.clone().unwrap();
+
+    // Deactivating an undelegated account fails
+    ctx.checks(&[Check::err(ProgramError::InvalidAccountData)])
+        .test_missing_signers(false)
+        .execute(
+            DeactivateBuilder::new()
+                .stake(stake)
+                .stake_authority(staker)
+                .instruction(),
+            &[(&stake, &stake_account)],
+        );
+
+    // Delegate
+    let result = ctx.execute(
+        DelegateStakeBuilder::new()
+            .stake(stake)
+            .vote(vote)
+            .unused(Pubkey::new_unique())
+            .stake_authority(staker)
+            .instruction(),
+        &[(&stake, &stake_account), (&vote, &vote_account_data)],
+    );
+    stake_account = result.resulting_accounts[0].1.clone().into();
+
+    if activate {
+        // Advance epoch to activate
+        let current_slot = ctx.mollusk.sysvars.clock.slot;
+        let slots_per_epoch = ctx.mollusk.sysvars.epoch_schedule.slots_per_epoch;
+        ctx.mollusk.warp_to_slot(current_slot + slots_per_epoch);
+    }
+
+    // Deactivate with withdrawer fails
+    ctx.checks(&[Check::err(ProgramError::MissingRequiredSignature)])
+        .test_missing_signers(false)
+        .execute(
+            DeactivateBuilder::new()
+                .stake(stake)
+                .stake_authority(withdrawer)
+                .instruction(),
+            &[(&stake, &stake_account)],
+        );
+
+    // Deactivate succeeds
+    let result = ctx
+        .checks(&[
+            Check::success(),
+            Check::all_rent_exempt(),
+            Check::account(&stake)
+                .lamports(rent_exempt_reserve + min_delegation)
+                .owner(&id())
+                .space(StakeStateV2::size_of())
+                .build(),
+        ])
+        .execute(
+            DeactivateBuilder::new()
+                .stake(stake)
+                .stake_authority(staker)
+                .instruction(),
+            &[(&stake, &stake_account)],
+        );
+    stake_account = result.resulting_accounts[0].1.clone().into();
+
+    let clock = ctx.mollusk.sysvars.clock.clone();
+    let stake_state: StakeStateV2 = bincode::deserialize(stake_account.data()).unwrap();
+    if let StakeStateV2::Stake(_, stake_data, _) = stake_state {
+        assert_eq!(stake_data.delegation.deactivation_epoch, clock.epoch);
+    } else {
+        panic!("Expected StakeStateV2::Stake");
+    }
+
+    // Deactivate again fails
+    ctx.checks(&[Check::err(StakeError::AlreadyDeactivated.into())])
+        .test_missing_signers(false)
+        .execute(
+            DeactivateBuilder::new()
+                .stake(stake)
+                .stake_authority(staker)
+                .instruction(),
+            &[(&stake, &stake_account)],
+        );
+
+    // Advance epoch
+    let current_slot = ctx.mollusk.sysvars.clock.slot;
+    let slots_per_epoch = ctx.mollusk.sysvars.epoch_schedule.slots_per_epoch;
+    ctx.mollusk.warp_to_slot(current_slot + slots_per_epoch);
+
+    // Deactivate again still fails
+    ctx.checks(&[Check::err(StakeError::AlreadyDeactivated.into())])
+        .test_missing_signers(false)
+        .execute(
+            DeactivateBuilder::new()
+                .stake(stake)
+                .stake_authority(staker)
+                .instruction(),
+            &[(&stake, &stake_account)],
+        );
+}

program/tests/helpers/context.rs

@@ -2,7 +2,7 @@ use {
     super::{
         execution::ExecutionWithChecks,
         lifecycle::StakeLifecycle,
-        utils::{add_sysvars, STAKE_RENT_EXEMPTION},
+        utils::{add_sysvars, create_vote_account, STAKE_RENT_EXEMPTION},
     },
     mollusk_svm::{result::Check, Mollusk},
     solana_account::AccountSharedData,
@@ -25,7 +25,7 @@ pub struct StakeAccountBuilder<'a> {
     stake_pubkey: Option<Pubkey>,
 }
 
-impl<'a> StakeAccountBuilder<'a> {
+impl StakeAccountBuilder<'_> {
     /// Set the staked amount (lamports delegated to validator)
     pub fn staked_amount(mut self, amount: u64) -> Self {
         self.staked_amount = amount;
@@ -65,7 +65,24 @@ impl<'a> StakeAccountBuilder<'a> {
     /// Build the stake account and return (pubkey, account_data)
     pub fn build(self) -> (Pubkey, AccountSharedData) {
         let stake_pubkey = self.stake_pubkey.unwrap_or_else(Pubkey::new_unique);
-        let account = self.lifecycle.create_uninitialized_account();
+        let vote_account_ref = self.vote_account.as_ref().unwrap_or_else(|| {
+            self.ctx
+                .vote_account
+                .as_ref()
+                .map(|(pk, _)| pk)
+                .expect("vote_account required for this lifecycle")
+        });
+        let account = self.lifecycle.create_stake_account_fully_specified(
+            &mut self.ctx.mollusk,
+            &stake_pubkey,
+            vote_account_ref,
+            self.staked_amount,
+            self.stake_authority.as_ref().unwrap_or(&self.ctx.staker),
+            self.withdraw_authority
+                .as_ref()
+                .unwrap_or(&self.ctx.withdrawer),
+            self.lockup.as_ref().unwrap_or(&Lockup::default()),
+        );
         (stake_pubkey, account)
     }
 }
@@ -75,6 +92,9 @@ pub struct StakeTestContext {
     pub rent_exempt_reserve: u64,
     pub staker: Pubkey,
     pub withdrawer: Pubkey,
+    pub minimum_delegation: Option<u64>,
+    /// Vote account (pubkey, account_data) for delegation tests
+    pub vote_account: Option<(Pubkey, AccountSharedData)>,
 }
 
 impl StakeTestContext {
@@ -85,6 +105,21 @@ impl StakeTestContext {
             rent_exempt_reserve: STAKE_RENT_EXEMPTION,
             staker: Pubkey::new_unique(),
             withdrawer: Pubkey::new_unique(),
+            minimum_delegation: None,
+            vote_account: None,
+        }
+    }
+
+    pub fn with_delegation() -> Self {
+        let mollusk = Mollusk::new(&id(), "solana_stake_program");
+        let minimum_delegation = solana_stake_program::get_minimum_delegation();
+        Self {
+            mollusk,
+            rent_exempt_reserve: STAKE_RENT_EXEMPTION,
+            staker: Pubkey::new_unique(),
+            withdrawer: Pubkey::new_unique(),
+            minimum_delegation: Some(minimum_delegation),
+            vote_account: Some((Pubkey::new_unique(), create_vote_account())),
         }
     }
 
@@ -95,6 +130,8 @@ impl StakeTestContext {
     /// let (stake, account) = ctx
     ///     .stake_account(StakeLifecycle::Active)
     ///     .staked_amount(1_000_000)
+    ///     .stake_account(StakeLifecycle::Active)
+    ///     .staked_amount(1_000_000)
     ///     .build();
     /// ```
     pub fn stake_account(&mut self, lifecycle: StakeLifecycle) -> StakeAccountBuilder<'_> {
@@ -117,6 +154,25 @@ impl StakeTestContext {
         ExecutionWithChecks::new(self, checks)
     }
 
+    /// Create a lockup that expires in the future
+    pub fn create_future_lockup(&self, epochs_ahead: u64) -> Lockup {
+        Lockup {
+            unix_timestamp: 0,
+            epoch: self.mollusk.sysvars.clock.epoch + epochs_ahead,
+            custodian: Pubkey::new_unique(),
+        }
+    }
+
+    /// Create a lockup that's currently in force (far future)
+    pub fn create_in_force_lockup(&self) -> Lockup {
+        self.create_future_lockup(1_000_000)
+    }
+
+    /// Create a second vote account (for testing different vote accounts)
+    pub fn create_second_vote_account(&self) -> (Pubkey, AccountSharedData) {
+        (Pubkey::new_unique(), create_vote_account())
+    }
+
     /// Execute an instruction with default success checks and missing signer testing
     ///
     /// Usage: `ctx.execute(instruction, accounts)`
@@ -154,7 +210,7 @@ impl StakeTestContext {
 
 impl Default for StakeTestContext {
     fn default() -> Self {
-        Self::new()
+        Self::with_delegation()
     }
 }