apollo_gateway: dependency inject transaction converter

Author: alonh5

Cargo.lock

@@ -23,7 +23,13 @@ starknet_api.workspace = true
 strum = { workspace = true, features = ["derive"] }
 strum_macros.workspace = true
 thiserror.workspace = true
+tokio.workspace = true
 
 [dev-dependencies]
+assert_matches.workspace = true
+blockifier = { workspace = true, features = ["testing"] }
+mempool_test_utils.workspace = true
 mockall.workspace = true
+rstest.workspace = true
+starknet-types-core.workspace = true
 starknet_api = { workspace = true, features = ["testing"] }

crates/apollo_class_manager_types/Cargo.toml

@@ -14,7 +14,7 @@ use apollo_infra::component_definitions::{
 use apollo_infra::{impl_debug_for_infra_requests_and_responses, impl_labeled_request};
 use apollo_proc_macros::handle_all_response_variants;
 use async_trait::async_trait;
-#[cfg(feature = "testing")]
+#[cfg(any(feature = "testing", test))]
 use mockall::automock;
 use serde::{Deserialize, Serialize};
 use starknet_api::contract_class::ContractClass;
@@ -50,7 +50,7 @@ pub struct ClassHashes {
 /// Serves as the class manager's shared interface.
 /// Requires `Send + Sync` to allow transferring and sharing resources (inputs, futures) across
 /// threads.
-#[cfg_attr(feature = "testing", automock)]
+#[cfg_attr(any(test, feature = "testing"), automock)]
 #[async_trait]
 pub trait ClassManagerClient: Send + Sync {
     async fn add_class(&self, class: Class) -> ClassManagerClientResult<ClassHashes>;
@@ -130,7 +130,7 @@ impl From<serde_json::Error> for ClassManagerError {
     }
 }
 
-#[derive(Clone, Debug, Error)]
+#[derive(Clone, Debug, Error, PartialEq)]
 pub enum ClassManagerClientError {
     #[error(transparent)]
     ClientError(#[from] ClientError),

crates/apollo_class_manager_types/src/lib.rs

@@ -27,7 +27,11 @@ use thiserror::Error;
 
 use crate::{ClassHashes, ClassManagerClientError, SharedClassManagerClient};
 
-#[derive(Error, Debug, Clone)]
+#[cfg(test)]
+#[path = "transaction_converter_test.rs"]
+pub mod transaction_converter_test;
+
+#[derive(Error, Debug, Clone, PartialEq)]
 pub enum TransactionConverterError {
     #[error(transparent)]
     ClassManagerClientError(#[from] ClassManagerClientError),

crates/apollo_class_manager_types/src/transaction_converter.rs

@@ -0,0 +1,55 @@
+use std::sync::Arc;
+
+use assert_matches::assert_matches;
+use blockifier::context::ChainInfo;
+use mempool_test_utils::starknet_api_test_utils::declare_tx;
+use mockall::predicate::eq;
+use rstest::rstest;
+use starknet_api::compiled_class_hash;
+use starknet_api::executable_transaction::ValidateCompiledClassHashError;
+use starknet_api::rpc_transaction::{RpcDeclareTransaction, RpcTransaction};
+
+use crate::transaction_converter::{
+    TransactionConverter,
+    TransactionConverterError,
+    TransactionConverterTrait,
+};
+use crate::{ClassHashes, MockClassManagerClient};
+
+#[rstest]
+#[tokio::test]
+async fn test_compiled_class_hash_mismatch() {
+    let declare_tx = declare_tx();
+    let declare_tx_inner = assert_matches!(declare_tx.clone(), RpcTransaction::Declare(RpcDeclareTransaction::V3(tx)) => tx);
+
+    let other_compiled_class_hash = compiled_class_hash!(2_u8);
+    assert_ne!(declare_tx_inner.compiled_class_hash, other_compiled_class_hash);
+
+    let mut mock_class_manager_client = MockClassManagerClient::new();
+
+    mock_class_manager_client
+        .expect_add_class()
+        .once()
+        .with(eq(declare_tx_inner.contract_class.clone()))
+        .return_once(move |_| {
+            Ok(ClassHashes {
+                class_hash: declare_tx_inner.contract_class.calculate_class_hash(),
+                executable_class_hash_v2: other_compiled_class_hash,
+            })
+        });
+
+    let transaction_converter = TransactionConverter::new(
+        Arc::new(mock_class_manager_client),
+        ChainInfo::create_for_testing().chain_id,
+    );
+
+    let err =
+        transaction_converter.convert_rpc_tx_to_internal_rpc_tx(declare_tx).await.unwrap_err();
+    let expected_code = TransactionConverterError::ValidateCompiledClassHashError(
+        ValidateCompiledClassHashError::CompiledClassHashMismatch {
+            computed_class_hash: other_compiled_class_hash,
+            supplied_class_hash: declare_tx_inner.compiled_class_hash,
+        },
+    );
+    assert_eq!(err, expected_code);
+}

crates/apollo_class_manager_types/src/transaction_converter_test.rs

@@ -94,7 +94,7 @@ impl BenchTestSetup {
             config.gateway_config,
             Arc::new(state_reader_factory),
             Arc::new(mempool_client),
-            transaction_converter,
+            Arc::new(transaction_converter),
         );
 
         Self { gateway: gateway_business_logic, txs }

crates/apollo_gateway/benches/utils.rs

@@ -62,15 +62,15 @@ pub struct Gateway {
     pub stateful_tx_validator_factory: Arc<dyn StatefulTransactionValidatorFactoryTrait>,
     pub state_reader_factory: Arc<dyn StateReaderFactory>,
     pub mempool_client: SharedMempoolClient,
-    pub transaction_converter: Arc<TransactionConverter>,
+    pub transaction_converter: Arc<dyn TransactionConverterTrait>,
 }
 
 impl Gateway {
     pub fn new(
         config: GatewayConfig,
         state_reader_factory: Arc<dyn StateReaderFactory>,
         mempool_client: SharedMempoolClient,
-        transaction_converter: TransactionConverter,
+        transaction_converter: Arc<dyn TransactionConverterTrait>,
     ) -> Self {
         Self {
             config: Arc::new(config.clone()),
@@ -83,7 +83,7 @@ impl Gateway {
             }),
             state_reader_factory,
             mempool_client,
-            transaction_converter: Arc::new(transaction_converter),
+            transaction_converter,
         }
     }
 
@@ -292,8 +292,10 @@ pub fn create_gateway(
         class_manager_client: class_manager_client.clone(),
         runtime,
     });
-    let transaction_converter =
-        TransactionConverter::new(class_manager_client, config.chain_info.chain_id.clone());
+    let transaction_converter = Arc::new(TransactionConverter::new(
+        class_manager_client,
+        config.chain_info.chain_id.clone(),
+    ));
 
     Gateway::new(config, state_reader_factory, mempool_client, transaction_converter)
 }