Deprecate commitment variants (#14797)

* Deprecate commitment variants

* Add new CommitmentConfig builders

* Add helpers to avoid allowing deprecated variants

* Remove deprecated transaction-status code

* Include new commitment variants in runtime commitment; allow deprecated as long as old variants persist

* Remove deprecated banks code

* Remove deprecated variants in core; allow deprecated in rpc/rpc-subscriptions for now

* Heavier hand with rpc/rpc-subscription commitment

* Remove deprecated variants from local-cluster

* Remove deprecated variants from various tools

* Remove deprecated variants from validator

* Update docs

* Remove deprecated client code

* Add new variants to cli; remove deprecated variants as possible

* Don't send new commitment variants to old clusters

* Retain deprecated method in test_validator_saves_tower

* Fix clippy matches! suggestion for BPF solana-sdk legacy compile test

* Refactor node version check to handle commitment variants and transaction encoding

* Hide deprecated variants from cli help

* Add cli App comments

sdk/src/commitment_config.rs

@@ -1,3 +1,6 @@
+#![allow(deprecated)]
+#![cfg(feature = "full")]
+
 use std::str::FromStr;
 use thiserror::Error;
 
@@ -8,36 +11,74 @@ pub struct CommitmentConfig {
 }
 
 impl CommitmentConfig {
+    #[deprecated(
+        since = "1.5.5",
+        note = "Please use CommitmentConfig::processed() instead"
+    )]
     pub fn recent() -> Self {
         Self {
             commitment: CommitmentLevel::Recent,
         }
     }
 
+    #[deprecated(
+        since = "1.5.5",
+        note = "Please use CommitmentConfig::finalized() instead"
+    )]
     pub fn max() -> Self {
         Self {
             commitment: CommitmentLevel::Max,
         }
     }
 
+    #[deprecated(
+        since = "1.5.5",
+        note = "Please use CommitmentConfig::finalized() instead"
+    )]
     pub fn root() -> Self {
         Self {
             commitment: CommitmentLevel::Root,
         }
     }
 
+    #[deprecated(
+        since = "1.5.5",
+        note = "Please use CommitmentConfig::confirmed() instead"
+    )]
     pub fn single() -> Self {
         Self {
             commitment: CommitmentLevel::Single,
         }
     }
 
+    #[deprecated(
+        since = "1.5.5",
+        note = "Please use CommitmentConfig::confirmed() instead"
+    )]
     pub fn single_gossip() -> Self {
         Self {
             commitment: CommitmentLevel::SingleGossip,
         }
     }
 
+    pub fn finalized() -> Self {
+        Self {
+            commitment: CommitmentLevel::Finalized,
+        }
+    }
+
+    pub fn confirmed() -> Self {
+        Self {
+            commitment: CommitmentLevel::Confirmed,
+        }
+    }
+
+    pub fn processed() -> Self {
+        Self {
+            commitment: CommitmentLevel::Processed,
+        }
+    }
+
     pub fn ok(self) -> Option<Self> {
         if self == Self::default() {
             None
@@ -45,6 +86,36 @@ impl CommitmentConfig {
             Some(self)
         }
     }
+
+    pub fn is_finalized(&self) -> bool {
+        matches!(
+            &self.commitment,
+            CommitmentLevel::Finalized | CommitmentLevel::Max | CommitmentLevel::Root
+        )
+    }
+
+    pub fn is_confirmed(&self) -> bool {
+        matches!(
+            &self.commitment,
+            CommitmentLevel::Confirmed | CommitmentLevel::SingleGossip | CommitmentLevel::Single
+        )
+    }
+
+    pub fn is_processed(&self) -> bool {
+        matches!(
+            &self.commitment,
+            CommitmentLevel::Processed | CommitmentLevel::Recent
+        )
+    }
+
+    pub fn use_deprecated_commitment(commitment: CommitmentConfig) -> Self {
+        match commitment.commitment {
+            CommitmentLevel::Finalized => CommitmentConfig::max(),
+            CommitmentLevel::Confirmed => CommitmentConfig::single_gossip(),
+            CommitmentLevel::Processed => CommitmentConfig::recent(),
+            _ => commitment,
+        }
+    }
 }
 
 impl FromStr for CommitmentConfig {
@@ -62,32 +133,67 @@ impl FromStr for CommitmentConfig {
 /// finalized. When querying the ledger state, use lower levels of commitment to report progress and higher
 /// levels to ensure state changes will not be rolled back.
 pub enum CommitmentLevel {
-    /// The highest slot having reached max vote lockout, as recognized by a supermajority of the cluster.
+    /// (DEPRECATED) The highest slot having reached max vote lockout, as recognized by a supermajority of the cluster.
+    #[deprecated(
+        since = "1.5.5",
+        note = "Please use CommitmentLevel::Finalized instead"
+    )]
     Max,
 
-    /// The highest slot of the heaviest fork. Ledger state at this slot is not derived from a finalized
+    /// (DEPRECATED) The highest slot of the heaviest fork. Ledger state at this slot is not derived from a finalized
     /// block, but if multiple forks are present, is from the fork the validator believes is most likely
     /// to finalize.
+    #[deprecated(
+        since = "1.5.5",
+        note = "Please use CommitmentLevel::Processed instead"
+    )]
     Recent,
 
