0xMiden · kkovaacs · Sep 29, 2026 · Sep 25, 2026
diff --git a/bin/benchmark/src/inclusion.rs b/bin/benchmark/src/inclusion.rs
@@ -11,7 +11,7 @@ use std::collections::HashMap;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use miden_node_proto::clients::RpcClient;
-use miden_node_proto::generated::rpc::BlockHeaderByNumberRequest;
+use miden_node_proto::generated::rpc::GetBlockHeaderByNumberRequest;
 use miden_node_proto::{DecodeMessageExt, generated as proto};
 use miden_protocol::block::BlockHeader;
 use miden_protocol::transaction::TransactionId;
@@ -110,7 +110,7 @@ pub(crate) async fn scan_with_drain(
         // Scan every unwatched block, capped at the max-bound target.
         let scan_to = tip.min(max_target);
         while next_block <= scan_to {
-            let request = proto::rpc::BlockRequest {
+            let request = proto::rpc::GetBlockByNumberRequest {
                 block_num: next_block,
                 include_proof: None,
             };
@@ -217,7 +217,7 @@ pub(crate) async fn scan_with_drain(
 
 pub(crate) async fn current_block_height(mut client: RpcClient) -> u32 {
     let response = client
-        .get_block_header_by_number(BlockHeaderByNumberRequest {
+        .get_block_header_by_number(GetBlockHeaderByNumberRequest {
             block_num: None,
             include_mmr_proof: None,
             include_protocol_config: None,

diff --git a/bin/benchmark/src/main.rs b/bin/benchmark/src/main.rs
@@ -13,7 +13,7 @@ use miden_node_proto::domain::encryption::{
     TransactionInputsSealer,
     TrustedTransactionEncryptionState,
 };
-use miden_node_proto::generated::rpc::BlockHeaderByNumberRequest;
+use miden_node_proto::generated::rpc::GetBlockHeaderByNumberRequest;
 use miden_node_proto::{DecodeMessageExt, VerifyWith};
 use miden_protocol::Word;
 use miden_protocol::block::{BlockHeader, BlockNumber};
@@ -222,10 +222,14 @@ pub(crate) async fn create_genesis_aware_rpc_client_pool(
     }
     let key = pool[0]
         .clone()
-        .get_transaction_encryption_key(())
+        .get_transaction_encryption_key(
+            miden_node_proto::generated::rpc::GetTransactionEncryptionKeyRequest {},
+        )
         .await
         .context("Failed to fetch the transaction encryption key")?
-        .into_inner();
+        .into_inner()
+        .key
+        .ok_or_else(|| tonic::Status::internal("missing transaction encryption key"))?;
     let trusted_keys = [trusted_validator_signing_key];
     let verified = key
         .verify_with(TrustedTransactionEncryptionState::new(genesis, &trusted_keys))
@@ -234,8 +238,8 @@ pub(crate) async fn create_genesis_aware_rpc_client_pool(
     Ok((pool, TransactionInputsSealer::new(verified)))
 }
 
-pub(crate) fn get_genesis_header_request() -> BlockHeaderByNumberRequest {
-    BlockHeaderByNumberRequest {
+pub(crate) fn get_genesis_header_request() -> GetBlockHeaderByNumberRequest {
+    GetBlockHeaderByNumberRequest {
         block_num: Some(BlockNumber::GENESIS.as_u32()),
         include_mmr_proof: None,
         include_protocol_config: None,

diff --git a/bin/benchmark/src/prover.rs b/bin/benchmark/src/prover.rs
@@ -16,8 +16,8 @@ use std::time::{Duration, Instant};
 use anyhow::{Context, Result};
 use miden_node_proto::clients::{Builder, RemoteProverClient};
 use miden_node_proto::errors::ConversionError;
-use miden_node_proto::generated::remote_prover::proof_request::Request;
-use miden_node_proto::generated::remote_prover::{DecodedProof, ProofRequest};
+use miden_node_proto::generated::remote_prover::prove_request::Request;
+use miden_node_proto::generated::remote_prover::{DecodedProveResponse, ProveRequest};
 use miden_node_proto::{BuildUnchecked, DecodeMessage};
 use miden_node_tracing::spawn::spawn_blocking_in_current_span;
 use miden_protocol::transaction::{ExecutedTransaction, ProvenTransaction, TransactionInputs};
@@ -200,7 +200,7 @@ impl RemoteTransactionProver {
         &self,
         tx_inputs: &TransactionInputs,
     ) -> Result<ProvenTransaction, TransactionProverError> {
-        let request = tonic::Request::new(ProofRequest {
+        let request = tonic::Request::new(ProveRequest {
             request: Some(Request::Transaction(tx_inputs.into())),
         });
 
@@ -211,7 +211,7 @@ impl RemoteTransactionProver {
         response
             .into_inner()
             .decode_fields()
-            .and_then(DecodedProof::into_transaction)
+            .and_then(DecodedProveResponse::into_transaction)
             // SAFETY: This benchmark trusts the configured prover to return a valid proof for the
             // requested transaction.
             .and_then(|transaction| transaction.build_unchecked().map_err(ConversionError::new))

diff --git a/bin/benchmark/src/submit.rs b/bin/benchmark/src/submit.rs
@@ -224,7 +224,10 @@ async fn submit_all(
                 sealed_transaction_inputs: Some(sealed_inputs),
             };
             let t0 = Instant::now();
-            let outcome = match client.submit_proven_tx(request).await {
+            let outcome = match client
+                .submit_proven_tx(proto::rpc::SubmitProvenTxRequest { submission: Some(request) })
+                .await
+            {
                 Ok(_) => SubmitOutcome {
                     index: i,
                     result: Ok(t0.elapsed()),
@@ -285,7 +288,10 @@ async fn submit_sequential(
         };
 
         let t0 = Instant::now();
-        let outcome = match client.submit_proven_tx(request).await {
+        let outcome = match client
+            .submit_proven_tx(proto::rpc::SubmitProvenTxRequest { submission: Some(request) })
+            .await
+        {
             Ok(_) => SubmitOutcome {
                 index: i,
                 result: Ok(t0.elapsed()),

diff --git a/bin/funding-service/src/node.rs b/bin/funding-service/src/node.rs
@@ -14,13 +14,13 @@ use miden_node_proto::domain::encryption::{
     TrustedTransactionEncryptionState,
 };
 use miden_node_proto::domain::protocol_config::ensure_protocol_config_is_present_and_matches_header;
-use miden_node_proto::generated::rpc::account_request::AccountDetailRequest;
+use miden_node_proto::generated::rpc::get_account_request::AccountDetailRequest;
 use miden_node_proto::generated::rpc::{
-    AccountRequest as ProtoAccountRequest,
-    BlockHeaderByNumberRequest,
     BlockRange,
     FinalityLevel,
-    NotesByIdRequest,
+    GetAccountRequest as ProtoAccountRequest,
+    GetBlockHeaderByNumberRequest,
+    GetNotesByIdRequest,
     SyncChainMmrRequest,
     SyncNotesRequest,
     SyncNullifiersRequest,
@@ -248,7 +248,7 @@ impl RpcNodeClient {
             let response = self
                 .rpc_client
                 .clone()
-                .get_notes_by_id(NotesByIdRequest { note_ids })
+                .get_notes_by_id(GetNotesByIdRequest { note_ids })
                 .await
                 .context("failed to fetch notes from RPC")?
                 .into_inner();
@@ -389,7 +389,7 @@ impl RpcNodeClient {
         let status = self
             .rpc_client
             .clone()
-            .status(())
+            .status(miden_node_proto::generated::rpc::StatusRequest {})
             .await
             .context("failed to fetch the node status")?
             .into_inner();
@@ -412,7 +412,13 @@ impl RpcNodeClient {
             transaction: Some(proven_tx.into()),
             sealed_transaction_inputs: Some(sealed),
         };
-        let result = self.rpc_client.clone().submit_proven_tx(request).await;
+        let result = self
+            .rpc_client
+            .clone()
+            .submit_proven_tx(miden_node_proto::generated::rpc::SubmitProvenTxRequest {
+                submission: Some(request),
+            })
+            .await;
 
         if result.is_err() {
             // The encryption key can be stale. Fetch it again for the next submission.
@@ -434,10 +440,14 @@ impl RpcNodeClient {
         let key = self
             .rpc_client
             .clone()
-            .get_transaction_encryption_key(())
+            .get_transaction_encryption_key(
+                miden_node_proto::generated::rpc::GetTransactionEncryptionKeyRequest {},
+            )
             .await
             .context("failed to fetch the transaction encryption key")?
-            .into_inner();
+            .into_inner()
+            .key
+            .ok_or_else(|| tonic::Status::internal("missing transaction encryption key"))?;
         let verified = key
             .verify_with(TrustedTransactionEncryptionState::new(
                 self.genesis_commitment,
@@ -577,7 +587,7 @@ async fn fetch_block_header(
     rpc_client: &mut RpcClient,
     block_num: Option<BlockNumber>,
 ) -> Result<BlockHeader> {
-    let request = BlockHeaderByNumberRequest {
+    let request = GetBlockHeaderByNumberRequest {
         block_num: block_num.map(|block_num| block_num.as_u32()),
         include_mmr_proof: None,
         include_protocol_config: None,
@@ -606,7 +616,7 @@ async fn fetch_genesis_header_and_config(
     rpc_client: &mut RpcClient,
 ) -> Result<(BlockHeader, ProtocolConfig)> {
     let response = rpc_client
-        .get_block_header_by_number(BlockHeaderByNumberRequest {
+        .get_block_header_by_number(GetBlockHeaderByNumberRequest {
             block_num: Some(BlockNumber::GENESIS.as_u32()),
             include_mmr_proof: None,
             include_protocol_config: Some(true),
@@ -688,8 +698,8 @@ async fn fetch_public_account(
     account_id: AccountId,
     block_num: BlockNumber,
 ) -> Result<(Account, AccountWitness)> {
-    use miden_node_proto::generated::rpc::account_request::AccountDetailRequest;
-    use miden_node_proto::generated::rpc::account_request::account_detail_request::StorageRequest;
+    use miden_node_proto::generated::rpc::get_account_request::AccountDetailRequest;
+    use miden_node_proto::generated::rpc::get_account_request::account_detail_request::StorageRequest;
 
     // Dummy commitments force the server to include code and vault data in the response.
     let dummy: miden_node_proto::generated::primitives::Word = Word::default().into();

diff --git a/bin/funding-service/src/node/tests.rs b/bin/funding-service/src/node/tests.rs
@@ -106,8 +106,8 @@ impl TestChain {
         }
     }
 
-    fn notes_by_id(&self, request: &NotesByIdRequest) -> rpc::NotesByIdResponse {
-        rpc::NotesByIdResponse {
+    fn notes_by_id(&self, request: &GetNotesByIdRequest) -> rpc::GetNotesByIdResponse {
+        rpc::GetNotesByIdResponse {
             notes: request
                 .note_ids
                 .iter()
@@ -223,10 +223,12 @@ impl Service<http::Request<Body>> for RpcFixture {
             return Box::pin(async { Ok(tonic::Status::unavailable("retry").into_http()) });
         }
         match method {
-            "Status" => self.respond(request, |chain, _: &()| rpc::RpcStatus {
-                chain_tip: chain.tip,
-                ..Default::default()
-            }),
+            "Status" => {
+                self.respond(request, |chain, _: &rpc::StatusRequest| rpc::StatusResponse {
+                    chain_tip: chain.tip,
+                    ..Default::default()
+                })
+            },
             "SyncTransactions" => self.respond(request, TestChain::sync_transactions),
             "SyncNotes" => self.respond(request, TestChain::sync_notes),
             "GetNotesById" => self.respond(request, TestChain::notes_by_id),

diff --git a/bin/funding-service/src/prover.rs b/bin/funding-service/src/prover.rs
@@ -4,8 +4,8 @@ use std::time::Duration;
 
 use anyhow::{Context, Result};
 use miden_node_proto::clients::{Builder, RemoteProverClient};
-use miden_node_proto::generated::remote_prover::proof_request::Request as ProofRequestVariant;
-use miden_node_proto::generated::remote_prover::{DecodedProof, ProofRequest};
+use miden_node_proto::generated::remote_prover::prove_request::Request as ProofRequestVariant;
+use miden_node_proto::generated::remote_prover::{DecodedProveResponse, ProveRequest};
 use miden_node_proto::{BuildUnchecked, DecodeMessage};
 use miden_node_tracing::spawn::spawn_blocking_in_current_span;
 use miden_node_tracing::{ErrorReport, warn};
@@ -96,7 +96,7 @@ impl RemoteProver {
 
     /// Proves one transaction on the remote prover.
     async fn prove_remotely(&self, executed_tx: &ExecutedTransaction) -> Result<ProvenTransaction> {
-        let request = tonic::Request::new(ProofRequest {
+        let request = tonic::Request::new(ProveRequest {
             request: Some(ProofRequestVariant::Transaction(executed_tx.tx_inputs().into())),
         });
 
@@ -110,7 +110,7 @@ impl RemoteProver {
         response
             .into_inner()
             .decode_fields()
-            .and_then(DecodedProof::into_transaction)
+            .and_then(DecodedProveResponse::into_transaction)
             .context("failed to decode the response of the remote transaction prover")?
             .build_unchecked()
             .context("failed to build the response of the remote transaction prover")

diff --git a/bin/large-account-benchmark/src/rpc.rs b/bin/large-account-benchmark/src/rpc.rs
@@ -11,11 +11,11 @@ use miden_node_proto::domain::encryption::{
 };
 use miden_node_proto::domain::protocol_config::ensure_protocol_config_is_present_and_matches_header;
 use miden_node_proto::generated::account::account_storage_header::storage_slot::Content as SlotContent;
-use miden_node_proto::generated::rpc::account_request::AccountDetailRequest;
+use miden_node_proto::generated::rpc::get_account_request::AccountDetailRequest;
 use miden_node_proto::generated::rpc::{
-    AccountRequest,
-    BlockHeaderByNumberRequest,
-    BlockHeaderByNumberResponse,
+    GetAccountRequest,
+    GetBlockHeaderByNumberRequest,
+    GetBlockHeaderByNumberResponse,
 };
 use miden_node_proto::generated::submission::ProvenTransactionSubmission as ProtoProvenTransaction;
 use miden_node_proto::{DecodeMessageExt, VerifyWith};
@@ -136,7 +136,7 @@ impl SubmissionClient {
         let status = self
             .rpc
             .clone()
-            .status(())
+            .status(miden_node_proto::generated::rpc::StatusRequest {})
             .await
             .context("failed to read node status")?
             .into_inner();
@@ -151,7 +151,7 @@ impl SubmissionClient {
     /// this tool submitted, while the counter account's slot only advances when the ntx-builder has
     /// actually loaded the large account and consumed a network note.
     pub async fn slot_value(&self, account_id: AccountId, slot_name: &str) -> Result<Option<u64>> {
-        let request = AccountRequest {
+        let request = GetAccountRequest {
             account_id: Some(account_id.into()),
             block_num: None,
             details: Some(AccountDetailRequest {
@@ -214,7 +214,7 @@ impl SubmissionClient {
         account_id: AccountId,
         block_num: BlockNumber,
     ) -> Result<AccountWitness> {
-        let request = AccountRequest {
+        let request = GetAccountRequest {
             account_id: Some(account_id.into()),
             block_num: Some(block_num.into()),
             details: None,
@@ -252,10 +252,14 @@ impl SubmissionClient {
         let key = self
             .rpc
             .clone()
-            .get_transaction_encryption_key(())
+            .get_transaction_encryption_key(
+                miden_node_proto::generated::rpc::GetTransactionEncryptionKeyRequest {},
+            )
             .await
             .context("failed to fetch the transaction encryption key")?
-            .into_inner();
+            .into_inner()
+            .key
+            .ok_or_else(|| tonic::Status::internal("missing transaction encryption key"))?;
 
         let verified = key
             .verify_with(TrustedTransactionEncryptionState::new(
@@ -306,9 +310,11 @@ impl SubmissionClient {
         let response = self
             .rpc
             .clone()
-            .submit_proven_tx(ProtoProvenTransaction {
-                transaction: Some(proven_tx.into()),
-                sealed_transaction_inputs: Some(sealed),
+            .submit_proven_tx(miden_node_proto::generated::rpc::SubmitProvenTxRequest {
+                submission: Some(ProtoProvenTransaction {
+                    transaction: Some(proven_tx.into()),
+                    sealed_transaction_inputs: Some(sealed),
+                }),
             })
             .await
             .context("failed to submit the proven transaction")?;
@@ -330,7 +336,7 @@ async fn genesis_block_state(rpc: &mut RpcClient) -> Result<(BlockHeader, Protoc
 }
 
 fn decode_genesis_block_state(
-    response: BlockHeaderByNumberResponse,
+    response: GetBlockHeaderByNumberResponse,
 ) -> Result<(BlockHeader, ProtocolConfig)> {
     let header = response
         .block_header
@@ -345,8 +351,8 @@ fn decode_genesis_block_state(
     Ok((header, protocol_config))
 }
 
-fn genesis_header_request() -> BlockHeaderByNumberRequest {
-    BlockHeaderByNumberRequest {
+fn genesis_header_request() -> GetBlockHeaderByNumberRequest {
+    GetBlockHeaderByNumberRequest {
         block_num: Some(BlockNumber::GENESIS.as_u32()),
         include_mmr_proof: None,
         include_protocol_config: Some(true),
@@ -364,7 +370,7 @@ fn is_stale_key(err: &anyhow::Error) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use miden_node_proto::generated::rpc::BlockHeaderByNumberResponse;
+    use miden_node_proto::generated::rpc::GetBlockHeaderByNumberResponse;
     use miden_protocol::account::AccountId;
     use miden_protocol::testing::account_id::ACCOUNT_ID_PUBLIC_FUNGIBLE_FAUCET_1;
     use miden_testing::MockChain;
@@ -381,7 +387,7 @@ mod tests {
             )
             .build()
             .expect("chain should build");
-        let response = BlockHeaderByNumberResponse {
+        let response = GetBlockHeaderByNumberResponse {
             block_header: Some(chain.genesis_block_header().into()),
             mmr_path: None,
             chain_length: None,