feat: Add block validation logic against validated transactions (in-memory)

CHANGELOG.md

@@ -13,6 +13,7 @@
 - The mempool's transaction capacity is now configurable ([#1433](https://github.com/0xMiden/miden-node/pull/1433)).
 - Renamed card's names in the `miden-network-monitor` binary ([#1441](https://github.com/0xMiden/miden-node/pull/1441)).
 - Integrated RPC stack with Validator component for transaction validation ([#1457](https://github.com/0xMiden/miden-node/pull/1457)).
+- Added validated transactions check to block validation logc in Validator ([#1460](https://github.com/0xMiden/miden-node/pull/1460)).
 
 ### Changes
 

crates/validator/src/block_validation/mod.rs

@@ -0,0 +1,60 @@
+use std::sync::Arc;
+
+use miden_lib::block::build_block;
+use miden_objects::ProposedBlockError;
+use miden_objects::block::{BlockNumber, BlockSigner, ProposedBlock};
+use miden_objects::crypto::dsa::ecdsa_k256_keccak::Signature;
+use miden_objects::transaction::TransactionId;
+
+use crate::server::ValidatedTransactions;
+
+// BLOCK VALIDATION ERROR
+// ================================================================================================
+
+#[derive(thiserror::Error, Debug)]
+pub enum BlockValidationError {
+    #[error("transaction {0} in block {1} has not been validated")]
+    TransactionNotValidated(TransactionId, BlockNumber),
+    #[error("failed to build block")]
+    BlockBuildingFailed(#[from] ProposedBlockError),
+}
+
+// BLOCK VALIDATION
+// ================================================================================================
+
+/// Validates a block by checking that all transactions in the proposed block have been processed by
+/// the validator in the past.
+///
+/// Removes the validated transactions from the cache upon success.
+pub async fn validate_block<S: BlockSigner>(
+    proposed_block: ProposedBlock,
+    signer: &S,
+    validated_transactions: Arc<ValidatedTransactions>,
+) -> Result<Signature, BlockValidationError> {
+    // Build the block.
+    let (header, body) = build_block(proposed_block)?;
+
+    // Check that all transactions in the proposed block have been validated
+    let validated_txs = validated_transactions.read().await;
+    for tx_header in body.transactions().as_slice() {
+        let tx_id = tx_header.id();
+        if !validated_txs.contains_key(&tx_id) {
+            return Err(BlockValidationError::TransactionNotValidated(tx_id, header.block_num()));
+        }
+    }
+    // Release the validated transactions read lock.
+    drop(validated_txs);
+
+    // Sign the header.
+    let signature = signer.sign(&header);
+
+    // Remove the validated transactions from the cache.
+    let mut validated_txs = validated_transactions.write().await;
+    for tx_header in body.transactions().as_slice() {
+        validated_txs.remove(&tx_header.id());
+    }
+    // Release the validated transactions write lock.
+    drop(validated_txs);
+
+    Ok(signature)
+}

crates/validator/src/lib.rs

@@ -1,3 +1,4 @@
+mod block_validation;
 mod server;
 mod tx_validation;
 

crates/validator/src/server/mod.rs

@@ -1,26 +1,37 @@
+use std::collections::HashMap;
 use std::net::SocketAddr;
+use std::sync::Arc;
 use std::time::Duration;
 
 use anyhow::Context;
-use miden_lib::block::build_block;
 use miden_node_proto::generated::validator::api_server;
 use miden_node_proto::generated::{self as proto};
 use miden_node_proto_build::validator_api_descriptor;
 use miden_node_utils::ErrorReport;
 use miden_node_utils::panic::catch_panic_layer_fn;
 use miden_node_utils::tracing::grpc::grpc_trace_fn;
 use miden_objects::block::{BlockSigner, ProposedBlock};
-use miden_objects::transaction::{ProvenTransaction, TransactionInputs};
+use miden_objects::transaction::{
+    ProvenTransaction,
+    TransactionHeader,
+    TransactionId,
+    TransactionInputs,
+};
 use miden_objects::utils::{Deserializable, Serializable};
 use tokio::net::TcpListener;
+use tokio::sync::RwLock;
 use tokio_stream::wrappers::TcpListenerStream;
 use tonic::Status;
 use tower_http::catch_panic::CatchPanicLayer;
 use tower_http::trace::TraceLayer;
 
 use crate::COMPONENT;
+use crate::block_validation::validate_block;
 use crate::tx_validation::validate_transaction;
 
+/// A type alias for a read-write lock that stores validated transactions.
+pub type ValidatedTransactions = RwLock<HashMap<TransactionId, TransactionHeader>>;
+
 // VALIDATOR
 // ================================================================================
 
@@ -70,7 +81,7 @@ impl<S: BlockSigner + Send + Sync + 'static> Validator<S> {
             .layer(CatchPanicLayer::custom(catch_panic_layer_fn))
             .layer(TraceLayer::new_for_grpc().make_span_with(grpc_trace_fn))
             .timeout(self.grpc_timeout)
-            .add_service(api_server::ApiServer::new(ValidatorServer { signer: self.signer }))
+            .add_service(api_server::ApiServer::new(ValidatorServer::new(self.signer)))
             .add_service(reflection_service)
             .add_service(reflection_service_alpha)
             .serve_with_incoming(TcpListenerStream::new(listener))
@@ -87,6 +98,14 @@ impl<S: BlockSigner + Send + Sync + 'static> Validator<S> {
 /// Implements the gRPC API for the validator.
 struct ValidatorServer<S> {
     signer: S,
+    validated_transactions: Arc<ValidatedTransactions>,
+}
+
+impl<S> ValidatorServer<S> {
+    fn new(signer: S) -> Self {
+        let validated_transactions = Arc::new(ValidatedTransactions::default());
+        Self { signer, validated_transactions }
+    }
 }
 
 #[tonic::async_trait]
@@ -123,9 +142,14 @@ impl<S: BlockSigner + Send + Sync + 'static> api_server::Api for ValidatorServer
         })?;
 
         // Validate the transaction.
-        validate_transaction(proven_tx, tx_inputs).await.map_err(|err| {
-            Status::invalid_argument(err.as_report_context("Invalid transaction"))
-        })?;
+        let validated_tx_header =
+            validate_transaction(proven_tx.clone(), tx_inputs).await.map_err(|err| {
+                Status::invalid_argument(err.as_report_context("Invalid transaction"))
+            })?;
+
+        // Register the validated transaction.
+        let tx_id = validated_tx_header.id();
+        self.validated_transactions.write().await.insert(tx_id, validated_tx_header);
 
         Ok(tonic::Response::new(()))
     }
@@ -145,10 +169,13 @@ impl<S: BlockSigner + Send + Sync + 'static> api_server::Api for ValidatorServer
                 ))
             })?;
 
