migrate Split tests

Author: rustopian

program/tests/helpers/instruction_builders.rs

@@ -138,3 +138,24 @@ impl InstructionConfig for DelegateConfig<'_> {
         ]
     }
 }
+
+pub struct SplitConfig<'a> {
+    pub source: (&'a Pubkey, &'a AccountSharedData),
+    pub destination: (&'a Pubkey, &'a AccountSharedData),
+    pub amount: u64,
+    pub signer: &'a Pubkey,
+}
+
+impl InstructionConfig for SplitConfig<'_> {
+    fn build_instruction(&self, _ctx: &StakeTestContext) -> Instruction {
+        let instructions = ixn::split(self.source.0, self.signer, self.amount, self.destination.0);
+        instructions[2].clone() // The actual split instruction
+    }
+
+    fn build_accounts(&self) -> Vec<(Pubkey, AccountSharedData)> {
+        vec![
+            (*self.source.0, self.source.1.clone()),
+            (*self.destination.0, self.destination.1.clone()),
+        ]
+    }
+}

program/tests/helpers/utils.rs

@@ -108,3 +108,21 @@ pub fn increment_vote_account_credits(
 
     vote_account.set_data(bincode::serialize(&vote_state).unwrap());
 }
+
+/// Get the effective stake for an account
+pub fn get_effective_stake(mollusk: &Mollusk, stake_account: &AccountSharedData) -> u64 {
+    let stake_state: StakeStateV2 = bincode::deserialize(stake_account.data()).unwrap();
+
+    if let StakeStateV2::Stake(_, stake, _) = stake_state {
+        stake
+            .delegation
+            .stake_activating_and_deactivating(
+                mollusk.sysvars.clock.epoch,
+                &mollusk.sysvars.stake_history,
+                Some(0),
+            )
+            .effective
+    } else {
+        0
+    }
+}

program/tests/split.rs

