single-pool-cli: add reactivate

Author: 2501babe

single-pool/cli/src/cli.rs

@@ -76,6 +76,11 @@ pub enum Command {
     /// along with the cluster-configured minimum stake delegation
     Initialize(InitializeCli),
 
+    /// 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),
+
     /// Deposit delegated stake into a pool in exchange for pool tokens, closing out
     /// the original stake account. Provide either a stake account address, or a
     /// pool or vote account address along with the --default-stake-account flag to
@@ -114,6 +119,22 @@ pub struct InitializeCli {
     pub skip_metadata: bool,
 }
 
+#[derive(Clone, Debug, Args)]
+#[clap(group(pool_source_group()))]
+pub struct ReactivateCli {
+    /// The pool to reactivate
+    #[clap(short, long = "pool", value_parser = |p: &str| parse_address(p, "pool_address"))]
+    pub pool_address: Option<Pubkey>,
+
+    /// The vote account corresponding to the pool to reactivate
+    #[clap(long = "vote-account", value_parser = |p: &str| parse_address(p, "vote_account_address"))]
+    pub vote_account_address: Option<Pubkey>,
+
+    // backdoor for testing, theres no reason to ever use this
+    #[clap(long, hide = true)]
+    pub yolo: bool,
+}
+
 #[derive(Clone, Debug, Args)]
 #[clap(group(ArgGroup::new("stake-source").required(true).args(&["stake-account-address", "default-stake-account"])))]
 #[clap(group(pool_source_group().required(false)))]

single-pool/cli/src/main.rs

@@ -61,6 +61,7 @@ impl Command {
     pub async fn execute(self, config: &Config) -> CommandResult {
         match self {
             Command::Initialize(command_config) => command_initialize(config, command_config).await,
+            Command::Reactivate(command_config) => command_reactivate(config, command_config).await,
             Command::Deposit(command_config) => command_deposit(config, command_config).await,
             Command::Withdraw(command_config) => command_withdraw(config, command_config).await,
             Command::CreateTokenMetadata(command_config) => {
@@ -157,6 +158,61 @@ async fn command_initialize(config: &Config, command_config: InitializeCli) -> C
     ))
 }
 
+// reactivate stake account
+async fn command_reactivate(config: &Config, command_config: ReactivateCli) -> CommandResult {
+    let payer = config.fee_payer()?;
+    let pool_address = pool_address_from_args(
+        command_config.pool_address,
+        command_config.vote_account_address,
+    );
+
+    println_display(
+        config,
+        format!("Reactivating stake account for pool {}\n", pool_address),
+    );
+
+    let vote_account_address =
+        if let Some(pool_data) = config.program_client.get_account(pool_address).await? {
+            try_from_slice_unchecked::<SinglePool>(&pool_data.data)?.vote_account_address
+        } else {
+            return Err(format!("Pool {} has not been initialized", pool_address).into());
+        };
+
+    // the only reason this check is skippable is for testing, otherwise theres no reason
+    if !command_config.yolo {
+        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)
+            .await?
+            .unwrap()
+            .1
+            .delegation
+            .deactivation_epoch
+            < current_epoch;
+
+        if !pool_stake_deactivated {
+            return Err("Pool stake account is not deactivated".into());
+        }
+    }
+
+    let instruction =
+        single_pool::instruction::reactivate_pool(&single_pool::id(), &vote_account_address);
+    let transaction = Transaction::new_signed_with_payer(
+        &[instruction],
+        Some(&payer.pubkey()),
+        &vec![payer],
+        config.program_client.get_latest_blockhash().await?,
+    );
+
+    let signature = process_transaction(config, transaction).await?;
+
+    Ok(format_output(
+        config,
+        "Reactivate".to_string(),
+        SignatureOutput { signature },
+    ))
+}
+
 // deposit stake
 async fn command_deposit(config: &Config, command_config: DepositCli) -> CommandResult {
     let payer = config.fee_payer()?;
@@ -572,7 +628,7 @@ async fn command_update_metadata(
             .into());
         }
     } else {
-        // we know the pool exists so the vote accound must exist
+        // we know the pool exists so the vote account must exist
         unreachable!();
     }
 

single-pool/cli/tests/test.rs

@@ -248,6 +248,29 @@ async fn create_and_delegate_stake_account(
     stake_account.pubkey()
 }
 
+#[tokio::test]
+#[serial]
+async fn reactivate() {
+    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([
+            "reactivate",
+            "-C",
+            &env.config_file_path,
+            "--vote-account",
+            &env.vote_account.to_string(),
+            "--yolo",
+        ])
+        .output()
+        .unwrap();
+    assert!(String::from_utf8(output.stderr)
+        .unwrap()
+        .contains("custom program error: 0xc"));
+}
+
 #[test_case(true; "default_stake")]
 #[test_case(false; "normal_stake")]
 #[tokio::test]