feat(starknet_gateway): add class manager client

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_api/src/rpc_transaction.rs

@@ -124,6 +124,44 @@ impl From<RpcTransaction> for Transaction {
     }
 }
 
+macro_rules! implement_internal_getters_for_internal_rpc {
+    ($(($field_name:ident, $field_ty:ty)),* $(,)?) => {
+        $(
+            pub fn $field_name(&self) -> $field_ty {
+                match &self.tx {
+                    InternalRpcTransactionWithoutTxHash::Declare(tx) => tx.$field_name.clone(),
+                    InternalRpcTransactionWithoutTxHash::Invoke(RpcInvokeTransaction::V3(tx)) => tx.$field_name.clone(),
+                    InternalRpcTransactionWithoutTxHash::DeployAccount(tx) => {
+                        let RpcDeployAccountTransaction::V3(tx) = &tx.tx;
+                        tx.$field_name.clone()
+                    },
+                }
+            }
+        )*
+    };
+}
+
+impl InternalRpcTransaction {
+    implement_internal_getters_for_internal_rpc!(
+        (nonce, Nonce),
+        (resource_bounds, AllResourceBounds),
+        (tip, Tip),
+    );
+
+    pub fn contract_address(&self) -> ContractAddress {
+        match &self.tx {
+            InternalRpcTransactionWithoutTxHash::Declare(tx) => tx.sender_address,
+            InternalRpcTransactionWithoutTxHash::Invoke(RpcInvokeTransaction::V3(tx)) => {
+                tx.sender_address
+            }
+            InternalRpcTransactionWithoutTxHash::DeployAccount(tx) => tx.contract_address,
+        }
+    }
+
+    pub fn tx_hash(&self) -> TransactionHash {
+        self.tx_hash
+    }
+}
 /// A RPC declare transaction.
 ///
 /// This transaction is equivalent to the component DECLARE_TXN in the

crates/starknet_api/src/test_utils/invoke.rs

@@ -6,7 +6,13 @@ use crate::executable_transaction::{
     AccountTransaction,
     InvokeTransaction as ExecutableInvokeTransaction,
 };
-use crate::rpc_transaction::{RpcInvokeTransaction, RpcInvokeTransactionV3, RpcTransaction};
+use crate::rpc_transaction::{
+    InternalRpcTransaction,
+    InternalRpcTransactionWithoutTxHash,
+    RpcInvokeTransaction,
+    RpcInvokeTransactionV3,
+    RpcTransaction,
+};
 use crate::transaction::constants::EXECUTE_ENTRY_POINT_NAME;
 use crate::transaction::fields::{
     AccountDeploymentData,
@@ -149,3 +155,17 @@ pub fn rpc_invoke_tx(invoke_args: InvokeTxArgs) -> RpcTransaction {
         account_deployment_data: invoke_args.account_deployment_data,
     }))
 }
+
+pub fn internal_invoke_tx(invoke_args: InvokeTxArgs) -> InternalRpcTransaction {
+    if invoke_args.version != TransactionVersion::THREE {
+        panic!("Unsupported transaction version: {:?}.", invoke_args.version);
+    }
+    let tx_hash = invoke_args.tx_hash;
+    let RpcTransaction::Invoke(tx) = rpc_invoke_tx(invoke_args) else {
+        panic!("Expected RpcTransaction::Invoke");
+    };
+
+    let invoke_tx = InternalRpcTransactionWithoutTxHash::Invoke(tx);
+
+    InternalRpcTransaction { tx: invoke_tx, tx_hash }
+}

crates/starknet_batcher/Cargo.toml

@@ -12,13 +12,15 @@ workspace = true
 async-trait.workspace = true
 blockifier.workspace = true
 chrono.workspace = true
+futures.workspace = true
 indexmap.workspace = true
 papyrus_config.workspace = true
 papyrus_state_reader.workspace = true
 papyrus_storage.workspace = true
 serde.workspace = true
 starknet_api.workspace = true
 starknet_batcher_types.workspace = true
+starknet_class_manager_types.workspace = true
 starknet_l1_provider_types.workspace = true
 starknet_mempool_types.workspace = true
 starknet_sequencer_infra.workspace = true

crates/starknet_batcher/src/batcher.rs

@@ -31,6 +31,8 @@ use starknet_batcher_types::batcher_types::{
     ValidateBlockInput,
 };
 use starknet_batcher_types::errors::BatcherError;
+use starknet_class_manager_types::transaction_converter::TransactionConverter;
+use starknet_class_manager_types::SharedClassManagerClient;
 use starknet_l1_provider_types::SharedL1ProviderClient;
 use starknet_mempool_types::communication::SharedMempoolClient;
 use starknet_mempool_types::mempool_types::CommitBlockArgs;
