Update fee api to use blockhash (#21054)

cli/src/checks.rs

@@ -65,7 +65,7 @@ pub fn check_account_for_spend_multiple_fees_with_commitment(
     messages: &[&Message],
     commitment: CommitmentConfig,
 ) -> Result<(), CliError> {
-    let fee = get_fee_for_message(rpc_client, messages)?;
+    let fee = get_fee_for_messages(rpc_client, messages)?;
     if !check_account_for_balance_with_commitment(
         rpc_client,
         account_pubkey,
@@ -90,10 +90,16 @@ pub fn check_account_for_spend_multiple_fees_with_commitment(
     Ok(())
 }
 
-pub fn get_fee_for_message(rpc_client: &RpcClient, messages: &[&Message]) -> Result<u64, CliError> {
+pub fn get_fee_for_messages(
+    rpc_client: &RpcClient,
+    messages: &[&Message],
+) -> Result<u64, CliError> {
     Ok(messages
         .iter()
-        .map(|message| rpc_client.get_fee_for_message(message))
+        .map(|message| {
+            println!("msg {:?}", message.recent_blockhash);
+            rpc_client.get_fee_for_message(message)
+        })
         .collect::<Result<Vec<_>, _>>()?
         .iter()
         .sum())
@@ -235,7 +241,7 @@ mod tests {
     }
 
     #[test]
-    fn test_get_fee_for_message() {
+    fn test_get_fee_for_messages() {
         let check_fee_response = json!(Response {
             context: RpcResponseContext { slot: 1 },
             value: json!(1),
@@ -245,14 +251,14 @@ mod tests {
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
 
         // No messages, no fee.
-        assert_eq!(get_fee_for_message(&rpc_client, &[]).unwrap(), 0);
+        assert_eq!(get_fee_for_messages(&rpc_client, &[]).unwrap(), 0);
 
         // One message w/ one signature, a fee.
         let pubkey0 = Pubkey::new(&[0; 32]);
         let pubkey1 = Pubkey::new(&[1; 32]);
         let ix0 = system_instruction::transfer(&pubkey0, &pubkey1, 1);
         let message0 = Message::new(&[ix0], Some(&pubkey0));
-        assert_eq!(get_fee_for_message(&rpc_client, &[&message0]).unwrap(), 1);
+        assert_eq!(get_fee_for_messages(&rpc_client, &[&message0]).unwrap(), 1);
 
         // No signatures, no fee.
         let check_fee_response = json!(Response {
@@ -264,7 +270,7 @@ mod tests {
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
         let message = Message::default();
         assert_eq!(
-            get_fee_for_message(&rpc_client, &[&message, &message]).unwrap(),
+            get_fee_for_messages(&rpc_client, &[&message, &message]).unwrap(),
             0
         );
     }

cli/src/program.rs

@@ -1710,6 +1710,7 @@ fn do_process_program_write_and_deploy(
 ) -> ProcessResult {
     // Build messages to calculate fees
     let mut messages: Vec<&Message> = Vec::new();
+    let blockhash = rpc_client.get_latest_blockhash()?;
 
     // Initialize buffer account or complete if already partially initialized
     let (initial_message, write_messages, balance_needed) =
@@ -1755,9 +1756,10 @@ fn do_process_program_write_and_deploy(
                 )
             };
             let initial_message = if !initial_instructions.is_empty() {
-                Some(Message::new(
+                Some(Message::new_with_blockhash(
                     &initial_instructions,
                     Some(&config.signers[0].pubkey()),
+                    &blockhash,
                 ))
             } else {
                 None
@@ -1777,7 +1779,7 @@ fn do_process_program_write_and_deploy(
                 } else {
                     loader_instruction::write(buffer_pubkey, loader_id, offset, bytes)
                 };
-                Message::new(&[instruction], Some(&payer_pubkey))
+                Message::new_with_blockhash(&[instruction], Some(&payer_pubkey), &blockhash)
             };
 
             let mut write_messages = vec![];
@@ -1806,7 +1808,7 @@ fn do_process_program_write_and_deploy(
 
     let final_message = if let Some(program_signers) = program_signers {
         let message = if loader_id == &bpf_loader_upgradeable::id() {
-            Message::new(
+            Message::new_with_blockhash(
                 &bpf_loader_upgradeable::deploy_with_max_program_len(
                     &config.signers[0].pubkey(),
                     &program_signers[0].pubkey(),
@@ -1818,11 +1820,13 @@ fn do_process_program_write_and_deploy(
                     programdata_len,
                 )?,
                 Some(&config.signers[0].pubkey()),
+                &blockhash,
             )
         } else {
-            Message::new(
+            Message::new_with_blockhash(
                 &[loader_instruction::finalize(buffer_pubkey, loader_id)],
                 Some(&config.signers[0].pubkey()),
+                &blockhash,
             )
         };
         Some(message)
@@ -1876,6 +1880,7 @@ fn do_process_program_upgrade(
 
     // Build messages to calculate fees
     let mut messages: Vec<&Message> = Vec::new();
+    let blockhash = rpc_client.get_latest_blockhash()?;
 
     let (initial_message, write_messages, balance_needed) =
         if let Some(buffer_signer) = buffer_signer {
@@ -1907,9 +1912,10 @@ fn do_process_program_upgrade(
             };
 
             let initial_message = if !initial_instructions.is_empty() {
-                Some(Message::new(
+                Some(Message::new_with_blockhash(
                     &initial_instructions,
                     Some(&config.signers[0].pubkey()),
+                    &blockhash,
                 ))
             } else {
                 None
@@ -1925,7 +1931,7 @@ fn do_process_program_upgrade(
                     offset,
                     bytes,
                 );
-                Message::new(&[instruction], Some(&payer_pubkey))
+                Message::new_with_blockhash(&[instruction], Some(&payer_pubkey), &blockhash)
             };
 
             // Create and add write messages
@@ -1952,7 +1958,7 @@ fn do_process_program_upgrade(
     }
 
     // Create and add final message
-    let final_message = Message::new(
+    let final_message = Message::new_with_blockhash(
         &[bpf_loader_upgradeable::upgrade(
             program_id,
             buffer_pubkey,
@@ -1960,6 +1966,7 @@ fn do_process_program_upgrade(
             &config.signers[0].pubkey(),
         )],
         Some(&config.signers[0].pubkey()),
+        &blockhash,
     );
     messages.push(&final_message);
 

cli/src/spend_utils.rs

@@ -1,5 +1,5 @@
 use crate::{
-    checks::{check_account_for_balance_with_commitment, get_fee_for_message},
+    checks::{check_account_for_balance_with_commitment, get_fee_for_messages},
     cli::CliError,
 };
 use clap::ArgMatches;
@@ -144,9 +144,10 @@ where
     F: Fn(u64) -> Message,
 {
     let fee = match blockhash {
-        Some(_) => {
-            let dummy_message = build_message(0);
-            get_fee_for_message(rpc_client, &[&dummy_message])?
+        Some(blockhash) => {
+            let mut dummy_message = build_message(0);
+            dummy_message.recent_blockhash = *blockhash;
+            get_fee_for_messages(rpc_client, &[&dummy_message])?
         }
         None => 0, // Offline, cannot calulate fee
     };