fix(api): Return correct flat call tracer

Signed-off-by: Danil <deniallugo@gmail.com>

Author: Deniallugo

core/lib/dal/.sqlx/query-34ea9042ca05af21601e0b065078ec515a8916a247d93e655dde3a5b43bda244.json

@@ -527,7 +527,7 @@ impl BlocksWeb3Dal<'_, '_> {
     pub async fn get_traces_for_l2_block(
         &mut self,
         block_number: L2BlockNumber,
-    ) -> DalResult<Vec<Call>> {
+    ) -> DalResult<Vec<(Call, H256, usize)>> {
         let protocol_version = sqlx::query!(
             r#"
             SELECT
@@ -554,6 +554,8 @@ impl BlocksWeb3Dal<'_, '_> {
             CallTrace,
             r#"
             SELECT
+                transactions.hash,
+                transactions.index_in_block,
                 call_trace
             FROM
                 call_traces
@@ -570,7 +572,11 @@ impl BlocksWeb3Dal<'_, '_> {
         .fetch_all(self.storage)
         .await?
         .into_iter()
-        .map(|call_trace| call_trace.into_call(protocol_version))
+        .map(|call_trace| {
+            let hash = H256::from_slice(&call_trace.hash);
+            let index = call_trace.index_in_block.unwrap_or_default() as usize;
+            (call_trace.into_call(protocol_version), hash, index)
+        })
         .collect())
     }
 
@@ -1084,8 +1090,9 @@ mod tests {
             .await
             .unwrap();
         assert_eq!(traces.len(), 2);
-        for (trace, tx_result) in traces.iter().zip(&tx_results) {
+        for ((trace, hash, _index), tx_result) in traces.iter().zip(&tx_results) {
             let expected_trace = tx_result.call_trace().unwrap();
+            assert_eq!(&tx_result.hash, hash);
             assert_eq!(*trace, expected_trace);
         }
     }

core/lib/dal/.sqlx/query-87f27295de500591f01ed76731df2aed7049c3f44a6d25556967ea867e0caf25.json

@@ -561,6 +561,8 @@ impl StorageApiTransaction {
 #[derive(Debug, Clone, sqlx::FromRow)]
 pub(crate) struct CallTrace {
     pub call_trace: Vec<u8>,
+    pub hash: Vec<u8>,
+    pub index_in_block: Option<i32>,
 }
 
 impl CallTrace {
@@ -578,15 +580,16 @@ impl CallTrace {
             bincode::deserialize(&self.call_trace).unwrap()
         }
     }
+}
 
-    pub(crate) fn from_call(call: Call, protocol_version: ProtocolVersionId) -> Self {
-        let call_trace = if protocol_version.is_pre_1_5_0() {
-            bincode::serialize(&LegacyCall::try_from(call).unwrap())
-        } else {
-            bincode::serialize(&call)
-        }
-        .unwrap();
-
-        Self { call_trace }
+pub(crate) fn serialize_call_into_bytes(
+    call: Call,
+    protocol_version: ProtocolVersionId,
+) -> Vec<u8> {
+    if protocol_version.is_pre_1_5_0() {
+        bincode::serialize(&LegacyCall::try_from(call).unwrap())
+    } else {
+        bincode::serialize(&call)
     }
+    .unwrap()
 }

core/lib/dal/.sqlx/query-96ef4ff06739b249eeafc987dcbad918a7d282b6f18d2bd02b020afbd1cde19b.json

@@ -20,7 +20,7 @@ use zksync_vm_interface::{
 };
 
 use crate::{
-    models::storage_transaction::{CallTrace, StorageTransaction},
+    models::storage_transaction::{serialize_call_into_bytes, CallTrace, StorageTransaction},
     Core, CoreDal,
 };
 
@@ -518,8 +518,7 @@ impl TransactionsDal<'_, '_> {
         let mut bytea_call_traces = Vec::with_capacity(transactions.len());
         for tx_res in transactions {
             if let Some(call_trace) = tx_res.call_trace() {
-                bytea_call_traces
-                    .push(CallTrace::from_call(call_trace, protocol_version).call_trace);
+                bytea_call_traces.push(serialize_call_into_bytes(call_trace, protocol_version));
                 call_traces_tx_hashes.push(tx_res.hash.as_bytes());
             }
         }
@@ -2101,7 +2100,10 @@ impl TransactionsDal<'_, '_> {
         Ok(data)
     }
 
-    pub async fn get_call_trace(&mut self, tx_hash: H256) -> DalResult<Option<Call>> {
+    pub async fn get_call_trace(
+        &mut self,
+        tx_hash: H256,
+    ) -> DalResult<Option<(Call, H256, usize)>> {
         let row = sqlx::query!(
             r#"
             SELECT
@@ -2132,7 +2134,9 @@ impl TransactionsDal<'_, '_> {
             CallTrace,
             r#"
             SELECT
-                call_trace
+                call_trace,
+                tx_hash AS hash,
+                0 AS index_in_block
             FROM
                 call_traces
             WHERE
@@ -2144,7 +2148,11 @@ impl TransactionsDal<'_, '_> {
         .with_arg("tx_hash", &tx_hash)
         .fetch_optional(self.storage)
         .await?
-        .map(|call_trace| call_trace.into_call(protocol_version)))
+        .map(|call_trace| {
+            let hash = H256::from_slice(&call_trace.hash);
+            let index = call_trace.index_in_block.unwrap_or_default() as usize;
+            (call_trace.into_call(protocol_version), hash, index)
+        }))
     }
 
     pub(crate) async fn get_tx_by_hash(&mut self, hash: H256) -> DalResult<Option<Transaction>> {
@@ -2216,7 +2224,7 @@ mod tests {
             .await
             .unwrap();
 
-        let call_trace = conn
+        let (call_trace, _, _) = conn
             .transactions_dal()
             .get_call_trace(tx_hash)
             .await

core/lib/dal/.sqlx/query-c37432fabd092fa235fc70e11430fb28594859564a0f888eae748ad1f9fcede5.json

@@ -12,7 +12,10 @@ use zksync_contracts::BaseSystemContractsHashes;
 pub use crate::transaction_request::{
     Eip712Meta, SerializationTransactionError, TransactionRequest,
 };
-use crate::{protocol_version::L1VerifierConfig, Address, L2BlockNumber, ProtocolVersionId};
+use crate::{
+    debug_flat_call::DebugCallFlat, protocol_version::L1VerifierConfig, Address, L2BlockNumber,
+    ProtocolVersionId,
+};
 
 pub mod en;
 pub mod state_override;
@@ -597,10 +600,11 @@ pub struct GetLogsFilter {
 #[derive(Debug, Serialize, Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct ResultDebugCall {
-    pub result: DebugCall,
+    pub result: CallTracerResult,
 }
 
 #[derive(Debug, Default, Serialize, Deserialize, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
 pub enum DebugCallType {
     #[default]
     Call,
@@ -700,19 +704,20 @@ impl ProtocolVersion {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
 #[serde(rename_all = "camelCase")]
 pub enum SupportedTracers {
     CallTracer,
+    FlatCallTracer,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, Default)]
+#[derive(Debug, Serialize, Deserialize, Clone, Default, Copy)]
 #[serde(rename_all = "camelCase")]
 pub struct CallTracerConfig {
     pub only_top_call: bool,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
 #[serde(rename_all = "camelCase")]
 pub struct TracerConfig {
     pub tracer: SupportedTracers,
@@ -727,6 +732,22 @@ pub enum BlockStatus {
     Verified,
 }
 
+/// FlatTracer is always more than one trace, so when we have to trace one transaction it also appeared as many traces
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase", untagged)]
+pub enum CallTracerResult {
+    CallTrace(DebugCall),
+    FlattCallTrace(Box<Vec<DebugCallFlat>>),
+}
+
+/// For tracing blocks we need to have all traces being combined all together without separation.
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase", untagged)]
+pub enum CallTracerOption {
+    CallTrace(DebugCall),
+    FlattCallTrace(Box<DebugCallFlat>),
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct BlockDetailsBase {