rpc: add config for max size of json rendered move value

Author: bmwill

crates/sui-rpc-api/src/config.rs

@@ -29,6 +29,15 @@ pub struct Config {
     /// If not provided then the node will not create an https service.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub tls: Option<TlsConfig>,
+
+    /// Maxumum budget for rendering a Move value into JSON.
+    ///
+    /// This sets the numbers of bytes that we are willing to spend on rendering field names and
+    /// values when rendering a Move value into a JSON value.
+    ///
+    /// Defaults to `1MiB` if not specified.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_json_move_value_size: Option<usize>,
 }
 
 impl Config {
@@ -44,6 +53,10 @@ impl Config {
     pub fn tls_config(&self) -> Option<&TlsConfig> {
         self.tls.as_ref()
     }
+
+    pub fn max_json_move_value_size(&self) -> usize {
+        self.max_json_move_value_size.unwrap_or(1024 * 1024)
+    }
 }
 
 #[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]

crates/sui-rpc-api/src/grpc/v2beta/ledger_service/get_object.rs

@@ -130,7 +130,7 @@ fn get_object_impl(
                 Some((layout, s.contents()))
             })
             .and_then(|(layout, contents)| {
-                sui_types::proto_value::ProtoVisitor::default()
+                sui_types::proto_value::ProtoVisitor::new(service.config.max_json_move_value_size())
                     .deserialize_value(contents, &layout)
                     .map_err(|e| tracing::debug!("unable to convert to JSON: {e}"))
                     .ok()

crates/sui-rpc-api/src/grpc/v2beta/ledger_service/get_transaction.rs

@@ -190,11 +190,13 @@ fn transaction_to_response(
                                 Some((layout, &event.contents))
                             })
                             .and_then(|(layout, contents)| {
-                                sui_types::proto_value::ProtoVisitor::default()
-                                    .deserialize_value(contents, &layout)
-                                    .map_err(|e| tracing::debug!("unable to convert to JSON: {e}"))
-                                    .ok()
-                                    .map(Box::new)
+                                sui_types::proto_value::ProtoVisitor::new(
+                                    service.config.max_json_move_value_size(),
+                                )
+                                .deserialize_value(contents, &layout)
+                                .map_err(|e| tracing::debug!("unable to convert to JSON: {e}"))
+                                .ok()
+                                .map(Box::new)
                             });
                     }
                 }

crates/sui-types/src/proto_value.rs

@@ -20,54 +20,12 @@ use move_core_types::{
 use prost_types::value::Kind;
 use prost_types::Struct;
 use prost_types::Value;
-use std::sync::LazyLock;
-use tracing::info;
 
 /// This is the maximum depth of a proto message
 /// The maximum depth of a proto message is 100. Given this value may be nested itself somewhere
 /// we'll conservitively cap this to ~80% of that.
 const MAX_DEPTH: usize = 80;
 
-/// Environment variable to override the default budget for deserialization. This can be set at
-/// runtime to change the maximum size of values that can be deserialized.
-const MAX_BOUND_VAR_NAME: &str = "MAX_JSON_MOVE_VALUE_SIZE";
-
-/// Default budget for deserialization -- we're okay to spend 1MiB on rendering a move value to
-/// JSON.
-const DEFAULT_MAX_BOUND: usize = 1024 * 1024;
-
-/// Budget for rendering a Move value into JSON. This sets the numbers of bytes that we
-/// are willing to spend on rendering field names and values when rendering a Move value into a
-/// JSON value.
-///
-/// Bounded deserialization is intended for use outside of the validator, and so uses a fixed bound
-/// that needs to be set at startup rather than one that is configured as part of the protocol.
-///
-/// If the environment variable `MAX_JSON_MOVE_VALUE_SIZE` is unset we default to
-/// `DEFAULT_MAX_BOUND` which allows 1MiB space usage on rendering a value to JSON.
-///
-/// This is read only once and after that the value is cached. To change this value you will need
-/// to restart the process with the new value set (or the value unset if you wish to use the
-/// `DEFAULT_MAX_BOUND` value).
-static MAX_BOUND: LazyLock<usize> = LazyLock::new(|| {
-    let max_bound_opt = std::env::var(MAX_BOUND_VAR_NAME)
-        .ok()
-        .and_then(|s| s.parse().ok());
-    if let Some(max_bound) = max_bound_opt {
-        info!(
-            "Using custom value for '{}' max bound: {}",
-            MAX_BOUND_VAR_NAME, max_bound
-        );
-        max_bound
-    } else {
-        info!(
-            "Using default value for '{}' -- max bound: {}",
-            MAX_BOUND_VAR_NAME, DEFAULT_MAX_BOUND
-        );
-        DEFAULT_MAX_BOUND
-    }
-});
-
 pub struct ProtoVisitor {
     /// Budget left to spend on visiting.
     bound: usize,
@@ -89,12 +47,6 @@ pub enum Error {
     UnexpectedType,
 }
 
-impl Default for ProtoVisitor {
-    fn default() -> Self {
-        Self::new(*MAX_BOUND)
-    }
-}
-
 impl ProtoVisitor {
     pub fn new(bound: usize) -> Self {
         Self { bound, depth: 0 }
@@ -698,7 +650,7 @@ pub(crate) mod tests {
 
     fn json<T: serde::Serialize>(layout: A::MoveTypeLayout, data: T) -> serde_json::Value {
         let bcs = bcs::to_bytes(&data).unwrap();
-        let proto_value = ProtoVisitor::default()
+        let proto_value = ProtoVisitor::new(1024 * 1024)
             .deserialize_value(&bcs, &layout)
             .unwrap();
         proto_value_to_json_value(proto_value)