stake: deprecate on chain warmup/cooldown rate and config (#32723)

* stake: deprecate on chain warmup/cooldown rate and config

* Pr feedback: Deprecate since 1.16.7

Co-authored-by: Jon Cinque <[email protected]>

---------

Co-authored-by: Jon Cinque <[email protected]>

Author: AshwinSekar

account-decoder/src/lib.rs

@@ -7,6 +7,7 @@ extern crate serde_derive;
 pub mod parse_account_data;
 pub mod parse_address_lookup_table;
 pub mod parse_bpf_loader;
+#[allow(deprecated)]
 pub mod parse_config;
 pub mod parse_nonce;
 pub mod parse_stake;

account-decoder/src/parse_config.rs

@@ -8,7 +8,9 @@ use {
     solana_config_program::{get_config_data, ConfigKeys},
     solana_sdk::{
         pubkey::Pubkey,
-        stake::config::{self as stake_config, Config as StakeConfig},
+        stake::config::{
+            Config as StakeConfig, {self as stake_config},
+        },
     },
 };
 
@@ -66,6 +68,10 @@ pub struct UiConfigKey {
     pub signer: bool,
 }
 
+#[deprecated(
+    since = "1.16.7",
+    note = "Please use `solana_sdk::stake::state::warmup_cooldown_rate()` instead"
+)]
 #[derive(Debug, Serialize, Deserialize, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub struct UiStakeConfig {

account-decoder/src/parse_stake.rs

