single-pool: add reactivate instruction

Author: 2501babe

single-pool/program/src/instruction.rs

@@ -43,6 +43,19 @@ pub enum SinglePoolInstruction {
     ///  12. `[]` Stake program
     InitializePool,
 
+    ///   Restake the pool stake account if its validator is force-deactivated and later
+    ///   recreated with the same vote account.
+    ///
+    ///   0. `[]` Validator vote account
+    ///   1. `[]` Pool account
+    ///   2. `[w]` Pool stake account
+    ///   3. `[]` Pool stake authority
+    ///   4. `[]` Clock sysvar
+    ///   5. `[]` Stake history sysvar
+    ///   6. `[]` Stake config sysvar
+    ///   7. `[]` Stake program
+    ReactivatePool,
+
     ///   Deposit stake into the pool.  The output is a "pool" token representing fractional
     ///   ownership of the pool stake. Inputs are converted to the current ratio.
     ///
@@ -177,6 +190,33 @@ pub fn initialize_pool(program_id: &Pubkey, vote_account_address: &Pubkey) -> In
     }
 }
 
+/// Creates a `ReactivatePool` instruction.
+pub fn reactivate_pool(program_id: &Pubkey, vote_account_address: &Pubkey) -> Instruction {
+    let pool_address = find_pool_address(program_id, vote_account_address);
+
+    let data = SinglePoolInstruction::ReactivatePool.try_to_vec().unwrap();
+    let accounts = vec![
+        AccountMeta::new_readonly(*vote_account_address, false),
+        AccountMeta::new_readonly(pool_address, false),
+        AccountMeta::new(find_pool_stake_address(program_id, &pool_address), false),
+        AccountMeta::new_readonly(
+            find_pool_stake_authority_address(program_id, &pool_address),
+            false,
+        ),
+        AccountMeta::new_readonly(sysvar::clock::id(), false),
+        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
+        #[allow(deprecated)]
+        AccountMeta::new_readonly(stake::config::id(), false),
+        AccountMeta::new_readonly(stake::program::id(), false),
+    ];
+
+    Instruction {
+        program_id: *program_id,
+        accounts,
+        data,
+    }
+}
+
 /// Creates all necessary instructions to deposit stake.
 pub fn deposit(
     program_id: &Pubkey,

single-pool/program/src/processor.rs

@@ -707,6 +707,64 @@ impl Processor {
         Ok(())
     }
 
+    fn process_reactivate_pool(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
+        let account_info_iter = &mut accounts.iter();
+        let vote_account_info = next_account_info(account_info_iter)?;
+        let pool_info = next_account_info(account_info_iter)?;
+        let pool_stake_info = next_account_info(account_info_iter)?;
+        let pool_stake_authority_info = next_account_info(account_info_iter)?;
+        let clock_info = next_account_info(account_info_iter)?;
+        let clock = &Clock::from_account_info(clock_info)?;
+        let stake_history_info = next_account_info(account_info_iter)?;
+        let stake_config_info = next_account_info(account_info_iter)?;
+        let stake_program_info = next_account_info(account_info_iter)?;
+
+        check_vote_account(vote_account_info)?;
+        check_pool_address(program_id, vote_account_info.key, pool_info.key)?;
+
+        SinglePool::from_account_info(pool_info, program_id)?;
+
+        check_pool_stake_address(program_id, pool_info.key, pool_stake_info.key)?;
+        let stake_authority_bump_seed = check_pool_stake_authority_address(
+            program_id,
+            pool_info.key,
+            pool_stake_authority_info.key,
+        )?;
+        check_stake_program(stake_program_info.key)?;
+
+        let (_, pool_stake_state) = get_stake_state(pool_stake_info)?;
+        if pool_stake_state.delegation.deactivation_epoch >= clock.epoch {
+            return Err(SinglePoolError::WrongStakeState.into());
+        }
+
+        let stake_authority_seeds = &[
+            POOL_STAKE_AUTHORITY_PREFIX,
+            pool_info.key.as_ref(),
+            &[stake_authority_bump_seed],
+        ];
+        let stake_authority_signers = &[&stake_authority_seeds[..]];
+
+        // delegate stake so it activates
+        invoke_signed(
+            &stake::instruction::delegate_stake(
+                pool_stake_info.key,
+                pool_stake_authority_info.key,
+                vote_account_info.key,
+            ),
+            &[
+                pool_stake_info.clone(),
+                vote_account_info.clone(),
+                clock_info.clone(),
+                stake_history_info.clone(),
+                stake_config_info.clone(),
+                pool_stake_authority_info.clone(),
+            ],
+            stake_authority_signers,
+        )?;
+
+        Ok(())
+    }
+
     fn process_deposit_stake(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
         let account_info_iter = &mut accounts.iter();
         let pool_info = next_account_info(account_info_iter)?;
@@ -1120,6 +1178,10 @@ impl Processor {
                 msg!("Instruction: InitializePool");
                 Self::process_initialize_pool(program_id, accounts)
             }
+            SinglePoolInstruction::ReactivatePool => {
+                msg!("Instruction: ReactivatePool");
+                Self::process_reactivate_pool(program_id, accounts)
+            }
             SinglePoolInstruction::DepositStake => {
                 msg!("Instruction: DepositStake");
                 Self::process_deposit_stake(program_id, accounts)

single-pool/program/tests/accounts.rs

@@ -196,6 +196,7 @@ async fn fail_account_checks(test_mode: TestMode) {
 
 // make an individual instruction for all program instructions
 // the match is just so this will error if new instructions are added
+// if you are reading this because of that error, add the case to the `consistent_account_order` test!!!
 fn make_basic_instruction(
     accounts: &SinglePoolAccounts,
     instruction_type: SinglePoolInstruction,
@@ -204,6 +205,9 @@ fn make_basic_instruction(
         SinglePoolInstruction::InitializePool => {
             instruction::initialize_pool(&id(), &accounts.vote_account.pubkey())
         }
+        SinglePoolInstruction::ReactivatePool => {
+            instruction::reactivate_pool(&id(), &accounts.vote_account.pubkey())
+        }
         SinglePoolInstruction::DepositStake => instruction::deposit_stake(
             &id(),
             &accounts.pool,
@@ -258,6 +262,7 @@ fn consistent_account_order() {
 
     let instructions = vec![
         make_basic_instruction(&accounts, SinglePoolInstruction::InitializePool),
+        make_basic_instruction(&accounts, SinglePoolInstruction::ReactivatePool),
         make_basic_instruction(&accounts, SinglePoolInstruction::DepositStake),
         make_basic_instruction(
             &accounts,

single-pool/program/tests/reactivate.rs

@@ -0,0 +1,149 @@
+#![allow(clippy::integer_arithmetic)]
+#![cfg(feature = "test-sbf")]
+
+mod helpers;
+
+use {
+    bincode::serialize,
+    helpers::*,
+    solana_program_test::*,
+    solana_sdk::{
+        account::AccountSharedData,
+        signature::Signer,
+        stake::state::{Delegation, Stake, StakeState},
+        transaction::Transaction,
+    },
+    spl_single_validator_pool::{error::SinglePoolError, id, instruction},
+    test_case::test_case,
+};
+
+#[tokio::test]
+async fn success() {
+    let mut context = program_test().start_with_context().await;
+    let accounts = SinglePoolAccounts::default();
+    accounts
+        .initialize_for_deposit(&mut context, TEST_STAKE_AMOUNT, None)
+        .await;
+    advance_epoch(&mut context).await;
+
+    // deactivate the pool stake account
+    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 account_data = serialize(&StakeState::Stake(
+        meta,
+        Stake {
+            delegation,
+            ..stake.unwrap()
+        },
+    ))
+    .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),
+    );
+
+    // make sure deposit fails
+    let instructions = instruction::deposit(
+        &id(),
+        &accounts.pool,
+        &accounts.alice_stake.pubkey(),
+        &accounts.alice_token,
+        &accounts.alice.pubkey(),
+        &accounts.alice.pubkey(),
+    );
+    let transaction = Transaction::new_signed_with_payer(
+        &instructions,
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &accounts.alice],
+        context.last_blockhash,
+    );
+
+    let e = context
+        .banks_client
+        .process_transaction(transaction)
+        .await
+        .unwrap_err();
+    check_error(e, SinglePoolError::WrongStakeState);
+
+    // reactivate
+    let instruction = instruction::reactivate_pool(&id(), &accounts.vote_account.pubkey());
+    let transaction = Transaction::new_signed_with_payer(
+        &[instruction],
+        Some(&context.payer.pubkey()),
+        &[&context.payer],
+        context.last_blockhash,
+    );
+
+    context
+        .banks_client
+        .process_transaction(transaction)
+        .await
+        .unwrap();
+
+    advance_epoch(&mut context).await;
+
+    // deposit works again
+    let instructions = instruction::deposit(
+        &id(),
+        &accounts.pool,
+        &accounts.alice_stake.pubkey(),
+        &accounts.alice_token,
+        &accounts.alice.pubkey(),
+        &accounts.alice.pubkey(),
+    );
+    let transaction = Transaction::new_signed_with_payer(
+        &instructions,
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &accounts.alice],
+        context.last_blockhash,
+    );
+
+    context
+        .banks_client
+        .process_transaction(transaction)
+        .await
+        .unwrap();
+
+    assert!(context
+        .banks_client
+        .get_account(accounts.alice_stake.pubkey())
+        .await
+        .expect("get_account")
+        .is_none());
+}
+
+#[test_case(true; "activated")]
+#[test_case(false; "activating")]
+#[tokio::test]
+async fn fail_not_deactivated(activate: bool) {
+    let mut context = program_test().start_with_context().await;
+    let accounts = SinglePoolAccounts::default();
+    accounts.initialize(&mut context).await;
+
+    if activate {
+        advance_epoch(&mut context).await;
+    }
+
+    let instruction = instruction::reactivate_pool(&id(), &accounts.vote_account.pubkey());
+    let transaction = Transaction::new_signed_with_payer(
+        &[instruction],
+        Some(&context.payer.pubkey()),
+        &[&context.payer],
+        context.last_blockhash,
+    );
+
+    let e = context
+        .banks_client
+        .process_transaction(transaction)
+        .await
+        .unwrap_err();
+    check_error(e, SinglePoolError::WrongStakeState);
+}