Withdraw available stake

clap-utils/src/input_validators.rs

@@ -303,6 +303,23 @@ where
     }
 }
 
+pub fn is_amount_or_all_or_available<T>(amount: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    if amount.as_ref().parse::<u64>().is_ok()
+        || amount.as_ref().parse::<f64>().is_ok()
+        || amount.as_ref() == "ALL"
+        || amount.as_ref() == "AVAILABLE"
+    {
+        Ok(())
+    } else {
+        Err(format!(
+            "Unable to parse input amount as integer or float, provided: {amount}"
+        ))
+    }
+}
+
 pub fn is_rfc3339_datetime<T>(value: T) -> Result<(), String>
 where
     T: AsRef<str> + Display,

cli/src/spend_utils.rs

@@ -2,6 +2,7 @@ use {
     crate::{
         checks::{check_account_for_balance_with_commitment, get_fee_for_messages},
         cli::CliError,
+        stake,
     },
     clap::ArgMatches,
     solana_clap_utils::{input_parsers::lamports_of_sol, offline::SIGN_ONLY_ARG},
@@ -15,6 +16,7 @@ use {
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum SpendAmount {
     All,
+    Available,
     Some(u64),
     RentExempt,
 }
@@ -35,9 +37,16 @@ impl SpendAmount {
     }
 
     pub fn new_from_matches(matches: &ArgMatches<'_>, name: &str) -> Self {
-        let amount = lamports_of_sol(matches, name);
         let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
-        SpendAmount::new(amount, sign_only)
+        let amount = lamports_of_sol(matches, name);
+        if amount.is_some() {
+            return SpendAmount::new(amount, sign_only);
+        }
+        match matches.value_of(name).unwrap_or("ALL") {
+            "ALL" if !sign_only => SpendAmount::All,
+            "AVAILABLE" if !sign_only => SpendAmount::Available,
+            _ => panic!("Only specific amounts are supported for sign-only operations"),
+        }
     }
 }
 
@@ -96,7 +105,7 @@ where
         )?;
         Ok((message, spend))
     } else {
-        let from_balance = rpc_client
+        let mut from_balance = rpc_client
             .get_balance_with_commitment(from_pubkey, commitment)?
             .value;
         let from_rent_exempt_minimum = if amount == SpendAmount::RentExempt {
@@ -105,6 +114,26 @@ where
         } else {
             0
         };
+        if amount == SpendAmount::Available {
+            if let Some(account) = rpc_client
+                .get_account_with_commitment(from_pubkey, commitment)?
+                .value
+            {
+                if account.owner == solana_sdk::stake::program::id() {
+                    let state = stake::get_account_stake_state(
+                        rpc_client,
+                        from_pubkey,
+                        account,
+                        true,
+                        None,
+                        false,
+                    )?;
+                    if let Some(active_stake) = state.active_stake {
+                        from_balance = from_balance.saturating_sub(active_stake);
+                    }
+                }
+            }
+        }
         let (message, SpendAndFee { spend, fee }) = resolve_spend_message(
             rpc_client,
             amount,
@@ -172,7 +201,7 @@ where
                 fee,
             },
         )),
-        SpendAmount::All => {
+        SpendAmount::All | SpendAmount::Available => {
             let lamports = if from_pubkey == fee_pubkey {
                 from_balance.saturating_sub(fee)
             } else {

cli/src/stake.rs

@@ -156,7 +156,7 @@ impl StakeSubCommands for App<'_, '_> {
                         .index(2)
                         .value_name("AMOUNT")
                         .takes_value(true)
-                        .validator(is_amount_or_all)
+                        .validator(is_amount_or_all_or_available)
                         .required(true)
                         .help(
                             "The amount to send to the stake account, in SOL; accepts keyword ALL",
@@ -249,7 +249,7 @@ impl StakeSubCommands for App<'_, '_> {
                         .index(2)
                         .value_name("AMOUNT")
                         .takes_value(true)
-                        .validator(is_amount_or_all)
+                        .validator(is_amount_or_all_or_available)
                         .required(true)
                         .help(
                             "The amount to send to the stake account, in SOL; accepts keyword ALL",
@@ -606,11 +606,11 @@ impl StakeSubCommands for App<'_, '_> {
                         .index(3)
                         .value_name("AMOUNT")
                         .takes_value(true)
-                        .validator(is_amount_or_all)
+                        .validator(is_amount_or_all_or_available)
                         .required(true)
                         .help(
                             "The amount to withdraw from the stake account, in SOL; accepts \
-                             keyword ALL",
+                             keyword ALL and AVAILABLE",
                         ),
                 )
                 .arg(
@@ -2554,11 +2554,29 @@ pub fn process_show_stake_account(
     use_csv: bool,
 ) -> ProcessResult {
     let stake_account = rpc_client.get_account(stake_account_address)?;
+    let state = get_account_stake_state(
+        rpc_client,
+        stake_account_address,
+        stake_account,
+        use_lamports_unit,
+        with_rewards,
+        use_csv,
+    )?;
+    Ok(config.output_format.formatted_string(&state))
+}
+
+pub fn get_account_stake_state(
+    rpc_client: &RpcClient,
+    stake_account_address: &Pubkey,
+    stake_account: solana_sdk::account::Account,
+    use_lamports_unit: bool,
+    with_rewards: Option<usize>,
+    use_csv: bool,
+) -> Result<CliStakeState, CliError> {
     if stake_account.owner != stake::program::id() {
         return Err(CliError::RpcRequestError(format!(
             "{stake_account_address:?} is not a stake account",
-        ))
-        .into());
+        )));
     }
     match stake_account.state() {
         Ok(stake_state) => {
@@ -2597,12 +2615,11 @@ pub fn process_show_stake_account(
                 });
                 state.epoch_rewards = epoch_rewards;
             }
-            Ok(config.output_format.formatted_string(&state))
+            Ok(state)
         }
         Err(err) => Err(CliError::RpcRequestError(format!(
             "Account data could not be deserialized to stake state: {err}"
-        ))
-        .into()),
+        ))),
     }
 }
 
@@ -4490,6 +4507,38 @@ mod tests {
             }
         );
 
+        // Test WithdrawStake Subcommand w/ AVAILABLE amount
+        let test_withdraw_stake = test_commands.clone().get_matches_from(vec![
+            "test",
+            "withdraw-stake",
+            &stake_account_string,
+            &stake_account_string,
+            "AVAILABLE",
+        ]);
+
+        assert_eq!(
+            parse_command(&test_withdraw_stake, &default_signer, &mut None).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::WithdrawStake {
+                    stake_account_pubkey,
+                    destination_account_pubkey: stake_account_pubkey,
+                    amount: SpendAmount::Available,
+                    withdraw_authority: 0,
+                    custodian: None,
+                    sign_only: false,
+                    dump_transaction_message: false,
+                    blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
+                    nonce_account: None,
+                    nonce_authority: 0,
+                    memo: None,
+                    seed: None,
+                    fee_payer: 0,
+                    compute_unit_price: None,
+                },
+                signers: vec![Box::new(read_keypair_file(&default_keypair_file).unwrap())],
+            }
+        );
+
         // Test WithdrawStake Subcommand w/ ComputeUnitPrice
         let test_withdraw_stake = test_commands.clone().get_matches_from(vec![
             "test",