@@ -0,0 +1,190 @@
+#![allow(clippy::arithmetic_side_effects)]
+
+mod helpers;
+
+use {
+    helpers::{
+        context::StakeTestContext,
+        instruction_builders::SplitConfig,
+        lifecycle::StakeLifecycle,
+        utils::{get_effective_stake, parse_stake_account},
+    },
+    mollusk_svm::result::Check,
+    solana_account::{AccountSharedData, WritableAccount},
+    solana_program_error::ProgramError,
+    solana_pubkey::Pubkey,
+    solana_stake_interface::state::StakeStateV2,
+    solana_stake_program::id,
+    test_case::test_case,
+};
+
+#[test_case(StakeLifecycle::Uninitialized; "uninitialized")]
+#[test_case(StakeLifecycle::Initialized; "initialized")]
+#[test_case(StakeLifecycle::Activating; "activating")]
+#[test_case(StakeLifecycle::Active; "active")]
+#[test_case(StakeLifecycle::Deactivating; "deactivating")]
+#[test_case(StakeLifecycle::Deactive; "deactive")]
+fn test_split(split_source_type: StakeLifecycle) {
+    let mut ctx = StakeTestContext::new();
+    let staked_amount = ctx.minimum_delegation.unwrap() * 2;
+
+    // Create source stake account at the specified lifecycle stage
+    let (split_source, mut split_source_account) = ctx
+        .stake_account(split_source_type)
+        .staked_amount(staked_amount)
+        .build();
+
+    // Create destination stake account matching what create_blank_stake_account does:
+    // rent-exempt lamports, correct size, stake program owner, uninitialized data
+    let split_dest = Pubkey::new_unique();
+    let split_dest_account =
+        AccountSharedData::new(ctx.rent_exempt_reserve, StakeStateV2::size_of(), &id());
+
+    // Determine signer based on lifecycle stage
+    let signer = if split_source_type == StakeLifecycle::Uninitialized {
+        split_source
+    } else {
+        ctx.staker
+    };
+
+    // Fail: split more than available (would violate rent exemption)
+    // Note: Behavior differs between program-test and Mollusk:
+    // - program-test: Transaction-level rent check returns InsufficientFunds before program runs
+    // - Mollusk: Program succeeds for uninitialized (no program-level check), but violates rent
+    // For initialized+ accounts, the program itself checks and returns InsufficientFunds
+    if split_source_type == StakeLifecycle::Uninitialized {
+        // Mollusk: Program succeeds, but resulting accounts violate rent exemption
+        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            ctx.process_with(SplitConfig {
+                source: (&split_source, &split_source_account),
+                destination: (&split_dest, &split_dest_account),
+                signer: &signer,
+                amount: staked_amount + 1,
+            })
+            .checks(&[Check::success(), Check::all_rent_exempt()])
+            .execute()
+        }));
+        assert!(
+            result.is_err(),
+            "Expected rent exemption check to fail for uninitialized split"
+        );
+    } else {
+        // Program-level check returns InsufficientFunds for initialized+ accounts
+        ctx.process_with(SplitConfig {
+            source: (&split_source, &split_source_account),
+            destination: (&split_dest, &split_dest_account),
+            signer: &signer,
+            amount: staked_amount + 1,
+        })
+        .checks(&[Check::err(ProgramError::InsufficientFunds)])
+        .test_missing_signers(false)
+        .execute();
+    }
+
+    // Test minimum delegation enforcement for active/transitioning stakes
+    if split_source_type.split_minimum_enforced() {
+        // Zero split fails
+        ctx.process_with(SplitConfig {
+            source: (&split_source, &split_source_account),
+            destination: (&split_dest, &split_dest_account),
+            signer: &signer,
+            amount: 0,
+        })
+        .checks(&[Check::err(ProgramError::InsufficientFunds)])
+        .test_missing_signers(false)
+        .execute();
+
+        // Underfunded destination fails
+        ctx.process_with(SplitConfig {
+            source: (&split_source, &split_source_account),
+            destination: (&split_dest, &split_dest_account),
+            signer: &signer,
+            amount: ctx.minimum_delegation.unwrap() - 1,
+        })
+        .checks(&[Check::err(ProgramError::InsufficientFunds)])
+        .test_missing_signers(false)
+        .execute();
+
+        // Underfunded source fails
+        ctx.process_with(SplitConfig {
+            source: (&split_source, &split_source_account),
+            destination: (&split_dest, &split_dest_account),
+            signer: &signer,
+            amount: ctx.minimum_delegation.unwrap() + 1,
+        })
+        .checks(&[Check::err(ProgramError::InsufficientFunds)])
+        .test_missing_signers(false)
+        .execute();
+    }
+
+    // Split to account with wrong owner fails
+    let fake_split_dest = Pubkey::new_unique();
+    let mut fake_split_dest_account = split_dest_account.clone();
+    fake_split_dest_account.set_owner(Pubkey::new_unique());
+
+    ctx.process_with(SplitConfig {
+        source: (&split_source, &split_source_account),
+        destination: (&fake_split_dest, &fake_split_dest_account),
+        signer: &signer,
+        amount: staked_amount / 2,
+    })
+    .checks(&[Check::err(ProgramError::InvalidAccountOwner)])
+    .test_missing_signers(false)
+    .execute();
+
+    // Success: split half
+    let result = ctx
+        .process_with(SplitConfig {
+            source: (&split_source, &split_source_account),
+            destination: (&split_dest, &split_dest_account),
+            signer: &signer,
+            amount: staked_amount / 2,
+        })
+        .checks(&[
+            Check::success(),
+            Check::all_rent_exempt(),
+            Check::account(&split_source)
+                .lamports(staked_amount / 2 + ctx.rent_exempt_reserve)
+                .owner(&id())
+                .space(StakeStateV2::size_of())
+                .build(),
+            Check::account(&split_dest)
+                .lamports(staked_amount / 2 + ctx.rent_exempt_reserve)
+                .owner(&id())
+                .space(StakeStateV2::size_of())
+                .build(),
+        ])
+        .test_missing_signers(true)
+        .execute();
+
+    split_source_account = result.resulting_accounts[0].1.clone().into();
+    let split_dest_account: AccountSharedData = result.resulting_accounts[1].1.clone().into();
+
+    // Verify metadata is copied for initialized and above
+    if split_source_type >= StakeLifecycle::Initialized {
+        let (source_meta, source_stake, _) = parse_stake_account(&split_source_account);
+        let (dest_meta, dest_stake, _) = parse_stake_account(&split_dest_account);
+        assert_eq!(dest_meta, source_meta);
+
+        // Verify delegations are set properly for activating/active/deactivating
+        if split_source_type >= StakeLifecycle::Activating
+            && split_source_type < StakeLifecycle::Deactive
+        {
+            assert_eq!(source_stake.unwrap().delegation.stake, staked_amount / 2);
+            assert_eq!(dest_stake.unwrap().delegation.stake, staked_amount / 2);
+        }
+    }
+
+    // Verify nothing has been deactivated for active stakes
+    if split_source_type >= StakeLifecycle::Active && split_source_type < StakeLifecycle::Deactive {
+        assert_eq!(
+            get_effective_stake(&ctx.mollusk, &split_source_account),
+            staked_amount / 2,
+        );
+
+        assert_eq!(
+            get_effective_stake(&ctx.mollusk, &split_dest_account),
+            staked_amount / 2,
+        );
+    }
+}

