Simplify away the JsonRpcResponse code.

Author: MathieuDutSik

linera-ethereum/src/client.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Zefchain Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-use std::{fmt, fmt::Debug};
+use std::fmt::Debug;
 
 use alloy::{
     primitives::{Address, U256},
@@ -13,8 +13,7 @@ use alloy::{
 use alloy_primitives::{Bytes, U64};
 use async_trait::async_trait;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
-use serde_json::{value::RawValue, Value};
-use thiserror::Error;
+use serde_json::value::RawValue;
 
 use crate::common::{
     event_name_from_expanded, parse_log, EthereumEvent, EthereumQueryError, EthereumServiceError,
@@ -38,12 +37,7 @@ pub trait JsonRpcClient {
         let payload = serde_json::to_vec(&payload)?;
         let body = self.request_inner(payload).await?;
         let result = serde_json::from_slice::<JsonRpcResponse>(&body)?;
-        let raw = match result {
-            JsonRpcResponse::Success { result, .. } => result.to_owned(),
-            JsonRpcResponse::Error { error: _, .. } => {
-                return Err(EthereumQueryError::DeserializationError.into());
-            }
-        };
+        let raw = result.result;
         let res = serde_json::from_str(raw.get())?;
         Ok(res)
     }
@@ -69,126 +63,11 @@ impl<'a, T> Request<'a, T> {
     }
 }
 
-#[derive(Deserialize, Debug, Clone, Error)]
-pub struct JsonRpcError {
-    /// The error code
-    pub code: i64,
-    /// The error message
-    pub message: String,
-    /// Additional data
-    pub data: Option<Value>,
-}
-
-impl fmt::Display for JsonRpcError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "(code: {}, message: {}, data: {:?})",
-            self.code, self.message, self.data
-        )
-    }
-}
-
-#[derive(Debug)]
-pub enum JsonRpcResponse<'a> {
-    Success { id: u64, result: &'a RawValue },
-    Error { id: u64, error: JsonRpcError },
-}
-
-impl<'de: 'a, 'a> Deserialize<'de> for JsonRpcResponse<'a> {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        #[allow(dead_code)]
-        struct JsonRpcResponseVisitor<'a>(&'a ());
-        impl<'de: 'a, 'a> serde::de::Visitor<'de> for JsonRpcResponseVisitor<'a> {
-            type Value = JsonRpcResponse<'a>;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("a valid jsonrpc 2.0 response object")
-            }
-
-            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-            where
-                A: serde::de::MapAccess<'de>,
-            {
-                let mut jsonrpc = false;
-
-                // response & error
-                let mut id = None;
-                // only response
-                let mut result = None;
-                // only error
-                let mut error = None;
-
-                while let Some(key) = map.next_key()? {
-                    match key {
-                        "jsonrpc" => {
-                            if jsonrpc {
-                                return Err(serde::de::Error::duplicate_field("jsonrpc"));
-                            }
-
-                            let value = map.next_value()?;
-                            if value != "2.0" {
-                                return Err(serde::de::Error::invalid_value(
-                                    serde::de::Unexpected::Str(value),
-                                    &"2.0",
-                                ));
-                            }
-
-                            jsonrpc = true;
-                        }
-                        "id" => {
-                            if id.is_some() {
-                                return Err(serde::de::Error::duplicate_field("id"));
-                            }
-
-                            let value: u64 = map.next_value()?;
-                            id = Some(value);
-                        }
-                        "result" => {
-                            if result.is_some() {
-                                return Err(serde::de::Error::duplicate_field("result"));
-                            }
-
-                            let value: &RawValue = map.next_value()?;
-                            result = Some(value);
-                        }
-                        "error" => {
-                            if error.is_some() {
-                                return Err(serde::de::Error::duplicate_field("error"));
-                            }
-
-                            let value: JsonRpcError = map.next_value()?;
-                            error = Some(value);
-                        }
-                        key => {
-                            return Err(serde::de::Error::unknown_field(
-                                key,
-                                &["id", "jsonrpc", "result", "error"],
-                            ))
-                        }
-                    }
-                }
-
-                // jsonrpc version must be present in all responses
-                if !jsonrpc {
-                    return Err(serde::de::Error::missing_field("jsonrpc"));
-                }
-
-                match (id, result, error) {
-                    (Some(id), Some(result), None) => Ok(JsonRpcResponse::Success { id, result }),
-                    (Some(id), None, Some(error)) => Ok(JsonRpcResponse::Error { id, error }),
-                    _ => Err(serde::de::Error::custom(
-                        "response must be either a success/error or notification object",
-                    )),
-                }
-            }
-        }
-
-        deserializer.deserialize_map(JsonRpcResponseVisitor(&()))
-    }
+#[derive(Debug, Deserialize)]
+pub struct JsonRpcResponse {
+    pub id: u64,
+    pub jsonrpc: String,
+    pub result: Box<RawValue>,
 }
 
 /// The basic Ethereum queries that can be used from a smart contract and do not require