refactor: align gateway and mempool tests with InternalRpcTx change

Author: noamsp-starkware

crates/starknet_gateway/src/gateway_test.rs

@@ -9,9 +9,13 @@ use papyrus_network_types::network_types::BroadcastedMessageMetadata;
 use papyrus_test_utils::{get_rng, GetTestInstance};
 use rstest::{fixture, rstest};
 use starknet_api::core::{ChainId, CompiledClassHash, ContractAddress, Nonce};
-use starknet_api::executable_transaction::{AccountTransaction, InvokeTransaction};
-use starknet_api::rpc_transaction::{RpcDeclareTransaction, RpcTransaction};
-use starknet_api::transaction::TransactionHash;
+use starknet_api::rpc_transaction::{
+    InternalRpcTransaction,
+    InternalRpcTransactionWithoutTxHash,
+    RpcDeclareTransaction,
+    RpcTransaction,
+};
+use starknet_api::transaction::{InvokeTransaction, TransactionHash, TransactionVersion};
 use starknet_class_manager_types::test_utils::MemoryClassManagerClient;
 use starknet_class_manager_types::transaction_converter::TransactionConverter;
 use starknet_class_manager_types::SharedClassManagerClient;
@@ -61,12 +65,7 @@ fn mock_dependencies(
 ) -> MockDependencies {
     let mock_mempool_client = MockMempoolClient::new();
     let class_manager_client = Arc::new(MemoryClassManagerClient::new());
-    MockDependencies {
-        config,
-        state_reader_factory,
-        mock_mempool_client,
-        class_manager_client,
-    }
+    MockDependencies { config, state_reader_factory, mock_mempool_client, class_manager_client }
 }
 
 struct MockDependencies {
@@ -131,18 +130,28 @@ async fn test_add_tx(
     #[case] expected_result: Result<(), MempoolClientError>,
     #[case] expected_error: Option<GatewaySpecError>,
 ) {
+    use starknet_api::transaction::TransactionHasher;
+
     let (rpc_tx, address) = create_tx();
     let rpc_invoke_tx =
         assert_matches!(rpc_tx.clone(), RpcTransaction::Invoke(rpc_invoke_tx) => rpc_invoke_tx);
-    let executable_tx = AccountTransaction::Invoke(
-        InvokeTransaction::from_rpc_tx(rpc_invoke_tx, &ChainId::create_for_testing()).unwrap(),
-    );
 
-    let tx_hash = executable_tx.tx_hash();
+    let InvokeTransaction::V3(invoke_tx): InvokeTransaction = rpc_invoke_tx.clone().into() else {
+        panic!("Unexpected transaction version")
+    };
+
+    let tx_hash = invoke_tx
+        .calculate_transaction_hash(&ChainId::create_for_testing(), &TransactionVersion::THREE)
+        .unwrap();
+
+    let internal_invoke_tx = InternalRpcTransaction {
+        tx: InternalRpcTransactionWithoutTxHash::Invoke(rpc_invoke_tx.clone()),
+        tx_hash,
+    };
 
     let p2p_message_metadata = Some(BroadcastedMessageMetadata::get_test_instance(&mut get_rng()));
     let add_tx_args = AddTransactionArgs {
-        tx: executable_tx,
+        tx: internal_invoke_tx,
         account_state: AccountState { address, nonce: *rpc_tx.nonce() },
     };
     mock_dependencies.expect_add_tx(

crates/starknet_mempool/src/test_utils.rs

@@ -1,7 +1,7 @@
 use std::collections::{HashMap, HashSet};
 
 use pretty_assertions::assert_eq;
-use starknet_api::executable_transaction::AccountTransaction;
+use starknet_api::rpc_transaction::InternalRpcTransaction;
 use starknet_api::{contract_address, nonce, tx_hash};
 use starknet_mempool_types::errors::MempoolError;
 use starknet_mempool_types::mempool_types::{AddTransactionArgs, CommitBlockArgs};
@@ -21,7 +21,7 @@ macro_rules! tx {
     ) => {{
             use starknet_api::block::GasPrice;
             use starknet_api::{invoke_tx_args, tx_hash};
-            use starknet_api::test_utils::invoke::executable_invoke_tx;
+            use starknet_api::test_utils::invoke::internal_invoke_tx;
             use starknet_api::transaction::fields::{
                 AllResourceBounds,
                 ResourceBounds,
@@ -37,7 +37,7 @@ macro_rules! tx {
                 ..Default::default()
             });
 
-            executable_invoke_tx(invoke_tx_args!{
+            internal_invoke_tx(invoke_tx_args!{
                 tx_hash: tx_hash!($tx_hash),
                 sender_address: contract_address!($address),
                 nonce: nonce!($tx_nonce),
@@ -256,7 +256,7 @@ pub fn commit_block(
 pub fn get_txs_and_assert_expected(
     mempool: &mut Mempool,
     n_txs: usize,
-    expected_txs: &[AccountTransaction],
+    expected_txs: &[InternalRpcTransaction],
 ) {
     let txs = mempool.get_txs(n_txs).unwrap();
     assert_eq!(txs, expected_txs);

crates/starknet_mempool_p2p/src/propagator/test.rs

@@ -12,6 +12,10 @@ use papyrus_protobuf::mempool::RpcTransactionWrapper;
 use papyrus_test_utils::{get_rng, GetTestInstance};
 use starknet_api::rpc_transaction::RpcTransaction;
 use starknet_class_manager_types::test_utils::MemoryClassManagerClient;
+use starknet_class_manager_types::transaction_converter::{
+    TransactionConverter,
+    TransactionConverterTrait,
+};
 use starknet_mempool_p2p_types::communication::MempoolP2pPropagatorRequest;
 use starknet_sequencer_infra::component_definitions::ComponentRequestHandler;
 use tokio::time::timeout;
@@ -29,10 +33,16 @@ async fn process_handle_add_tx() {
     let BroadcastNetworkMock { mut messages_to_broadcast_receiver, .. } = mock_network;
     let rpc_transaction = RpcTransaction::get_test_instance(&mut get_rng());
     let class_manager_client = Arc::new(MemoryClassManagerClient::new());
+    let transaction_converter =
+        TransactionConverter { class_manager_client: class_manager_client.clone() };
+    let internal_tx = transaction_converter
+        .convert_rpc_tx_to_internal_rpc_tx(rpc_transaction.clone())
+        .await
+        .unwrap();
     let mut mempool_p2p_propagator =
         MempoolP2pPropagator::new(broadcast_topic_client, class_manager_client);
     mempool_p2p_propagator
-        .handle_request(MempoolP2pPropagatorRequest::AddTransaction(rpc_transaction.clone()))
+        .handle_request(MempoolP2pPropagatorRequest::AddTransaction(internal_tx))
         .await;
     let message = timeout(TIMEOUT, messages_to_broadcast_receiver.next()).await.unwrap().unwrap();
     assert_eq!(message, RpcTransactionWrapper(rpc_transaction));