0xMiden · bobbinth · Mar 28, 2026 · Mar 1, 2026 · Mar 1, 2026 · Mar 1, 2026
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -17,6 +17,7 @@
 - Introduce `SyncChainMmr` RPC endpoint to sync chain MMR deltas within specified block ranges ([#1591](https://github.com/0xMiden/node/issues/1591)).
 - Fixed `TransactionHeader` serialization for row insertion on database & fixed transaction cursor on retrievals ([#1701](https://github.com/0xMiden/node/issues/1701)).
 - Added KMS signing support in validator ([#1677](https://github.com/0xMiden/node/pull/1677)).
+- Added finality field for `SyncChainMmr` requests ([#1725](https://github.com/0xMiden/miden-node/pull/1725)).
 - Added per-IP gRPC rate limiting across services as well as global concurrent connection limit ([#1746](https://github.com/0xMiden/node/issues/1746)).
 - Added limit to execution cycles for a transaction network, configurable through CLI args (`--ntx-builder.max-tx-cycles`) ([#1801](https://github.com/0xMiden/node/issues/1801)).
 - Added monitor version and network name to the network monitor dashboard, network name is configurable via `--network-name` / `MIDEN_MONITOR_NETWORK_NAME` ([#1838](https://github.com/0xMiden/node/pull/1838)).

diff --git a/Cargo.lock b/Cargo.lock
diff --git a/bin/node/src/commands/bundled.rs b/bin/node/src/commands/bundled.rs
@@ -1,10 +1,11 @@
 use std::collections::HashMap;
+use std::num::NonZeroUsize;
 use std::path::PathBuf;
 
 use anyhow::Context;
 use miden_node_block_producer::BlockProducer;
 use miden_node_rpc::Rpc;
-use miden_node_store::Store;
+use miden_node_store::{DEFAULT_MAX_CONCURRENT_PROOFS, Store};
 use miden_node_utils::clap::{GrpcOptionsExternal, StorageOptions};
 use miden_node_utils::grpc::UrlExt;
 use miden_node_validator::{Validator, ValidatorSigner};
@@ -82,6 +83,14 @@ pub enum BundledCommand {
         #[arg(long = "enable-otel", default_value_t = false, env = ENV_ENABLE_OTEL, value_name = "BOOL")]
         enable_otel: bool,
 
+        /// Maximum number of concurrent block proofs to be scheduled.
+        #[arg(
+            long = "max-concurrent-proofs",
+            default_value_t = DEFAULT_MAX_CONCURRENT_PROOFS,
+            value_name = "NUM"
+        )]
+        max_concurrent_proofs: NonZeroUsize,
+
         #[command(flatten)]
         grpc_options: GrpcOptionsExternal,
 
@@ -125,6 +134,7 @@ impl BundledCommand {
                 validator,
                 enable_otel: _,
                 grpc_options,
+                max_concurrent_proofs,
                 storage_options,
             } => {
                 Self::start(
@@ -135,6 +145,7 @@ impl BundledCommand {
                     ntx_builder,
                     validator,
                     grpc_options,
+                    max_concurrent_proofs,
                     storage_options,
                 )
                 .await
@@ -151,6 +162,7 @@ impl BundledCommand {
         ntx_builder: NtxBuilderConfig,
         validator: BundledValidatorConfig,
         grpc_options: GrpcOptionsExternal,
+        max_concurrent_proofs: NonZeroUsize,
         storage_options: StorageOptions,
     ) -> anyhow::Result<()> {
         // Start listening on all gRPC urls so that inter-component connections can be created
@@ -209,6 +221,7 @@ impl BundledCommand {
                     data_directory: data_directory_clone,
                     block_prover_url,
                     grpc_options: grpc_options.into(),
+                    max_concurrent_proofs,
                     storage_options,
                 }
                 .serve()

diff --git a/bin/node/src/commands/store.rs b/bin/node/src/commands/store.rs
@@ -1,8 +1,9 @@
+use std::num::NonZeroUsize;
 use std::path::{Path, PathBuf};
 
 use anyhow::Context;
-use miden_node_store::Store;
 use miden_node_store::genesis::GenesisBlock;
+use miden_node_store::{DEFAULT_MAX_CONCURRENT_PROOFS, Store};
 use miden_node_utils::clap::{GrpcOptionsInternal, StorageOptions};
 use miden_node_utils::fs::ensure_empty_directory;
 use miden_node_utils::grpc::UrlExt;
@@ -65,6 +66,13 @@ pub enum StoreCommand {
         #[arg(long = "enable-otel", default_value_t = false, env = ENV_ENABLE_OTEL, value_name = "BOOL")]
         enable_otel: bool,
 
+        /// Maximum number of concurrent block proofs to be scheduled.
+        #[arg(
+            long = "max-concurrent-proofs",
+            default_value_t = DEFAULT_MAX_CONCURRENT_PROOFS,
+            value_name = "NUM"
+        )]
+        max_concurrent_proofs: NonZeroUsize,
         #[command(flatten)]
         grpc_options: GrpcOptionsInternal,
 
@@ -89,6 +97,7 @@ impl StoreCommand {
                 data_directory,
                 enable_otel: _,
                 grpc_options,
+                max_concurrent_proofs,
                 storage_options,
             } => {
                 Self::start(
@@ -98,6 +107,7 @@ impl StoreCommand {
                     block_prover_url,
                     data_directory,
                     grpc_options,
+                    max_concurrent_proofs,
                     storage_options,
                 )
                 .await
@@ -113,13 +123,15 @@ impl StoreCommand {
         }
     }
 
+    #[expect(clippy::too_many_arguments)]
     async fn start(
         rpc_url: Url,
         ntx_builder_url: Url,
         block_producer_url: Url,
         block_prover_url: Option<Url>,
         data_directory: PathBuf,
         grpc_options: GrpcOptionsInternal,
+        max_concurrent_proofs: NonZeroUsize,
         storage_options: StorageOptions,
     ) -> anyhow::Result<()> {
         let rpc_listener = rpc_url
@@ -150,6 +162,7 @@ impl StoreCommand {
             block_producer_listener,
             data_directory,
             grpc_options,
+            max_concurrent_proofs,
             storage_options,
         }
         .serve()
@@ -167,5 +180,5 @@ pub fn bootstrap_store(data_directory: &Path, genesis_block_path: &Path) -> anyh
     let genesis_block =
         GenesisBlock::try_from(proven_block).context("genesis block validation failed")?;
 
-    Store::bootstrap(&genesis_block, data_directory)
+    Store::bootstrap(genesis_block, data_directory)
 }
diff --git a/bin/stress-test/src/seeding/mod.rs b/bin/stress-test/src/seeding/mod.rs
@@ -95,13 +95,13 @@ pub async fn seed_store(
     let faucet = create_faucet();
     let fee_params = FeeParameters::new(faucet.id(), 0).unwrap();
     let signer = EcdsaSecretKey::new();
-    let genesis_state = GenesisState::new(vec![faucet.clone()], fee_params, 1, 1, signer);
+    let genesis_state = GenesisState::new(vec![faucet.clone()], fee_params, 1, 1, signer.clone());
     let genesis_block = genesis_state
         .clone()
         .into_block()
         .await
         .expect("genesis block should be created");
-    Store::bootstrap(&genesis_block, &data_directory).expect("store should bootstrap");
+    Store::bootstrap(genesis_block, &data_directory).expect("store should bootstrap");
 
     // start the store
     let (_, store_url) = start_store(data_directory.clone()).await;
@@ -120,6 +120,7 @@ pub async fn seed_store(
         &store_client,
         data_directory,
         accounts_filepath,
+        &signer,
     )
     .await;
 
@@ -131,6 +132,7 @@ pub async fn seed_store(
 ///
 /// The first transaction in each batch sends assets from the faucet to 255 accounts.
 /// The rest of the transactions consume the notes created by the faucet in the previous block.
+#[expect(clippy::too_many_arguments)]
 async fn generate_blocks(
     num_accounts: usize,
     public_accounts_percentage: u8,
@@ -139,6 +141,7 @@ async fn generate_blocks(
     store_client: &StoreClient,
     data_directory: DataDirectory,
     accounts_filepath: PathBuf,
+    signer: &EcdsaSecretKey,
 ) -> SeedingMetrics {
     // Each block is composed of [`BATCHES_PER_BLOCK`] batches, and each batch is composed of
     // [`TRANSACTIONS_PER_BATCH`] txs. The first note of the block is always a send assets tx
@@ -217,7 +220,8 @@ async fn generate_blocks(
         let block_inputs = get_block_inputs(store_client, &batches, &mut metrics).await;
 
         // update blocks
-        prev_block_header = apply_block(batches, block_inputs, store_client, &mut metrics).await;
+        prev_block_header =
+            apply_block(batches, block_inputs, store_client, &mut metrics, signer).await;
         if current_anchor_header.block_epoch() != prev_block_header.block_epoch() {
             current_anchor_header = prev_block_header.clone();
         }
@@ -252,11 +256,12 @@ async fn apply_block(
     block_inputs: BlockInputs,
     store_client: &StoreClient,
     metrics: &mut SeedingMetrics,
+    signer: &EcdsaSecretKey,
 ) -> BlockHeader {
     let proposed_block = ProposedBlock::new(block_inputs, batches).unwrap();
     let (header, body) = proposed_block.clone().into_header_and_body().unwrap();
     let block_size: usize = header.to_bytes().len() + body.to_bytes().len();
-    let signature = EcdsaSecretKey::new().sign(header.commitment());
+    let signature = signer.sign(header.commitment());
     // SAFETY: The header, body, and signature are known to correspond to each other.
     let signed_block = SignedBlock::new_unchecked(header, body, signature);
     let ordered_batches = proposed_block.batches().clone();
@@ -569,6 +574,7 @@ pub async fn start_store(
             block_producer_listener,
             data_directory: dir,
             grpc_options: GrpcOptionsInternal::bench(),
+            max_concurrent_proofs: miden_node_store::DEFAULT_MAX_CONCURRENT_PROOFS,
             storage_options: StorageOptions::bench(),
         }
         .serve()

diff --git a/bin/stress-test/src/store/mod.rs b/bin/stress-test/src/store/mod.rs
@@ -470,6 +470,7 @@ async fn sync_chain_mmr(
 ) -> SyncChainMmrRun {
     let sync_request = proto::rpc::SyncChainMmrRequest {
         block_range: Some(proto::rpc::BlockRange { block_from, block_to: Some(block_to) }),
+        finality: proto::rpc::Finality::Committed.into(),
     };
 
     let start = Instant::now();

diff --git a/crates/block-producer/src/server/tests.rs b/crates/block-producer/src/server/tests.rs
@@ -2,7 +2,7 @@ use std::num::NonZeroUsize;
 use std::time::Duration;
 
 use miden_node_proto::generated::block_producer::api_client as block_producer_client;
-use miden_node_store::{GenesisState, Store};
+use miden_node_store::{DEFAULT_MAX_CONCURRENT_PROOFS, GenesisState, Store};
 use miden_node_utils::clap::{GrpcOptionsInternal, StorageOptions};
 use miden_node_utils::fee::test_fee_params;
 use miden_node_validator::{Validator, ValidatorSigner};
@@ -136,7 +136,7 @@ async fn start_store(
         .into_block()
         .await
         .expect("genesis block should be created");
-    Store::bootstrap(&genesis_block, data_directory).expect("store should bootstrap");
+    Store::bootstrap(genesis_block, data_directory).expect("store should bootstrap");
 
     let dir = data_directory.to_path_buf();
     let rpc_listener =
@@ -159,6 +159,7 @@ async fn start_store(
             block_prover_url: None,
             data_directory: dir,
             grpc_options: GrpcOptionsInternal::bench(),
+            max_concurrent_proofs: DEFAULT_MAX_CONCURRENT_PROOFS,
             storage_options: StorageOptions::bench(),
         }
         .serve()

diff --git a/crates/rpc/src/tests.rs b/crates/rpc/src/tests.rs
@@ -7,8 +7,8 @@ use http::{HeaderMap, HeaderValue};
 use miden_node_proto::clients::{Builder, GrpcClient, Interceptor, RpcClient};
 use miden_node_proto::generated::rpc::api_client::ApiClient as ProtoClient;
 use miden_node_proto::generated::{self as proto};
-use miden_node_store::Store;
 use miden_node_store::genesis::config::GenesisConfig;
+use miden_node_store::{DEFAULT_MAX_CONCURRENT_PROOFS, Store};
 use miden_node_utils::clap::{GrpcOptionsExternal, GrpcOptionsInternal, StorageOptions};
 use miden_node_utils::fee::test_fee;
 use miden_node_utils::limiter::{
@@ -464,7 +464,7 @@ async fn start_store(store_listener: TcpListener) -> (Runtime, TempDir, Word, So
         .into_block()
         .await
         .expect("genesis block should be created");
-    Store::bootstrap(&genesis_block, data_directory.path()).expect("store should bootstrap");
+    Store::bootstrap(genesis_block, data_directory.path()).expect("store should bootstrap");
     let dir = data_directory.path().to_path_buf();
     let store_addr =
         store_listener.local_addr().expect("store listener should get a local address");
@@ -487,6 +487,7 @@ async fn start_store(store_listener: TcpListener) -> (Runtime, TempDir, Word, So
             block_producer_listener,
             data_directory: dir,
             grpc_options: GrpcOptionsInternal::test(),
+            max_concurrent_proofs: DEFAULT_MAX_CONCURRENT_PROOFS,
             storage_options: StorageOptions::default(),
         }
         .serve()
@@ -530,6 +531,7 @@ async fn restart_store(store_addr: SocketAddr, data_directory: &std::path::Path)
             block_producer_listener,
             data_directory: dir,
             grpc_options: GrpcOptionsInternal::test(),
+            max_concurrent_proofs: DEFAULT_MAX_CONCURRENT_PROOFS,
             storage_options: StorageOptions::default(),
         }
         .serve()
@@ -606,6 +608,7 @@ async fn sync_chain_mmr_returns_delta() {
 
     let request = proto::rpc::SyncChainMmrRequest {
         block_range: Some(proto::rpc::BlockRange { block_from: 0, block_to: None }),
+        finality: proto::rpc::Finality::Committed.into(),
     };
     let response = rpc_client.sync_chain_mmr(request).await.expect("sync_chain_mmr should succeed");
     let response = response.into_inner();

diff --git a/crates/store/Cargo.toml b/crates/store/Cargo.toml
@@ -21,7 +21,6 @@ deadpool-diesel                 = { features = ["sqlite"], version = "0.6" }
 diesel                          = { features = ["numeric", "sqlite"], version = "2.3" }
 diesel_migrations               = { features = ["sqlite"], version = "2.3" }
 fs-err                          = { workspace = true }
-futures                         = { workspace = true }
 hex                             = { version = "0.4" }
 indexmap                        = { workspace = true }
 libsqlite3-sys                  = { workspace = true }