refactor(starknet_gateway, starknet_mempool): align tests with InternalRpcTx change

Author: noamsp-starkware

crates/papyrus_test_utils/src/lib.rs

@@ -87,8 +87,12 @@ use starknet_api::deprecated_contract_class::{
 use starknet_api::execution_resources::{Builtin, ExecutionResources, GasAmount, GasVector};
 use starknet_api::hash::{PoseidonHash, StarkHash};
 use starknet_api::rpc_transaction::{
+    DeployAccountTransactionV3WithAddress,
     EntryPointByType as RpcEntryPointByType,
     EntryPointByType,
+    InternalRpcDeclareTransactionV3,
+    InternalRpcTransaction,
+    InternalRpcTransactionWithoutTxHash,
     RpcDeclareTransaction,
     RpcDeclareTransactionV3,
     RpcDeployAccountTransaction,
@@ -749,6 +753,32 @@ auto_impl_get_test_instance! {
         pub max_amount: GasAmount,
         pub max_price_per_unit: GasPrice,
     }
+    pub struct InternalRpcTransaction {
+        pub tx: InternalRpcTransactionWithoutTxHash,
+        pub tx_hash: TransactionHash,
+    }
+    pub enum InternalRpcTransactionWithoutTxHash {
+        Declare(InternalRpcDeclareTransactionV3) = 0,
+        Invoke(RpcInvokeTransaction) = 1,
+        DeployAccount(DeployAccountTransactionV3WithAddress) = 2,
+    }
+    pub struct InternalRpcDeclareTransactionV3 {
+        pub sender_address: ContractAddress,
+        pub compiled_class_hash: CompiledClassHash,
+        pub signature: TransactionSignature,
+        pub nonce: Nonce,
+        pub class_hash: ClassHash,
+        pub resource_bounds: AllResourceBounds,
+        pub tip: Tip,
+        pub paymaster_data: PaymasterData,
+        pub account_deployment_data: AccountDeploymentData,
+        pub nonce_data_availability_mode: DataAvailabilityMode,
+        pub fee_data_availability_mode: DataAvailabilityMode,
+    }
+    pub struct DeployAccountTransactionV3WithAddress {
+        pub tx: RpcDeployAccountTransaction,
+        pub contract_address: ContractAddress,
+    }
     pub enum RpcTransaction {
         Declare(RpcDeclareTransaction) = 0,
         DeployAccount(RpcDeployAccountTransaction) = 1,

crates/starknet_gateway/src/gateway_test.rs

@@ -10,8 +10,14 @@ 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::{EmptyClassManagerClient, SharedClassManagerClient};
 use starknet_gateway_types::errors::GatewaySpecError;
@@ -119,18 +125,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

@@ -11,8 +11,11 @@ use papyrus_network_types::network_types::BroadcastedMessageMetadata;
 use papyrus_protobuf::mempool::RpcTransactionWrapper;
 use papyrus_test_utils::{get_rng, GetTestInstance};
 use starknet_api::core::ChainId;
-use starknet_api::rpc_transaction::RpcTransaction;
-use starknet_class_manager_types::transaction_converter::TransactionConverter;
+use starknet_api::rpc_transaction::InternalRpcTransaction;
+use starknet_class_manager_types::transaction_converter::{
+    TransactionConverter,
+    TransactionConverterTrait,
+};
 use starknet_class_manager_types::EmptyClassManagerClient;
 use starknet_mempool_p2p_types::communication::MempoolP2pPropagatorRequest;
 use starknet_sequencer_infra::component_definitions::ComponentRequestHandler;
@@ -29,14 +32,16 @@ async fn process_handle_add_tx() {
     let BroadcastTopicChannels { broadcasted_messages_receiver: _, broadcast_topic_client } =
         subscriber_channels;
     let BroadcastNetworkMock { mut messages_to_broadcast_receiver, .. } = mock_network;
-    let rpc_transaction = RpcTransaction::get_test_instance(&mut get_rng());
+    let internal_tx = InternalRpcTransaction::get_test_instance(&mut get_rng());
     // TODO(noamsp): use MockTransactionConverterTrait
     let transaction_converter =
         TransactionConverter::new(Arc::new(EmptyClassManagerClient), ChainId::create_for_testing());
+    let rpc_transaction =
+        transaction_converter.convert_internal_rpc_tx_to_rpc_tx(internal_tx.clone()).await.unwrap();
     let mut mempool_p2p_propagator =
         MempoolP2pPropagator::new(broadcast_topic_client, transaction_converter);
     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));