Merge main into dvir/consen_manager

crates/papyrus_network/src/db_executor/mod.rs

@@ -6,8 +6,6 @@ use futures::channel::mpsc::Sender;
 use futures::future::{pending, poll_fn};
 #[cfg(test)]
 use mockall::automock;
-use papyrus_protobuf::converters::common::volition_domain_to_enum_int;
-use papyrus_protobuf::converters::state_diff::DOMAIN;
 use papyrus_protobuf::protobuf;
 use papyrus_protobuf::sync::{
     BlockHashOrNumber,
@@ -259,96 +257,6 @@ impl FetchBlockDataFromDb for DataType {
     }
 }
 
-// A wrapper struct for Vec<StateDiffsResponse> so that we can implement traits for it.
-pub struct StateDiffsResponseVec(pub Vec<protobuf::StateDiffsResponse>);
-
-impl From<ThinStateDiff> for StateDiffsResponseVec {
-    fn from(value: ThinStateDiff) -> Self {
-        let mut result = Vec::new();
-
-        for (contract_address, class_hash) in
-            value.deployed_contracts.into_iter().chain(value.replaced_classes.into_iter())
-        {
-            result.push(protobuf::StateDiffsResponse {
-                state_diff_message: Some(
-                    protobuf::state_diffs_response::StateDiffMessage::ContractDiff(
-                        protobuf::ContractDiff {
-                            address: Some(contract_address.into()),
-                            class_hash: Some(class_hash.0.into()),
-                            domain: volition_domain_to_enum_int(DOMAIN),
-                            ..Default::default()
-                        },
-                    ),
-                ),
-            });
-        }
-        for (contract_address, storage_diffs) in value.storage_diffs {
-            if storage_diffs.is_empty() {
-                continue;
-            }
-            result.push(protobuf::StateDiffsResponse {
-                state_diff_message: Some(
-                    protobuf::state_diffs_response::StateDiffMessage::ContractDiff(
-                        protobuf::ContractDiff {
-                            address: Some(contract_address.into()),
-                            values: storage_diffs
-                                .into_iter()
-                                .map(|(key, value)| protobuf::ContractStoredValue {
-                                    key: Some((*key.0.key()).into()),
-                                    value: Some(value.into()),
-                                })
-                                .collect(),
-                            domain: volition_domain_to_enum_int(DOMAIN),
-                            ..Default::default()
-                        },
-                    ),
-                ),
-            });
-        }
-        for (contract_address, nonce) in value.nonces {
-            result.push(protobuf::StateDiffsResponse {
-                state_diff_message: Some(
-                    protobuf::state_diffs_response::StateDiffMessage::ContractDiff(
-                        protobuf::ContractDiff {
-                            address: Some(contract_address.into()),
-                            nonce: Some(nonce.0.into()),
-                            domain: volition_domain_to_enum_int(DOMAIN),
-                            ..Default::default()
-                        },
-                    ),
-                ),
-            });
-        }
-
-        for (class_hash, compiled_class_hash) in value.declared_classes {
-            result.push(protobuf::StateDiffsResponse {
-                state_diff_message: Some(
-                    protobuf::state_diffs_response::StateDiffMessage::DeclaredClass(
-                        protobuf::DeclaredClass {
-                            class_hash: Some(class_hash.0.into()),
-                            compiled_class_hash: Some(compiled_class_hash.0.into()),
-                        },
-                    ),
-                ),
-            });
-        }
-        for class_hash in value.deprecated_declared_classes {
-            result.push(protobuf::StateDiffsResponse {
-                state_diff_message: Some(
-                    protobuf::state_diffs_response::StateDiffMessage::DeclaredClass(
-                        protobuf::DeclaredClass {
-                            class_hash: Some(class_hash.0.into()),
-                            compiled_class_hash: None,
-                        },
-                    ),
-                ),
-            });
-        }
-
-        Self(result)
-    }
-}
-
 pub fn split_thin_state_diff(thin_state_diff: ThinStateDiff) -> Vec<StateDiffChunk> {
     let mut state_diff_chunks = Vec::new();
     let mut contract_addresses = std::collections::HashSet::new();

crates/papyrus_network/src/lib.rs

@@ -16,7 +16,6 @@ mod utils;
 
 use std::collections::{BTreeMap, HashMap};
 use std::time::Duration;
-use std::usize;
 
 use derive_more::Display;
 use enum_iterator::Sequence;

crates/papyrus_protobuf/src/converters/event.rs

@@ -1,3 +1,6 @@
+#[cfg(test)]
+#[path = "event_test.rs"]
+mod event_test;
 use prost::Message;
 use starknet_api::core::{ContractAddress, PatriciaKey};
 use starknet_api::transaction::{Event, EventContent, EventData, EventKey, TransactionHash};

crates/papyrus_protobuf/src/converters/event_test.rs

@@ -0,0 +1,25 @@
+use starknet_api::transaction::{Event, TransactionHash};
+use test_utils::{get_rng, GetTestInstance};
+
+use crate::sync::DataOrFin;
+
+#[test]
+fn convert_event_to_vec_u8_and_back() {
+    let mut rng = get_rng();
+    let event = Event::get_test_instance(&mut rng);
+    let mut rng = get_rng();
+    let transaction_hash = TransactionHash::get_test_instance(&mut rng);
+
+    let data = DataOrFin(Some((event, transaction_hash)));
+    let bytes_data = Vec::<u8>::from(data.clone());
+    let res_data = DataOrFin::try_from(bytes_data).unwrap();
+    assert_eq!(data, res_data);
+}
+
+#[test]
+fn fin_event_to_bytes_and_back() {
+    let bytes_data = Vec::<u8>::from(DataOrFin::<(Event, TransactionHash)>(None));
+
+    let res_data = DataOrFin::<(Event, TransactionHash)>::try_from(bytes_data).unwrap();
+    assert!(res_data.0.is_none());
+}

crates/papyrus_protobuf/src/converters/transaction_test.rs

@@ -32,103 +32,103 @@ macro_rules! create_transaction_output {
 }
 
 #[test]
-fn test_l1_handler_transaction() {
+fn convert_l1_handler_transaction_to_vec_u8_and_back() {
     let mut rng = get_rng();
     let transaction = starknet_api::transaction::L1HandlerTransaction::get_test_instance(&mut rng);
     let transaction = StarknetApiTransaction::L1Handler(transaction);
 
     let transaction_output = create_transaction_output!(L1HandlerTransactionOutput, L1Handler);
-    transaction_test(transaction, transaction_output);
+    convert_transaction_to_vec_u8_and_back(transaction, transaction_output);
 }
 
 #[test]
-fn test_deploy_transaction() {
+fn convert_deploy_transaction_to_vec_u8_and_back() {
     let mut rng = get_rng();
     let transaction = starknet_api::transaction::DeployTransaction::get_test_instance(&mut rng);
     let transaction = StarknetApiTransaction::Deploy(transaction);
 
     let transaction_output = create_transaction_output!(DeployTransactionOutput, Deploy);
-    transaction_test(transaction, transaction_output);
+    convert_transaction_to_vec_u8_and_back(transaction, transaction_output);
 }
 
 #[test]
-fn test_declare_transaction_v0() {
+fn convert_declare_transaction_v0_to_vec_u8_and_back() {
     let mut rng = get_rng();
     let transaction =
         starknet_api::transaction::DeclareTransactionV0V1::get_test_instance(&mut rng);
     let transaction = StarknetApiTransaction::Declare(DeclareTransaction::V0(transaction));
 
     let transaction_output = create_transaction_output!(DeclareTransactionOutput, Declare);
-    transaction_test(transaction, transaction_output);
+    convert_transaction_to_vec_u8_and_back(transaction, transaction_output);
 }
 
 #[test]
-fn test_declare_transaction_v1() {
+fn convert_declare_transaction_v1_to_vec_u8_and_back() {
     let mut rng = get_rng();
     let transaction =
         starknet_api::transaction::DeclareTransactionV0V1::get_test_instance(&mut rng);
     let transaction = StarknetApiTransaction::Declare(DeclareTransaction::V1(transaction));
 
     let transaction_output = create_transaction_output!(DeclareTransactionOutput, Declare);
-    transaction_test(transaction, transaction_output);
+    convert_transaction_to_vec_u8_and_back(transaction, transaction_output);
 }
 
 #[test]
-fn test_declare_transaction_v2() {
+fn convert_declare_transaction_v2_to_vec_u8_and_back() {
     let mut rng = get_rng();
     let transaction = starknet_api::transaction::DeclareTransactionV2::get_test_instance(&mut rng);
     let transaction = StarknetApiTransaction::Declare(DeclareTransaction::V2(transaction));
 
     let transaction_output = create_transaction_output!(DeclareTransactionOutput, Declare);
-    transaction_test(transaction, transaction_output);
+    convert_transaction_to_vec_u8_and_back(transaction, transaction_output);
 }
 
 #[test]
-fn test_declare_transaction_v3() {
+fn convert_declare_transaction_v3_to_vec_u8_and_back() {
     let mut rng = get_rng();
     let mut transaction =
         starknet_api::transaction::DeclareTransactionV3::get_test_instance(&mut rng);
     transaction.resource_bounds = RESOURCE_BOUNDS_MAPPING.clone();
     let transaction = StarknetApiTransaction::Declare(DeclareTransaction::V3(transaction));
 
     let transaction_output = create_transaction_output!(DeclareTransactionOutput, Declare);
-    transaction_test(transaction, transaction_output);
+    convert_transaction_to_vec_u8_and_back(transaction, transaction_output);
 }
 
 #[test]
-fn test_invoke_transaction_v0() {
+fn convert_invoke_transaction_v0_to_vec_u8_and_back() {
     let mut rng = get_rng();
     let transaction = starknet_api::transaction::InvokeTransactionV0::get_test_instance(&mut rng);
     let transaction = StarknetApiTransaction::Invoke(InvokeTransaction::V0(transaction));
 
     let transaction_output = create_transaction_output!(InvokeTransactionOutput, Invoke);
-    transaction_test(transaction, transaction_output);
+    convert_transaction_to_vec_u8_and_back(transaction, transaction_output);
 }
 
 #[test]
-fn test_invoke_transaction_v1() {
+fn convert_invoke_transaction_v1_to_vec_u8_and_back() {
     let mut rng = get_rng();
     let transaction = starknet_api::transaction::InvokeTransactionV1::get_test_instance(&mut rng);
     let transaction = StarknetApiTransaction::Invoke(InvokeTransaction::V1(transaction));
 
     let transaction_output = create_transaction_output!(InvokeTransactionOutput, Invoke);
-    transaction_test(transaction, transaction_output);
+    convert_transaction_to_vec_u8_and_back(transaction, transaction_output);
 }
 
 #[test]
-fn test_invoke_transaction_v3() {
+fn convert_invoke_transaction_v3_to_vec_u8_and_back() {
     let mut rng = get_rng();
     let mut transaction =
         starknet_api::transaction::InvokeTransactionV3::get_test_instance(&mut rng);
     transaction.resource_bounds = RESOURCE_BOUNDS_MAPPING.clone();
     let transaction = StarknetApiTransaction::Invoke(InvokeTransaction::V3(transaction));
 
     let transaction_output = create_transaction_output!(InvokeTransactionOutput, Invoke);
-    transaction_test(transaction, transaction_output);
+    convert_transaction_to_vec_u8_and_back(transaction, transaction_output);
 }
 
 #[test]
-fn test_deploy_account_transaction_v1() {
+fn convert_deploy_account_transaction_v1_to_vec_u8_and_back() {
     let mut rng = get_rng();
     let transaction =
         starknet_api::transaction::DeployAccountTransactionV1::get_test_instance(&mut rng);
@@ -137,11 +137,11 @@ fn test_deploy_account_transaction_v1() {
 
     let transaction_output =
         create_transaction_output!(DeployAccountTransactionOutput, DeployAccount);
-    transaction_test(transaction, transaction_output);
+    convert_transaction_to_vec_u8_and_back(transaction, transaction_output);
 }
 
 #[test]
-fn test_deploy_account_transaction_v3() {
+fn convert_deploy_account_transaction_v3_to_vec_u8_and_back() {
     let mut rng = get_rng();
     let mut transaction =
         starknet_api::transaction::DeployAccountTransactionV3::get_test_instance(&mut rng);
@@ -151,10 +151,23 @@ fn test_deploy_account_transaction_v3() {
 
     let transaction_output =
         create_transaction_output!(DeployAccountTransactionOutput, DeployAccount);
-    transaction_test(transaction, transaction_output);
+    convert_transaction_to_vec_u8_and_back(transaction, transaction_output);
 }
 
-fn transaction_test(transaction: StarknetApiTransaction, transaction_output: TransactionOutput) {
+#[test]
+fn fin_transaction_to_bytes_and_back() {
+    let bytes_data =
+        Vec::<u8>::from(DataOrFin::<(StarknetApiTransaction, TransactionOutput)>(None));
+
+    let res_data =
+        DataOrFin::<(StarknetApiTransaction, TransactionOutput)>::try_from(bytes_data).unwrap();
+    assert!(res_data.0.is_none());
+}
+
+fn convert_transaction_to_vec_u8_and_back(
+    transaction: StarknetApiTransaction,
+    transaction_output: TransactionOutput,
+) {
     let data = DataOrFin(Some((transaction, transaction_output)));
     let bytes_data = Vec::<u8>::from(data.clone());
     let res_data = DataOrFin::try_from(bytes_data).unwrap();

crates/test_utils/src/lib.rs

@@ -376,7 +376,7 @@ pub fn get_test_block(
     keys: Option<Vec<Vec<EventKey>>>,
 ) -> Block {
     let mut rng = get_rng();
-    let events_per_tx = if let Some(events_per_tx) = events_per_tx { events_per_tx } else { 0 };
+    let events_per_tx = events_per_tx.unwrap_or_default();
     get_rand_test_block_with_events(
         &mut rng,
         transaction_count,
@@ -394,7 +394,7 @@ pub fn get_test_body(
     keys: Option<Vec<Vec<EventKey>>>,
 ) -> BlockBody {
     let mut rng = get_rng();
-    let events_per_tx = if let Some(events_per_tx) = events_per_tx { events_per_tx } else { 0 };
+    let events_per_tx = events_per_tx.unwrap_or_default();
     get_rand_test_body_with_events(&mut rng, transaction_count, events_per_tx, from_addresses, keys)
 }