fix(stage): extract execution resources from gateway type (#381)

Author: kariy

crates/executor/src/implementation/blockifier/mod.rs

@@ -258,9 +258,10 @@ impl<'a> BlockExecutor<'a> for StarknetVMProcessor<'a> {
                 Ok(exec_result) => {
                     match &exec_result {
                         ExecutionResult::Success { receipt, trace } => {
-                            self.stats.l1_gas_used += receipt.resources_used().gas.l1_gas as u128;
+                            self.stats.l1_gas_used +=
+                                receipt.resources_used().total_gas_consumed.l1_gas as u128;
                             self.stats.cairo_steps_used +=
-                                receipt.resources_used().computation_resources.n_steps as u128;
+                                receipt.resources_used().vm_resources.n_steps as u128;
 
                             if let Some(reason) = receipt.revert_reason() {
                                 info!(target: LOG_TARGET, hash = format!("{hash:#x}"), %reason, "Transaction reverted.");

crates/executor/src/utils.rs

@@ -87,7 +87,11 @@ fn get_receipt_resources(receipt: &TransactionReceipt) -> receipt::ExecutionReso
         l1_data_gas: receipt.da_gas.l1_data_gas.0,
     };
 
-    receipt::ExecutionResources { da_resources, computation_resources, gas }
+    receipt::ExecutionResources {
+        data_availability: da_resources,
+        vm_resources: computation_resources,
+        total_gas_consumed: gas,
+    }
 }
 
 fn events_from_exec_info(info: &TransactionExecutionInfo) -> Vec<Event> {

crates/executor/tests/executor.rs

@@ -273,10 +273,10 @@ fn test_executor_with_valid_blocks_impl(
         .map(|(tx, res)| {
             if let Some(receipt) = res.receipt() {
                 let resources = receipt.resources_used();
-                actual_total_gas += resources.gas.l1_gas as u128;
+                actual_total_gas += resources.total_gas_consumed.l1_gas as u128;
             }
             if let Some(rec) = res.receipt() {
-                actual_total_steps += rec.resources_used().computation_resources.n_steps as u128;
+                actual_total_steps += rec.resources_used().vm_resources.n_steps as u128;
             }
             tx.clone()
         })

crates/gateway/gateway-types/src/conversion.rs

@@ -264,21 +264,54 @@ impl From<katana_primitives::receipt::Receipt> for ReceiptBody {
             Some(ExecutionStatus::Succeeded)
         };
 
-        let execution_resources = Some(ExecutionResources {
-            vm_resources: receipt.resources_used().computation_resources.clone(),
-            data_availability: Some(receipt.resources_used().da_resources.clone()),
-            total_gas_consumed: Some(receipt.resources_used().gas.clone()),
-        });
+        match receipt {
+            katana_primitives::receipt::Receipt::Invoke(receipt) => {
+                Self {
+                    execution_resources: Some(receipt.execution_resources.into()),
+                    // This would need to be populated from transaction context
+                    l1_to_l2_consumed_message: None,
+                    l2_to_l1_messages: receipt.messages_sent,
+                    events: receipt.events,
+                    actual_fee: receipt.fee.overall_fee.into(),
+                    execution_status,
+                    revert_error: receipt.revert_error,
+                }
+            }
 
-        Self {
-            execution_resources,
-            l1_to_l2_consumed_message: None, /* This would need to be populated from transaction
-                                              * context */
-            l2_to_l1_messages: receipt.messages_sent().to_vec(),
-            events: receipt.events().to_vec(),
-            actual_fee: receipt.fee().overall_fee.into(),
-            execution_status,
-            revert_error: receipt.revert_reason().map(|s| s.to_string()),
+            katana_primitives::receipt::Receipt::Declare(receipt) => Self {
+                execution_resources: Some(receipt.execution_resources.into()),
+                // This would need to be populated from transaction context
+                l1_to_l2_consumed_message: None,
+                l2_to_l1_messages: receipt.messages_sent,
+                events: receipt.events,
+                actual_fee: receipt.fee.overall_fee.into(),
+                execution_status,
+                revert_error: receipt.revert_error,
+            },
+
+            katana_primitives::receipt::Receipt::DeployAccount(receipt) => {
+                Self {
+                    execution_resources: Some(receipt.execution_resources.into()),
+                    // This would need to be populated from transaction context
+                    l1_to_l2_consumed_message: None,
+                    l2_to_l1_messages: receipt.messages_sent,
+                    events: receipt.events,
+                    actual_fee: receipt.fee.overall_fee.into(),
+                    execution_status,
+                    revert_error: receipt.revert_error,
+                }
+            }
+
+            katana_primitives::receipt::Receipt::L1Handler(receipt) => Self {
+                execution_resources: Some(receipt.execution_resources.into()),
+                // This would need to be populated from transaction context
+                l1_to_l2_consumed_message: None,
+                l2_to_l1_messages: receipt.messages_sent,
+                events: receipt.events,
+                actual_fee: receipt.fee.overall_fee.into(),
+                execution_status,
+                revert_error: receipt.revert_error,
+            },
         }
     }
 }
@@ -340,6 +373,26 @@ impl From<StateDiff> for katana_primitives::state::StateUpdates {
     }
 }
 
+impl From<katana_primitives::receipt::ExecutionResources> for ExecutionResources {
+    fn from(value: katana_primitives::receipt::ExecutionResources) -> Self {
+        Self {
+            vm_resources: value.vm_resources,
+            data_availability: Some(value.data_availability),
+            total_gas_consumed: Some(value.total_gas_consumed),
+        }
+    }
+}
+
+impl From<ExecutionResources> for katana_primitives::receipt::ExecutionResources {
+    fn from(value: ExecutionResources) -> Self {
+        Self {
+            vm_resources: value.vm_resources,
+            data_availability: value.data_availability.unwrap_or_default(),
+            total_gas_consumed: value.total_gas_consumed.unwrap_or_default(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod from_primitives_test {
     use katana_primitives::transaction::TxWithHash;

crates/primitives/src/receipt.rs

@@ -224,9 +224,9 @@ impl ReceiptWithTxHash {
     pub fn compute_hash(&self) -> Felt {
         let resources_used = self.resources_used();
         let gas_uasge = hash::Poseidon::hash_array(&[
-            resources_used.gas.l2_gas.into(),
-            resources_used.gas.l1_gas.into(),
-            resources_used.gas.l1_data_gas.into(),
+            resources_used.total_gas_consumed.l2_gas.into(),
+            resources_used.total_gas_consumed.l1_gas.into(),
+            resources_used.total_gas_consumed.l1_data_gas.into(),
         ]);
 
         let messages_hash = self.compute_messages_to_l1_hash();
@@ -277,10 +277,10 @@ impl ReceiptWithTxHash {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct ExecutionResources {
     /// The total gas used by the transaction execution.
-    pub gas: GasUsed,
+    pub total_gas_consumed: GasUsed,
     /// Computation resources if the transaction is executed on the CairoVM.
-    pub computation_resources: VmResources,
-    pub da_resources: DataAvailabilityResources,
+    pub vm_resources: VmResources,
+    pub data_availability: DataAvailabilityResources,
 }
 
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
@@ -325,6 +325,10 @@ impl<'a> arbitrary::Arbitrary<'a> for ExecutionResources {
         let gas = u.arbitrary::<GasUsed>()?;
         let da_resources = u.arbitrary::<DataAvailabilityResources>()?;
 
-        Ok(Self { da_resources, computation_resources, gas })
+        Ok(Self {
+            data_availability: da_resources,
+            vm_resources: computation_resources,
+            total_gas_consumed: gas,
+        })
     }
 }

crates/rpc/rpc-server/src/starknet/blockifier.rs

@@ -90,10 +90,10 @@ pub fn estimate_fees(
                             overall_fee: fee.overall_fee,
                             l2_gas_price: fee.l2_gas_price,
                             l1_gas_price: fee.l1_gas_price,
-                            l2_gas_consumed: resources.gas.l2_gas,
-                            l1_gas_consumed: resources.gas.l1_gas,
+                            l2_gas_consumed: resources.total_gas_consumed.l2_gas,
+                            l1_gas_consumed: resources.total_gas_consumed.l1_gas,
                             l1_data_gas_price: fee.l1_data_gas_price,
-                            l1_data_gas_consumed: resources.gas.l1_data_gas,
+                            l1_data_gas_consumed: resources.total_gas_consumed.l1_data_gas,
                         });
                     }
                 }

crates/rpc/rpc-types/src/receipt.rs

@@ -360,9 +360,9 @@ pub struct ExecutionResources {
 impl From<receipt::ExecutionResources> for ExecutionResources {
     fn from(resources: receipt::ExecutionResources) -> Self {
         ExecutionResources {
-            l2_gas: resources.gas.l2_gas,
-            l1_gas: resources.gas.l1_gas,
-            l1_data_gas: resources.gas.l1_data_gas,
+            l2_gas: resources.total_gas_consumed.l2_gas,
+            l1_gas: resources.total_gas_consumed.l1_gas,
+            l1_data_gas: resources.total_gas_consumed.l1_data_gas,
         }
     }
 }
@@ -398,18 +398,18 @@ impl From<ExecutionResources> for receipt::ExecutionResources {
         use std::collections::HashMap;
 
         receipt::ExecutionResources {
-            gas: receipt::GasUsed {
+            total_gas_consumed: receipt::GasUsed {
                 l2_gas: resources.l2_gas,
                 l1_gas: resources.l1_gas,
                 l1_data_gas: resources.l1_data_gas,
             },
             // VM resources are not available in RPC types, use defaults
-            computation_resources: VmResources {
+            vm_resources: VmResources {
                 n_steps: 0,
                 n_memory_holes: 0,
                 builtin_instance_counter: HashMap::new(),
             },
-            da_resources: receipt::DataAvailabilityResources {
+            data_availability: receipt::DataAvailabilityResources {
                 l1_gas: resources.l1_gas,
                 l1_data_gas: resources.l1_data_gas,
             },

crates/rpc/rpc-types/src/trace.rs

@@ -330,9 +330,9 @@ pub fn to_rpc_fee_estimate(resources: &receipt::ExecutionResources, fee: &FeeInf
         l2_gas_price: fee.l2_gas_price,
         l1_gas_price: fee.l1_gas_price,
         l1_data_gas_price: fee.l1_data_gas_price,
-        l1_gas_consumed: resources.gas.l1_gas,
-        l2_gas_consumed: resources.gas.l2_gas,
-        l1_data_gas_consumed: resources.gas.l1_data_gas,
+        l1_gas_consumed: resources.total_gas_consumed.l1_gas,
+        l2_gas_consumed: resources.total_gas_consumed.l2_gas,
+        l1_data_gas_consumed: resources.total_gas_consumed.l1_data_gas,
     }
 }
 

crates/sync/stage/src/blocks/mod.rs

@@ -198,6 +198,7 @@ fn extract_block_data(
             let revert_error = receipt.body.revert_error;
             let messages_sent = receipt.body.l2_to_l1_messages;
             let overall_fee = receipt.body.actual_fee.to_u128().expect("valid u128");
+            let execution_resources = receipt.body.execution_resources.unwrap_or_default();
 
             let unit = if tx.transaction.version() >= Felt::THREE {
                 PriceUnit::Fri
@@ -213,30 +214,30 @@ fn extract_block_data(
                     events,
                     revert_error,
                     messages_sent,
-                    execution_resources: Default::default(),
+                    execution_resources: execution_resources.into(),
                 }),
                 Tx::Declare(_) => Receipt::Declare(DeclareTxReceipt {
                     fee,
                     events,
                     revert_error,
                     messages_sent,
-                    execution_resources: Default::default(),
+                    execution_resources: execution_resources.into(),
                 }),
                 Tx::L1Handler(_) => Receipt::L1Handler(L1HandlerTxReceipt {
                     fee,
                     events,
                     messages_sent,
                     revert_error,
                     message_hash: Default::default(),
-                    execution_resources: Default::default(),
+                    execution_resources: execution_resources.into(),
                 }),
                 Tx::DeployAccount(_) => Receipt::DeployAccount(DeployAccountTxReceipt {
                     fee,
                     events,
                     revert_error,
                     messages_sent,
                     contract_address: Default::default(),
-                    execution_resources: Default::default(),
+                    execution_resources: execution_resources.into(),
                 }),
                 Tx::Deploy(_) => unreachable!("Deploy transactions are not supported"),
             }