-    /// The highest slot having reached max vote lockout.
+    /// (DEPRECATED) The highest slot having reached max vote lockout.
+    #[deprecated(
+        since = "1.5.5",
+        note = "Please use CommitmentLevel::Finalized instead"
+    )]
     Root,
 
     /// (DEPRECATED) The highest slot having reached 1 confirmation by supermajority of the cluster.
+    #[deprecated(
+        since = "1.5.5",
+        note = "Please use CommitmentLevel::Confirmed instead"
+    )]
     Single,
 
-    /// The highest slot that has been voted on by supermajority of the cluster
+    /// (DEPRECATED) The highest slot that has been voted on by supermajority of the cluster
     /// This differs from `single` in that:
     /// 1) It incorporates votes from gossip and replay.
     /// 2) It does not count votes on descendants of a block, only direct votes on that block.
     /// 3) This confirmation level also upholds "optimistic confirmation" guarantees in
     /// release 1.3 and onwards.
+    #[deprecated(
+        since = "1.5.5",
+        note = "Please use CommitmentLevel::Confirmed instead"
+    )]
     SingleGossip,
+
+    /// The highest slot of the heaviest fork processed by the node. Ledger state at this slot is
+    /// not derived from a confirmed or finalized block, but if multiple forks are present, is from
+    /// the fork the validator believes is most likely to finalize.
+    Processed,
+
+    /// The highest slot that has been voted on by supermajority of the cluster, ie. is confirmed.
+    /// Confirmation incorporates votes from gossip and replay. It does not count votes on
+    /// descendants of a block, only direct votes on that block, and upholds "optimistic
+    /// confirmation" guarantees in release 1.3 and onwards.
+    Confirmed,
+
+    /// The highest slot having reached max vote lockout, as recognized by a supermajority of the
+    /// cluster.
+    Finalized,
 }
 
 impl Default for CommitmentLevel {
     fn default() -> Self {
-        Self::Max
+        Self::Finalized
     }
 }
 
@@ -101,6 +207,9 @@ impl FromStr for CommitmentLevel {
             "root" => Ok(CommitmentLevel::Root),
             "single" => Ok(CommitmentLevel::Single),
             "singleGossip" => Ok(CommitmentLevel::SingleGossip),
+            "processed" => Ok(CommitmentLevel::Processed),
+            "confirmed" => Ok(CommitmentLevel::Confirmed),
+            "finalized" => Ok(CommitmentLevel::Finalized),
             _ => Err(ParseCommitmentLevelError::Invalid),
         }
     }
@@ -114,6 +223,9 @@ impl std::fmt::Display for CommitmentLevel {
             CommitmentLevel::Root => "root",
             CommitmentLevel::Single => "single",
             CommitmentLevel::SingleGossip => "singleGossip",
+            CommitmentLevel::Processed => "processed",
+            CommitmentLevel::Confirmed => "confirmed",
+            CommitmentLevel::Finalized => "finalized",
         };
         write!(f, "{}", s)
     }