migrate Split tests

rustopian · rustopian · commit 647046f16681 · 2025-11-04T11:48:41.000Z
diff --git a/program/tests/helpers/instruction_builders.rs b/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()),
+        ]
+    }
+}
diff --git a/program/tests/helpers/utils.rs b/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
+    }
+}
diff --git a/program/tests/program_test.rs b/program/tests/program_test.rs
@@ -740,156 +740,6 @@ impl StakeLifecycle {
     }
 }
 
-#[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")]
-#[tokio::test]
-async fn program_test_split(split_source_type: StakeLifecycle) {
-    let mut context = program_test().start_with_context().await;
-    let accounts = Accounts::default();
-    accounts.initialize(&mut context).await;
-
-    let rent_exempt_reserve = get_stake_account_rent(&mut context.banks_client).await;
-    let minimum_delegation = get_minimum_delegation(&mut context).await;
-    let staked_amount = minimum_delegation * 2;
-
-    let (split_source_keypair, staker_keypair, _) = split_source_type
-        .new_stake_account(&mut context, &accounts.vote_account.pubkey(), staked_amount)
-        .await;
-
-    let split_source = split_source_keypair.pubkey();
-    let split_dest = create_blank_stake_account(&mut context).await;
-
-    let signers = match split_source_type {
-        StakeLifecycle::Uninitialized => vec![&split_source_keypair],
-        _ => vec![&staker_keypair],
-    };
-
-    // fail, split more than available (even if not active, would kick source out of
-    // rent exemption)
-    let instruction = &ixn::split(
-        &split_source,
-        &signers[0].pubkey(),
-        staked_amount + 1,
-        &split_dest,
-    )[2];
-
-    let e = process_instruction(&mut context, instruction, &signers)
-        .await
-        .unwrap_err();
-    assert_eq!(e, ProgramError::InsufficientFunds);
-
-    // an active or transitioning stake account cannot have less than the minimum
-    // delegation note this is NOT dependent on the minimum delegation feature.
-    // there was ALWAYS a minimum. it was one lamport!
-    if split_source_type.split_minimum_enforced() {
-        // zero split fails
-        let instruction = &ixn::split(&split_source, &signers[0].pubkey(), 0, &split_dest)[2];
-        let e = process_instruction(&mut context, instruction, &signers)
-            .await
-            .unwrap_err();
-        assert_eq!(e, ProgramError::InsufficientFunds);
-
-        // underfunded destination fails
-        let instruction = &ixn::split(
-            &split_source,
-            &signers[0].pubkey(),
-            minimum_delegation - 1,
-            &split_dest,
-        )[2];
-
-        let e = process_instruction(&mut context, instruction, &signers)
-            .await
-            .unwrap_err();
-        assert_eq!(e, ProgramError::InsufficientFunds);
-
-        // underfunded source fails
-        let instruction = &ixn::split(
-            &split_source,
-            &signers[0].pubkey(),
-            minimum_delegation + 1,
-            &split_dest,
-        )[2];
-
-        let e = process_instruction(&mut context, instruction, &signers)
-            .await
-            .unwrap_err();
-        assert_eq!(e, ProgramError::InsufficientFunds);
-    }
-
-    // split to non-owned account fails
-    let mut fake_split_dest_account = get_account(&mut context.banks_client, &split_dest).await;
-    fake_split_dest_account.owner = Pubkey::new_unique();
-    let fake_split_dest = Pubkey::new_unique();
-    context.set_account(&fake_split_dest, &fake_split_dest_account.into());
-
-    let instruction = &ixn::split(
-        &split_source,
-        &signers[0].pubkey(),
-        staked_amount / 2,
-        &fake_split_dest,
-    )[2];
-
-    let e = process_instruction(&mut context, instruction, &signers)
-        .await
-        .unwrap_err();
-    assert_eq!(e, ProgramError::InvalidAccountOwner);
-
-    // success
-    let instruction = &ixn::split(
-        &split_source,
-        &signers[0].pubkey(),
-        staked_amount / 2,
-        &split_dest,
-    )[2];
-    process_instruction_test_missing_signers(&mut context, instruction, &signers).await;
-
-    // source lost split amount
-    let source_lamports = get_account(&mut context.banks_client, &split_source)
-        .await
-        .lamports;
-    assert_eq!(source_lamports, staked_amount / 2 + rent_exempt_reserve);
-
-    // destination gained split amount
-    let dest_lamports = get_account(&mut context.banks_client, &split_dest)
-        .await
-        .lamports;
-    assert_eq!(dest_lamports, staked_amount / 2 + rent_exempt_reserve);
-
-    // destination meta has been set properly if ever delegated
-    if split_source_type >= StakeLifecycle::Initialized {
-        let (source_meta, source_stake, _) =
-            get_stake_account(&mut context.banks_client, &split_source).await;
-        let (dest_meta, dest_stake, _) =
-            get_stake_account(&mut context.banks_client, &split_dest).await;
-        assert_eq!(dest_meta, source_meta);
-
-        // delegations are set properly if activating or active
-        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);
-        }
-    }
-
-    // nothing has been deactivated if active
-    if split_source_type >= StakeLifecycle::Active && split_source_type < StakeLifecycle::Deactive {
-        assert_eq!(
-            get_effective_stake(&mut context.banks_client, &split_source).await,
-            staked_amount / 2,
-        );
-
-        assert_eq!(
-            get_effective_stake(&mut context.banks_client, &split_dest).await,
-            staked_amount / 2,
-        );
-    }
-}
-
 #[test_case(StakeLifecycle::Uninitialized; "uninitialized")]
 #[test_case(StakeLifecycle::Initialized; "initialized")]
 #[test_case(StakeLifecycle::Activating; "activating")]
diff --git a/program/tests/split.rs b/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,
+        );
+    }
+}
