refactor(native_blockifier, starknet_consensus_orchestrator): share e…

…xecution objects

Cargo.toml

@@ -26,6 +26,7 @@ members = [
   "crates/papyrus_storage",
   "crates/papyrus_sync",
   "crates/papyrus_test_utils",
+  "crates/shared_execution_objects",
   "crates/starknet_api",
   "crates/starknet_batcher",
   "crates/starknet_batcher_types",
@@ -218,6 +219,7 @@ serde_repr = "0.1.19"
 serde_yaml = "0.9.16"
 sha2 = "0.10.8"
 sha3 = "0.10.8"
+shared_execution_objects = { path = "crates/shared_execution_objects", version = "0.0.0" }
 simple_logger = "4.0.0"
 starknet-core = "0.6.0"
 starknet-crypto = "0.7.1"

crates/native_blockifier/Cargo.toml

@@ -41,8 +41,8 @@ papyrus_state_reader.workspace = true
 papyrus_storage.workspace = true
 pyo3 = { workspace = true, features = ["hashbrown", "num-bigint"] }
 pyo3-log.workspace = true
-serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, features = ["arbitrary_precision"] }
+shared_execution_objects.workspace = true
 starknet-types-core.workspace = true
 starknet_api.workspace = true
 starknet_sierra_multicompile.workspace = true

crates/native_blockifier/src/py_block_executor.rs

@@ -1,8 +1,5 @@
 #![allow(non_local_definitions)]
 
