refactor(proto): separate signing and proving requests

bin/validator/src/server/validator_service/sign_block.rs

@@ -1,7 +1,6 @@
 use std::sync::atomic::Ordering;
 
-use miden_node_proto::domain::protocol_config::ensure_protocol_config_is_present_and_matches_header;
-use miden_node_proto::{BlockProofRequest, generated as grpc};
+use miden_node_proto::{SignBlockRequest, generated as grpc};
 use miden_node_tracing::spawn::spawn_blocking_in_current_span;
 use miden_node_tracing::{ErrorReport, Instrument, info_span, miden_instrument};
 use miden_protocol::Word;
@@ -14,14 +13,14 @@ use crate::COMPONENT;
 
 #[tonic::async_trait]
 impl grpc::server::validator_api::SignBlock for ValidatorService {
-    type Input = grpc::block_proving::BlockProofRequest;
+    type Input = grpc::validator::SignBlockRequest;
     type Output = (Signature, Word, PublicKey);
 
     #[miden_instrument(
         target = COMPONENT,
         err,
     )]
-    fn decode(request: grpc::block_proving::BlockProofRequest) -> tonic::Result<Self::Input> {
+    fn decode(request: grpc::validator::SignBlockRequest) -> tonic::Result<Self::Input> {
         Ok(request)
     }
 
@@ -62,18 +61,8 @@ impl grpc::server::validator_api::SignBlock for ValidatorService {
 
         let (proposed_block, protocol_config, protocol_config_commitment) =
             spawn_blocking_in_current_span(move || {
-                let mut request = request;
-                let supplied_protocol_config = request.protocol_config.take();
-                let request = BlockProofRequest::try_from(request).map_err(tonic::Status::from)?;
-                let protocol_config = supplied_protocol_config
-                    .map(|config| {
-                        ensure_protocol_config_is_present_and_matches_header(
-                            Some(config),
-                            &request.block_header,
-                        )
-                    })
-                    .transpose()
-                    .map_err(tonic::Status::from)?;
+                let request = SignBlockRequest::try_from(request).map_err(tonic::Status::from)?;
+                let protocol_config = request.protocol_config;
                 let protocol_config_commitment = request.block_header.protocol_config_commitment();
                 let proposed_block = ProposedBlock::new_at(
                     request.block_inputs,

bin/validator/src/server/validator_service/tests.rs

@@ -1,12 +1,12 @@
 use std::collections::BTreeMap;
 
+use miden_node_proto::SignBlockRequest;
 use miden_node_proto::domain::encryption::{
     TransactionEncryptionScheme,
     TrustedTransactionEncryptionState,
     transaction_inputs_associated_data,
     verify_transaction_encryption_key,
 };
-use miden_node_proto::domain::proof_request::BlockProofRequest;
 use miden_node_proto::generated::{self as proto};
 use miden_node_proto::server::validator_api;
 use miden_node_store::{BlockStore, GenesisState};
@@ -184,13 +184,13 @@ impl TestValidator {
             BTreeMap::new(),
         );
         let (block_header, _) = proposed_block.clone().into_header_and_body().unwrap();
-        let mut request: proto::block_proving::BlockProofRequest = BlockProofRequest {
+        let request: proto::validator::SignBlockRequest = SignBlockRequest {
             tx_batches: OrderedBatches::new(proposed_block.batches().as_slice().to_vec()),
             block_header,
             block_inputs,
+            protocol_config: protocol_config.cloned(),
         }
         .into();
-        request.protocol_config = protocol_config.map(Into::into);
         let request = tonic::Request::new(request);
         validator_api::SignBlock::full(&self.server, request).await
     }

crates/block-producer/src/validator/mod.rs

@@ -95,7 +95,7 @@ impl BlockProducerValidatorClient {
         block_inputs: &BlockInputs,
         protocol_config: &ProtocolConfig,
     ) -> Result<Vec<SignBlockResponse>, ValidatorError> {
-        let message = proto::block_proving::BlockProofRequest {
+        let message = proto::validator::SignBlockRequest {
             protocol_config: Some(protocol_config.into()),
             batches: proposed_block.batches().as_slice().iter().map(Into::into).collect(),
             block_inputs: Some(block_inputs.into()),

crates/proto/src/domain/block_proposal.rs

@@ -0,0 +1,46 @@
+//! Shared decoding of block proposal fields.
+
+use miden_protocol::batch::{OrderedBatches, ProvenBatch};
+use miden_protocol::block::{BlockHeader, BlockInputs, ProposedBlock};
+
+use crate::errors::ConversionError;
+use crate::generated as proto;
+
+pub(super) struct DecodedBlockProposal {
+    pub tx_batches: OrderedBatches,
+    pub block_header: BlockHeader,
+    pub block_inputs: BlockInputs,
+}
+
+pub(super) fn decode(
+    block_inputs: proto::block_proving::BlockInputs,
+    batches: Vec<proto::transaction::ProvenBatch>,
+    timestamp: u32,
+    next_validator_config: proto::blockchain::ValidatorConfig,
+    next_protocol_config: Option<proto::blockchain::NextProtocolConfig>,
+) -> Result<DecodedBlockProposal, ConversionError> {
+    let block_inputs: BlockInputs = block_inputs.try_into()?;
+    let batches = batches
+        .into_iter()
+        .enumerate()
+        .map(|(index, batch)| {
+            miden_objects::conversion::decode_standalone_proven_batch(batch)
+                .map_err(|error| ConversionError::from(error.context(format!("batches[{index}]"))))
+        })
+        .collect::<Result<Vec<ProvenBatch>, _>>()?;
+    let next_validator_config = next_validator_config.try_into().map_err(ConversionError::from)?;
+    let next_protocol_config = next_protocol_config
+        .map(TryInto::try_into)
+        .transpose()
+        .map_err(ConversionError::from)?;
+    let proposed_block = ProposedBlock::new_at(block_inputs.clone(), batches.clone(), timestamp)
+        .map_err(ConversionError::new)?
+        .with_next_validator_config(next_validator_config)
+        .with_next_protocol_config(next_protocol_config);
+    let (block_header, _) = proposed_block.into_header_and_body().map_err(ConversionError::new)?;
+    Ok(DecodedBlockProposal {
+        tx_batches: OrderedBatches::new(batches),
+        block_header,
+        block_inputs,
+    })
+}

crates/proto/src/domain/mod.rs

@@ -1,8 +1,11 @@
+mod block_proposal;
+
 pub mod account;
 pub mod block;
 pub mod encryption;
 pub mod proof_request;
 pub mod protocol_config;
+pub mod sign_block_request;
 pub mod submission;
 
 use miden_node_tracing::{RecordAttribute, Value};

crates/proto/src/domain/proof_request.rs

@@ -1,10 +1,10 @@
 use std::collections::BTreeMap;
 
 use miden_protocol::account::AccountId;
-use miden_protocol::batch::{OrderedBatches, ProvenBatch};
+use miden_protocol::batch::OrderedBatches;
 use miden_protocol::block::account_tree::AccountWitness;
 use miden_protocol::block::nullifier_tree::NullifierWitness;
-use miden_protocol::block::{BlockHeader, BlockInputs, ProposedBlock};
+use miden_protocol::block::{BlockHeader, BlockInputs};
 use miden_protocol::note::{NoteId, NoteInclusionProof, Nullifier};
 use miden_protocol::transaction::PartialBlockchain;
 use miden_protocol::utils::serde::{
@@ -34,7 +34,6 @@ impl From<&BlockProofRequest> for proto::block_proving::BlockProofRequest {
             timestamp: value.block_header.timestamp(),
             next_validator_config: Some(value.block_header.validator_config().into()),
             next_protocol_config: value.block_header.next_protocol_config().map(Into::into),
-            protocol_config: None,
         }
     }
 }
@@ -49,53 +48,27 @@ impl TryFrom<proto::block_proving::BlockProofRequest> for BlockProofRequest {
     type Error = ConversionError;
 
     fn try_from(value: proto::block_proving::BlockProofRequest) -> Result<Self, Self::Error> {
-        let block_inputs: BlockInputs = value
-            .block_inputs
-            .ok_or_else(|| {
-                ConversionError::missing_field::<proto::block_proving::BlockProofRequest>(
-                    "block_inputs",
-                )
-            })?
-            .try_into()?;
-
-        let batches = value
-            .batches
-            .into_iter()
-            .enumerate()
-            .map(|(index, batch)| {
-                miden_objects::conversion::decode_standalone_proven_batch(batch).map_err(|error| {
-                    ConversionError::from(error.context(format!("batches[{index}]")))
-                })
-            })
-            .collect::<Result<Vec<ProvenBatch>, _>>()?;
-
-        let next_validator_config = value
-            .next_validator_config
-            .ok_or_else(|| {
-                ConversionError::missing_field::<proto::block_proving::BlockProofRequest>(
-                    "next_validator_config",
-                )
-            })?
-            .try_into()
-            .map_err(ConversionError::from)?;
-        let next_protocol_config = value
-            .next_protocol_config
-            .map(TryInto::try_into)
-            .transpose()
-            .map_err(ConversionError::from)?;
-
-        let proposed_block =
-            ProposedBlock::new_at(block_inputs.clone(), batches.clone(), value.timestamp)
-                .map_err(ConversionError::new)?
-                .with_next_validator_config(next_validator_config)
-                .with_next_protocol_config(next_protocol_config);
-        let (block_header, _) =
-            proposed_block.into_header_and_body().map_err(ConversionError::new)?;
-
-        Ok(Self {
-            tx_batches: OrderedBatches::new(batches),
-            block_header,
+        let block_inputs = value.block_inputs.ok_or_else(|| {
+            ConversionError::missing_field::<proto::block_proving::BlockProofRequest>(
+                "block_inputs",
+            )
+        })?;
+        let next_validator_config = value.next_validator_config.ok_or_else(|| {
+            ConversionError::missing_field::<proto::block_proving::BlockProofRequest>(
+                "next_validator_config",
+            )
+        })?;
+        let decoded = super::block_proposal::decode(
             block_inputs,
+            value.batches,
+            value.timestamp,
+            next_validator_config,
+            value.next_protocol_config,
+        )?;
+        Ok(Self {
+            tx_batches: decoded.tx_batches,
+            block_header: decoded.block_header,
+            block_inputs: decoded.block_inputs,
         })
     }
 }

crates/proto/src/domain/sign_block_request.rs

@@ -0,0 +1,74 @@
+//! Validator signing request conversions.
+
+use miden_protocol::batch::OrderedBatches;
+use miden_protocol::block::{BlockHeader, BlockInputs};
+use miden_protocol::protocol_config::ProtocolConfig;
+
+use super::protocol_config::ensure_protocol_config_is_present_and_matches_header;
+use crate::errors::ConversionError;
+use crate::generated as proto;
+
+/// The domain inputs needed to validate and sign a block.
+#[derive(Debug)]
+pub struct SignBlockRequest {
+    pub tx_batches: OrderedBatches,
+    pub block_header: BlockHeader,
+    pub block_inputs: BlockInputs,
+    pub protocol_config: Option<ProtocolConfig>,
+}
+
+impl TryFrom<proto::validator::SignBlockRequest> for SignBlockRequest {
+    type Error = ConversionError;
+
+    fn try_from(value: proto::validator::SignBlockRequest) -> Result<Self, Self::Error> {
+        let block_inputs = value.block_inputs.ok_or_else(|| {
+            ConversionError::missing_field::<proto::validator::SignBlockRequest>("block_inputs")
+        })?;
+        let next_validator_config = value.next_validator_config.ok_or_else(|| {
+            ConversionError::missing_field::<proto::validator::SignBlockRequest>(
+                "next_validator_config",
+            )
+        })?;
+        let decoded = super::block_proposal::decode(
+            block_inputs,
+            value.batches,
+            value.timestamp,
+            next_validator_config,
+            value.next_protocol_config,
+        )?;
+        let protocol_config = value
+            .protocol_config
+            .map(|config| {
+                ensure_protocol_config_is_present_and_matches_header(
+                    Some(config),
+                    &decoded.block_header,
+                )
+            })
+            .transpose()?;
+        Ok(Self {
+            tx_batches: decoded.tx_batches,
+            block_header: decoded.block_header,
+            block_inputs: decoded.block_inputs,
+            protocol_config,
+        })
+    }
+}
+
+impl From<&SignBlockRequest> for proto::validator::SignBlockRequest {
+    fn from(value: &SignBlockRequest) -> Self {
+        Self {
+            batches: value.tx_batches.as_slice().iter().map(Into::into).collect(),
+            block_inputs: Some((&value.block_inputs).into()),
+            timestamp: value.block_header.timestamp(),
+            next_validator_config: Some(value.block_header.validator_config().into()),
+            next_protocol_config: value.block_header.next_protocol_config().map(Into::into),
+            protocol_config: value.protocol_config.as_ref().map(Into::into),
+        }
+    }
+}
+
+impl From<SignBlockRequest> for proto::validator::SignBlockRequest {
+    fn from(value: SignBlockRequest) -> Self {
+        Self::from(&value)
+    }
+}

crates/proto/src/lib.rs

@@ -10,6 +10,7 @@ pub mod generated;
 // ================================================================================================
 
 pub use domain::proof_request::BlockProofRequest;
+pub use domain::sign_block_request::SignBlockRequest;
 pub use domain::submission::{ProvenTransactionSubmission, TransactionBatchSubmission};
 pub use domain::{convert, try_convert};
 pub use generated::server;