Add DECLARE and DEPLOY_ACCOUNT support to rpc_state_reader.

rpc_state_reader/src/lib.rs

@@ -138,7 +138,7 @@ mod tests {
         );
 
         assert_eq!(
-            tx_trace.validate_invocation.calldata,
+            tx_trace.validate_invocation.as_ref().unwrap().calldata,
             Some(vec![
                 stark_felt!("1"),
                 stark_felt!("690c876e61beda61e994543af68038edac4e1cb1990ab06e52a2d27e56a1232"),
@@ -157,9 +157,16 @@ mod tests {
                 stark_felt!("38bd34c31a0a5c"),
             ])
         );
-        assert_eq!(tx_trace.validate_invocation.retdata, Some(vec![]));
+        assert_eq!(
+            tx_trace.validate_invocation.as_ref().unwrap().retdata,
+            Some(vec![])
+        );
         assert_eq_sorted!(
-            tx_trace.validate_invocation.execution_resources,
+            tx_trace
+                .validate_invocation
+                .as_ref()
+                .unwrap()
+                .execution_resources,
             ExecutionResources {
                 n_steps: 790,
                 n_memory_holes: 51,
@@ -170,7 +177,15 @@ mod tests {
                 ]),
             }
         );
-        assert_eq!(tx_trace.validate_invocation.internal_calls.len(), 1);
+        assert_eq!(
+            tx_trace
+                .validate_invocation
+                .as_ref()
+                .unwrap()
+                .internal_calls
+                .len(),
+            1
+        );
 
         assert_eq!(
             tx_trace.function_invocation.as_ref().unwrap().calldata,
@@ -243,19 +258,23 @@ mod tests {
         );
 
         assert_eq!(
-            tx_trace.fee_transfer_invocation.calldata,
+            tx_trace.fee_transfer_invocation.as_ref().unwrap().calldata,
             Some(vec![
                 stark_felt!("1176a1bd84444c89232ec27754698e5d2e7e1a7f1539f12027f28b23ec9f3d8"),
                 stark_felt!("2b0322a23ba4"),
                 stark_felt!("0"),
             ])
         );
         assert_eq!(
-            tx_trace.fee_transfer_invocation.retdata,
+            tx_trace.fee_transfer_invocation.as_ref().unwrap().retdata,
             Some(vec![1u128.into()])
         );
         assert_eq_sorted!(
-            tx_trace.fee_transfer_invocation.execution_resources,
+            tx_trace
+                .fee_transfer_invocation
+                .as_ref()
+                .unwrap()
+                .execution_resources,
             ExecutionResources {
                 n_steps: 586,
                 n_memory_holes: 42,
@@ -265,7 +284,15 @@ mod tests {
                 ]),
             }
         );
-        assert_eq!(tx_trace.fee_transfer_invocation.internal_calls.len(), 1);
+        assert_eq!(
+            tx_trace
+                .fee_transfer_invocation
+                .as_ref()
+                .unwrap()
+                .internal_calls
+                .len(),
+            1
+        );
     }
 
     #[test]

rpc_state_reader/src/rpc_state.rs

@@ -1,3 +1,4 @@
+use crate::utils;
 use cairo_vm::vm::runners::cairo_runner::ExecutionResources as VmExecutionResources;
 use core::fmt;
 use dotenv::dotenv;
@@ -14,8 +15,6 @@ use starknet_api::{
 use std::{collections::HashMap, env, fmt::Display};
 use thiserror::Error;
 
-use crate::utils;
-
 /// Starknet chains supported in Infura.
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord)]
 pub enum RpcChain {
@@ -142,14 +141,42 @@ pub struct RpcBlockInfo {
 /// A RPC response.
 #[derive(Debug, Deserialize, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
 pub struct RpcResponse<T> {
-    result: T,
+    result: Option<T>,
+    error: Option<RpcResponseError>,
+}
+
+impl<T> RpcResponse<T> {
+    fn into_result(self) -> Result<T, RpcError> {
+        match (self.result, self.error) {
+            (None, None) => panic!("API returned neither a result nor an error"),
+            (None, Some(error)) => Err(RpcError::RpcCall(match error.data {
+                Some(data) => format!(
+                    "The API returned an error {} '{}' with data '{}'",
+                    error.code, error.message, data
+                ),
+                None => format!(
+                    "The API returned an error {} '{}'",
+                    error.code, error.message
+                ),
+            })),
+            (Some(result), None) => Ok(result),
+            (Some(_), Some(_)) => panic!("API returned both a result and an error"),
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
+pub struct RpcResponseError {
+    code: i32,
+    message: String,
+    data: Option<String>,
 }
 
 #[derive(Debug, Deserialize, Clone, Eq, PartialEq)]
 pub struct TransactionTrace {
-    pub validate_invocation: RpcCallInfo,
+    pub validate_invocation: Option<RpcCallInfo>,
     pub function_invocation: Option<RpcCallInfo>,
-    pub fee_transfer_invocation: RpcCallInfo,
+    pub fee_transfer_invocation: Option<RpcCallInfo>,
     pub signature: Vec<StarkFelt>,
     pub revert_error: Option<String>,
 }
@@ -270,7 +297,8 @@ impl RpcState {
         method: &str,
         params: &serde_json::Value,
     ) -> Result<T, RpcError> {
-        Ok(self.rpc_call::<RpcResponse<T>>(method, params)?.result)
+        self.rpc_call::<RpcResponse<T>>(method, params)?
+            .into_result()
     }
 
     fn rpc_call<T: for<'a> Deserialize<'a>>(
@@ -302,7 +330,8 @@ impl RpcState {
     fn deserialize_call<T: for<'a> Deserialize<'a>>(
         response: serde_json::Value,
     ) -> Result<T, RpcError> {
-        serde_json::from_value(response).map_err(|err| RpcError::RpcCall(err.to_string()))
+        serde_json::from_value(response.clone())
+            .map_err(|err| RpcError::RpcCall(format!("'{}' while deserializing {}", err, response)))
     }
 
     /// Gets the url of the feeder endpoint

rpc_state_reader/src/utils.rs

@@ -11,7 +11,7 @@ use starknet_api::{
     core::EntryPointSelector,
     deprecated_contract_class::{EntryPoint, EntryPointOffset, EntryPointType},
     hash::{StarkFelt, StarkHash},
-    transaction::{InvokeTransaction, Transaction},
+    transaction::{DeclareTransaction, InvokeTransaction, Transaction},
 };
 
 #[derive(Debug, Deserialize)]
@@ -82,6 +82,24 @@ pub fn deserialize_transaction_json(
                 "unimplemented invoke version: {x}"
             ))),
         },
+        "DECLARE" => match tx_version.as_str() {
+            "0x0" => Ok(Transaction::Declare(DeclareTransaction::V0(
+                serde_json::from_value(transaction)?,
+            ))),
+            "0x1" => Ok(Transaction::Declare(DeclareTransaction::V1(
+                serde_json::from_value(transaction)?,
+            ))),
+            "0x2" => Ok(Transaction::Declare(DeclareTransaction::V2(
+                serde_json::from_value(transaction)?,
+            ))),
+            x => Err(serde::de::Error::custom(format!(
+                "unimplemented declare version: {x}"
+            ))),
+        },
+        "DEPLOY" => Ok(Transaction::Deploy(serde_json::from_value(transaction)?)),
+        "DEPLOY_ACCOUNT" => Ok(Transaction::DeployAccount(serde_json::from_value(
+            transaction,
+        )?)),
         x => Err(serde::de::Error::custom(format!(
             "unimplemented transaction type deserialization: {x}"
         ))),