Update solana program to use last_valid_block_height

cli/src/program.rs

@@ -23,6 +23,7 @@ use solana_client::{
     rpc_config::{RpcAccountInfoConfig, RpcProgramAccountsConfig},
     rpc_filter::{Memcmp, MemcmpEncodedBytes, RpcFilterType},
     rpc_request::MAX_GET_SIGNATURE_STATUSES_QUERY_ITEMS,
+    rpc_response::Fees,
     tpu_client::{TpuClient, TpuClientConfig},
 };
 use solana_rbpf::{
@@ -35,7 +36,6 @@ use solana_sdk::{
     account_utils::StateMut,
     bpf_loader, bpf_loader_deprecated,
     bpf_loader_upgradeable::{self, UpgradeableLoaderState},
-    clock::Slot,
     commitment_config::CommitmentConfig,
     instruction::Instruction,
     instruction::InstructionError,
@@ -1943,8 +1943,12 @@ fn send_deploy_messages(
     if let Some(write_messages) = write_messages {
         if let Some(write_signer) = write_signer {
             trace!("Writing program data");
-            let (blockhash, _, last_valid_slot) = rpc_client
-                .get_recent_blockhash_with_commitment(config.commitment)?
+            let Fees {
+                blockhash,
+                last_valid_block_height,
+                ..
+            } = rpc_client
+                .get_fees_with_commitment(config.commitment)?
                 .value;
             let mut write_transactions = vec![];
             for message in write_messages.iter() {
@@ -1959,7 +1963,7 @@ fn send_deploy_messages(
                 write_transactions,
                 &[payer_signer, write_signer],
                 config.commitment,
-                last_valid_slot,
+                last_valid_block_height,
             )
             .map_err(|err| format!("Data writes to account failed: {}", err))?;
         }
@@ -2029,7 +2033,7 @@ fn send_and_confirm_transactions_with_spinner<T: Signers>(
     mut transactions: Vec<Transaction>,
     signer_keys: &T,
     commitment: CommitmentConfig,
-    mut last_valid_slot: Slot,
+    mut last_valid_block_height: u64,
 ) -> Result<(), Box<dyn error::Error>> {
     let progress_bar = new_spinner_progress_bar();
     let mut send_retries = 5;
@@ -2069,7 +2073,7 @@ fn send_and_confirm_transactions_with_spinner<T: Signers>(
 
         // Collect statuses for all the transactions, drop those that are confirmed
         loop {
-            let mut slot = 0;
+            let mut block_height = 0;
             let pending_signatures = pending_transactions.keys().cloned().collect::<Vec<_>>();
             for pending_signatures_chunk in
                 pending_signatures.chunks(MAX_GET_SIGNATURE_STATUSES_QUERY_ITEMS)
@@ -2094,20 +2098,20 @@ fn send_and_confirm_transactions_with_spinner<T: Signers>(
                     }
                 }
 
-                slot = rpc_client.get_slot()?;
+                block_height = rpc_client.get_block_height()?;
                 progress_bar.set_message(format!(
-                    "[{}/{}] Transactions confirmed. Retrying in {} slots",
+                    "[{}/{}] Transactions confirmed. Retrying in {} blocks",
                     num_transactions - pending_transactions.len(),
                     num_transactions,
-                    last_valid_slot.saturating_sub(slot)
+                    last_valid_block_height.saturating_sub(block_height)
                 ));
             }
 
             if pending_transactions.is_empty() {
                 return Ok(());
             }
 
-            if slot > last_valid_slot {
+            if block_height > last_valid_block_height {
                 break;
             }
 
@@ -2137,10 +2141,12 @@ fn send_and_confirm_transactions_with_spinner<T: Signers>(
         send_retries -= 1;
 
         // Re-sign any failed transactions with a new blockhash and retry
-        let (blockhash, _fee_calculator, new_last_valid_slot) = rpc_client
-            .get_recent_blockhash_with_commitment(commitment)?
-            .value;
-        last_valid_slot = new_last_valid_slot;
+        let Fees {
+            blockhash,
+            last_valid_block_height: new_last_valid_block_height,
+            ..
+        } = rpc_client.get_fees_with_commitment(commitment)?.value;
+        last_valid_block_height = new_last_valid_block_height;
         transactions = vec![];
         for (_, mut transaction) in pending_transactions.into_iter() {
             transaction.try_sign(signer_keys, blockhash)?;

client/src/blockhash_query.rs

@@ -122,10 +122,10 @@ mod tests {
     use crate::{
         blockhash_query,
         rpc_request::RpcRequest,
-        rpc_response::{Response, RpcFeeCalculator, RpcResponseContext},
+        rpc_response::{Response, RpcFeeCalculator, RpcFees, RpcResponseContext},
     };
     use clap::App;
-    use serde_json::{self, json, Value};
+    use serde_json::{self, json};
     use solana_account_decoder::{UiAccount, UiAccountEncoding};
     use solana_sdk::{account::Account, hash::hash, nonce, system_program};
     use std::collections::HashMap;
@@ -288,10 +288,12 @@ mod tests {
         let rpc_fee_calc = FeeCalculator::new(42);
         let get_recent_blockhash_response = json!(Response {
             context: RpcResponseContext { slot: 1 },
-            value: json!((
-                Value::String(rpc_blockhash.to_string()),
-                serde_json::to_value(rpc_fee_calc.clone()).unwrap()
-            )),
+            value: json!(RpcFees {
+                blockhash: rpc_blockhash.to_string(),
+                fee_calculator: rpc_fee_calc.clone(),
+                last_valid_slot: 42,
+                last_valid_block_height: 42,
+            }),
         });
         let get_fee_calculator_for_blockhash_response = json!(Response {
             context: RpcResponseContext { slot: 1 },
@@ -300,10 +302,7 @@ mod tests {
             }),
         });
         let mut mocks = HashMap::new();
-        mocks.insert(
-            RpcRequest::GetRecentBlockhash,
-            get_recent_blockhash_response.clone(),
-        );
+        mocks.insert(RpcRequest::GetFees, get_recent_blockhash_response.clone());
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
         assert_eq!(
             BlockhashQuery::default()
@@ -312,10 +311,7 @@ mod tests {
             (rpc_blockhash, rpc_fee_calc.clone()),
         );
         let mut mocks = HashMap::new();
-        mocks.insert(
-            RpcRequest::GetRecentBlockhash,
-            get_recent_blockhash_response.clone(),
-        );
+        mocks.insert(RpcRequest::GetFees, get_recent_blockhash_response.clone());
         mocks.insert(
             RpcRequest::GetFeeCalculatorForBlockhash,
             get_fee_calculator_for_blockhash_response,
@@ -328,10 +324,7 @@ mod tests {
             (test_blockhash, rpc_fee_calc),
         );
         let mut mocks = HashMap::new();
-        mocks.insert(
-            RpcRequest::GetRecentBlockhash,
-            get_recent_blockhash_response,
-        );
+        mocks.insert(RpcRequest::GetFees, get_recent_blockhash_response);
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
         assert_eq!(
             BlockhashQuery::None(test_blockhash)

client/src/mock_sender.rs

@@ -6,7 +6,7 @@ use {
         rpc_config::RpcBlockProductionConfig,
         rpc_request::RpcRequest,
         rpc_response::{
-            Response, RpcAccountBalance, RpcBlockProduction, RpcBlockProductionRange,
+            Response, RpcAccountBalance, RpcBlockProduction, RpcBlockProductionRange, RpcFees,
             RpcResponseContext, RpcSimulateTransactionResult, RpcStakeActivation, RpcSupply,
             RpcVersionInfo, RpcVoteAccountStatus, StakeActivationState,
         },
@@ -123,6 +123,16 @@ impl RpcSender for MockSender {
                 context: RpcResponseContext { slot: 1 },
                 value: serde_json::to_value(FeeRateGovernor::default()).unwrap(),
             })?,
+            "getFees" => serde_json::to_value(Response {
+                context: RpcResponseContext { slot: 1 },
+                value: serde_json::to_value(RpcFees {
+                    blockhash: PUBKEY.to_string(),
+                    fee_calculator: FeeCalculator::default(),
+                    last_valid_slot: 42,
+                    last_valid_block_height: 42,
+                })
+                .unwrap(),
+            })?,
             "getSignatureStatuses" => {
                 let status: transaction::Result<()> = if self.url == "account_in_use" {
                     Err(TransactionError::AccountInUse)