program: remove default deposit helpers (#632)

Author: 2501babe

clients/cli/src/cli.rs

@@ -76,22 +76,14 @@ pub enum Command {
     Manage(ManageCli),
 
     /// 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 use an account created with
-    /// create-stake.
+    /// out the original stake account. Pool address is inferred from stake account.
     Deposit(DepositCli),
 
     /// Withdraw stake into a new stake account, burning tokens in exchange.
     /// Provide either pool or vote account address, plus either an amount of
     /// tokens to burn or the ALL keyword to burn all.
     Withdraw(WithdrawCli),
 
-    /// WARNING: This command is DEPRECATED and will be removed in a future release.
-    /// Create and delegate a new stake account to a given validator, using a
-    /// default address linked to the intended depository pool
-    CreateDefaultStake(CreateStakeCli),
-
     /// Display info for one or all single-validator stake pool(s)
     Display(DisplayCli),
 }
@@ -158,31 +150,18 @@ pub struct ReplenishCli {
 }
 
 #[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)))]
 pub struct DepositCli {
     /// The stake account to deposit from. Must be in the same activation state
     /// as the pool's stake account
     #[clap(value_parser = |p: &str| parse_address(p, "stake_account_address"))]
-    pub stake_account_address: Option<Pubkey>,
-
-    /// WARNING: This flag is DEPRECATED and will be removed in a future release.
-    /// Instead of using a stake account by address, use the user's default
-    /// account for a specified pool
-    #[clap(
-        short,
-        long,
-        conflicts_with = "stake-account-address",
-        requires = "pool-source"
-    )]
-    pub default_stake_account: bool,
+    pub stake_account_address: Pubkey,
 
-    /// The pool to deposit into. Optional when stake account is provided
+    /// The pool to deposit into. Optional for validation
     #[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 deposit into. Optional
-    /// when stake account or pool is provided
+    /// The vote account corresponding to the pool to deposit into. Optional for validation
     #[clap(long = "vote-account", value_parser = |p: &str| parse_address(p, "vote_account_address"))]
     pub vote_account_address: Option<Pubkey>,
 

clients/cli/src/config.rs

@@ -22,15 +22,6 @@ pub fn println_display(config: &Config, message: String) {
     }
 }
 
-pub fn eprintln_display(config: &Config, message: String) {
-    match config.output_format {
-        OutputFormat::Display | OutputFormat::DisplayVerbose => {
-            eprintln!("{}", message);
-        }
-        _ => {}
-    }
-}
-
 pub struct Config {
     pub rpc_client: Arc<RpcClient>,
     pub program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>>,

clients/cli/src/main.rs

@@ -27,9 +27,6 @@ use {
     std::{rc::Rc, sync::Arc},
 };
 
-#[allow(deprecated)]
-use spl_single_pool::find_default_deposit_account_address;
-
 mod config;
 use config::*;
 
@@ -93,9 +90,6 @@ impl Command {
             Command::Withdraw(command_config) => {
                 command_withdraw(config, command_config, matches, wallet_manager).await
             }
-            Command::CreateDefaultStake(command_config) => {
-                command_create_stake(config, command_config).await
-            }
             Command::Display(command_config) => command_display(config, command_config).await,
         }
     }
