RPC: Add getFeeCalculatorForBlockhash method call (#8687)

Returns the `FeeCalculator` associated with the given blockhash, or
`null` if said blockhash has expired

client/src/mock_rpc_client_request.rs

@@ -71,6 +71,17 @@ impl GenericRpcClientRequest for MockRpcClientRequest {
                     serde_json::to_value(FeeCalculator::default()).unwrap(),
                 ),
             })?,
+            RpcRequest::GetFeeCalculatorForBlockhash => {
+                let value = if self.url == "blockhash_expired" {
+                    Value::Null
+                } else {
+                    serde_json::to_value(Some(FeeCalculator::default())).unwrap()
+                };
+                serde_json::to_value(Response {
+                    context: RpcResponseContext { slot: 1 },
+                    value,
+                })?
+            }
             RpcRequest::GetFeeRateGovernor => serde_json::to_value(Response {
                 context: RpcResponseContext { slot: 1 },
                 value: serde_json::to_value(FeeRateGovernor::default()).unwrap(),

client/src/rpc_client.rs

@@ -6,8 +6,8 @@ use crate::{
     rpc_request::RpcRequest,
     rpc_response::{
         Response, RpcAccount, RpcBlockhashFeeCalculator, RpcConfirmedBlock, RpcContactInfo,
-        RpcEpochInfo, RpcFeeRateGovernor, RpcIdentity, RpcKeyedAccount, RpcLeaderSchedule,
-        RpcResponse, RpcVersionInfo, RpcVoteAccountStatus,
+        RpcEpochInfo, RpcFeeCalculator, RpcFeeRateGovernor, RpcIdentity, RpcKeyedAccount,
+        RpcLeaderSchedule, RpcResponse, RpcVersionInfo, RpcVoteAccountStatus,
     },
 };
 use bincode::serialize;
@@ -839,6 +839,35 @@ impl RpcClient {
         })
     }
 
+    pub fn get_fee_calculator_for_blockhash(
+        &self,
+        blockhash: &Hash,
+    ) -> io::Result<Option<FeeCalculator>> {
+        let response = self
+            .client
+            .send(
+                &RpcRequest::GetFeeCalculatorForBlockhash,
+                json!([blockhash.to_string()]),
+                0,
+            )
+            .map_err(|e| {
+                io::Error::new(
+                    io::ErrorKind::Other,
+                    format!("GetFeeCalculatorForBlockhash request failure: {:?}", e),
+                )
+            })?;
+        let Response { value, .. } = serde_json::from_value::<Response<Option<RpcFeeCalculator>>>(
+            response,
+        )
+        .map_err(|e| {
+            io::Error::new(
+                io::ErrorKind::Other,
+                format!("GetFeeCalculatorForBlockhash parse failure: {:?}", e),
+            )
+        })?;
+        Ok(value.map(|rf| rf.fee_calculator))
+    }
+
     pub fn get_fee_rate_governor(&self) -> RpcResponse<FeeRateGovernor> {
         let response = self
             .client

client/src/rpc_request.rs

@@ -21,6 +21,7 @@ pub enum RpcRequest {
     GetNumBlocksSinceSignatureConfirmation,
     GetProgramAccounts,
     GetRecentBlockhash,
+    GetFeeCalculatorForBlockhash,
     GetFeeRateGovernor,
     GetSignatureStatus,
     GetSlot,
@@ -64,6 +65,7 @@ impl RpcRequest {
             }
             RpcRequest::GetProgramAccounts => "getProgramAccounts",
             RpcRequest::GetRecentBlockhash => "getRecentBlockhash",
+            RpcRequest::GetFeeCalculatorForBlockhash => "getFeeCalculatorForBlockhash",
             RpcRequest::GetFeeRateGovernor => "getFeeRateGovernor",
             RpcRequest::GetSignatureStatus => "getSignatureStatus",
             RpcRequest::GetSlot => "getSlot",
@@ -127,7 +129,7 @@ mod tests {
         assert_eq!(request["params"], json!([addr]));
 
         let test_request = RpcRequest::GetBalance;
-        let request = test_request.build_request_json(1, json!([addr]));
+        let request = test_request.build_request_json(1, json!([addr.clone()]));
         assert_eq!(request["method"], "getBalance");
 
         let test_request = RpcRequest::GetEpochInfo;
@@ -142,6 +144,10 @@ mod tests {
         let request = test_request.build_request_json(1, Value::Null);
         assert_eq!(request["method"], "getRecentBlockhash");
 
+        let test_request = RpcRequest::GetFeeCalculatorForBlockhash;
+        let request = test_request.build_request_json(1, json!([addr.clone()]));
+        assert_eq!(request["method"], "getFeeCalculatorForBlockhash");
+
         let test_request = RpcRequest::GetFeeRateGovernor;
         let request = test_request.build_request_json(1, Value::Null);
         assert_eq!(request["method"], "getFeeRateGovernor");

client/src/rpc_response.rs

@@ -152,6 +152,12 @@ pub struct RpcBlockhashFeeCalculator {
     pub fee_calculator: FeeCalculator,
 }
 
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcFeeCalculator {
+    pub fee_calculator: FeeCalculator,
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct RpcFeeRateGovernor {

client/src/thin_client.rs

@@ -445,6 +445,16 @@ impl SyncClient for ThinClient {
         }
     }
 
+    fn get_fee_calculator_for_blockhash(
+        &self,
+        blockhash: &Hash,
+    ) -> TransportResult<Option<FeeCalculator>> {
+        let fee_calculator = self
+            .rpc_client()
+            .get_fee_calculator_for_blockhash(blockhash)?;
+        Ok(fee_calculator)
+    }
+
     fn get_fee_rate_governor(&self) -> TransportResult<FeeRateGovernor> {
         let fee_rate_governor = self.rpc_client().get_fee_rate_governor()?;
         Ok(fee_rate_governor.value)