Reimplement spl-stake-pool list command to use the StakePool/ValidatorList as the primary source of information

Author: mvines

stake-pool/cli/src/client.rs

@@ -18,17 +18,17 @@ use {
 
 type Error = Box<dyn std::error::Error>;
 
-pub(crate) fn get_stake_pool(
+pub fn get_stake_pool(
     rpc_client: &RpcClient,
-    pool_address: &Pubkey,
+    stake_pool_address: &Pubkey,
 ) -> Result<StakePool, Error> {
-    let account_data = rpc_client.get_account_data(pool_address)?;
+    let account_data = rpc_client.get_account_data(stake_pool_address)?;
     let stake_pool = StakePool::try_from_slice(account_data.as_slice())
-        .map_err(|err| format!("Invalid stake pool {}: {}", pool_address, err))?;
+        .map_err(|err| format!("Invalid stake pool {}: {}", stake_pool_address, err))?;
     Ok(stake_pool)
 }
 
-pub(crate) fn get_validator_list(
+pub fn get_validator_list(
     rpc_client: &RpcClient,
     validator_list_address: &Pubkey,
 ) -> Result<ValidatorList, Error> {
@@ -38,7 +38,7 @@ pub(crate) fn get_validator_list(
     Ok(validator_list)
 }
 
-pub(crate) fn get_token_account(
+pub fn get_token_account(
     rpc_client: &RpcClient,
     token_account_address: &Pubkey,
     expected_token_mint: &Pubkey,
@@ -58,7 +58,7 @@ pub(crate) fn get_token_account(
     }
 }
 
-pub(crate) fn get_token_mint(
+pub fn get_token_mint(
     rpc_client: &RpcClient,
     token_mint_address: &Pubkey,
 ) -> Result<spl_token::state::Mint, Error> {

stake-pool/cli/src/main.rs

@@ -372,7 +372,7 @@ fn command_vsa_remove(
     // Calculate amount of tokens to withdraw
     let stake_account = config.rpc_client.get_account(&stake)?;
     let tokens_to_withdraw = stake_pool
-        .calc_pool_withdraw_amount(stake_account.lamports)
+        .calc_pool_tokens_for_withdraw(stake_account.lamports)
         .unwrap();
 
     // Check balance and mint
@@ -583,47 +583,84 @@ fn command_deposit(
 
 fn command_list(config: &Config, stake_pool_address: &Pubkey) -> CommandResult {
     let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
+    let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
+    let pool_mint = get_token_mint(&config.rpc_client, &stake_pool.pool_mint)?;
+    let epoch_info = config.rpc_client.get_epoch_info()?;
+
+    for validator in validator_list.validators {
+        println!(
+            "Validator Vote Account: {}\tBalance: {}\tLast Update Epoch: {}{}",
+            validator.vote_account,
+            Sol(validator.stake_lamports),
+            validator.last_update_epoch,
+            if validator.last_update_epoch != epoch_info.epoch {
+                " [UPDATE REQUIRED]"
+            } else {
+                ""
+            }
+        );
+    }
+
+    println!(
+        "Total Pool Stake: {}{}",
+        Sol(stake_pool.total_stake_lamports),
+        if stake_pool.last_update_epoch != epoch_info.epoch {
+            " [UPDATE REQUIRED]"
+        } else {
+            ""
+        }
+    );
+    println!(
+        "Total Pool Tokens: {}",
+        spl_token::amount_to_ui_amount(stake_pool.pool_token_supply, pool_mint.decimals)
+    );
 
     if config.verbose {
-        println!("Current validator list");
-        let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
-        for validator in validator_list.validators {
+        println!();
+
+        let pool_withdraw_authority =
+            find_withdraw_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
+
+        let accounts =
+            get_stake_accounts_by_withdraw_authority(&config.rpc_client, &pool_withdraw_authority)?;
+        if accounts.is_empty() {
+            return Err(format!("No stake accounts found for {}", pool_withdraw_authority).into());
+        }
+
+        let mut total_stake_lamports: u64 = 0;
+        for (pubkey, stake_lamports, stake_state) in accounts {
+            total_stake_lamports += stake_lamports;
             println!(
-                "Vote Account: {}\tBalance: {}\tEpoch: {}",
-                validator.vote_account, validator.balance, validator.last_update_epoch
+                "Stake Account: {}\tVote Account: {}\t{}",
+                pubkey,
+                stake_state.delegation().expect("delegation").voter_pubkey,
+                Sol(stake_lamports)
             );
         }
-    }
-
-    let pool_withdraw_authority =
-        find_withdraw_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
-
-    let accounts =
-        get_stake_accounts_by_withdraw_authority(&config.rpc_client, &pool_withdraw_authority)?;
-    if accounts.is_empty() {
-        return Err("No accounts found.".to_string().into());
-    }
+        println!("Total Stake Account Balance: {}", Sol(total_stake_lamports));
 
-    let mut total_lamports: u64 = 0;
-    for (pubkey, lamports, stake_state) in accounts {
-        total_lamports += lamports;
-        println!(
-            "Stake Account: {}\tVote Account: {}\t{}",
-            pubkey,
-            stake_state.delegation().expect("delegation").voter_pubkey,
-            Sol(lamports)
-        );
+        if pool_mint.supply != stake_pool.pool_token_supply {
+            println!(
+                "BUG! Pool Tokens supply mismatch.  Pool mint reports {}",
+                spl_token::amount_to_ui_amount(pool_mint.supply, pool_mint.decimals)
+            );
+        }
     }
-    println!("Total Stake: {}", Sol(total_lamports));
 
     Ok(())
 }
 
 fn command_update(config: &Config, stake_pool_address: &Pubkey) -> CommandResult {
     let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-    let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
     let epoch_info = config.rpc_client.get_epoch_info()?;
 
+    if stake_pool.last_update_epoch == epoch_info.epoch {
+        println!("Update not required");
+        return Ok(());
+    }
+
+    let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
+
     let accounts_to_update: Vec<Pubkey> = validator_list
         .validators
         .iter()
@@ -651,26 +688,21 @@ fn command_update(config: &Config, stake_pool_address: &Pubkey) -> CommandResult
         )?);
     }
 
-    if instructions.is_empty() && stake_pool.last_update_epoch == epoch_info.epoch {
-        println!("Stake pool balances are up to date, no update required.");
-        Ok(())
-    } else {
-        println!("Updating stake pool...");
-        instructions.push(spl_stake_pool::instruction::update_stake_pool_balance(
-            &spl_stake_pool::id(),
-            stake_pool_address,
-            &stake_pool.validator_list,
-        )?);
+    println!("Updating stake pool...");
+    instructions.push(spl_stake_pool::instruction::update_stake_pool_balance(
+        &spl_stake_pool::id(),
+        stake_pool_address,
+        &stake_pool.validator_list,
+    )?);
 
-        let mut transaction =
-            Transaction::new_with_payer(&instructions, Some(&config.fee_payer.pubkey()));
+    let mut transaction =
+        Transaction::new_with_payer(&instructions, Some(&config.fee_payer.pubkey()));
 
-        let (recent_blockhash, fee_calculator) = config.rpc_client.get_recent_blockhash()?;
-        check_fee_payer_balance(config, fee_calculator.calculate_fee(&transaction.message()))?;
-        transaction.sign(&[config.fee_payer.as_ref()], recent_blockhash);
-        send_transaction(&config, transaction)?;
-        Ok(())
-    }
+    let (recent_blockhash, fee_calculator) = config.rpc_client.get_recent_blockhash()?;
+    check_fee_payer_balance(config, fee_calculator.calculate_fee(&transaction.message()))?;
+    transaction.sign(&[config.fee_payer.as_ref()], recent_blockhash);
+    send_transaction(&config, transaction)?;
+    Ok(())
 }
 
 #[derive(PartialEq, Debug)]

stake-pool/program/src/processor.rs

@@ -513,8 +513,8 @@ impl Processor {
 
         // Calculate and mint tokens
         let stake_lamports = **stake_account_info.lamports.borrow();
-        let token_amount = stake_pool
-            .calc_pool_deposit_amount(stake_lamports)
+        let pool_tokens = stake_pool
+            .calc_pool_tokens_for_deposit(stake_lamports)
             .ok_or(StakePoolError::CalculationFailure)?;
         Self::token_mint_to(
             stake_pool_info.key,
@@ -524,21 +524,21 @@ impl Processor {
             withdraw_info.clone(),
             AUTHORITY_WITHDRAW,
             stake_pool.withdraw_bump_seed,
-            token_amount,
+            pool_tokens,
         )?;
 
         // Check if stake is warmed up
         Self::check_stake_activation(stake_account_info, clock, stake_history)?;
 
         validator_list.validators.push(ValidatorStakeInfo {
             vote_account,
-            balance: stake_lamports,
+            stake_lamports,
             last_update_epoch: clock.epoch,
         });
         validator_list.serialize(&mut *validator_list_info.data.borrow_mut())?;
 
-        stake_pool.pool_total += token_amount;
-        stake_pool.stake_total += stake_lamports;
+        stake_pool.pool_token_supply += pool_tokens;
+        stake_pool.total_stake_lamports += stake_lamports;
         stake_pool.serialize(&mut *stake_pool_info.data.borrow_mut())?;
 
         Ok(())
@@ -622,8 +622,8 @@ impl Processor {
 
         // Calculate and burn tokens
         let stake_lamports = **stake_account_info.lamports.borrow();
-        let token_amount = stake_pool
-            .calc_pool_withdraw_amount(stake_lamports)
+        let pool_tokens = stake_pool
+            .calc_pool_tokens_for_withdraw(stake_lamports)
             .ok_or(StakePoolError::CalculationFailure)?;
         Self::token_burn(
             stake_pool_info.key,
@@ -633,16 +633,16 @@ impl Processor {
             withdraw_info.clone(),
             AUTHORITY_WITHDRAW,
             stake_pool.withdraw_bump_seed,
-            token_amount,
+            pool_tokens,
         )?;
 
         validator_list
             .validators
             .retain(|item| item.vote_account != vote_account);
         validator_list.serialize(&mut *validator_list_info.data.borrow_mut())?;
 
-        stake_pool.pool_total -= token_amount;
-        stake_pool.stake_total -= stake_lamports;
+        stake_pool.pool_token_supply -= pool_tokens;
+        stake_pool.total_stake_lamports -= stake_lamports;
         stake_pool.serialize(&mut *stake_pool_info.data.borrow_mut())?;
 
         Ok(())
@@ -685,7 +685,7 @@ impl Processor {
                     continue;
                 }
                 validator_stake_record.last_update_epoch = clock.epoch;
-                validator_stake_record.balance = **validator_stake_account.lamports.borrow();
+                validator_stake_record.stake_lamports = **validator_stake_account.lamports.borrow();
                 changes = true;
             }
         }
@@ -723,15 +723,15 @@ impl Processor {
             return Err(StakePoolError::InvalidState.into());
         }
 
-        let mut total_balance: u64 = 0;
+        let mut total_stake_lamports: u64 = 0;
         for validator_stake_record in validator_list.validators {
             if validator_stake_record.last_update_epoch < clock.epoch {
                 return Err(StakePoolError::StakeListOutOfDate.into());
             }
-            total_balance += validator_stake_record.balance;
+            total_stake_lamports += validator_stake_record.stake_lamports;
         }
 
-        stake_pool.stake_total = total_balance;
+        stake_pool.total_stake_lamports = total_stake_lamports;
         stake_pool.last_update_epoch = clock.epoch;
         stake_pool.serialize(&mut *stake_pool_info.data.borrow_mut())?;
 
@@ -830,16 +830,16 @@ impl Processor {
             .ok_or(StakePoolError::ValidatorNotFound)?;
 
         let stake_lamports = **stake_info.lamports.borrow();
-        let pool_amount = stake_pool
-            .calc_pool_deposit_amount(stake_lamports)
+        let new_pool_tokens = stake_pool
+            .calc_pool_tokens_for_deposit(stake_lamports)
             .ok_or(StakePoolError::CalculationFailure)?;
 
-        let fee_amount = stake_pool
-            .calc_fee_amount(pool_amount)
+        let fee_pool_tokens = stake_pool
+            .calc_fee_amount(new_pool_tokens)
             .ok_or(StakePoolError::CalculationFailure)?;
 
-        let user_amount = pool_amount
-            .checked_sub(fee_amount)
+        let user_pool_tokens = new_pool_tokens
+            .checked_sub(fee_pool_tokens)
             .ok_or(StakePoolError::CalculationFailure)?;
 
         Self::stake_authorize(
@@ -886,7 +886,7 @@ impl Processor {
             withdraw_info.clone(),
             AUTHORITY_WITHDRAW,
             stake_pool.withdraw_bump_seed,
-            user_amount,
+            user_pool_tokens,
         )?;
 
         Self::token_mint_to(
@@ -897,13 +897,13 @@ impl Processor {
             withdraw_info.clone(),
             AUTHORITY_WITHDRAW,
             stake_pool.withdraw_bump_seed,
-            fee_amount,
+            fee_pool_tokens,
         )?;
-        stake_pool.pool_total += pool_amount;
-        stake_pool.stake_total += stake_lamports;
+        stake_pool.pool_token_supply += new_pool_tokens;
+        stake_pool.total_stake_lamports += stake_lamports;
         stake_pool.serialize(&mut *stake_pool_info.data.borrow_mut())?;
 
-        validator_list_item.balance = **validator_stake_account_info.lamports.borrow();
+        validator_list_item.stake_lamports = **validator_stake_account_info.lamports.borrow();
         validator_list.serialize(&mut *validator_list_info.data.borrow_mut())?;
 
         Ok(())
@@ -912,7 +912,7 @@ impl Processor {
     /// Processes [Withdraw](enum.Instruction.html).
     fn process_withdraw(
         program_id: &Pubkey,
-        pool_amount: u64,
+        pool_tokens: u64,
         accounts: &[AccountInfo],
     ) -> ProgramResult {
         let account_info_iter = &mut accounts.iter();
@@ -965,8 +965,8 @@ impl Processor {
             .find_mut(&vote_account)
             .ok_or(StakePoolError::ValidatorNotFound)?;
 
-        let stake_amount = stake_pool
-            .calc_lamports_withdraw_amount(pool_amount)
+        let stake_lamports = stake_pool
+            .calc_lamports_withdraw_amount(pool_tokens)
             .ok_or(StakePoolError::CalculationFailure)?;
 
         Self::stake_split(
@@ -975,7 +975,7 @@ impl Processor {
             withdraw_info.clone(),
             AUTHORITY_WITHDRAW,
             stake_pool.withdraw_bump_seed,
-            stake_amount,
+            stake_lamports,
             stake_split_to.clone(),
         )?;
 
@@ -1011,14 +1011,14 @@ impl Processor {
             withdraw_info.clone(),
             AUTHORITY_WITHDRAW,
             stake_pool.withdraw_bump_seed,
-            pool_amount,
+            pool_tokens,
         )?;
 
-        stake_pool.pool_total -= pool_amount;
-        stake_pool.stake_total -= stake_amount;
+        stake_pool.pool_token_supply -= pool_tokens;
+        stake_pool.total_stake_lamports -= stake_lamports;
         stake_pool.serialize(&mut *stake_pool_info.data.borrow_mut())?;
 
-        validator_list_item.balance = **stake_split_from.lamports.borrow();
+        validator_list_item.stake_lamports = **stake_split_from.lamports.borrow();
         validator_list.serialize(&mut *validator_list_info.data.borrow_mut())?;
 
         Ok(())