program/tests/stake_instruction.rs

@@ -2288,138 +2288,6 @@ fn test_redelegate_consider_balance_changes() {
     );
 }
 
-#[test]
-fn test_split() {
-    let mollusk = mollusk_bpf();
-
-    let stake_history = StakeHistory::default();
-    let current_epoch = 100;
-    let clock = Clock {
-        epoch: current_epoch,
-        ..Clock::default()
-    };
-    let stake_address = solana_pubkey::new_rand();
-    let minimum_delegation = crate::get_minimum_delegation();
-    let stake_lamports = minimum_delegation * 2;
-    let split_to_address = solana_pubkey::new_rand();
-    let split_to_account = AccountSharedData::new_data_with_space(
-        0,
-        &StakeStateV2::Uninitialized,
-        StakeStateV2::size_of(),
-        &id(),
-    )
-    .unwrap();
-    let mut transaction_accounts = vec![
-        (stake_address, AccountSharedData::default()),
-        (split_to_address, split_to_account.clone()),
-        (
-            rent::id(),
-            create_account_shared_data_for_test(&Rent {
-                lamports_per_byte_year: 0,
-                ..Rent::default()
-            }),
-        ),
-        (
-            StakeHistory::id(),
-            create_account_shared_data_for_test(&stake_history),
-        ),
-        (clock::id(), create_account_shared_data_for_test(&clock)),
-        (
-            epoch_schedule::id(),
-            create_account_shared_data_for_test(&EpochSchedule::default()),
-        ),
-    ];
-    let instruction_accounts = vec![
-        AccountMeta {
-            pubkey: stake_address,
-            is_signer: true,
-            is_writable: true,
-        },
-        AccountMeta {
-            pubkey: split_to_address,
-            is_signer: false,
-            is_writable: true,
-        },
-    ];
-
-    for state in [
-        StakeStateV2::Initialized(Meta::auto(&stake_address)),
-        just_stake(Meta::auto(&stake_address), stake_lamports),
-    ] {
-        let stake_account = AccountSharedData::new_data_with_space(
-            stake_lamports,
-            &state,
-            StakeStateV2::size_of(),
-            &id(),
-        )
-        .unwrap();
-        let expected_active_stake = get_active_stake_for_tests(
-            &[stake_account.clone(), split_to_account.clone()],
-            &clock,
-            &stake_history,
-        );
-        transaction_accounts[0] = (stake_address, stake_account);
-
-        // should fail, split more than available
-        process_instruction(
-            &mollusk,
-            &serialize(&StakeInstruction::Split(stake_lamports + 1)).unwrap(),
-            transaction_accounts.clone(),
-            instruction_accounts.clone(),
-            Err(ProgramError::InsufficientFunds),
-        );
-
-        // should pass
-        let accounts = process_instruction(
-            &mollusk,
-            &serialize(&StakeInstruction::Split(stake_lamports / 2)).unwrap(),
-            transaction_accounts.clone(),
-            instruction_accounts.clone(),
-            Ok(()),
-        );
-        // no lamport leakage
-        assert_eq!(
-            accounts[0].lamports() + accounts[1].lamports(),
-            stake_lamports
-        );
-
-        // no deactivated stake
-        assert_eq!(
-            expected_active_stake,
-            get_active_stake_for_tests(&accounts[0..2], &clock, &stake_history)
-        );
-
-        assert_eq!(from(&accounts[0]).unwrap(), from(&accounts[1]).unwrap());
-        match state {
-            StakeStateV2::Initialized(_meta) => {
-                assert_eq!(from(&accounts[0]).unwrap(), state);
-            }
-            StakeStateV2::Stake(_meta, _stake, _) => {
-                let stake_0 = from(&accounts[0]).unwrap().stake();
-                assert_eq!(stake_0.unwrap().delegation.stake, stake_lamports / 2);
-            }
-            _ => unreachable!(),
-        }
-    }
-
-    // should fail, fake owner of destination
-    let split_to_account = AccountSharedData::new_data_with_space(
-        0,
-        &StakeStateV2::Uninitialized,
-        StakeStateV2::size_of(),
-        &solana_pubkey::new_rand(),
-    )
-    .unwrap();
-    transaction_accounts[1] = (split_to_address, split_to_account);
-    process_instruction(
-        &mollusk,
-        &serialize(&StakeInstruction::Split(stake_lamports / 2)).unwrap(),
-        transaction_accounts,
-        instruction_accounts,
-        Err(ProgramError::InvalidAccountOwner),
-    );
-}
-
 #[test]
 fn test_withdraw_stake() {
     let mollusk = mollusk_bpf();