single-pool: rename ReactivatePool to ReactivatePoolStake

Author: 2501babe

single-pool/cli/src/cli.rs

@@ -110,7 +110,7 @@ pub enum ManageCommand {
     /// Permissionlessly re-stake the pool stake account in the case when it has been deactivated.
     /// This may happen if the validator is force-deactivated, and then later reactivated using
     /// the same address for its vote account.
-    Reactivate(ReactivateCli),
+    ReactivatePoolStake(ReactivateCli),
 
     /// Permissionlessly create default MPL token metadata for the pool mint. Normally this is done
     /// automatically upon initialization, so this does not need to be called.
@@ -145,7 +145,7 @@ pub struct ReactivateCli {
 
     // backdoor for testing, theres no reason to ever use this
     #[clap(long, hide = true)]
-    pub yolo: bool,
+    pub skip_deactivation_check: bool,
 }
 
 #[derive(Clone, Debug, Args)]

single-pool/cli/src/main.rs

@@ -64,8 +64,8 @@ impl Command {
                 ManageCommand::Initialize(command_config) => {
                     command_initialize(config, command_config).await
                 }
-                ManageCommand::Reactivate(command_config) => {
-                    command_reactivate(config, command_config).await
+                ManageCommand::ReactivatePoolStake(command_config) => {
+                    command_reactivate_pool_stake(config, command_config).await
                 }
                 ManageCommand::CreateTokenMetadata(command_config) => {
                     command_create_metadata(config, command_config).await
@@ -164,8 +164,11 @@ async fn command_initialize(config: &Config, command_config: InitializeCli) -> C
     ))
 }
 
-// reactivate stake account
-async fn command_reactivate(config: &Config, command_config: ReactivateCli) -> CommandResult {
+// reactivate pool stake account
+async fn command_reactivate_pool_stake(
+    config: &Config,
+    command_config: ReactivateCli,
+) -> CommandResult {
     let payer = config.fee_payer()?;
     let pool_address = pool_address_from_args(
         command_config.pool_address,
@@ -185,7 +188,7 @@ async fn command_reactivate(config: &Config, command_config: ReactivateCli) -> C
         };
 
     // the only reason this check is skippable is for testing, otherwise theres no reason
-    if !command_config.yolo {
+    if !command_config.skip_deactivation_check {
         let current_epoch = config.rpc_client.get_epoch_info().await?.epoch;
         let pool_stake_address = find_pool_stake_address(&single_pool::id(), &pool_address);
         let pool_stake_deactivated = quarantine::get_stake_info(config, &pool_stake_address)
@@ -194,15 +197,15 @@ async fn command_reactivate(config: &Config, command_config: ReactivateCli) -> C
             .1
             .delegation
             .deactivation_epoch
-            < current_epoch;
+            <= current_epoch;
 
         if !pool_stake_deactivated {
-            return Err("Pool stake account is not deactivated".into());
+            return Err("Pool stake account is neither deactivating nor deactivated".into());
         }
     }
 
     let instruction =
-        single_pool::instruction::reactivate_pool(&single_pool::id(), &vote_account_address);
+        single_pool::instruction::reactivate_pool_stake(&single_pool::id(), &vote_account_address);
     let transaction = Transaction::new_signed_with_payer(
         &[instruction],
         Some(&payer.pubkey()),
@@ -214,7 +217,7 @@ async fn command_reactivate(config: &Config, command_config: ReactivateCli) -> C
 
     Ok(format_output(
         config,
-        "Reactivate".to_string(),
+        "ReactivatePoolStake".to_string(),
         SignatureOutput { signature },
     ))
 }

single-pool/cli/tests/test.rs

@@ -253,20 +253,20 @@ async fn create_and_delegate_stake_account(
 
 #[tokio::test]
 #[serial]
-async fn reactivate() {
+async fn reactivate_pool_stake() {
     let env = setup(true).await;
 
     // setting up a test validator for this to succeed is hell, and success is tested in program tests
     // so we just make sure the cli can send a well-formed instruction
     let output = Command::new(SVSP_CLI)
         .args([
             "manage",
-            "reactivate",
+            "reactivate-pool-stake",
             "-C",
             &env.config_file_path,
             "--vote-account",
             &env.vote_account.to_string(),
-            "--yolo",
+            "--skip-deactivation-check",
         ])
         .output()
         .unwrap();

single-pool/program/src/instruction.rs

@@ -43,8 +43,8 @@ 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.
+    ///   Restake the pool stake account if it was deactivated. This can happen through the
+    ///   stake program's `DeactivateDelinquent` instruction, or during a cluster restart.
     ///
     ///   0. `[]` Validator vote account
     ///   1. `[]` Pool account
@@ -54,7 +54,7 @@ pub enum SinglePoolInstruction {
     ///   5. `[]` Stake history sysvar
     ///   6. `[]` Stake config sysvar
     ///   7. `[]` Stake program
-    ReactivatePool,
+    ReactivatePoolStake,
 
     ///   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.
@@ -190,11 +190,13 @@ 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 {
+/// Creates a `ReactivatePoolStake` instruction.
+pub fn reactivate_pool_stake(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 data = SinglePoolInstruction::ReactivatePoolStake
+        .try_to_vec()
+        .unwrap();
     let accounts = vec![
         AccountMeta::new_readonly(*vote_account_address, false),
         AccountMeta::new_readonly(pool_address, false),

single-pool/program/src/processor.rs

@@ -707,7 +707,10 @@ impl Processor {
         Ok(())
     }
 
-    fn process_reactivate_pool(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
+    fn process_reactivate_pool_stake(
+        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)?;
@@ -733,7 +736,7 @@ impl Processor {
         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 {
+        if pool_stake_state.delegation.deactivation_epoch > clock.epoch {
             return Err(SinglePoolError::WrongStakeState.into());
         }
 
@@ -1178,9 +1181,9 @@ 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::ReactivatePoolStake => {
+                msg!("Instruction: ReactivatePoolStake");
+                Self::process_reactivate_pool_stake(program_id, accounts)
             }
             SinglePoolInstruction::DepositStake => {
                 msg!("Instruction: DepositStake");

single-pool/program/tests/accounts.rs

@@ -205,8 +205,8 @@ 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::ReactivatePoolStake => {
+            instruction::reactivate_pool_stake(&id(), &accounts.vote_account.pubkey())
         }
         SinglePoolInstruction::DepositStake => instruction::deposit_stake(
             &id(),
@@ -262,7 +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::ReactivatePoolStake),
         make_basic_instruction(&accounts, SinglePoolInstruction::DepositStake),
         make_basic_instruction(
             &accounts,

single-pool/program/tests/reactivate.rs

@@ -4,7 +4,6 @@
 mod helpers;
 
 use {
-    bincode::serialize,
     helpers::*,
     solana_program_test::*,
     solana_sdk::{
@@ -34,13 +33,17 @@ async fn success() {
         deactivation_epoch: 0,
         ..stake.unwrap().delegation
     };
-    let account_data = serialize(&StakeState::Stake(
-        meta,
-        Stake {
-            delegation,
-            ..stake.unwrap()
-        },
-    ))
+    let mut account_data = vec![0; std::mem::size_of::<StakeState>()];
+    bincode::serialize_into(
+        &mut account_data[..],
+        &StakeState::Stake(
+            meta,
+            Stake {
+                delegation,
+                ..stake.unwrap()
+            },
+        ),
+    )
     .unwrap();
 
     let mut stake_account = get_account(&mut context.banks_client, &accounts.stake_account).await;
@@ -74,7 +77,7 @@ async fn success() {
     check_error(e, SinglePoolError::WrongStakeState);
 
     // reactivate
-    let instruction = instruction::reactivate_pool(&id(), &accounts.vote_account.pubkey());
+    let instruction = instruction::reactivate_pool_stake(&id(), &accounts.vote_account.pubkey());
     let transaction = Transaction::new_signed_with_payer(
         &[instruction],
         Some(&context.payer.pubkey()),
@@ -132,7 +135,7 @@ async fn fail_not_deactivated(activate: bool) {
         advance_epoch(&mut context).await;
     }
 
-    let instruction = instruction::reactivate_pool(&id(), &accounts.vote_account.pubkey());
+    let instruction = instruction::reactivate_pool_stake(&id(), &accounts.vote_account.pubkey());
     let transaction = Transaction::new_signed_with_payer(
         &[instruction],
         Some(&context.payer.pubkey()),