feat(starknet_batcher): use transaction converter to infer executable from mempool internal tx

Author: noamsp-starkware

Cargo.lock

@@ -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_api/src/test_utils/invoke.rs

@@ -12,6 +12,7 @@ workspace = true
 async-trait.workspace = true
 blockifier.workspace = true
 chrono.workspace = true
+futures.workspace = true
 indexmap.workspace = true
 metrics.workspace = true
 papyrus_config.workspace = true
@@ -20,6 +21,7 @@ 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/Cargo.toml

@@ -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;
@@ -68,6 +70,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.
@@ -103,6 +106,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
@@ -115,6 +119,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)),
@@ -165,6 +170,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,
         );
@@ -615,6 +621,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");
@@ -628,12 +635,18 @@ 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.block_builder_config.chain_info.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.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_infra_utils::metrics::parse_numeric_metric;
 use starknet_l1_provider_types::MockL1ProviderClient;
 use starknet_mempool_types::communication::MockMempoolClient;
@@ -85,6 +87,7 @@ struct MockDependencies {
     mempool_client: MockMempoolClient,
     l1_provider_client: MockL1ProviderClient,
     block_builder_factory: MockBlockBuilderFactoryTrait,
+    class_manager_client: SharedClassManagerClient,
 }
 
 impl Default for MockDependencies {
@@ -97,6 +100,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),
         }
     }
 }
@@ -108,6 +113,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/batcher_test.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.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),
     }
 }
 

crates/starknet_batcher/src/transaction_provider_test.rs

@@ -55,7 +55,14 @@ pub fn create_node_components(
             let l1_provider_client = clients
                 .get_l1_provider_shared_client()
                 .expect("L1 Provider Client should be available");
-            Some(create_batcher(config.batcher_config.clone(), mempool_client, l1_provider_client))
+            // TODO(noamsp): Remove this and use the real client instead once implemented.
+            let class_manager_client = Arc::new(EmptyClassManagerClient);
+            Some(create_batcher(
+                config.batcher_config.clone(),
+                mempool_client,
+                l1_provider_client,
+                class_manager_client,
+            ))
         }
         ReactiveComponentExecutionMode::Disabled | ReactiveComponentExecutionMode::Remote => None,
     };