@@ -74,6 +76,7 @@ pub struct Batcher {
     pub storage_writer: Box<dyn BatcherStorageWriterTrait>,
     pub l1_provider_client: SharedL1ProviderClient,
     pub mempool_client: SharedMempoolClient,
+    pub transaction_converter: TransactionConverter,
 
     // Used to create block builders.
     // Using the factory pattern to allow for easier testing.
@@ -109,6 +112,7 @@ impl Batcher {
         storage_writer: Box<dyn BatcherStorageWriterTrait>,
         l1_provider_client: SharedL1ProviderClient,
         mempool_client: SharedMempoolClient,
+        transaction_converter: TransactionConverter,
         block_builder_factory: Box<dyn BlockBuilderFactoryTrait>,
     ) -> Self {
         let storage_height = storage_reader
@@ -121,6 +125,7 @@ impl Batcher {
             storage_writer,
             l1_provider_client,
             mempool_client,
+            transaction_converter,
             block_builder_factory,
             active_height: None,
             active_proposal: Arc::new(Mutex::new(None)),
@@ -171,6 +176,7 @@ impl Batcher {
         let tx_provider = ProposeTransactionProvider::new(
             self.mempool_client.clone(),
             self.l1_provider_client.clone(),
+            self.transaction_converter.clone(),
             self.config.max_l1_handler_txs_per_block_proposal,
             propose_block_input.block_info.block_number,
         );
@@ -629,6 +635,7 @@ pub fn create_batcher(
     config: BatcherConfig,
     mempool_client: SharedMempoolClient,
     l1_provider_client: SharedL1ProviderClient,
+    class_manager_client: SharedClassManagerClient,
 ) -> Batcher {
     let (storage_reader, storage_writer) = papyrus_storage::open_storage(config.storage.clone())
         .expect("Failed to open batcher's storage");
@@ -642,12 +649,16 @@ pub fn create_batcher(
     });
     let storage_reader = Arc::new(storage_reader);
     let storage_writer = Box::new(storage_writer);
+    let transaction_converter =
+        TransactionConverter::new(class_manager_client, config.storage.db_config.chain_id.clone());
+
     Batcher::new(
         config,
         storage_reader,
         storage_writer,
         l1_provider_client,
         mempool_client,
+        transaction_converter,
         block_builder_factory,
     )
 }

crates/starknet_batcher/src/batcher_test.rs

@@ -8,7 +8,7 @@ use metrics_exporter_prometheus::PrometheusBuilder;
 use mockall::predicate::eq;
 use rstest::rstest;
 use starknet_api::block::{BlockHeaderWithoutHash, BlockInfo, BlockNumber};
-use starknet_api::core::{ContractAddress, Nonce};
+use starknet_api::core::{ChainId, ContractAddress, Nonce};
 use starknet_api::executable_transaction::Transaction;
 use starknet_api::state::ThinStateDiff;
 use starknet_api::transaction::TransactionHash;
@@ -31,6 +31,8 @@ use starknet_batcher_types::batcher_types::{
     ValidateBlockInput,
 };
 use starknet_batcher_types::errors::BatcherError;
+use starknet_class_manager_types::transaction_converter::TransactionConverter;
+use starknet_class_manager_types::{EmptyClassManagerClient, SharedClassManagerClient};
 use starknet_l1_provider_types::MockL1ProviderClient;
 use starknet_mempool_types::communication::MockMempoolClient;
 use starknet_mempool_types::mempool_types::CommitBlockArgs;
@@ -93,6 +95,7 @@ struct MockDependencies {
     mempool_client: MockMempoolClient,
     l1_provider_client: MockL1ProviderClient,
     block_builder_factory: MockBlockBuilderFactoryTrait,
+    class_manager_client: SharedClassManagerClient,
 }
 
 impl Default for MockDependencies {
@@ -105,6 +108,8 @@ impl Default for MockDependencies {
             l1_provider_client: MockL1ProviderClient::new(),
             mempool_client: MockMempoolClient::new(),
             block_builder_factory: MockBlockBuilderFactoryTrait::new(),
+            // TODO(noamsp): use MockClassManagerClient
+            class_manager_client: Arc::new(EmptyClassManagerClient),
         }
     }
 }
@@ -116,6 +121,10 @@ fn create_batcher(mock_dependencies: MockDependencies) -> Batcher {
         Box::new(mock_dependencies.storage_writer),
         Arc::new(mock_dependencies.l1_provider_client),
         Arc::new(mock_dependencies.mempool_client),
+        TransactionConverter::new(
+            mock_dependencies.class_manager_client,
+            ChainId::create_for_testing(),
+        ),
         Box::new(mock_dependencies.block_builder_factory),
     )
 }

crates/starknet_batcher/src/transaction_provider.rs

@@ -2,11 +2,17 @@ use std::cmp::min;
 use std::vec;
 
 use async_trait::async_trait;
+use futures::future::try_join_all;
 #[cfg(test)]
 use mockall::automock;
 use starknet_api::block::BlockNumber;
 use starknet_api::executable_transaction::Transaction;
 use starknet_api::transaction::TransactionHash;
+use starknet_class_manager_types::transaction_converter::{
+    TransactionConverter,
+    TransactionConverterError,
+    TransactionConverterTrait,
+};
 use starknet_l1_provider_types::errors::L1ProviderClientError;
 use starknet_l1_provider_types::{SharedL1ProviderClient, ValidationStatus as L1ValidationStatus};
 use starknet_mempool_types::communication::{MempoolClientError, SharedMempoolClient};
@@ -22,6 +28,8 @@ pub enum TransactionProviderError {
     L1HandlerTransactionValidationFailed(TransactionHash),
     #[error(transparent)]
     L1ProviderError(#[from] L1ProviderClientError),
+    #[error(transparent)]
+    TransactionConverterError(#[from] TransactionConverterError),
 }
 
 #[derive(Debug, PartialEq)]
@@ -40,6 +48,7 @@ pub trait TransactionProvider: Send {
 pub struct ProposeTransactionProvider {
     pub mempool_client: SharedMempoolClient,
     pub l1_provider_client: SharedL1ProviderClient,
+    pub transaction_converter: TransactionConverter,
     pub max_l1_handler_txs_per_block: usize,
     pub height: BlockNumber,
     phase: TxProviderPhase,
@@ -57,12 +66,14 @@ impl ProposeTransactionProvider {
     pub fn new(
         mempool_client: SharedMempoolClient,
         l1_provider_client: SharedL1ProviderClient,
+        transaction_converter: TransactionConverter,
         max_l1_handler_txs_per_block: usize,
         height: BlockNumber,
     ) -> Self {
         Self {
             mempool_client,
             l1_provider_client,
+            transaction_converter,
             max_l1_handler_txs_per_block,
             height,
             phase: TxProviderPhase::L1,
@@ -87,13 +98,17 @@ impl ProposeTransactionProvider {
         &mut self,
         n_txs: usize,
     ) -> TransactionProviderResult<Vec<Transaction>> {
-        Ok(self
+        let txs_futures = self
             .mempool_client
             .get_txs(n_txs)
             .await?
             .into_iter()
-            .map(Transaction::Account)
-            .collect())
+            .map(|tx| self.transaction_converter.convert_internal_rpc_tx_to_executable_tx(tx));
+
+        let converted_txs =
+            try_join_all(txs_futures).await?.into_iter().map(Transaction::Account).collect();
+
+        Ok(converted_txs)
     }
 }
 

crates/starknet_batcher/src/transaction_provider_test.rs

@@ -4,9 +4,12 @@ use assert_matches::assert_matches;
 use mockall::predicate::eq;
 use rstest::{fixture, rstest};
 use starknet_api::block::BlockNumber;
+use starknet_api::core::ChainId;
 use starknet_api::executable_transaction::{L1HandlerTransaction, Transaction};
-use starknet_api::test_utils::invoke::{executable_invoke_tx, InvokeTxArgs};
+use starknet_api::test_utils::invoke::{executable_invoke_tx, internal_invoke_tx, InvokeTxArgs};
 use starknet_api::tx_hash;
+use starknet_class_manager_types::transaction_converter::TransactionConverter;
+use starknet_class_manager_types::{EmptyClassManagerClient, SharedClassManagerClient};
 use starknet_l1_provider_types::{MockL1ProviderClient, ValidationStatus as L1ValidationStatus};
 use starknet_mempool_types::communication::MockMempoolClient;
 
@@ -28,6 +31,7 @@ struct MockDependencies {
     l1_provider_client: MockL1ProviderClient,
     tx_sender: tokio::sync::mpsc::Sender<Transaction>,
     tx_receiver: tokio::sync::mpsc::Receiver<Transaction>,
+    class_manager_client: SharedClassManagerClient,
 }
 
 impl MockDependencies {
@@ -40,7 +44,7 @@ impl MockDependencies {
 
     fn expect_get_mempool_txs(&mut self, n_to_request: usize) {
         self.mempool_client.expect_get_txs().with(eq(n_to_request)).returning(move |n_requested| {
-            Ok(vec![executable_invoke_tx(InvokeTxArgs::default()); n_requested])
+            Ok(vec![internal_invoke_tx(InvokeTxArgs::default()); n_requested])
         });
     }
 
@@ -61,6 +65,7 @@ impl MockDependencies {
         ProposeTransactionProvider::new(
             Arc::new(self.mempool_client),
             Arc::new(self.l1_provider_client),
+            TransactionConverter::new(self.class_manager_client, ChainId::create_for_testing()),
             MAX_L1_HANDLER_TXS_PER_BLOCK,
             HEIGHT,
         )
@@ -85,6 +90,8 @@ fn mock_dependencies(
         l1_provider_client: MockL1ProviderClient::new(),
         tx_sender,
         tx_receiver,
+        // TODO(noamsp): use MockClassManagerClient
+        class_manager_client: Arc::new(EmptyClassManagerClient),
     }
 }