@@ -218,6 +212,7 @@ async fn command_deposit(
 ) -> CommandResult {
     let payer = config.fee_payer()?;
     let owner = config.default_signer()?;
+    let stake_account_address = command_config.stake_account_address;
     let stake_authority = command_config
         .stake_withdraw_authority
         .and_then(|source| {
@@ -232,34 +227,16 @@ async fn command_deposit(
 
     let current_epoch = config.rpc_client.get_epoch_info().await?.epoch;
 
-    // the cli invocation for this is conceptually simple, but a bit tricky
-    // the user can provide pool or vote and let the cli infer the stake account
-    // address but they can also provide pool or vote with the stake account, as
-    // a safety check first we want to get the pool address if they provided a
-    // pool or vote address
+    // we originally accepted this because there was the notion of a "canonical"
+    // stake account keyed off each wallet/pool combination. now we just derive
+    // the pool address from the stake account delegation, but we still allow
+    // the pool or vote address to be supplied for optional validation
     let provided_pool_address = command_config.pool_address.or_else(|| {
         command_config
             .vote_account_address
             .map(|address| find_pool_address(&spl_single_pool::id(), &address))
     });
 
-    // from there we can determine the stake account address
-    let stake_account_address = if let Some(stake_account_address) =
-        command_config.stake_account_address
-    {
-        stake_account_address
-    } else if let Some(pool_address) = provided_pool_address {
-        assert!(command_config.default_stake_account);
-        eprintln_display(
-            config,
-            "WARNING: This flag is DEPRECATED and will be removed in a future release.".to_string(),
-        );
-        #[allow(deprecated)]
-        find_default_deposit_account_address(&pool_address, &stake_authority.pubkey())
-    } else {
-        unreachable!()
-    };
-
     // now we validate the stake account and definitively resolve the pool address
     let (pool_address, user_stake_active) = if let Some((meta, stake)) =
         quarantine::get_stake_info(config, &stake_account_address).await?
@@ -694,86 +671,6 @@ async fn command_update_metadata(
     ))
 }
 
-// create default stake account
-async fn command_create_stake(config: &Config, command_config: CreateStakeCli) -> CommandResult {
-    eprintln_display(
-        config,
-        "WARNING: This command is DEPRECATED and will be removed in a future release.".to_string(),
-    );
-
-    let payer = config.fee_payer()?;
-    let owner = config.default_signer()?;
-    let stake_authority_address = command_config
-        .stake_authority_address
-        .unwrap_or_else(|| owner.pubkey());
-
-    let pool_address = pool_address_from_args(
-        command_config.pool_address,
-        command_config.vote_account_address,
-    );
-
-    #[allow(deprecated)]
-    let stake_account_address =
-        find_default_deposit_account_address(&pool_address, &stake_authority_address);
-
-    println_display(
-        config,
-        format!("Creating default stake account for pool {}\n", pool_address),
-    );
-
-    let vote_account_address = if let Some(vote_account_address) =
-        command_config.vote_account_address
-    {
-        vote_account_address
-    } else if let Ok(vote_account_address) = get_vote_address_from_pool(config, pool_address).await
-    {
-        vote_account_address
-    } else {
-        return Err(format!(
-            "Cannot determine vote account address from provided pool address {}",
-            pool_address,
-        )
-        .into());
-    };
-
-    if command_config.vote_account_address.is_some()
-        && pool_is_initialized(config, pool_address).await.is_err()
-    {
-        eprintln_display(
-            config,
-            format!("warning: Pool {} has not been initialized", pool_address),
-        );
-    }
-
-    #[allow(deprecated)]
-    let instructions = spl_single_pool::instruction::create_and_delegate_user_stake(
-        &spl_single_pool::id(),
-        &vote_account_address,
-        &stake_authority_address,
-        &quarantine::get_rent(config).await?,
-        command_config.lamports,
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&payer.pubkey()),
-        &vec![payer],
-        config.program_client.get_latest_blockhash().await?,
-    );
-
-    let signature = process_transaction(config, transaction).await?;
-
-    Ok(format_output(
-        config,
-        "CreateDefaultStake".to_string(),
-        CreateStakeOutput {
-            pool_address,
-            stake_account_address,
-            signature,
-        },
-    ))
-}
-
 // display stake pool(s)
 async fn command_display(config: &Config, command_config: DisplayCli) -> CommandResult {
     let minimum_pool_balance = quarantine::get_minimum_pool_balance(config).await?;

clients/cli/src/output.rs

@@ -291,37 +291,3 @@ impl Display for WithdrawOutput {
         Ok(())
     }
 }
-
-#[serde_as]
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CreateStakeOutput {
-    #[serde_as(as = "DisplayFromStr")]
-    pub pool_address: Pubkey,
-    #[serde_as(as = "DisplayFromStr")]
-    pub stake_account_address: Pubkey,
-    #[serde_as(as = "Option<DisplayFromStr>")]
-    pub signature: Option<Signature>,
-}
-
-impl QuietDisplay for CreateStakeOutput {}
-impl VerboseDisplay for CreateStakeOutput {}
-
-impl Display for CreateStakeOutput {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        writeln!(f)?;
-        writeln_name_value(f, "Pool address:", &self.pool_address.to_string())?;
-        writeln_name_value(
-            f,
-            "Stake account address:",
-            &self.stake_account_address.to_string(),
-        )?;
-
-        if let Some(signature) = self.signature {
-            writeln!(f)?;
-            writeln_name_value(f, "Signature:", &signature.to_string())?;
-        }
-
-        Ok(())
-    }
-}