-        // Build and sign header.
-        let (header, _body) = build_block(proposed_block)
-            .map_err(|err| tonic::Status::internal(format!("Failed to build block: {err}")))?;
-        let signature = self.signer.sign(&header);
+        // Validate the block.
+        let signature =
+            validate_block(proposed_block, &self.signer, self.validated_transactions.clone())
+                .await
+                .map_err(|err| {
+                    tonic::Status::invalid_argument(format!("Failed to validate block: {err}",))
+                })?;
 
         // Send the signature.
         let response = proto::blockchain::BlockSignature { signature: signature.to_bytes() };

crates/validator/src/tx_validation/mod.rs

@@ -27,10 +27,12 @@ pub enum TransactionValidationError {
 
 /// Validates a transaction by verifying its proof, executing it and comparing its header with the
 /// provided proven transaction.
+///
+/// Returns the header of the executed transaction if successful.
 pub async fn validate_transaction(
     proven_tx: ProvenTransaction,
     tx_inputs: TransactionInputs,
-) -> Result<(), TransactionValidationError> {
+) -> Result<TransactionHeader, TransactionValidationError> {
     // First, verify the transaction proof
     let tx_verifier = TransactionVerifier::new(MIN_PROOF_SECURITY_LEVEL);
     tx_verifier.verify(&proven_tx)?;
@@ -50,7 +52,7 @@ pub async fn validate_transaction(
     let executed_tx_header: TransactionHeader = (&executed_tx).into();
     let proven_tx_header: TransactionHeader = (&proven_tx).into();
     if executed_tx_header == proven_tx_header {
-        Ok(())
+        Ok(executed_tx_header)
     } else {
         Err(TransactionValidationError::Mismatch {
             proven_tx_header: proven_tx_header.into(),