Deprecate FeeCalculator returning APIs (#19120)

core/src/test_validator.rs

@@ -28,6 +28,8 @@ use {
         exit::Exit,
         fee_calculator::{FeeCalculator, FeeRateGovernor},
         hash::Hash,
+        instruction::{AccountMeta, Instruction},
+        message::Message,
         native_token::sol_to_lamports,
         pubkey::Pubkey,
         rent::Rent,
@@ -551,25 +553,40 @@ impl TestValidator {
         {
             let rpc_client =
                 RpcClient::new_with_commitment(rpc_url.clone(), CommitmentConfig::processed());
-
-            if let Ok(result) = rpc_client.get_fee_rate_governor() {
-                let fee_rate_governor = result.value;
-                if fee_rate_governor.target_lamports_per_signature > 0 {
-                    loop {
-                        match rpc_client.get_recent_blockhash() {
-                            Ok((_blockhash, fee_calculator)) => {
-                                if fee_calculator.lamports_per_signature != 0 {
-                                    break;
-                                }
-                            }
-                            Err(err) => {
-                                warn!("get_recent_blockhash() failed: {:?}", err);
+            let message = Message::new(
+                &[Instruction::new_with_bytes(
+                    Pubkey::new_unique(),
+                    &[],
+                    vec![AccountMeta::new(Pubkey::new_unique(), true)],
+                )],
+                None,
+            );
+            const MAX_TRIES: u64 = 10;
+            let mut num_tries = 0;
+            loop {
+                num_tries += 1;
+                if num_tries > MAX_TRIES {
+                    break;
+                }
+                println!("Waiting for fees to stabilize {:?}...", num_tries);
+                match rpc_client.get_latest_blockhash() {
+                    Ok(blockhash) => match rpc_client.get_fee_for_message(&blockhash, &message) {
+                        Ok(fee) => {
+                            if fee != 0 {
                                 break;
                             }
                         }
-                        sleep(Duration::from_millis(DEFAULT_MS_PER_SLOT));
+                        Err(err) => {
+                            warn!("get_fee_for_message() failed: {:?}", err);
+                            break;
+                        }
+                    },
+                    Err(err) => {
+                        warn!("get_latest_blockhash() failed: {:?}", err);
+                        break;
                     }
                 }
+                sleep(Duration::from_millis(DEFAULT_MS_PER_SLOT));
             }
         }
 
@@ -615,6 +632,7 @@ impl TestValidator {
     pub fn rpc_client(&self) -> (RpcClient, Hash, FeeCalculator) {
         let rpc_client =
             RpcClient::new_with_commitment(self.rpc_url.clone(), CommitmentConfig::processed());
+        #[allow(deprecated)]
         let (recent_blockhash, fee_calculator) = rpc_client
             .get_recent_blockhash()
             .expect("get_recent_blockhash");

core/src/vote_simulator.rs

@@ -82,12 +82,12 @@ impl VoteSimulator {
             for (pubkey, vote) in cluster_votes.iter() {
                 if vote.contains(&parent) {
                     let keypairs = self.validator_keypairs.get(pubkey).unwrap();
-                    let last_blockhash = parent_bank.last_blockhash();
+                    let latest_blockhash = parent_bank.last_blockhash();
                     let vote_tx = vote_transaction::new_vote_transaction(
                         // Must vote > root to be processed
                         vec![parent],
                         parent_bank.hash(),
-                        last_blockhash,
+                        latest_blockhash,
                         &keypairs.node_keypair,
                         &keypairs.vote_keypair,
                         &keypairs.vote_keypair,

core/tests/client.rs

@@ -53,7 +53,7 @@ fn test_rpc_client() {
 
     let original_alice_balance = client.get_balance(&alice.pubkey()).unwrap();
 
-    let (blockhash, _fee_calculator) = client.get_recent_blockhash().unwrap();
+    let blockhash = client.get_latest_blockhash().unwrap();
 
     let tx = system_transaction::transfer(&alice, &bob_pubkey, sol_to_lamports(20.0), blockhash);
     let signature = client.send_transaction(&tx).unwrap();

core/tests/rpc.rs

@@ -231,7 +231,7 @@ fn test_rpc_subscriptions() {
     transactions_socket.connect(test_validator.tpu()).unwrap();
 
     let rpc_client = RpcClient::new(test_validator.rpc_url());
-    let recent_blockhash = rpc_client.get_recent_blockhash().unwrap().0;
+    let recent_blockhash = rpc_client.get_latest_blockhash().unwrap();
 
     // Create transaction signatures to subscribe to
     let transactions: Vec<Transaction> = (0..1000)
@@ -406,7 +406,7 @@ fn test_tpu_send_transaction() {
     )
     .unwrap();
 
-    let recent_blockhash = rpc_client.get_recent_blockhash().unwrap().0;
+    let recent_blockhash = rpc_client.get_latest_blockhash().unwrap();
     let tx =
         system_transaction::transfer(&mint_keypair, &Pubkey::new_unique(), 42, recent_blockhash);
     assert!(tpu_client.send_transaction(&tx));
@@ -433,8 +433,8 @@ fn deserialize_rpc_error() -> ClientResult<()> {
 
     let bob = Keypair::new();
     let lamports = 50;
-    let (recent_blockhash, _) = rpc_client.get_recent_blockhash()?;
-    let mut tx = system_transaction::transfer(&alice, &bob.pubkey(), lamports, recent_blockhash);
+    let blockhash = rpc_client.get_latest_blockhash()?;
+    let mut tx = system_transaction::transfer(&alice, &bob.pubkey(), lamports, blockhash);
 
     // This will cause an error
     tx.signatures.clear();