Moves out block proposal validation to its own fn

zebra-rpc/src/methods/get_block_template_rpcs.rs

@@ -26,9 +26,8 @@ use crate::methods::{
             DEFAULT_SOLUTION_RATE_WINDOW_SIZE, GET_BLOCK_TEMPLATE_MEMPOOL_LONG_POLL_INTERVAL,
         },
         get_block_template::{
-            check_get_block_template_parameters, check_miner_address, check_synced_to_tip,
-            fetch_mempool_transactions, fetch_state_tip_and_local_time,
-            generate_coinbase_and_roots,
+            check_miner_address, check_synced_to_tip, fetch_mempool_transactions,
+            fetch_state_tip_and_local_time, generate_coinbase_and_roots, validate_block_proposal,
         },
         types::{
             get_block_template::GetBlockTemplate, get_mining_info, hex_data::HexData,
@@ -331,43 +330,23 @@ where
         let mut latest_chain_tip = self.latest_chain_tip.clone();
         let sync_status = self.sync_status.clone();
         let state = self.state.clone();
-        let mut chain_verifier = self.chain_verifier.clone();
+        let chain_verifier = self.chain_verifier.clone();
 
         // To implement long polling correctly, we split this RPC into multiple phases.
         async move {
-            check_get_block_template_parameters(&parameters)?;
-
-            let client_long_poll_id = parameters
-                .as_mut()
-                .and_then(|params| params.long_poll_id.take());
+            get_block_template::check_parameters(&parameters)?;
 
             if let Some(HexData(block_proposal_bytes)) = parameters
                 .as_mut()
                 .and_then(get_block_template::JsonParameters::block_proposal_data)
             {
-                let block: Block = match block_proposal_bytes.zcash_deserialize_into() {
-                    Ok(block_bytes) => block_bytes,
-                    Err(_) => return Ok(get_block_template::ProposalRejectReason::Rejected.into()),
-                };
-
-                let chain_verifier_response = chain_verifier
-                    .ready()
-                    .await
-                    .map_err(|error| Error {
-                        code: ErrorCode::ServerError(0),
-                        message: error.to_string(),
-                        data: None,
-                    })?
-                    .call(zebra_consensus::Request::CheckProposal(Arc::new(block)))
-                    .await;
-
-                let response = chain_verifier_response
-                    .map(|_| get_block_template::ProposalResponse::Valid)
-                    .unwrap_or_else(|_| get_block_template::ProposalRejectReason::Rejected.into());
-
-                return Ok(response.into());
+                return validate_block_proposal(chain_verifier, block_proposal_bytes).await;
             }
 
+            let client_long_poll_id = parameters
+                .as_mut()
+                .and_then(|params| params.long_poll_id.take());
+
             // - One-off checks
 
             // Check config and parameters.

zebra-rpc/src/methods/get_block_template_rpcs/get_block_template.rs

@@ -8,12 +8,14 @@ use tower::{Service, ServiceExt};
 use zebra_chain::{
     amount::{self, Amount, NegativeOrZero, NonNegative},
     block::{
+        self,
         merkle::{self, AuthDataRoot},
         ChainHistoryBlockTxAuthCommitmentHash, Height,
     },
     chain_sync_status::ChainSyncStatus,
     chain_tip::ChainTip,
     parameters::Network,
+    serialization::ZcashDeserializeInto,
     transaction::{Transaction, UnminedTx, VerifiedUnminedTx},
     transparent,
 };
@@ -35,7 +37,7 @@ pub use crate::methods::get_block_template_rpcs::types::get_block_template::*;
 /// Checks that `data` is omitted in `Template` mode or provided in `Proposal` mode,
 ///
 /// Returns an error if there's a mismatch between the mode and whether `data` is provided.
-pub fn check_get_block_template_parameters(parameters: &Option<JsonParameters>) -> Result<()> {
+pub fn check_parameters(parameters: &Option<JsonParameters>) -> Result<()> {
     let Some(parameters) = parameters else {
             return Ok(())
         };
@@ -91,6 +93,42 @@ pub fn check_miner_address(
     })
 }
 
+/// Attempts to validate block proposal against all of the server's
+/// usual acceptance rules (except proof-of-work).
+///
+/// Returns a `getblocktemplate` [`Response`].
+pub async fn validate_block_proposal<ChainVerifier>(
+    mut chain_verifier: ChainVerifier,
+    block_proposal_bytes: Vec<u8>,
+) -> Result<Response>
+where
+    ChainVerifier: Service<zebra_consensus::Request, Response = block::Hash, Error = zebra_consensus::BoxError>
+        + Clone
+        + Send
+        + Sync
+        + 'static,
+{
+    let Ok(block) = block_proposal_bytes.zcash_deserialize_into() else {
+         return Ok(ProposalRejectReason::Rejected.into())
+    };
+
+    let chain_verifier_response = chain_verifier
+        .ready()
+        .await
+        .map_err(|error| Error {
+            code: ErrorCode::ServerError(0),
+            message: error.to_string(),
+            data: None,
+        })?
+        .call(zebra_consensus::Request::CheckProposal(Arc::new(block)))
+        .await;
+
+    Ok(chain_verifier_response
+        .map(|_| ProposalResponse::Valid)
+        .unwrap_or_else(|_| ProposalRejectReason::Rejected.into())
+        .into())
+}
+
 // - State and syncer checks
 
 /// Returns an error if Zebra is not synced to the consensus chain tip.