Merge branch 'next' into santiagopittella-update-base-vm

Author: bobbinth

CHANGELOG.md

@@ -15,6 +15,7 @@
 - Improved tracing in `miden-network-monitor` binary ([#1366](https://github.com/0xMiden/miden-node/pull/1366)).
 - Integrated RPC stack with Validator component for transaction validation ([#1457](https://github.com/0xMiden/miden-node/pull/1457)).
 - Added explorer status to the `miden-network-monitor` binary ([#1450](https://github.com/0xMiden/miden-node/pull/1450)).
+- Added `GetLimits` endpoint to the RPC server ([#1410](https://github.com/0xMiden/miden-node/pull/1410)).
 
 ### Changes
 

crates/proto/src/generated/rpc.rs

@@ -543,6 +543,27 @@ pub struct TransactionRecord {
     #[prost(message, optional, tag = "2")]
     pub header: ::core::option::Option<super::transaction::TransactionHeader>,
 }
+/// Represents the query parameter limits for RPC endpoints.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RpcLimits {
+    /// Maps RPC endpoint names to their parameter limits.
+    /// Key: endpoint name (e.g., "CheckNullifiers", "SyncState")
+    /// Value: map of parameter names to their limit values
+    #[prost(map = "string, message", tag = "1")]
+    pub endpoints: ::std::collections::HashMap<
+        ::prost::alloc::string::String,
+        EndpointLimits,
+    >,
+}
+/// Represents the parameter limits for a single endpoint.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct EndpointLimits {
+    /// Maps parameter names to their limit values.
+    /// Key: parameter name (e.g., "nullifier", "account_id")
+    /// Value: limit value
+    #[prost(map = "string, uint32", tag = "1")]
+    pub parameters: ::std::collections::HashMap<::prost::alloc::string::String, u32>,
+}
 /// Generated client implementations.
 pub mod api_client {
     #![allow(
@@ -1049,6 +1070,29 @@ pub mod api_client {
             req.extensions_mut().insert(GrpcMethod::new("rpc.Api", "SyncTransactions"));
             self.inner.unary(req, path, codec).await
         }
+        /// Returns the query parameter limits configured for RPC methods.
+        ///
+        /// These define the maximum number of each parameter a method will accept.
+        /// Exceeding the limit will result in the request being rejected and you should instead send
+        /// multiple smaller requests.
+        pub async fn get_limits(
+            &mut self,
+            request: impl tonic::IntoRequest<()>,
+        ) -> std::result::Result<tonic::Response<super::RpcLimits>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic_prost::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/rpc.Api/GetLimits");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new("rpc.Api", "GetLimits"));
+            self.inner.unary(req, path, codec).await
+        }
     }
 }
 /// Generated server implementations.
@@ -1234,6 +1278,15 @@ pub mod api_server {
             tonic::Response<super::SyncTransactionsResponse>,
             tonic::Status,
         >;
+        /// Returns the query parameter limits configured for RPC methods.
+        ///
+        /// These define the maximum number of each parameter a method will accept.
+        /// Exceeding the limit will result in the request being rejected and you should instead send
+        /// multiple smaller requests.
+        async fn get_limits(
+            &self,
+            request: tonic::Request<()>,
+        ) -> std::result::Result<tonic::Response<super::RpcLimits>, tonic::Status>;
     }
     /// RPC API for the RPC component
     #[derive(Debug)]
@@ -2027,6 +2080,45 @@ pub mod api_server {
                     };
                     Box::pin(fut)
                 }
+                "/rpc.Api/GetLimits" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetLimitsSvc<T: Api>(pub Arc<T>);
+                    impl<T: Api> tonic::server::UnaryService<()> for GetLimitsSvc<T> {
+                        type Response = super::RpcLimits;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Api>::get_limits(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetLimitsSvc(inner);
+                        let codec = tonic_prost::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
                 _ => {
                     Box::pin(async move {
                         let mut response = http::Response::new(

crates/rpc/README.md

@@ -19,6 +19,7 @@ The full gRPC method definitions can be found in the [proto](../proto/README.md)
 - [GetAccountProofs](#getaccountproofs)
 - [GetBlockByNumber](#getblockbynumber)
 - [GetBlockHeaderByNumber](#getblockheaderbynumber)
+- [GetLimits](#getlimits)
 - [GetNotesById](#getnotesbyid)
 - [GetNoteScriptByRoot](#getnotescriptbyroot)
 - [SubmitProvenTransaction](#submitproventransaction)
@@ -36,6 +37,8 @@ The full gRPC method definitions can be found in the [proto](../proto/README.md)
 
 Returns a nullifier proof for each of the requested nullifiers.
 
+**Limits:** `nullifier` (1000)
+
 #### Error Handling
 
 When nullifier checking fails, detailed error information is provided through gRPC status details. The following error codes may be returned:
@@ -73,10 +76,21 @@ authenticate the block's inclusion.
 
 ---
 
+### GetLimits
+
+Returns the query parameter limits configured for RPC endpoints.
+
+This endpoint allows clients to discover the maximum number of items that can be requested in a single call for
+various endpoints. The response contains a map of endpoint names to their parameter limits.
+
+---
+
 ### GetNotesById
 
 Returns a list of notes matching the provided note IDs.
 
+**Limits:** `note_id` (100)
+
 #### Error Handling
 
 When note retrieval fails, detailed error information is provided through gRPC status details. The following error codes may be returned:
@@ -137,6 +151,8 @@ Clients should inspect both the gRPC status code and the detailed error code in
 Returns nullifier synchronization data for a set of prefixes within a given block range. This method allows
 clients to efficiently track nullifier creation by retrieving only the nullifiers produced between two blocks.
 
+**Limits:** `nullifier` (1000)
+
 Caller specifies the `prefix_len` (currently only 16), the list of prefix values (`nullifiers`), and the block
 range (`from_start_block`, optional `to_end_block`). The response includes all matching nullifiers created within that
 range, the last block included in the response (`block_num`), and the current chain tip (`chain_tip`).
@@ -181,6 +197,8 @@ When account vault synchronization fails, detailed error information is provided
 
 Returns info which can be used by the client to sync up to the tip of chain for the notes they are interested in.
 
+**Limits:** `note_tag` (1000)
+
 Client specifies the `note_tags` they are interested in, and the block range from which to search for matching notes. The request will then return the next block containing any note matching the provided tags within the specified range.
 
 The response includes each note's metadata and inclusion proof.
@@ -205,6 +223,8 @@ When note synchronization fails, detailed error information is provided through
 Returns info which can be used by the client to sync up to the latest state of the chain for the objects (accounts and
 notes) the client is interested in.
 
+**Limits:** `account_id` (1000), `note_tag` (1000)
+
 This request returns the next block containing requested data. It also returns `chain_tip` which is the latest block
 number in the chain. Client is expected to repeat these requests in a loop until
 `response.block_header.block_num == response.chain_tip`, at which point the client is fully synchronized with the chain.

crates/rpc/src/server/api.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::sync::{Arc, LazyLock};
 use std::time::Duration;
 
 use anyhow::Context;
@@ -612,6 +612,23 @@ impl api_server::Api for RpcService {
 
         self.store.clone().sync_transactions(request).await
     }
+
+    #[instrument(
+        parent = None,
+        target = COMPONENT,
+        name = "rpc.server.get_limits",
+        skip_all,
+        ret(level = "debug"),
+        err
+    )]
+    async fn get_limits(
+        &self,
+        request: Request<()>,
+    ) -> Result<Response<proto::rpc::RpcLimits>, Status> {
+        debug!(target: COMPONENT, request = ?request);
+
+        Ok(Response::new(RPC_LIMITS.clone()))
+    }
 }
 
 // LIMIT HELPERS
@@ -627,3 +644,42 @@ fn out_of_range_error<E: core::fmt::Display>(err: E) -> Status {
 fn check<Q: QueryParamLimiter>(n: usize) -> Result<(), Status> {
     <Q as QueryParamLimiter>::check(n).map_err(out_of_range_error)
 }
+
+/// Helper to build an [`EndpointLimits`](proto::rpc::EndpointLimits) from (name, limit) pairs.
+fn endpoint_limits(params: &[(&str, usize)]) -> proto::rpc::EndpointLimits {
+    proto::rpc::EndpointLimits {
+        parameters: params.iter().map(|(k, v)| ((*k).to_string(), *v as u32)).collect(),
+    }
+}
+
+/// Cached RPC query parameter limits.
+static RPC_LIMITS: LazyLock<proto::rpc::RpcLimits> = LazyLock::new(|| {
+    use {
+        QueryParamAccountIdLimit as AccountId,
+        QueryParamNoteIdLimit as NoteId,
+        QueryParamNoteTagLimit as NoteTag,
+        QueryParamNullifierLimit as Nullifier,
+    };
+
+    proto::rpc::RpcLimits {
+        endpoints: std::collections::HashMap::from([
+            (
+                "CheckNullifiers".into(),
+                endpoint_limits(&[(Nullifier::PARAM_NAME, Nullifier::LIMIT)]),
+            ),
+            (
+                "SyncNullifiers".into(),
+                endpoint_limits(&[(Nullifier::PARAM_NAME, Nullifier::LIMIT)]),
+            ),
+            (
+                "SyncState".into(),
+                endpoint_limits(&[
+                    (AccountId::PARAM_NAME, AccountId::LIMIT),
+                    (NoteTag::PARAM_NAME, NoteTag::LIMIT),
+                ]),
+            ),
+            ("SyncNotes".into(), endpoint_limits(&[(NoteTag::PARAM_NAME, NoteTag::LIMIT)])),
+            ("GetNotesById".into(), endpoint_limits(&[(NoteId::PARAM_NAME, NoteId::LIMIT)])),
+        ]),
+    }
+});

crates/rpc/src/tests.rs

@@ -9,7 +9,13 @@ use miden_node_proto::generated::{self as proto};
 use miden_node_store::Store;
 use miden_node_store::genesis::config::GenesisConfig;
 use miden_node_utils::fee::test_fee;
-use miden_protocol::Word;
+use miden_node_utils::limiter::{
+    QueryParamAccountIdLimit,
+    QueryParamLimiter,
+    QueryParamNoteIdLimit,
+    QueryParamNoteTagLimit,
+    QueryParamNullifierLimit,
+};
 use miden_protocol::account::delta::AccountUpdateDetails;
 use miden_protocol::account::{
     AccountBuilder,
@@ -461,3 +467,58 @@ async fn start_store(store_addr: SocketAddr) -> (Runtime, TempDir, Word) {
         genesis_state.into_block().unwrap().inner().header().commitment(),
     )
 }
+
+#[tokio::test]
+async fn get_limits_endpoint() {
+    // Start the RPC and store
+    let (mut rpc_client, _rpc_addr, store_addr) = start_rpc().await;
+    let (store_runtime, _data_directory, _genesis) = start_store(store_addr).await;
+
+    // Call the get_limits endpoint
+    let response = rpc_client.get_limits(()).await.expect("get_limits should succeed");
+    let limits = response.into_inner();
+
+    // Verify the response contains expected endpoints and limits
+    assert!(!limits.endpoints.is_empty(), "endpoints should not be empty");
+
+    // Verify CheckNullifiers endpoint
+    let check_nullifiers =
+        limits.endpoints.get("CheckNullifiers").expect("CheckNullifiers should exist");
+
+    assert_eq!(
+        check_nullifiers.parameters.get("nullifier"),
+        Some(&(QueryParamNullifierLimit::LIMIT as u32)),
+        "CheckNullifiers nullifier limit should be {}",
+        QueryParamNullifierLimit::LIMIT
+    );
+
+    // Verify SyncState endpoint has multiple parameters
+    let sync_state = limits.endpoints.get("SyncState").expect("SyncState should exist");
+    assert_eq!(
+        sync_state.parameters.get(QueryParamAccountIdLimit::PARAM_NAME),
+        Some(&(QueryParamAccountIdLimit::LIMIT as u32)),
+        "SyncState {} limit should be {}",
+        QueryParamAccountIdLimit::PARAM_NAME,
+        QueryParamAccountIdLimit::LIMIT
+    );
+    assert_eq!(
+        sync_state.parameters.get(QueryParamNoteTagLimit::PARAM_NAME),
+        Some(&(QueryParamNoteTagLimit::LIMIT as u32)),
+        "SyncState {} limit should be {}",
+        QueryParamNoteTagLimit::PARAM_NAME,
+        QueryParamNoteTagLimit::LIMIT
+    );
+
+    // Verify GetNotesById endpoint
+    let get_notes_by_id = limits.endpoints.get("GetNotesById").expect("GetNotesById should exist");
+    assert_eq!(
+        get_notes_by_id.parameters.get(QueryParamNoteIdLimit::PARAM_NAME),
+        Some(&(QueryParamNoteIdLimit::LIMIT as u32)),
+        "GetNotesById {} limit should be {}",
+        QueryParamNoteIdLimit::PARAM_NAME,
+        QueryParamNoteIdLimit::LIMIT
+    );
+
+    // Shutdown to avoid runtime drop error.
+    store_runtime.shutdown_background();
+}