@@ -119,11 +119,16 @@ pub struct UiDelegation {
     pub stake: StringAmount,
     pub activation_epoch: StringAmount,
     pub deactivation_epoch: StringAmount,
+    #[deprecated(
+        since = "1.16.7",
+        note = "Please use `solana_sdk::stake::stake::warmup_cooldown_rate()` instead"
+    )]
     pub warmup_cooldown_rate: f64,
 }
 
 impl From<Delegation> for UiDelegation {
     fn from(delegation: Delegation) -> Self {
+        #[allow(deprecated)]
         Self {
             voter: delegation.voter_pubkey.to_string(),
             stake: delegation.stake.to_string(),
@@ -139,6 +144,7 @@ mod test {
     use {super::*, bincode::serialize, solana_sdk::stake::stake_flags::StakeFlags};
 
     #[test]
+    #[allow(deprecated)]
     fn test_parse_stake() {
         let stake_state = StakeState::Uninitialized;
         let stake_data = serialize(&stake_state).unwrap();

cli/src/cluster_query.rs

@@ -2,6 +2,7 @@ use {
     crate::{
         cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
         compute_unit_price::WithComputeUnitPrice,
+        feature::get_feature_activation_epoch,
         spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
     },
     clap::{value_t, value_t_or_exit, App, AppSettings, Arg, ArgMatches, SubCommand},
@@ -43,6 +44,7 @@ use {
         clock::{self, Clock, Slot},
         commitment_config::CommitmentConfig,
         epoch_schedule::Epoch,
+        feature_set,
         hash::Hash,
         message::Message,
         native_token::lamports_to_sol,
@@ -1800,6 +1802,8 @@ pub fn process_show_stakes(
     let stake_history = from_account(&stake_history_account).ok_or_else(|| {
         CliError::RpcRequestError("Failed to deserialize stake history".to_string())
     })?;
+    let new_rate_activation_epoch =
+        get_feature_activation_epoch(rpc_client, &feature_set::reduce_stake_warmup_cooldown::id())?;
 
     let mut stake_accounts: Vec<CliKeyedStakeState> = vec![];
     for (stake_pubkey, stake_account) in all_stake_accounts {
@@ -1815,6 +1819,7 @@ pub fn process_show_stakes(
                                 use_lamports_unit,
                                 &stake_history,
                                 &clock,
+                                new_rate_activation_epoch,
                             ),
                         });
                     }
@@ -1833,6 +1838,7 @@ pub fn process_show_stakes(
                                 use_lamports_unit,
                                 &stake_history,
                                 &clock,
+                                new_rate_activation_epoch,
                             ),
                         });
                     }

cli/src/feature.rs

@@ -22,6 +22,7 @@ use {
         genesis_config::ClusterType,
         message::Message,
         pubkey::Pubkey,
+        stake_history::Epoch,
         transaction::Transaction,
     },
     std::{cmp::Ordering, collections::HashMap, fmt, str::FromStr, sync::Arc},
@@ -817,6 +818,22 @@ pub fn get_feature_is_active(
         .map(|status| matches!(status, Some(CliFeatureStatus::Active(_))))
 }
 
+pub fn get_feature_activation_epoch(
+    rpc_client: &RpcClient,
+    feature_id: &Pubkey,
+) -> Result<Option<Epoch>, ClientError> {
+    rpc_client
+        .get_feature_activation_slot(feature_id)
+        .and_then(|activation_slot: Option<Slot>| {
+            rpc_client
+                .get_epoch_schedule()
+                .map(|epoch_schedule| (activation_slot, epoch_schedule))
+        })
+        .map(|(activation_slot, epoch_schedule)| {
+            activation_slot.map(|slot| epoch_schedule.get_epoch(slot))
+        })
+}
+
 fn process_status(
     rpc_client: &RpcClient,
     config: &CliConfig,

cli/src/stake.rs

@@ -6,6 +6,7 @@ use {
             ProcessResult,
         },
         compute_unit_price::WithComputeUnitPrice,
+        feature::get_feature_activation_epoch,
         memo::WithMemo,
         nonce::check_nonce_account,
         spend_utils::{resolve_spend_tx_and_check_account_balances, SpendAmount},
@@ -40,6 +41,7 @@ use {
         clock::{Clock, UnixTimestamp, SECONDS_PER_DAY},
         commitment_config::CommitmentConfig,
         epoch_schedule::EpochSchedule,
+        feature_set,
         message::Message,
         pubkey::Pubkey,
         stake::{
@@ -48,7 +50,7 @@ use {
             state::{Authorized, Lockup, Meta, StakeActivationStatus, StakeAuthorize, StakeState},
             tools::{acceptable_reference_epoch_credits, eligible_for_deactivate_delinquent},
         },
-        stake_history::StakeHistory,
+        stake_history::{Epoch, StakeHistory},
         system_instruction::SystemError,
         sysvar::{clock, stake_history},
         transaction::Transaction,
@@ -2186,6 +2188,7 @@ pub fn build_stake_state(
     use_lamports_unit: bool,
     stake_history: &StakeHistory,
     clock: &Clock,
+    new_rate_activation_epoch: Option<Epoch>,
 ) -> CliStakeState {
     match stake_state {
         StakeState::Stake(
@@ -2202,9 +2205,11 @@ pub fn build_stake_state(
                 effective,
                 activating,
                 deactivating,
-            } = stake
-                .delegation
-                .stake_activating_and_deactivating(current_epoch, Some(stake_history));
+            } = stake.delegation.stake_activating_and_deactivating(
+                current_epoch,
+                Some(stake_history),
+                new_rate_activation_epoch,
+            );
             let lockup = if lockup.is_in_force(clock, None) {
                 Some(lockup.into())
             } else {
@@ -2424,13 +2429,18 @@ pub fn process_show_stake_account(
             let clock: Clock = from_account(&clock_account).ok_or_else(|| {
                 CliError::RpcRequestError("Failed to deserialize clock sysvar".to_string())
             })?;
+            let new_rate_activation_epoch = get_feature_activation_epoch(
+                rpc_client,
+                &feature_set::reduce_stake_warmup_cooldown::id(),
+            )?;
 
             let mut state = build_stake_state(
                 stake_account.lamports,
                 &stake_state,
                 use_lamports_unit,
                 &stake_history,
                 &clock,
+                new_rate_activation_epoch,
             );
 
             if state.stake_type == CliStakeType::Stake && state.activation_epoch.is_some() {

local-cluster/src/local_cluster.rs

@@ -38,13 +38,13 @@ use {
         pubkey::Pubkey,
         signature::{Keypair, Signer},
         stake::{
-            config as stake_config, instruction as stake_instruction,
+            instruction as stake_instruction,
             state::{Authorized, Lockup},
         },
         system_transaction,
         transaction::Transaction,
     },
-    solana_stake_program::{config::create_account as create_stake_config_account, stake_state},
+    solana_stake_program::stake_state,
     solana_streamer::socket::SocketAddrSpace,
     solana_tpu_client::tpu_client::{
         DEFAULT_TPU_CONNECTION_POOL_SIZE, DEFAULT_TPU_ENABLE_UDP, DEFAULT_TPU_USE_QUIC,
@@ -267,18 +267,6 @@ impl LocalCluster {
             .native_instruction_processors
             .extend_from_slice(&config.native_instruction_processors);
 
-        // Replace staking config
-        genesis_config.add_account(
-            stake_config::id(),
-            create_stake_config_account(
-                1,
-                &stake_config::Config {
-                    warmup_cooldown_rate: std::f64::MAX,
-                    slash_penalty: std::u8::MAX,
-                },
-            ),
-        );
-
         let (leader_ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
         let leader_contact_info = leader_node.info.clone();
         let mut leader_config = safe_clone_config(&config.validator_configs[0]);

local-cluster/tests/local_cluster.rs

@@ -1535,10 +1535,13 @@ fn test_fake_shreds_broadcast_leader() {
 fn test_wait_for_max_stake() {
     solana_logger::setup_with_default(RUST_LOG_FILTER);
     let validator_config = ValidatorConfig::default_for_test();
+    let slots_per_epoch = MINIMUM_SLOTS_PER_EPOCH;
     let mut config = ClusterConfig {
         cluster_lamports: DEFAULT_CLUSTER_LAMPORTS,
         node_stakes: vec![DEFAULT_NODE_STAKE; 4],
         validator_configs: make_identical_validator_configs(&validator_config, 4),
+        slots_per_epoch,
+        stakers_slot_offset: slots_per_epoch,
         ..ClusterConfig::default()
     };
     let cluster = LocalCluster::new(&mut config, SocketAddrSpace::Unspecified);

program-test/tests/warp.rs

@@ -278,7 +278,7 @@ async fn stake_rewards_from_warp() {
     assert_eq!(
         stake
             .delegation
-            .stake_activating_and_deactivating(clock.epoch, Some(&stake_history)),
+            .stake_activating_and_deactivating(clock.epoch, Some(&stake_history), None),
         StakeActivationStatus::with_effective(stake.delegation.stake),
     );
 }
@@ -394,7 +394,7 @@ async fn stake_rewards_filter_bench_core(num_stake_accounts: u64) {
     assert_eq!(
         stake
             .delegation
-            .stake_activating_and_deactivating(clock.epoch, Some(&stake_history)),
+            .stake_activating_and_deactivating(clock.epoch, Some(&stake_history), None),
         StakeActivationStatus::with_effective(stake.delegation.stake),
     );
 }

programs/config/src/lib.rs

@@ -4,14 +4,15 @@ pub mod config_processor;
 pub mod date_instruction;
 
 pub use solana_sdk::config::program::id;
+#[allow(deprecated)]
+use solana_sdk::stake::config::Config as StakeConfig;
 use {
     bincode::{deserialize, serialize, serialized_size},
     serde_derive::{Deserialize, Serialize},
     solana_sdk::{
         account::{Account, AccountSharedData},
         pubkey::Pubkey,
         short_vec,
-        stake::config::Config as StakeConfig,
     },
 };
 
@@ -21,6 +22,7 @@ pub trait ConfigState: serde::Serialize + Default {
 }
 
 // TODO move ConfigState into `solana_program` to implement trait locally
+#[allow(deprecated)]
 impl ConfigState for StakeConfig {
     fn max_space() -> u64 {
         serialized_size(&StakeConfig::default()).unwrap()

programs/stake/src/config.rs

@@ -5,27 +5,31 @@
     note = "Please use `solana_sdk::stake::config` or `solana_program::stake::config` instead"
 )]
 pub use solana_sdk::stake::config::*;
+#[allow(deprecated)]
+use solana_sdk::stake::config::{self, Config};
 use {
     bincode::deserialize,
     solana_config_program::{create_config_account, get_config_data},
     solana_sdk::{
         account::{AccountSharedData, ReadableAccount, WritableAccount},
         genesis_config::GenesisConfig,
-        stake::config::{self, Config},
         transaction_context::BorrowedAccount,
     },
 };
 
+#[allow(deprecated)]
 pub fn from(account: &BorrowedAccount) -> Option<Config> {
     get_config_data(account.get_data())
         .ok()
         .and_then(|data| deserialize(data).ok())
 }
 
+#[allow(deprecated)]
 pub fn create_account(lamports: u64, config: &Config) -> AccountSharedData {
     create_config_account(vec![], config, lamports)
 }
 
+#[allow(deprecated)]
 pub fn add_genesis_account(genesis_config: &mut GenesisConfig) -> u64 {
     let mut account = create_config_account(vec![], &Config::default(), 0);
     let lamports = genesis_config.rent.minimum_balance(account.data().len());