clients/cli/tests/test.rs

@@ -291,52 +291,27 @@ async fn replenish_pool(raise_minimum_delegation: bool) {
     assert!(status.success());
 }
 
-#[test_case(false, false; "one_lamp::normal_stake")]
-#[test_case(true, false; "one_sol::normal_stake")]
-#[test_case(false, true; "one_lamp::default_stake")]
-#[test_case(true, true; "one_sol::default_stake")]
+#[test_case(false; "one_lamp")]
+#[test_case(true; "one_sol")]
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 #[serial]
-async fn deposit(raise_minimum_delegation: bool, use_default: bool) {
+async fn deposit(raise_minimum_delegation: bool) {
     let env = setup(raise_minimum_delegation, true).await;
 
-    let stake_account = if use_default {
-        let status = Command::new(SVSP_CLI)
-            .args([
-                "create-default-stake",
-                "-C",
-                &env.config_file_path,
-                "--vote-account",
-                &env.vote_account.to_string(),
-                &LAMPORTS_PER_SOL.to_string(),
-            ])
-            .status()
-            .unwrap();
-        assert!(status.success());
-
-        Pubkey::default()
-    } else {
-        create_and_delegate_stake_account(&env.rpc_client, &env.payer, &env.vote_account).await
-    };
+    let stake_account =
+        create_and_delegate_stake_account(&env.rpc_client, &env.payer, &env.vote_account).await;
 
     wait_for_next_epoch(&env.rpc_client).await;
 
-    let mut args = vec![
+    let args = vec![
         "deposit".to_string(),
         "-C".to_string(),
         env.config_file_path,
+        stake_account.to_string(),
+        "--vote-account".to_string(),
+        env.vote_account.to_string(),
     ];
 
-    if use_default {
-        args.extend([
-            "--vote-account".to_string(),
-            env.vote_account.to_string(),
-            "--default-stake-account".to_string(),
-        ]);
-    } else {
-        args.push(stake_account.to_string());
-    };
-
     let status = Command::new(SVSP_CLI).args(&args).status().unwrap();
     assert!(status.success());
 }

clients/js-legacy/src/addresses.ts

@@ -9,7 +9,6 @@ import {
   findPoolStakeAuthorityAddress as findStakeAuthorityModern,
   findPoolMintAuthorityAddress as findMintAuthorityModern,
   findPoolMplAuthorityAddress as findMplAuthorityModern,
-  findDefaultDepositAccountAddress as findDefaultDepositModern,
 } from '@solana/spl-single-pool';
 
 export async function findPoolAddress(programId: PublicKey, voteAccountAddress: PublicKey) {
@@ -65,16 +64,3 @@ export async function findPoolMplAuthorityAddress(programId: PublicKey, poolAddr
     ),
   );
 }
-
-/** @deprecated */
-export async function findDefaultDepositAccountAddress(
-  poolAddress: PublicKey,
-  userWallet: PublicKey,
-) {
-  return new PublicKey(
-    await findDefaultDepositModern(
-      poolAddress.toBase58() as PoolAddress,
-      userWallet.toBase58() as Address,
-    ),
-  );
-}

clients/js-legacy/src/transactions.ts

@@ -9,8 +9,7 @@ interface DepositParams {
   connection: Connection;
   pool: PublicKey;
   userWallet: PublicKey;
-  userStakeAccount?: PublicKey;
-  depositFromDefaultAccount?: boolean;
+  userStakeAccount: PublicKey;
   userTokenAccount?: PublicKey;
   userLamportAccount?: PublicKey;
   userWithdrawAuthority?: PublicKey;
@@ -106,20 +105,4 @@ export class SinglePoolProgram {
 
     return modernTransactionToLegacy(modernTransaction);
   }
-
-  static async createAndDelegateUserStake(
-    connection: Connection,
-    voteAccount: PublicKey,
-    userWallet: PublicKey,
-    stakeAmount: number | bigint,
-  ) {
-    const modernTransaction = await PoolProgramModern.createAndDelegateUserStake(
-      rpc(connection),
-      voteAccount.toBase58() as VoteAccountAddress,
-      userWallet.toBase58() as Address,
-      BigInt(stakeAmount),
-    );
-
-    return modernTransactionToLegacy(modernTransaction);
-  }
 }