feat(starknet_gateway): get executable tx from class manager

Author: noamsp-starkware

crates/starknet_class_manager_types/src/transaction_converter.rs

@@ -58,6 +58,7 @@ pub trait TransactionConverterTrait {
     ) -> TransactionConverterResult<AccountTransaction>;
 }
 
+#[derive(Clone)]
 pub struct TransactionConverter {
     class_manager_client: SharedClassManagerClient,
     chain_id: ChainId,

crates/starknet_gateway/src/compilation.rs

@@ -23,6 +23,7 @@ pub struct GatewayCompiler {
     pub sierra_to_casm_compiler: Arc<dyn SierraToCasmCompiler>,
 }
 
+#[allow(dead_code)]
 impl GatewayCompiler {
     pub fn new_command_line_compiler(config: SierraCompilationConfig) -> Self {
         Self { sierra_to_casm_compiler: Arc::new(CommandLineCompiler::new(config)) }

crates/starknet_gateway/src/gateway.rs

@@ -6,7 +6,10 @@ use papyrus_network_types::network_types::BroadcastedMessageMetadata;
 use starknet_api::executable_transaction::AccountTransaction;
 use starknet_api::rpc_transaction::RpcTransaction;
 use starknet_api::transaction::TransactionHash;
-use starknet_class_manager_types::transaction_converter::TransactionConverter;
+use starknet_class_manager_types::transaction_converter::{
+    TransactionConverter,
+    TransactionConverterTrait,
+};
 use starknet_class_manager_types::SharedClassManagerClient;
 use starknet_gateway_types::errors::GatewaySpecError;
 use starknet_mempool_types::communication::{AddTransactionArgsWrapper, SharedMempoolClient};
@@ -23,7 +26,6 @@ use crate::state_reader::StateReaderFactory;
 use crate::stateful_transaction_validator::StatefulTransactionValidator;
 use crate::stateless_transaction_validator::StatelessTransactionValidator;
 use crate::sync_state_reader::SyncStateReaderFactory;
-use crate::utils::compile_contract_and_build_executable_tx;
 
 #[cfg(test)]
 #[path = "gateway_test.rs"]
@@ -80,7 +82,8 @@ impl Gateway {
                 .map_err(|join_err| {
                     error!("Failed to process tx: {}", join_err);
                     GatewaySpecError::UnexpectedError { data: "Internal server error".to_owned() }
-                })??;
+                })?
+                .await?;
 
         let tx_hash = add_tx_args.tx.tx_hash();
 
@@ -97,10 +100,13 @@ struct ProcessTxBlockingTask {
     stateless_tx_validator: Arc<StatelessTransactionValidator>,
     stateful_tx_validator: Arc<StatefulTransactionValidator>,
     state_reader_factory: Arc<dyn StateReaderFactory>,
+    // TODO(noamsp): remove gatewayCompiler from here and erase it
+    #[allow(dead_code)]
     gateway_compiler: Arc<GatewayCompiler>,
     mempool_client: SharedMempoolClient,
     chain_info: ChainInfo,
     tx: RpcTransaction,
+    transaction_converter: TransactionConverter,
 }
 
 impl ProcessTxBlockingTask {
@@ -113,20 +119,32 @@ impl ProcessTxBlockingTask {
             mempool_client: gateway.mempool_client.clone(),
             chain_info: gateway.chain_info.clone(),
             tx,
+            transaction_converter: gateway.transaction_converter.clone(),
         }
     }
 
-    fn process_tx(self) -> GatewayResult<AddTransactionArgs> {
+    async fn process_tx(self) -> GatewayResult<AddTransactionArgs> {
         // TODO(Arni, 1/5/2024): Perform congestion control.
 
         // Perform stateless validations.
         self.stateless_tx_validator.validate(&self.tx)?;
 
-        let executable_tx = compile_contract_and_build_executable_tx(
-            self.tx,
-            self.gateway_compiler.as_ref(),
-            &self.chain_info.chain_id,
-        )?;
+        let internal_tx =
+            self.transaction_converter.convert_rpc_tx_to_internal_rpc_tx(self.tx).await.map_err(
+                |err| {
+                    error!(
+                        "Failed to convert internal RPC transaction to executable transaction: {}",
+                        err
+                    );
+                    GatewaySpecError::UnexpectedError { data: "Internal server error.".to_owned() }
+                },
+            )?;
+
+        let executable_tx = self
+            .transaction_converter
+            .convert_internal_rpc_tx_to_executable_tx(internal_tx.clone())
+            .await
+            .unwrap();
 
         // Perform post compilation validations.
         if let AccountTransaction::Declare(executable_declare_tx) = &executable_tx {
@@ -152,6 +170,7 @@ impl ProcessTxBlockingTask {
         )?;
 
         // TODO(Arni): Add the Sierra and the Casm to the mempool input.
+        // TODO(noamsp): put internal_tx instead of executable_tx
         Ok(AddTransactionArgs { tx: executable_tx, account_state: AccountState { address, nonce } })
     }
 }

crates/starknet_gateway/src/utils.rs

@@ -15,6 +15,7 @@ use crate::errors::GatewayResult;
 /// Converts an RPC transaction to an executable transaction.
 /// Note, for declare transaction this step is heavy, as it requires compilation of Sierra to
 /// executable contract class.
+#[allow(dead_code)]
 pub fn compile_contract_and_build_executable_tx(
     rpc_tx: RpcTransaction,
     gateway_compiler: &GatewayCompiler,

crates/starknet_mempool_types/src/mempool_types.rs

@@ -21,6 +21,7 @@ impl std::fmt::Display for AccountState {
     }
 }
 
+// TODO(noamsp): Change tx to InternalRpcTransaction.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct AddTransactionArgs {
     pub tx: AccountTransaction,