Add RPCState::get_transaction_trace (#909)

* Add RPCState::get_transaction_receipt

* Deserialize signature

* Parse execution resources

* Parse retdata

* Add parse_felt_array

* Fix tests

* Add feeder gateway link

* Fix link

* Add get_chain_name

* Add #[cfg(test)]

* Update test name

Author: matias-gonz

Cargo.lock

@@ -19,3 +19,4 @@ starknet = { workspace = true }
 thiserror = { workspace = true }
 serde_with = "3.0.0"
 dotenv = "0.15.0"
+cairo-vm = "0.8.5"

rpc_state_reader/Cargo.toml

@@ -6,10 +6,11 @@ use serde_with::{serde_as, DeserializeAs};
 use starknet::core::types::ContractClass;
 use starknet_in_rust::{
     core::errors::state_errors::StateError,
+    execution::CallInfo,
     felt::Felt252,
     services::api::contract_classes::compiled_class::CompiledClass,
     state::{state_api::StateReader, state_cache::StorageEntry},
-    utils::{Address, ClassHash, CompiledClassHash},
+    utils::{parse_felt_array, Address, ClassHash, CompiledClassHash},
 };
 use std::env;
 use thiserror::Error;
@@ -138,6 +139,63 @@ impl RpcState {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct TransactionTrace {
+    pub validate_invocation: CallInfo,
+    pub function_invocation: CallInfo,
+    pub fee_transfer_invocation: CallInfo,
+    pub signature: Vec<Felt252>,
+}
+
+impl<'de> Deserialize<'de> for TransactionTrace {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value: serde_json::Value = Deserialize::deserialize(deserializer)?;
+
+        let validate_invocation = value["validate_invocation"].clone();
+        let function_invocation = value["function_invocation"].clone();
+        let fee_transfer_invocation = value["fee_transfer_invocation"].clone();
+        let signature_value = value["signature"].clone();
+        let signature = parse_felt_array(signature_value.as_array().unwrap());
+
+        Ok(TransactionTrace {
+            validate_invocation: serde_json::from_value(validate_invocation)
+                .map_err(serde::de::Error::custom)?,
+            function_invocation: serde_json::from_value(function_invocation)
+                .map_err(serde::de::Error::custom)?,
+            fee_transfer_invocation: serde_json::from_value(fee_transfer_invocation)
+                .map_err(serde::de::Error::custom)?,
+            signature,
+        })
+    }
+}
+
+#[cfg(test)]
+impl RpcState {
+    pub fn get_transaction_trace(&self, hash: Felt252) -> TransactionTrace {
+        let chain_name = self.get_chain_name();
+        let response = ureq::get(&format!(
+            "https://{}.starknet.io/feeder_gateway/get_transaction_trace",
+            chain_name
+        ))
+        .query("transactionHash", &format!("0x{}", hash.to_str_radix(16)))
+        .call()
+        .unwrap();
+
+        serde_json::from_str(&response.into_string().unwrap()).unwrap()
+    }
+
+    fn get_chain_name(&self) -> String {
+        match self.chain {
+            RpcChain::MainNet => "alpha-mainnet".to_string(),
+            RpcChain::TestNet => "alpha4".to_string(),
+            RpcChain::TestNet2 => "alpha4-2".to_string(),
+        }
+    }
+}
+
 impl StateReader for RpcState {
     fn get_contract_class(&self, class_hash: &ClassHash) -> Result<CompiledClass, StateError> {
         let params = ureq::json!({
@@ -212,7 +270,8 @@ impl StateReader for RpcState {
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
+    use cairo_vm::vm::runners::cairo_runner::ExecutionResources;
+    use std::{collections::HashMap, sync::Arc};
 
     use super::*;
     use starknet_in_rust::{
@@ -658,4 +717,135 @@ mod tests {
             .execute(&mut state, &block_context, 0)
             .unwrap();
     }
+
+    // https://alpha4-2.starknet.io/feeder_gateway/get_transaction_trace?transactionHash=0x019feb888a2d53ffddb7a1750264640afab8e9c23119e648b5259f1b5e7d51bc
+    #[test]
+    fn test_get_transaction_trace() {
+        let state_reader = RpcState::new(
+            RpcChain::TestNet2,
+            BlockValue::Number(serde_json::to_value(838683).unwrap()),
+        );
+
+        let tx_hash_str = "19feb888a2d53ffddb7a1750264640afab8e9c23119e648b5259f1b5e7d51bc";
+        let tx_hash = felt_str!(format!("{}", tx_hash_str), 16);
+
+        let tx_trace = state_reader.get_transaction_trace(tx_hash);
+
+        assert_eq!(
+            tx_trace.signature,
+            vec![
+                felt_str!(
+                    "ffab1c47d8d5e5b76bdcc4af79e98205716c36b440f20244c69599a91ace58",
+                    16
+                ),
+                felt_str!(
+                    "6aa48a0906c9c1f7381c1a040c043b649eeac1eea08f24a9d07813f6b1d05fe",
+                    16
+                ),
+            ]
+        );
+
+        assert_eq!(
+            tx_trace.validate_invocation.calldata,
+            vec![
+                felt_str!("1", 16),
+                felt_str!(
+                    "690c876e61beda61e994543af68038edac4e1cb1990ab06e52a2d27e56a1232",
+                    16
+                ),
+                felt_str!(
+                    "1f24f689ced5802b706d7a2e28743fe45c7bfa37431c97b1c766e9622b65573",
+                    16
+                ),
+                felt_str!("0", 16),
+                felt_str!("9", 16),
+                felt_str!("9", 16),
+                felt_str!("4", 16),
+                felt_str!("4254432d55534443", 16),
+                felt_str!("f02e7324ecbd65ce267", 16),
+                felt_str!("5754492d55534443", 16),
+                felt_str!("8e13050d06d8f514c", 16),
+                felt_str!("4554482d55534443", 16),
+                felt_str!("f0e4a142c3551c149d", 16),
+                felt_str!("4a50592d55534443", 16),
+                felt_str!("38bd34c31a0a5c", 16),
+            ]
+        );
+        assert_eq!(tx_trace.validate_invocation.retdata, vec![]);
+        assert_eq!(
+            tx_trace.validate_invocation.execution_resources,
+            ExecutionResources {
+                n_steps: 790,
+                n_memory_holes: 51,
+                builtin_instance_counter: HashMap::from([
+                    ("range_check_builtin".to_string(), 20),
+                    ("ecdsa_builtin".to_string(), 1),
+                    ("pedersen_builtin".to_string(), 2),
+                ]),
+            }
+        );
+
+        assert_eq!(
+            tx_trace.function_invocation.calldata,
+            vec![
+                felt_str!("1", 16),
+                felt_str!(
+                    "690c876e61beda61e994543af68038edac4e1cb1990ab06e52a2d27e56a1232",
+                    16
+                ),
+                felt_str!(
+                    "1f24f689ced5802b706d7a2e28743fe45c7bfa37431c97b1c766e9622b65573",
+                    16
+                ),
+                felt_str!("0", 16),
+                felt_str!("9", 16),
+                felt_str!("9", 16),
+                felt_str!("4", 16),
+                felt_str!("4254432d55534443", 16),
+                felt_str!("f02e7324ecbd65ce267", 16),
+                felt_str!("5754492d55534443", 16),
+                felt_str!("8e13050d06d8f514c", 16),
+                felt_str!("4554482d55534443", 16),
+                felt_str!("f0e4a142c3551c149d", 16),
+                felt_str!("4a50592d55534443", 16),
+                felt_str!("38bd34c31a0a5c", 16),
+            ]
+        );
+        assert_eq!(tx_trace.function_invocation.retdata, vec![0.into()]);
+        assert_eq!(
+            tx_trace.function_invocation.execution_resources,
+            ExecutionResources {
+                n_steps: 2808,
+                n_memory_holes: 136,
+                builtin_instance_counter: HashMap::from([
+                    ("range_check_builtin".to_string(), 49),
+                    ("pedersen_builtin".to_string(), 14),
+                ]),
+            }
+        );
+
+        assert_eq!(
+            tx_trace.fee_transfer_invocation.calldata,
+            vec![
+                felt_str!(
+                    "1176a1bd84444c89232ec27754698e5d2e7e1a7f1539f12027f28b23ec9f3d8",
+                    16
+                ),
+                felt_str!("2b0322a23ba4", 16),
+                felt_str!("0", 16),
+            ]
+        );
+        assert_eq!(tx_trace.fee_transfer_invocation.retdata, vec![1.into()]);
+        assert_eq!(
+            tx_trace.fee_transfer_invocation.execution_resources,
+            ExecutionResources {
+                n_steps: 586,
+                n_memory_holes: 42,
+                builtin_instance_counter: HashMap::from([
+                    ("range_check_builtin".to_string(), 21),
+                    ("pedersen_builtin".to_string(), 4),
+                ]),
+            }
+        );
+    }
 }

rpc_state_reader/src/lib.rs

@@ -4,6 +4,7 @@ pub mod os_usage;
 
 use crate::definitions::constants::QUERY_VERSION_BASE;
 use crate::services::api::contract_classes::deprecated_contract_class::EntryPointType;
+use crate::utils::parse_felt_array;
 use crate::{
     definitions::{constants::CONSTRUCTOR_ENTRY_POINT_SELECTOR, transaction_type::TransactionType},
     state::state_cache::StorageEntry,
@@ -18,6 +19,7 @@ use cairo_vm::{
 };
 use getset::Getters;
 use num_traits::{ToPrimitive, Zero};
+use serde::{Deserialize, Deserializer};
 use std::collections::{HashMap, HashSet};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -232,6 +234,46 @@ impl Default for CallInfo {
     }
 }
 
+impl<'de> Deserialize<'de> for CallInfo {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value: serde_json::Value = Deserialize::deserialize(deserializer)?;
+
+        // Parse execution_resources
+        let execution_resources_value = value["execution_resources"].clone();
+
+        let execution_resources = ExecutionResources {
+            n_steps: serde_json::from_value(execution_resources_value["n_steps"].clone())
+                .map_err(serde::de::Error::custom)?,
+            n_memory_holes: serde_json::from_value(
+                execution_resources_value["n_memory_holes"].clone(),
+            )
+            .map_err(serde::de::Error::custom)?,
+            builtin_instance_counter: serde_json::from_value(
+                execution_resources_value["builtin_instance_counter"].clone(),
+            )
+            .map_err(serde::de::Error::custom)?,
+        };
+
+        // Parse retdata
+        let retdata_value = value["result"].clone();
+        let retdata = parse_felt_array(retdata_value.as_array().unwrap());
+
+        // Parse calldata
+        let calldata_value = value["calldata"].clone();
+        let calldata = parse_felt_array(calldata_value.as_array().unwrap());
+
+        Ok(CallInfo {
+            execution_resources,
+            retdata,
+            calldata,
+            ..Default::default()
+        })
+    }
+}
+
 // ----------------------
 // CallResult structure
 // ----------------------

src/execution/mod.rs

@@ -19,6 +19,7 @@ use cairo_vm::{
 use cairo_vm::{types::relocatable::Relocatable, vm::vm_core::VirtualMachine};
 use num_traits::{Num, ToPrimitive};
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use sha3::{Digest, Keccak256};
 use starknet_crypto::FieldElement;
 use std::{
@@ -346,6 +347,21 @@ pub(crate) fn parse_builtin_names(
         .collect()
 }
 
+/// Parses an array of strings representing Felt252 as hex
+pub fn parse_felt_array(felt_strings: &[Value]) -> Vec<Felt252> {
+    let mut felts = vec![];
+
+    for felt in felt_strings {
+        let felt_string = felt.as_str().unwrap();
+        felts.push(match felt_string.starts_with("0x") {
+            true => Felt252::parse_bytes(felt_string[2..].as_bytes(), 16).unwrap(),
+            false => Felt252::parse_bytes(felt_string.as_bytes(), 16).unwrap(),
+        })
+    }
+
+    felts
+}
+
 //* -------------------
 //*      Macros
 //* -------------------