-use std::collections::HashMap;
-
-use blockifier::abi::constants as abi_constants;
 use blockifier::blockifier::config::{ContractClassManagerConfig, TransactionExecutorConfig};
 use blockifier::blockifier::transaction_executor::{
     BlockExecutionSummary,
@@ -12,20 +9,15 @@ use blockifier::blockifier::transaction_executor::{
 use blockifier::blockifier_versioned_constants::VersionedConstants;
 use blockifier::bouncer::BouncerConfig;
 use blockifier::context::{BlockContext, ChainInfo, FeeTokenAddresses};
-use blockifier::execution::call_info::CallInfo;
-use blockifier::fee::receipt::TransactionReceipt;
 use blockifier::state::contract_class_manager::ContractClassManager;
-use blockifier::transaction::objects::{ExecutionResourcesTraits, TransactionExecutionInfo};
 use blockifier::transaction::transaction_execution::Transaction;
 use papyrus_state_reader::papyrus_state::PapyrusReader;
 use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyList};
 use pyo3::{FromPyObject, PyAny, Python};
-use serde::Serialize;
+use shared_execution_objects::objects::CentralTransactionExecutionInfo;
 use starknet_api::block::BlockNumber;
 use starknet_api::core::{ChainId, ContractAddress};
-use starknet_api::execution_resources::GasVector;
-use starknet_api::transaction::fields::Fee;
 use starknet_types_core::felt::Felt;
 
 use crate::errors::{NativeBlockifierError, NativeBlockifierResult};
@@ -47,65 +39,16 @@ use crate::storage::{
 };
 
 pub(crate) type RawTransactionExecutionResult = Vec<u8>;
+const RESULT_SERIALIZE_ERR: &str = "Failed serializing execution info.";
 
 #[cfg(test)]
 #[path = "py_block_executor_test.rs"]
 mod py_block_executor_test;
 
-const RESULT_SERIALIZE_ERR: &str = "Failed serializing execution info.";
-
-/// A mapping from a transaction execution resource to its actual usage.
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize)]
-pub struct ResourcesMapping(pub HashMap<String, usize>);
-
-/// Stripped down `TransactionExecutionInfo` for Python serialization, containing only the required
-/// fields.
-#[derive(Debug, Serialize)]
-pub(crate) struct ThinTransactionExecutionInfo {
-    pub validate_call_info: Option<CallInfo>,
-    pub execute_call_info: Option<CallInfo>,
-    pub fee_transfer_call_info: Option<CallInfo>,
-    pub actual_fee: Fee,
-    pub da_gas: GasVector,
-    pub actual_resources: ResourcesMapping,
-    pub revert_error: Option<String>,
-    pub total_gas: GasVector,
-}
-
-impl ThinTransactionExecutionInfo {
-    pub fn from_tx_execution_info(tx_execution_info: TransactionExecutionInfo) -> Self {
-        Self {
-            validate_call_info: tx_execution_info.validate_call_info,
-            execute_call_info: tx_execution_info.execute_call_info,
-            fee_transfer_call_info: tx_execution_info.fee_transfer_call_info,
-            actual_fee: tx_execution_info.receipt.fee,
-            da_gas: tx_execution_info.receipt.da_gas,
-            actual_resources: ThinTransactionExecutionInfo::receipt_to_resources_mapping(
-                &tx_execution_info.receipt,
-            ),
-            revert_error: tx_execution_info.revert_error.map(|error| error.to_string()),
-            total_gas: tx_execution_info.receipt.gas,
-        }
-    }
-    pub fn serialize(self) -> RawTransactionExecutionResult {
-        serde_json::to_vec(&self).expect(RESULT_SERIALIZE_ERR)
-    }
-
-    pub fn receipt_to_resources_mapping(receipt: &TransactionReceipt) -> ResourcesMapping {
-        let vm_resources = &receipt.resources.computation.vm_resources;
-        let mut resources = HashMap::from([(
-            abi_constants::N_STEPS_RESOURCE.to_string(),
-            vm_resources.total_n_steps() + receipt.resources.computation.n_reverted_steps,
-        )]);
-        resources.extend(
-            vm_resources
-                .prover_builtins()
-                .iter()
-                .map(|(builtin, value)| (builtin.to_str_with_suffix().to_string(), *value)),
-        );
-
-        ResourcesMapping(resources)
-    }
+fn serialize(
+    py_transaction_execution_info: CentralTransactionExecutionInfo,
+) -> RawTransactionExecutionResult {
+    serde_json::to_vec(&py_transaction_execution_info).expect(RESULT_SERIALIZE_ERR)
 }
 
 #[pyclass]
@@ -198,11 +141,10 @@ impl PyBlockExecutor {
     ) -> NativeBlockifierResult<Py<PyBytes>> {
         let tx: Transaction = py_tx(tx, optional_py_class_info).expect(PY_TX_PARSING_ERR);
         let (tx_execution_info, _state_diff) = self.tx_executor().execute(&tx)?;
-        let thin_tx_execution_info =
-            ThinTransactionExecutionInfo::from_tx_execution_info(tx_execution_info);
+        let central_tx_execution_info = CentralTransactionExecutionInfo::from(tx_execution_info);
 
         // Serialize and convert to PyBytes.
-        let serialized_tx_execution_info = thin_tx_execution_info.serialize();
+        let serialized_tx_execution_info = serialize(central_tx_execution_info);
         Ok(Python::with_gil(|py| PyBytes::new(py, &serialized_tx_execution_info).into()))
     }
 
@@ -234,10 +176,9 @@ impl PyBlockExecutor {
             .map(|result| match result {
                 Ok((tx_execution_info, _state_diff)) => (
                     true,
-                    ThinTransactionExecutionInfo::from_tx_execution_info(
+                    serialize(CentralTransactionExecutionInfo::from(
                         tx_execution_info,
-                    )
-                    .serialize(),
+                    )),
                 ),
                 Err(error) => (false, serialize_failure_reason(error)),
             })

crates/shared_execution_objects/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "shared_execution_objects"
+version.workspace = true
+edition.workspace = true
+repository.workspace = true
+license-file.workspace = true
+
+[features]
+deserialize = ["blockifier/transaction_serde"]
+
+[dependencies]
+blockifier.workspace = true
+serde.workspace = true
+starknet_api.workspace = true
+
+[lints]
+workspace = true

crates/shared_execution_objects/src/lib.rs

@@ -0,0 +1 @@
+pub mod objects;

crates/shared_execution_objects/src/objects.rs

@@ -0,0 +1,61 @@
+use std::collections::HashMap;
+
+use blockifier::abi::constants as abi_constants;
+use blockifier::execution::call_info::CallInfo;
+use blockifier::fee::receipt::TransactionReceipt;
+use blockifier::transaction::objects::{ExecutionResourcesTraits, TransactionExecutionInfo};
+use serde::Serialize;
+use starknet_api::execution_resources::GasVector;
+use starknet_api::transaction::fields::Fee;
+
+/// A mapping from a transaction execution resource to its actual usage.
+#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize)]
+pub struct ResourcesMapping(pub HashMap<String, usize>);
+
+impl From<TransactionReceipt> for ResourcesMapping {
+    fn from(receipt: TransactionReceipt) -> ResourcesMapping {
+        let vm_resources = &receipt.resources.computation.vm_resources;
+        let mut resources = HashMap::from([(
+            abi_constants::N_STEPS_RESOURCE.to_string(),
+            vm_resources.total_n_steps() + receipt.resources.computation.n_reverted_steps,
+        )]);
+        resources.extend(
+            vm_resources
+                .prover_builtins()
+                .iter()
+                .map(|(builtin, value)| (builtin.to_str_with_suffix().to_string(), *value)),
+        );
+
+        ResourcesMapping(resources)
+    }
+}
+
+/// The TransactionExecutionInfo object as used by the Python code.
+#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
+#[derive(Debug, Serialize)]
+pub struct CentralTransactionExecutionInfo {
+    pub validate_call_info: Option<CallInfo>,
+    pub execute_call_info: Option<CallInfo>,
+    pub fee_transfer_call_info: Option<CallInfo>,
+    pub actual_fee: Fee,
+    pub da_gas: GasVector,
+    pub actual_resources: ResourcesMapping,
+    pub revert_error: Option<String>,
+    pub total_gas: GasVector,
+}
+
+impl From<TransactionExecutionInfo> for CentralTransactionExecutionInfo {
+    fn from(tx_execution_info: TransactionExecutionInfo) -> CentralTransactionExecutionInfo {
+        CentralTransactionExecutionInfo {
+            validate_call_info: tx_execution_info.validate_call_info,
+            execute_call_info: tx_execution_info.execute_call_info,
+            fee_transfer_call_info: tx_execution_info.fee_transfer_call_info,
+            actual_fee: tx_execution_info.receipt.fee,
+            da_gas: tx_execution_info.receipt.da_gas,
+            revert_error: tx_execution_info.revert_error.map(|error| error.to_string()),
+            total_gas: tx_execution_info.receipt.gas,
+            actual_resources: tx_execution_info.receipt.into(),
+        }
+    }
+}

crates/starknet_consensus_orchestrator/Cargo.toml

@@ -6,9 +6,6 @@ repository.workspace = true
 license-file.workspace = true
 description = "Implements the consensus context and orchestrates the node's components accordingly"
 
-[features]
-deserialize = ["blockifier/transaction_serde"]
-
 [dependencies]
 assert_matches.workspace = true
 async-trait.workspace = true
@@ -24,6 +21,7 @@ paste.workspace = true
 reqwest = { workspace = true, features = ["json"] }
 serde.workspace = true
 serde_json = { workspace = true, features = ["arbitrary_precision"] }
+shared_execution_objects.workspace = true
 starknet-types-core.workspace = true
 starknet_api.workspace = true
 starknet_batcher_types.workspace = true

crates/starknet_consensus_orchestrator/src/cende/central_objects.rs

@@ -1,12 +1,6 @@
-use std::collections::HashMap;
-
 use assert_matches::assert_matches;
-use blockifier::abi::constants as abi_constants;
 use blockifier::bouncer::BouncerWeights;
-use blockifier::execution::call_info::CallInfo;
-use blockifier::fee::receipt::TransactionReceipt;
 use blockifier::state::cached_state::CommitmentStateDiff;
-use blockifier::transaction::objects::{ExecutionResourcesTraits, TransactionExecutionInfo};
 use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;
 use cairo_lang_starknet_classes::NestedIntList;
 use indexmap::{indexmap, IndexMap};
@@ -35,7 +29,6 @@ use starknet_api::executable_transaction::{
     L1HandlerTransaction,
     Transaction,
 };
-use starknet_api::execution_resources::GasVector;
 use starknet_api::state::{StorageKey, ThinStateDiff};
 use starknet_api::transaction::fields::{
     AccountDeploymentData,
@@ -394,54 +387,3 @@ pub fn casm_contract_class_central_format(
         ..compiled_class_hash
     }
 }
-
-/// A mapping from a transaction execution resource to its actual usage.
-#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
-#[derive(Debug, Eq, PartialEq, Serialize)]
-pub struct ResourcesMapping(pub HashMap<String, usize>);
-
-impl From<TransactionReceipt> for ResourcesMapping {
-    fn from(receipt: TransactionReceipt) -> ResourcesMapping {
-        let vm_resources = &receipt.resources.computation.vm_resources;
-        let mut resources = HashMap::from([(
-            abi_constants::N_STEPS_RESOURCE.to_string(),
-            vm_resources.total_n_steps() + receipt.resources.computation.n_reverted_steps,
-        )]);
-        resources.extend(
-            vm_resources
-                .prover_builtins()
-                .iter()
-                .map(|(builtin, value)| (builtin.to_str_with_suffix().to_string(), *value)),
-        );
-
-        ResourcesMapping(resources)
-    }
-}
-
-#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
-#[derive(Debug, Serialize)]
-pub struct CentralTransactionExecutionInfo {
-    pub validate_call_info: Option<CallInfo>,
-    pub execute_call_info: Option<CallInfo>,
-    pub fee_transfer_call_info: Option<CallInfo>,
-    pub actual_fee: Fee,
-    pub da_gas: GasVector,
-    pub actual_resources: ResourcesMapping,
-    pub revert_error: Option<String>,
-    pub total_gas: GasVector,
-}
-
-impl From<TransactionExecutionInfo> for CentralTransactionExecutionInfo {
-    fn from(tx_execution_info: TransactionExecutionInfo) -> CentralTransactionExecutionInfo {
-        CentralTransactionExecutionInfo {
-            validate_call_info: tx_execution_info.validate_call_info,
-            execute_call_info: tx_execution_info.execute_call_info,
-            fee_transfer_call_info: tx_execution_info.fee_transfer_call_info,
-            actual_fee: tx_execution_info.receipt.fee,
-            da_gas: tx_execution_info.receipt.da_gas,
-            revert_error: tx_execution_info.revert_error.map(|error| error.to_string()),
-            total_gas: tx_execution_info.receipt.gas,
-            actual_resources: tx_execution_info.receipt.into(),
-        }
-    }
-}

crates/starknet_consensus_orchestrator/src/cende/central_objects_test.rs

@@ -45,6 +45,7 @@ use indexmap::indexmap;
 use num_bigint::BigUint;
 use rstest::rstest;
 use serde_json::Value;
+use shared_execution_objects::objects::CentralTransactionExecutionInfo;
 use starknet_api::block::{
     BlockHash,
     BlockInfo,
@@ -111,7 +112,6 @@ use super::{
     CentralInvokeTransaction,
     CentralStateDiff,
     CentralTransaction,
-    CentralTransactionExecutionInfo,
     CentralTransactionWritten,
 };
 use crate::cende::central_objects::casm_contract_class_central_format;