feat(starknet_mempool): handle declare tx properly

Author: noamsp-starkware

crates/starknet_gateway/src/gateway_test.rs

@@ -9,15 +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::{
     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;

crates/starknet_mempool/src/communication.rs

@@ -1,12 +1,7 @@
 use async_trait::async_trait;
 use papyrus_network_types::network_types::BroadcastedMessageMetadata;
 use starknet_api::core::ContractAddress;
-use starknet_api::executable_transaction::AccountTransaction;
-use starknet_api::rpc_transaction::{
-    RpcDeployAccountTransaction,
-    RpcInvokeTransaction,
-    RpcTransaction,
-};
+use starknet_api::rpc_transaction::InternalRpcTransaction;
 use starknet_mempool_p2p_types::communication::SharedMempoolP2pPropagatorClient;
 use starknet_mempool_types::communication::{
     AddTransactionArgsWrapper,
@@ -47,33 +42,20 @@ impl MempoolCommunicationWrapper {
     async fn send_tx_to_p2p(
         &self,
         message_metadata: Option<BroadcastedMessageMetadata>,
-        tx: AccountTransaction,
+        tx: InternalRpcTransaction,
     ) -> MempoolResult<()> {
         match message_metadata {
             Some(message_metadata) => self
                 .mempool_p2p_propagator_client
                 .continue_propagation(message_metadata)
                 .await
-                .map_err(|_| MempoolError::P2pPropagatorClientError { tx_hash: tx.tx_hash() }),
+                .map_err(|_| MempoolError::P2pPropagatorClientError { tx_hash: tx.tx_hash }),
             None => {
-                let tx_hash = tx.tx_hash();
-                match tx {
-                    AccountTransaction::Invoke(invoke_tx) => self
-                        .mempool_p2p_propagator_client
-                        .add_transaction(RpcTransaction::Invoke(RpcInvokeTransaction::V3(
-                            invoke_tx.into(),
-                        )))
-                        .await
-                        .map_err(|_| MempoolError::P2pPropagatorClientError { tx_hash })?,
-                    AccountTransaction::DeployAccount(deploy_account_tx) => self
-                        .mempool_p2p_propagator_client
-                        .add_transaction(RpcTransaction::DeployAccount(
-                            RpcDeployAccountTransaction::V3(deploy_account_tx.into()),
-                        ))
-                        .await
-                        .map_err(|_| MempoolError::P2pPropagatorClientError { tx_hash })?,
-                    AccountTransaction::Declare(_) => {}
-                }
+                let tx_hash = tx.tx_hash;
+                self.mempool_p2p_propagator_client
+                    .add_transaction(tx)
+                    .await
+                    .map_err(|_| MempoolError::P2pPropagatorClientError { tx_hash })?;
                 Ok(())
             }
         }
@@ -85,18 +67,14 @@ impl MempoolCommunicationWrapper {
     ) -> MempoolResult<()> {
         self.mempool.add_tx(args_wrapper.args.clone())?;
         // TODO(AlonH): Verify that only transactions that were added to the mempool are sent.
-        // TODO(AlonH): handle declare correctly and remove this match.
-        match args_wrapper.args.tx {
-            AccountTransaction::Declare(_) => Ok(()),
-            _ => self.send_tx_to_p2p(args_wrapper.p2p_message_metadata, args_wrapper.args.tx).await,
-        }
+        self.send_tx_to_p2p(args_wrapper.p2p_message_metadata, args_wrapper.args.tx).await
     }
 
     fn commit_block(&mut self, args: CommitBlockArgs) -> MempoolResult<()> {
         self.mempool.commit_block(args)
     }
 
-    fn get_txs(&mut self, n_txs: usize) -> MempoolResult<Vec<AccountTransaction>> {
+    fn get_txs(&mut self, n_txs: usize) -> MempoolResult<Vec<InternalRpcTransaction>> {
         self.mempool.get_txs(n_txs)
     }
 

crates/starknet_mempool_p2p/src/propagator/mod.rs

@@ -4,7 +4,10 @@ mod test;
 use async_trait::async_trait;
 use papyrus_network::network_manager::{BroadcastTopicClient, BroadcastTopicClientTrait};
 use papyrus_protobuf::mempool::RpcTransactionWrapper;
-use starknet_class_manager_types::transaction_converter::TransactionConverter;
+use starknet_class_manager_types::transaction_converter::{
+    TransactionConverter,
+    TransactionConverterTrait,
+};
 use starknet_mempool_p2p_types::communication::{
     MempoolP2pPropagatorRequest,
     MempoolP2pPropagatorResponse,
@@ -16,15 +19,15 @@ use tracing::warn;
 
 pub struct MempoolP2pPropagator {
     broadcast_topic_client: BroadcastTopicClient<RpcTransactionWrapper>,
-    _transaction_converter: TransactionConverter,
+    transaction_converter: TransactionConverter,
 }
 
 impl MempoolP2pPropagator {
     pub fn new(
         broadcast_topic_client: BroadcastTopicClient<RpcTransactionWrapper>,
         transaction_converter: TransactionConverter,
     ) -> Self {
-        Self { broadcast_topic_client, _transaction_converter: transaction_converter }
+        Self { broadcast_topic_client, transaction_converter }
     }
 }
 
@@ -38,6 +41,19 @@ impl ComponentRequestHandler<MempoolP2pPropagatorRequest, MempoolP2pPropagatorRe
     ) -> MempoolP2pPropagatorResponse {
         match request {
             MempoolP2pPropagatorRequest::AddTransaction(transaction) => {
+                let transaction = match self
+                    .transaction_converter
+                    .convert_internal_rpc_tx_to_rpc_tx(transaction)
+                    .await
+                {
+                    Ok(transaction) => transaction,
+                    Err(err) => {
+                        return MempoolP2pPropagatorResponse::AddTransaction(Err(
+                            MempoolP2pPropagatorError::TransactionConversionError(err.to_string()),
+                        ));
+                    }
+                };
+
                 let result = self
                     .broadcast_topic_client
                     .broadcast_message(RpcTransactionWrapper(transaction))

crates/starknet_mempool_p2p_types/src/errors.rs

@@ -5,4 +5,6 @@ use thiserror::Error;
 pub enum MempoolP2pPropagatorError {
     #[error("Sender request error")]
     NetworkSendError,
+    #[error("Transaction conversion error: {0}")]
+    TransactionConversionError(String),
 }