refactoring: use string for JSON data

Author: bingyanglin

crates/iota-grpc-api/proto/common.proto

@@ -10,11 +10,6 @@ message BcsData {
   bytes data = 1;
 }
 
-// JSON-serialized data container
-message JsonData {
-  bytes data = 1;
-}
-
 // 32-byte address type for IOTA addresses, object IDs, package IDs, etc.
 message Address {
   bytes address = 1;

crates/iota-grpc-api/proto/read.proto

@@ -30,6 +30,6 @@ message ObjectDataOptions {
 }
 
 message GetObjectResponse {
-  optional iota.grpc.common.JsonData json_data = 1;   // JSON-serialized IotaObjectData (success)
-  optional iota.grpc.common.JsonData json_error = 2;  // JSON-serialized IotaObjectResponseError (error)
+  optional string json_data = 1;   // JSON-serialized IotaObjectData (success)
+  optional string json_error = 2;  // JSON-serialized IotaObjectResponseError (error)
 }

crates/iota-grpc-api/proto/transaction.proto

@@ -19,7 +19,7 @@ message TransactionStreamRequest {
 
 // Transaction data
 message Transaction {
-  iota.grpc.common.JsonData json_data = 1;  // JSON-serialized IotaTransactionBlockEffects
+  string json_data = 1;  // JSON-serialized IotaTransactionBlockEffects
 }
 
 // Rich transaction filter that supports gRPC transaction filtering

crates/iota-grpc-api/proto/write.proto

@@ -46,5 +46,5 @@ enum ExecuteTransactionRequestType {
 }
 
 message ExecuteTransactionResponse {
-  iota.grpc.common.JsonData json_data = 1;  // JSON-serialized IotaTransactionBlockResponse
+  string json_data = 1;  // JSON-serialized IotaTransactionBlockResponse
 }

crates/iota-grpc-api/src/client/read.rs

@@ -67,19 +67,17 @@ impl ReadClient {
         response: &crate::read::GetObjectResponse,
     ) -> Result<IotaObjectResponse, Status> {
         // Check for success data first
-        if let Some(data_wrapper) = &response.json_data {
+        if let Some(json_data) = &response.json_data {
             // Deserialize success data
-            let object_data: IotaObjectData =
-                serde_json::from_slice(&data_wrapper.data).map_err(|e| {
-                    Status::internal(format!("Failed to deserialize object data from JSON: {e}"))
-                })?;
+            let object_data: IotaObjectData = serde_json::from_str(json_data).map_err(|e| {
+                Status::internal(format!("Failed to deserialize object data from JSON: {e}"))
+            })?;
             Ok(IotaObjectResponse::new_with_data(object_data))
-        } else if let Some(error_wrapper) = &response.json_error {
+        } else if let Some(json_error) = &response.json_error {
             // Deserialize error
-            let error: IotaObjectResponseError = serde_json::from_slice(&error_wrapper.data)
-                .map_err(|e| {
-                    Status::internal(format!("Failed to deserialize error from JSON: {e}"))
-                })?;
+            let error: IotaObjectResponseError = serde_json::from_str(json_error).map_err(|e| {
+                Status::internal(format!("Failed to deserialize error from JSON: {e}"))
+            })?;
             Ok(IotaObjectResponse::new_with_error(error))
         } else {
             Err(Status::internal("Response contains neither data nor error"))

crates/iota-grpc-api/src/read_service.rs

@@ -110,21 +110,19 @@ impl ReadService for ReadGrpcService {
                             })?;
 
                             return Ok(Response::new(GetObjectResponse {
-                                json_data: Some(crate::common::JsonData {
-                                    data: serde_json::to_vec(&data).map_err(|e| {
-                                        Status::internal(format!(
-                                            "Failed to serialize object data: {e}"
-                                        ))
-                                    })?,
-                                }),
-                                json_error: Some(crate::common::JsonData {
-                                    data: serde_json::to_vec(&IotaObjectResponseError::Display {
+                                json_data: Some(serde_json::to_string(&data).map_err(|e| {
+                                    Status::internal(format!(
+                                        "Failed to serialize object data: {e}"
+                                    ))
+                                })?),
+                                json_error: Some(
+                                    serde_json::to_string(&IotaObjectResponseError::Display {
                                         error: "Failed to compute display fields".to_string(),
                                     })
                                     .map_err(|e| {
                                         Status::internal(format!("Failed to serialize error: {e}"))
                                     })?,
-                                }),
+                                ),
                             }));
                         }
                     }
@@ -159,23 +157,23 @@ impl ReadService for ReadGrpcService {
 
 /// Serialize success data to JSON (matches IotaObjectResponse::new_with_data)
 fn serialize_data_to_json(data: IotaObjectData) -> Result<GetObjectResponse, Status> {
-    let json_data = serde_json::to_vec(&data)
+    let json_data = serde_json::to_string(&data)
         .map_err(|e| Status::internal(format!("Failed to serialize object data to JSON: {e}")))?;
 
     Ok(GetObjectResponse {
-        json_data: Some(crate::common::JsonData { data: json_data }),
+        json_data: Some(json_data),
         json_error: None,
     })
 }
 
 /// Serialize error to JSON (matches IotaObjectResponse::new_with_error)
 fn serialize_error_to_json(error: IotaObjectResponseError) -> Result<GetObjectResponse, Status> {
-    let error_data = serde_json::to_vec(&error)
+    let json_error = serde_json::to_string(&error)
         .map_err(|e| Status::internal(format!("Failed to serialize error to JSON: {e}")))?;
 
     Ok(GetObjectResponse {
         json_data: None,
-        json_error: Some(crate::common::JsonData { data: error_data }),
+        json_error: Some(json_error),
     })
 }
 

crates/iota-grpc-api/src/transaction_service.rs

@@ -255,11 +255,9 @@ fn parse_iota_address(
 impl From<&iota_json_rpc_types::IotaTransactionBlockEffects> for Transaction {
     fn from(effects: &iota_json_rpc_types::IotaTransactionBlockEffects) -> Self {
         // Serialize JSON-RPC effects directly to JSON
-        let data = serde_json::to_vec(effects)
+        let json_data = serde_json::to_string(effects)
             .expect("IotaTransactionBlockEffects should always serialize to JSON");
 
-        Transaction {
-            json_data: Some(crate::common::JsonData { data }),
-        }
+        Transaction { json_data }
     }
 }

crates/iota-grpc-api/src/write_service.rs

@@ -136,12 +136,10 @@ impl WriteGrpcService {
     fn serialize_response_to_json(
         response: &IotaTransactionBlockResponse,
     ) -> Result<ExecuteTransactionResponse, Status> {
-        let data = serde_json::to_vec(response)
+        let json_data = serde_json::to_string(response)
             .map_err(|e| Status::internal(format!("Failed to serialize response to JSON: {e}")))?;
 
-        Ok(ExecuteTransactionResponse {
-            json_data: Some(crate::common::JsonData { data }),
-        })
+        Ok(ExecuteTransactionResponse { json_data })
     }
 
     async fn handle_post_orchestration(