chore: remove additional transformations of params

src/common.rs

@@ -2172,12 +2172,24 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient {
                 "JSON Request Body:\n{}",
                 indent_payload(&format!("{:#}", request_payload))
             );
-            if !message_about_saving_payload.is_empty() {
-                tracing::info!(
-                    target: "near_teach_me",
-                    parent: &tracing::Span::none(),
-                    "{}", message_about_saving_payload
-                );
+            match message_about_saving_payload {
+                Ok(Some(message)) => {
+                    tracing::event!(
+                        target: "near_teach_me",
+                        parent: &tracing::Span::none(),
+                        tracing::Level::INFO,
+                        "{}", message
+                    );
+                }
+                Err(message) => {
+                    tracing::event!(
+                        target: "near_teach_me",
+                        parent: &tracing::Span::none(),
+                        tracing::Level::INFO,
+                        "{}", message
+                    );
+                }
+                _ => {}
             }
         }
 
@@ -2389,62 +2401,83 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient {
 
 fn check_request_payload_for_broadcast_tx_commit(
     mut request_payload: serde_json::Value,
-) -> (serde_json::Value, String) {
-    let mut message_about_saving_payload = String::new();
-    if let Some(method) = request_payload.get("method") {
+) -> (serde_json::Value, Result<Option<String>, String>) {
+    let mut message_about_saving_payload = Ok(None);
+    let method = request_payload.get("method").cloned();
+    let params_value = request_payload.get("params").cloned();
+    if let Some(method) = method {
         if method.to_string().contains("broadcast_tx_commit") {
-            if let Some(serde_json::Value::Array(array)) = request_payload.get("params") {
-                let signed_transaction_as_base64 =
-                    array.iter().map(|val| val.to_string()).collect::<String>();
-                let signed_transaction_as_base64 = signed_transaction_as_base64.trim_matches('"');
+            if let Some(params_value) = params_value {
+                message_about_saving_payload =
+                    replace_params_with_file(&mut request_payload, params_value);
+            }
+        }
+    }
+    (request_payload, message_about_saving_payload)
+}
 
-                if signed_transaction_as_base64.len() > 1000 {
-                    let data_signed_transaction = serde_json::json!(
-                        {"Signed transaction (serialized as base64)": signed_transaction_as_base64});
+fn replace_params_with_file(
+    request_payload: &mut serde_json::Value,
+    params_value: serde_json::Value,
+) -> Result<Option<String>, String> {
+    let total_params_length = {
+        match serde_json::to_vec_pretty(&params_value) {
+            Ok(serialized) => serialized.len(),
+            // skipping logic with replacing request's field, though
+            // this branch is supposed to be unreachable
+            Err(_err) => 0,
+        }
+    };
 
-                    let file_path = std::path::PathBuf::from("broadcast_tx_commit.json");
+    if total_params_length > 1000 {
+        let file_content = {
+            let mut map = serde_json::Map::new();
+            map.insert(
+                "original `params` field of JSON Request Body".into(),
+                params_value,
+            );
 
-                    request_payload["params"] = serde_json::json!(format!(
-                        "A transaction in base64 encoding contains {} characters. The entire payload will be stored in `{}`",
-                        signed_transaction_as_base64.len(),
-                        &file_path.display()
-                    ));
+            serde_json::Value::Object(map)
+        };
 
-                    match std::fs::File::create(&file_path) {
-                        Ok(mut file) => {
-                            match serde_json::to_vec(&data_signed_transaction) {
-                                Ok(buf) => match file.write(&buf) {
-                                    Ok(_) => {
-                                        message_about_saving_payload = format!("The file `{}` was created successfully. It has a signed transaction (serialized as base64).", &file_path.display());
-                                    }
-                                    Err(err) => {
-                                        message_about_saving_payload = format!("Failed to save payload to `{}`. Failed to write file:\n{}",
-                                            &file_path.display(),
-                                            indent_payload(&format!("{:#?}", err)));
-                                    }
-                                },
-                                Err(err) => {
-                                    message_about_saving_payload = format!(
-                                        "Failed to save payload to `{}`. Serialization error:\n{}",
-                                        &file_path.display(),
-                                        indent_payload(&format!("{:#?}", err))
-                                    );
-                                }
-                            }
-                        }
-                        Err(err) => {
-                            message_about_saving_payload = format!(
-                                "Failed to save payload to `{}`. Failed to create file:\n{}",
-                                &file_path.display(),
-                                indent_payload(&format!("{:#?}", err))
-                            );
-                        }
+        let file_path = std::path::PathBuf::from("broadcast_tx_commit__params_field.json");
+
+        let result = match std::fs::File::create(&file_path) {
+            Ok(mut file) => match serde_json::to_vec_pretty(&file_content) {
+                Ok(buf) => match file.write(&buf) {
+                    Ok(_) => {
+                        Ok(Some(format!("The file `{}` was created successfully. It has a signed transaction (serialized as base64).", &file_path.display())))
                     }
-                }
-            }
+                    Err(err) => Err(format!(
+                        "Failed to save payload to `{}`. Failed to write file:\n{}",
+                        &file_path.display(),
+                        indent_payload(&format!("{:#?}", err))
+                    )),
+                },
+                Err(err) => Err(format!(
+                    "Failed to save payload to `{}`. Serialization error:\n{}",
+                    &file_path.display(),
+                    indent_payload(&format!("{:#?}", err))
+                )),
+            },
+            Err(err) => Err(format!(
+                "Failed to save payload to `{}`. Failed to create file:\n{}",
+                &file_path.display(),
+                indent_payload(&format!("{:#?}", err))
+            )),
+        };
+
+        if result.is_ok() {
+            request_payload["params"] = serde_json::json!(format!(
+                "`params` field serialization contains {} characters. Current field will be stored in `{}`",
+                total_params_length,
+                &file_path.display()
+            ));
         }
+        result
+    } else {
+        Ok(None)
     }
-    (request_payload, message_about_saving_payload)
 }
 
 pub(crate) fn teach_me_call_response(response: &impl serde::Serialize) {