feat: Validator component

CHANGELOG.md

@@ -17,6 +17,7 @@
 - Added pagination to `SyncNotes` endpoint ([#1257](https://github.com/0xMiden/miden-node/pull/1257)).
 - Added application level error in gRPC endpoints ([#1266](https://github.com/0xMiden/miden-node/pull/1266)).
 - [BREAKING] Response type nuances of `GetAccountProof` in the public store API (#[1277](https://github.com/0xMiden/miden-node/pull/1277)).
+- Add `validator` crate with initial protobuf, gRPC server, and sub-command (#[1293](https://github.com/0xMiden/miden-node/pull/1293)).
 - Add optional `TransactionInputs` field to `SubmitProvenTransaction` endpoint for transaction re-execution (#[1278](https://github.com/0xMiden/miden-node/pull/1278)).
 
 ## v0.11.2 (2025-09-10)

Cargo.toml

@@ -13,6 +13,7 @@ members = [
   "crates/store",
   "crates/test-macro",
   "crates/utils",
+  "crates/validator",
   "proto",
 ]
 
@@ -44,6 +45,7 @@ miden-node-rpc              = { path = "crates/rpc", version = "0.12" }
 miden-node-store            = { path = "crates/store", version = "0.12" }
 miden-node-test-macro       = { path = "crates/test-macro" }
 miden-node-utils            = { path = "crates/utils", version = "0.12" }
+miden-node-validator        = { path = "crates/validator", version = "0.12" }
 miden-remote-prover-client  = { path = "crates/remote-prover-client", version = "0.12" }
 
 # miden-base aka protocol dependencies. These should be updated in sync.

bin/node/.env

@@ -1,6 +1,7 @@
 # For more info use -h on the relevant commands:
 # miden-node bundled start -h
 MIDEN_NODE_BLOCK_PRODUCER_URL=
+MIDEN_NODE_VALIDATOR_URL=
 MIDEN_NODE_NTX_BUILDER_URL=
 MIDEN_NODE_BATCH_PROVER_URL=
 MIDEN_NODE_BLOCK_PROVER_URL=

bin/node/Cargo.toml

@@ -27,6 +27,7 @@ miden-node-ntx-builder    = { workspace = true }
 miden-node-rpc            = { workspace = true }
 miden-node-store          = { workspace = true }
 miden-node-utils          = { workspace = true }
+miden-node-validator      = { workspace = true }
 miden-objects             = { workspace = true }
 tokio                     = { features = ["macros", "net", "rt-multi-thread"], workspace = true }
 url                       = { workspace = true }

bin/node/src/commands/bundled.rs

@@ -9,6 +9,7 @@ use miden_node_ntx_builder::NetworkTransactionBuilder;
 use miden_node_rpc::Rpc;
 use miden_node_store::Store;
 use miden_node_utils::grpc::UrlExt;
+use miden_node_validator::Validator;
 use tokio::net::TcpListener;
 use tokio::sync::Barrier;
 use tokio::task::JoinSet;
@@ -141,6 +142,12 @@ impl BundledCommand {
             .local_addr()
             .context("Failed to retrieve the block-producer's gRPC address")?;
 
+        let validator_address = TcpListener::bind("127.0.0.1:0")
+            .await
+            .context("Failed to bind to validator gRPC endpoint")?
+            .local_addr()
+            .context("Failed to retrieve the validator's gRPC address")?;
+
         // Store addresses for each exposed API
         let store_rpc_listener = TcpListener::bind("127.0.0.1:0")
             .await
@@ -213,6 +220,17 @@ impl BundledCommand {
             })
             .id();
 
+        let validator_id = join_set
+            .spawn({
+                async move {
+                    Validator { address: validator_address, grpc_timeout }
+                        .serve()
+                        .await
+                        .context("failed while serving validator component")
+                }
+            })
+            .id();
+
         // Start RPC component.
         let rpc_id = join_set
             .spawn(async move {
@@ -236,6 +254,7 @@ impl BundledCommand {
         let mut component_ids = HashMap::from([
             (store_id, "store"),
             (block_producer_id, "block-producer"),
+            (validator_id, "validator"),
             (rpc_id, "rpc"),
         ]);
 

bin/node/src/commands/mod.rs

@@ -7,8 +7,10 @@ pub mod block_producer;
 pub mod bundled;
 pub mod rpc;
 pub mod store;
+pub mod validator;
 
 const ENV_BLOCK_PRODUCER_URL: &str = "MIDEN_NODE_BLOCK_PRODUCER_URL";
+const ENV_VALIDATOR_URL: &str = "MIDEN_NODE_VALIDATOR_URL";
 const ENV_BATCH_PROVER_URL: &str = "MIDEN_NODE_BATCH_PROVER_URL";
 const ENV_BLOCK_PROVER_URL: &str = "MIDEN_NODE_BLOCK_PROVER_URL";
 const ENV_NTX_PROVER_URL: &str = "MIDEN_NODE_NTX_PROVER_URL";

bin/node/src/commands/validator.rs

@@ -0,0 +1,58 @@
+use std::time::Duration;
+
+use anyhow::Context;
+use miden_node_utils::grpc::UrlExt;
+use miden_node_validator::Validator;
+use url::Url;
+
+use crate::commands::{
+    DEFAULT_TIMEOUT,
+    ENV_ENABLE_OTEL,
+    ENV_VALIDATOR_URL,
+    duration_to_human_readable_string,
+};
+
+#[derive(clap::Subcommand)]
+pub enum ValidatorCommand {
+    /// Starts the validator component.
+    Start {
+        /// Url at which to serve the gRPC API.
+        #[arg(env = ENV_VALIDATOR_URL)]
+        url: Url,
+
+        /// Enables the exporting of traces for OpenTelemetry.
+        ///
+        /// This can be further configured using environment variables as defined in the official
+        /// OpenTelemetry documentation. See our operator manual for further details.
+        #[arg(long = "enable-otel", default_value_t = true, env = ENV_ENABLE_OTEL, value_name = "BOOL")]
+        enable_otel: bool,
+
+        /// Maximum duration a gRPC request is allocated before being dropped by the server.
+        #[arg(
+            long = "grpc.timeout",
+            default_value = &duration_to_human_readable_string(DEFAULT_TIMEOUT),
+            value_parser = humantime::parse_duration,
+            value_name = "DURATION"
+        )]
+        grpc_timeout: Duration,
+    },
+}
+
+impl ValidatorCommand {
+    pub async fn handle(self) -> anyhow::Result<()> {
+        let Self::Start { url, grpc_timeout, .. } = self;
+
+        let address =
+            url.to_socket().context("Failed to extract socket address from validator URL")?;
+
+        Validator { address, grpc_timeout }
+            .serve()
+            .await
+            .context("failed while serving validator component")
+    }
+
+    pub fn is_open_telemetry_enabled(&self) -> bool {
+        let Self::Start { enable_otel, .. } = self;
+        *enable_otel
+    }
+}

bin/node/src/main.rs

@@ -32,6 +32,10 @@ pub enum Command {
     #[command(subcommand)]
     BlockProducer(commands::block_producer::BlockProducerCommand),
 
+    // Commands related to the node's validator component.
+    #[command(subcommand)]
+    Validator(commands::validator::ValidatorCommand),
+
     /// Commands relevant to running all components in the same process.
     ///
     /// This is the recommended way to run the node at the moment.
@@ -48,6 +52,7 @@ impl Command {
             Command::Store(subcommand) => subcommand.is_open_telemetry_enabled(),
             Command::Rpc(subcommand) => subcommand.is_open_telemetry_enabled(),
             Command::BlockProducer(subcommand) => subcommand.is_open_telemetry_enabled(),
+            Command::Validator(subcommand) => subcommand.is_open_telemetry_enabled(),
             Command::Bundled(subcommand) => subcommand.is_open_telemetry_enabled(),
         } {
             OpenTelemetry::Enabled
@@ -61,6 +66,7 @@ impl Command {
             Command::Rpc(rpc_command) => rpc_command.handle().await,
             Command::Store(store_command) => store_command.handle().await,
             Command::BlockProducer(block_producer_command) => block_producer_command.handle().await,
+            Command::Validator(validator) => validator.handle().await,
             Command::Bundled(node) => node.handle().await,
         }
     }

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

@@ -75,8 +75,8 @@ pub struct BlockProducer {
 impl BlockProducer {
     /// Serves the block-producer RPC API, the batch-builder and the block-builder.
     ///
-    /// Note: Executes in place (i.e. not spawned) and will run indefinitely until
-    ///       a fatal error is encountered.
+    /// Executes in place (i.e. not spawned) and will run indefinitely until a fatal error is
+    /// encountered.
     #[allow(clippy::too_many_lines)]
     pub async fn serve(self) -> anyhow::Result<()> {
         info!(target: COMPONENT, endpoint=?self.block_producer_address, store=%self.store_url, "Initializing server");

crates/proto/build.rs

@@ -10,6 +10,7 @@ use miden_node_proto_build::{
     store_ntx_builder_api_descriptor,
     store_rpc_api_descriptor,
     store_shared_api_descriptor,
+    validator_api_descriptor,
 };
 use miette::{Context, IntoDiagnostic};
 use tonic_build::FileDescriptorSet;
@@ -46,6 +47,7 @@ fn main() -> miette::Result<()> {
     generate_bindings(store_shared_api_descriptor(), &dst_dir)?;
     generate_bindings(block_producer_api_descriptor(), &dst_dir)?;
     generate_bindings(remote_prover_api_descriptor(), &dst_dir)?;
+    generate_bindings(validator_api_descriptor(), &dst_dir)?;
 
     generate_mod_rs(&dst_dir).into_diagnostic().wrap_err("generating mod.rs")?;
 

crates/proto/src/generated/mod.rs

@@ -13,3 +13,4 @@ pub mod rpc;
 pub mod rpc_store;
 pub mod shared;
 pub mod transaction;
+pub mod validator;