test inactive

Author: 2501babe

program/tests/helpers/stake.rs

@@ -4,22 +4,26 @@
 use {
     crate::get_account,
     bincode::deserialize,
+    solana_account::AccountSharedData,
     solana_hash::Hash,
     solana_keypair::Keypair,
     solana_native_token::LAMPORTS_PER_SOL,
     solana_program_test::BanksClient,
+    solana_program_test::ProgramTestContext,
     solana_pubkey::Pubkey,
     solana_signer::Signer,
     solana_stake_interface::{
         instruction as stake_instruction, program as stake_program,
-        state::{Authorized, Lockup, Meta, Stake, StakeStateV2},
+        stake_flags::StakeFlags,
+        state::{Authorized, Delegation, Lockup, Meta, Stake, StakeStateV2},
     },
     solana_system_interface::instruction as system_instruction,
     solana_transaction::Transaction,
     std::convert::TryInto,
 };
 
 pub const TEST_STAKE_AMOUNT: u64 = 10_000_000_000; // 10 sol
+pub const MANGLED_DELEGATION: u64 = 12345;
 
 pub async fn get_stake_account(
     banks_client: &mut BanksClient,
@@ -145,3 +149,31 @@ pub async fn delegate_stake_account(
     transaction.sign(&[payer, authorized], *recent_blockhash);
     banks_client.process_transaction(transaction).await.unwrap();
 }
+
+pub async fn force_deactivate_stake_account(context: &mut ProgramTestContext, pubkey: &Pubkey) {
+    let (meta, stake, _) = get_stake_account(&mut context.banks_client, pubkey).await;
+    let delegation = Delegation {
+        activation_epoch: 0,
+        deactivation_epoch: 0,
+        // break anything which erroneously uses this in calculations without redelegating
+        stake: MANGLED_DELEGATION,
+        ..stake.unwrap().delegation
+    };
+    let mut account_data = vec![0; std::mem::size_of::<StakeStateV2>()];
+    bincode::serialize_into(
+        &mut account_data[..],
+        &StakeStateV2::Stake(
+            meta,
+            Stake {
+                delegation,
+                ..stake.unwrap()
+            },
+            StakeFlags::empty(),
+        ),
+    )
+    .unwrap();
+
+    let mut stake_account = get_account(&mut context.banks_client, pubkey).await;
+    stake_account.data = account_data;
+    context.set_account(pubkey, &AccountSharedData::from(stake_account));
+}

program/tests/replenish.rs

@@ -4,15 +4,11 @@ mod helpers;
 
 use {
     helpers::*,
-    solana_account::AccountSharedData,
     solana_clock::Clock,
     solana_program_test::*,
     solana_signer::Signer,
     solana_stake_interface::{
-        instruction as stake_instruction,
-        stake_flags::StakeFlags,
-        stake_history::StakeHistory,
-        state::{Delegation, Stake, StakeStateV2},
+        instruction as stake_instruction, stake_history::StakeHistory, state::StakeStateV2,
     },
     solana_transaction::Transaction,
     spl_single_pool::{error::SinglePoolError, id, instruction},
@@ -58,36 +54,9 @@ async fn reactivate_success(
 
     advance_epoch(&mut context).await;
 
-    // deactivate the pool stake account
     if reactivate_pool {
-        let (meta, stake, _) =
-            get_stake_account(&mut context.banks_client, &accounts.stake_account).await;
-        let delegation = Delegation {
-            activation_epoch: 0,
-            deactivation_epoch: 0,
-            ..stake.unwrap().delegation
-        };
-        let mut account_data = vec![0; std::mem::size_of::<StakeStateV2>()];
-        bincode::serialize_into(
-            &mut account_data[..],
-            &StakeStateV2::Stake(
-                meta,
-                Stake {
-                    delegation,
-                    ..stake.unwrap()
-                },
-                StakeFlags::empty(),
-            ),
-        )
-        .unwrap();
-
-        let mut stake_account =
-            get_account(&mut context.banks_client, &accounts.stake_account).await;
-        stake_account.data = account_data;
-        context.set_account(
-            &accounts.stake_account,
-            &AccountSharedData::from(stake_account),
-        );
+        // deactivate the pool stake account
+        force_deactivate_stake_account(&mut context, &accounts.stake_account).await;
 
         // active deposit into deactivated pool fails
         let instructions = instruction::deposit(

program/tests/withdraw.rs

@@ -291,3 +291,70 @@ async fn fail_withdraw_to_onramp() {
         .unwrap_err();
     check_error(e, SinglePoolError::InvalidPoolStakeAccountUsage);
 }
+
+#[test_matrix(
+    [StakeProgramVersion::Stable, StakeProgramVersion::Beta, StakeProgramVersion::Edge]
+)]
+#[tokio::test]
+async fn success_withdraw_from_inactive(stake_version: StakeProgramVersion) {
+    // this test would fail on bpf stake v1-4 because of a bug in Split
+    // when this assert fails, it means v5 is stable. delete this entire block
+    if stake_version == StakeProgramVersion::Stable {
+        assert!(stake_version
+            .basename()
+            .unwrap()
+            .starts_with("solana_stake_program-v4"));
+
+        return;
+    }
+
+    let Some(program_test) = program_test(stake_version) else {
+        return;
+    };
+    let mut context = program_test.start_with_context().await;
+
+    let accounts = SinglePoolAccounts::default();
+    accounts
+        .initialize_for_withdraw(&mut context, TEST_STAKE_AMOUNT, None, true)
+        .await;
+
+    force_deactivate_stake_account(&mut context, &accounts.stake_account).await;
+
+    let (_, pool_stake_before, _) =
+        get_stake_account(&mut context.banks_client, &accounts.stake_account).await;
+
+    // this proves we arent using delegation for math
+    assert_eq!(
+        pool_stake_before.unwrap().delegation.stake,
+        MANGLED_DELEGATION
+    );
+
+    let instructions = instruction::withdraw(
+        &id(),
+        &accounts.pool,
+        &accounts.alice_stake.pubkey(),
+        &accounts.alice.pubkey(),
+        &accounts.alice_token,
+        &accounts.alice.pubkey(),
+        get_token_balance(&mut context.banks_client, &accounts.alice_token).await,
+    );
+    let transaction = Transaction::new_signed_with_payer(
+        &instructions,
+        Some(&accounts.alice.pubkey()),
+        &[&accounts.alice],
+        context.last_blockhash,
+    );
+
+    context
+        .banks_client
+        .process_transaction(transaction)
+        .await
+        .unwrap();
+
+    let (_, _, alice_lamports_after) =
+        get_stake_account(&mut context.banks_client, &accounts.alice_stake.pubkey()).await;
+    assert_eq!(
+        alice_lamports_after,
+        TEST_STAKE_AMOUNT + get_stake_account_rent(&mut context.banks_client).await
+    );
+}