feat: add get_messages_status

madara/crates/client/gateway/server/src/handler.rs

@@ -246,7 +246,7 @@ pub async fn handle_get_block_traces(
     }
 
     let traces = v0_7_1_trace_block_transactions(
-        &Starknet::new(backend, add_transaction_provider, Default::default(), None, ctx),
+        &Starknet::new(backend, add_transaction_provider, Default::default(), None, None, ctx),
         block_id,
     )
     .await?;

madara/crates/client/rpc/Cargo.toml

@@ -29,6 +29,7 @@ m-proc-macros = { workspace = true }
 mc-block-production = { workspace = true }
 mc-db = { workspace = true }
 mc-exec = { workspace = true }
+mc-settlement-client = { workspace = true }
 mc-submit-tx = { workspace = true }
 mp-block = { workspace = true, default-features = true }
 mp-chain-config = { workspace = true }

madara/crates/client/rpc/src/lib.rs

@@ -13,6 +13,7 @@ pub mod versions;
 use jsonrpsee::RpcModule;
 use mc_db::db_block_id::DbBlockIdResolvable;
 use mc_db::MadaraBackend;
+use mc_settlement_client::client::SettlementLayerProvider;
 use mc_submit_tx::SubmitTransaction;
 use mp_block::{BlockId, BlockTag, MadaraMaybePendingBlock, MadaraMaybePendingBlockInfo};
 use mp_chain_config::ChainConfig;
@@ -49,6 +50,7 @@ pub struct Starknet {
     pub(crate) add_transaction_provider: Arc<dyn SubmitTransaction>,
     storage_proof_config: StorageProofConfig,
     pub(crate) block_prod_handle: Option<mc_block_production::BlockProductionHandle>,
+    pub(crate) settlement_client: Option<Arc<dyn SettlementLayerProvider>>,
     pub ctx: ServiceContext,
 }
 
@@ -58,10 +60,19 @@ impl Starknet {
         add_transaction_provider: Arc<dyn SubmitTransaction>,
         storage_proof_config: StorageProofConfig,
         block_prod_handle: Option<mc_block_production::BlockProductionHandle>,
+        settlement_client: Option<Arc<dyn SettlementLayerProvider>>,
         ctx: ServiceContext,
     ) -> Self {
         let ws_handles = Arc::new(WsSubscribeHandles::new());
-        Self { backend, ws_handles, add_transaction_provider, storage_proof_config, block_prod_handle, ctx }
+        Self {
+            backend,
+            ws_handles,
+            add_transaction_provider,
+            storage_proof_config,
+            block_prod_handle,
+            settlement_client,
+            ctx,
+        }
     }
 
     pub fn clone_backend(&self) -> Arc<MadaraBackend> {
@@ -72,6 +83,10 @@ impl Starknet {
         Arc::clone(self.backend.chain_config())
     }
 
+    pub fn settlement_client(&self) -> Option<Arc<dyn SettlementLayerProvider>> {
+        self.settlement_client.clone()
+    }
+
     pub fn get_block_info(
         &self,
         block_id: &impl DbBlockIdResolvable,

madara/crates/client/rpc/src/versions/user/v0_8_1/api.rs

@@ -1,6 +1,7 @@
 use jsonrpsee::core::RpcResult;
 use m_proc_macros::versioned_rpc;
 use mp_block::BlockId;
+use mp_rpc::v0_8_1::{L1TxnHash, TxnHashWithStatus};
 use starknet_types_core::felt::Felt;
 
 type SubscriptionItemPendingTxs = super::methods::ws::SubscriptionItem<mp_rpc::v0_8_1::PendingTxnInfo>;
@@ -65,4 +66,7 @@ pub trait StarknetReadRpcApi {
         contract_addresses: Option<Vec<Felt>>,
         contracts_storage_keys: Option<Vec<mp_rpc::v0_8_1::ContractStorageKeysItem>>,
     ) -> RpcResult<mp_rpc::v0_8_1::GetStorageProofResult>;
+
+    #[method(name = "getMessagesStatus")]
+    async fn get_messages_status(&self, tx_hash_l1: L1TxnHash) -> RpcResult<Vec<TxnHashWithStatus>>;
 }

madara/crates/client/rpc/src/versions/user/v0_8_1/methods/read/get_messages_status.rs

@@ -0,0 +1,34 @@
+use mc_settlement_client::error::SettlementClientError;
+use mp_rpc::v0_8_1::{L1TxnHash, TxnHashWithStatus};
+
+use crate::{
+    utils::display_internal_server_error,
+    versions::user::v0_7_1::methods::read::get_transaction_status::get_transaction_status, Starknet,
+    StarknetRpcApiError, StarknetRpcResult,
+};
+
+pub async fn get_messages_status(
+    starknet: &Starknet,
+    transaction_hash: L1TxnHash,
+) -> StarknetRpcResult<Vec<TxnHashWithStatus>> {
+    let transaction_hash = transaction_hash.into();
+    let settlement_client = starknet.settlement_client().ok_or(StarknetRpcApiError::InternalServerError)?;
+    let l1_handlers = settlement_client.get_messages_to_l2(transaction_hash).await.map_err(|e| match e {
+        SettlementClientError::TxNotFound => StarknetRpcApiError::TxnHashNotFound,
+        e => {
+            display_internal_server_error(format!(
+                "Error getting messages to L2 for L1 transaction {transaction_hash:?}: {e}"
+            ));
+            StarknetRpcApiError::InternalServerError
+        }
+    })?;
+
+    let mut results = Vec::new();
+    for msg in l1_handlers {
+        let transaction_hash = msg.tx.compute_hash(starknet.chain_id(), false, false);
+        let finality_status = get_transaction_status(starknet, transaction_hash).await?.finality_status;
+        // TODO: Add failure_reason when we support it in get_transaction_status in v0.8.1.
+        results.push(TxnHashWithStatus { transaction_hash, finality_status, failure_reason: None });
+    }
+    Ok(results)
+}

madara/crates/client/rpc/src/versions/user/v0_8_1/methods/read/mod.rs

@@ -3,10 +3,11 @@ use crate::Starknet;
 use jsonrpsee::core::{async_trait, RpcResult};
 use mp_block::BlockId;
 use mp_chain_config::RpcVersion;
-use mp_rpc::v0_8_1::{ContractStorageKeysItem, GetStorageProofResult};
+use mp_rpc::v0_8_1::{ContractStorageKeysItem, GetStorageProofResult, L1TxnHash, TxnHashWithStatus};
 use starknet_types_core::felt::Felt;
 
 pub mod get_compiled_casm;
+pub mod get_messages_status;
 pub mod get_storage_proof;
 
 #[async_trait]
@@ -28,4 +29,8 @@ impl StarknetReadRpcApiV0_8_1Server for Starknet {
     ) -> RpcResult<GetStorageProofResult> {
         get_storage_proof::get_storage_proof(self, block_id, class_hashes, contract_addresses, contracts_storage_keys)
     }
+
+    async fn get_messages_status(&self, tx_hash_l1: L1TxnHash) -> RpcResult<Vec<TxnHashWithStatus>> {
+        Ok(get_messages_status::get_messages_status(self, tx_hash_l1).await?)
+    }
 }

madara/crates/client/settlement_client/src/client.rs

@@ -3,6 +3,7 @@ use crate::messaging::MessageToL2WithMetadata;
 use crate::state_update::{StateUpdate, StateUpdateWorker};
 use async_trait::async_trait;
 use futures::stream::BoxStream;
+use mp_convert::L1TransactionHash;
 use mp_transactions::L1HandlerTransactionWithFee;
 use mp_utils::service::ServiceContext;
 
@@ -108,6 +109,18 @@ pub trait SettlementLayerProvider: Send + Sync {
     /// - An Error if the call fail
     async fn message_to_l2_is_pending(&self, msg_hash: &[u8]) -> Result<bool, SettlementClientError>;
 
+    /// Fetches L1 to L2 messages associated with a specific L1 transaction hash
+    ///
+    /// # Arguments
+    /// * `l1_tx_hash` - The hash of the L1 transaction
+    /// # Returns
+    /// - A vector of L1 to L2 messages associated with the given L1 transaction hash
+    /// - An error if the call fails
+    async fn get_messages_to_l2(
+        &self,
+        l1_tx_hash: L1TransactionHash,
+    ) -> Result<Vec<L1HandlerTransactionWithFee>, SettlementClientError>;
+
     /// Return a block timestamp in second.
     ///
     /// # Arguments

madara/crates/client/settlement_client/src/error.rs

@@ -10,6 +10,9 @@ pub enum SettlementClientError {
     #[error("Starknet client error: {0}")]
     Starknet(StarknetClientError),
 
+    #[error("Transaction not found")]
+    TxNotFound,
+
     #[error("Missing required field: {0}")]
     MissingField(&'static str),
 

madara/crates/client/settlement_client/src/eth/mod.rs

@@ -8,7 +8,7 @@ use crate::utils::convert_log_state_update;
 use alloy::eips::{BlockId, BlockNumberOrTag};
 use alloy::primitives::{keccak256, Address, B256, I256, U256};
 use alloy::providers::{Provider, ProviderBuilder, ReqwestProvider, RootProvider};
-use alloy::rpc::types::Filter;
+use alloy::rpc::types::{Filter, FilteredParams};
 use alloy::sol;
 use alloy::sol_types::SolValue;
 use alloy::transports::http::{Client, Http};
@@ -17,7 +17,7 @@ use bitvec::macros::internal::funty::Fundamental;
 use error::EthereumClientError;
 use futures::stream::BoxStream;
 use futures::StreamExt;
-use mp_convert::{FeltExt, ToFelt};
+use mp_convert::{FeltExt, L1TransactionHash, ToFelt};
 use mp_transactions::L1HandlerTransactionWithFee;
 use mp_utils::service::ServiceContext;
 use std::str::FromStr;
@@ -306,6 +306,33 @@ impl SettlementLayerProvider for EthereumClient {
         Ok(cancellation_timestamp._0 != U256::ZERO)
     }
 
+    async fn get_messages_to_l2(
+        &self,
+        l1_tx_hash: L1TransactionHash,
+    ) -> Result<Vec<L1HandlerTransactionWithFee>, SettlementClientError> {
+        let l1_tx_hash = B256::from(l1_tx_hash.into_eth().0);
+        let receipt = self
+            .provider
+            .get_transaction_receipt(l1_tx_hash)
+            .await
+            .map_err(|e| -> SettlementClientError {
+                EthereumClientError::Rpc(format!("Failed to get transaction receipt: {}", e)).into()
+            })?
+            .ok_or(SettlementClientError::TxNotFound)?;
+
+        let filter = FilteredParams::new(Some(self.l1_core_contract.LogMessageToL2_filter().filter));
+
+        receipt
+            .inner
+            .logs()
+            .iter()
+            .filter(|log| filter.filter_address(&log.address()) && filter.filter_topics(log.topics()))
+            .filter_map(|log| log.log_decode::<LogMessageToL2>().ok())
+            .map(|log| log.inner.data)
+            .map(TryInto::try_into)
+            .collect::<Result<Vec<L1HandlerTransactionWithFee>, _>>()
+    }
+
     async fn get_block_n_timestamp(&self, l1_block_n: u64) -> Result<u64, SettlementClientError> {
         let block = self
             .provider

madara/crates/client/settlement_client/src/lib.rs

@@ -15,7 +15,7 @@ use std::sync::Arc;
 use tokio::sync::Notify;
 use url::Url;
 
-mod client;
+pub mod client;
 pub mod error;
 mod eth;
 pub mod gas_price;

madara/crates/client/settlement_client/src/starknet/mod.rs

@@ -8,6 +8,7 @@ use async_trait::async_trait;
 use bigdecimal::ToPrimitive;
 use futures::stream::BoxStream;
 use futures::{StreamExt, TryStreamExt};
+use mp_convert::L1TransactionHash;
 use mp_transactions::L1HandlerTransactionWithFee;
 use mp_utils::service::ServiceContext;
 use starknet_core::types::{BlockId, BlockTag, EmittedEvent, EventFilter, FunctionCall, MaybePendingBlockWithTxHashes};
@@ -343,6 +344,57 @@ impl SettlementLayerProvider for StarknetClient {
         Ok(matches!(status, MessageToAppchainStatus::Pending(_)))
     }
 
+    async fn get_messages_to_l2(
+        &self,
+        l1_tx_hash: L1TransactionHash,
+    ) -> Result<Vec<L1HandlerTransactionWithFee>, SettlementClientError> {
+        let l1_tx_hash = l1_tx_hash.into_starknet().map_err(|e| -> SettlementClientError {
+            StarknetClientError::Conversion(format!("Invalid L1 transaction hash: {}", e)).into()
+        })?;
+        let receipt =
+            self.provider.get_transaction_receipt(l1_tx_hash).await.map_err(|e| -> SettlementClientError {
+                StarknetClientError::L1ToL2Messaging { message: format!("Failed to fetch transaction receipt: {}", e) }
+                    .into()
+            })?;
+
+        let block_number = receipt.block.block_number();
+        let block_hash = receipt.block.block_hash();
+
+        let events = match receipt.receipt {
+            starknet_core::types::TransactionReceipt::Invoke(receipt) => receipt.events,
+            starknet_core::types::TransactionReceipt::Declare(receipt) => receipt.events,
+            starknet_core::types::TransactionReceipt::Deploy(receipt) => receipt.events,
+            starknet_core::types::TransactionReceipt::DeployAccount(receipt) => receipt.events,
+            starknet_core::types::TransactionReceipt::L1Handler(receipt) => receipt.events,
+        };
+
+        let core_address = self.core_contract_address;
+        events
+            .into_iter()
+            .filter(|event| {
+                event.from_address == core_address
+                    && event.keys
+                        == vec![get_selector_from_name("MessageSent").expect("Failed to get MessageSent selector")]
+            })
+            .map(|event| EmittedEvent {
+                from_address: event.from_address,
+                keys: event.keys,
+                data: event.data,
+                block_hash,
+                block_number,
+                transaction_hash: l1_tx_hash,
+            })
+            .map(MessageToL2WithMetadata::try_from)
+            .map(|res| {
+                res.map(|m| m.message).map_err(|e| {
+                    SettlementClientError::from(StarknetClientError::L1ToL2Messaging {
+                        message: format!("Failed to parse MessageToL2 event: {e}"),
+                    })
+                })
+            })
+            .collect::<Result<Vec<L1HandlerTransactionWithFee>, SettlementClientError>>()
+    }
+
     async fn get_block_n_timestamp(&self, l1_block_n: u64) -> Result<u64, SettlementClientError> {
         tracing::debug!("get_block_n_timestamp l1_block_n={l1_block_n}");
         let block = self.provider.get_block_with_tx_hashes(BlockId::Number(l1_block_n)).await.map_err(

madara/crates/primitives/convert/Cargo.toml

@@ -15,6 +15,7 @@ workspace = true
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
+mp-rpc.workspace = true
 
 # Starknet
 alloy.workspace = true

madara/crates/primitives/convert/src/felt.rs

@@ -105,6 +105,12 @@ impl L1TransactionHash {
     }
 }
 
+impl From<mp_rpc::v0_8_1::L1TxnHash> for L1TransactionHash {
+    fn from(value: mp_rpc::v0_8_1::L1TxnHash) -> Self {
+        Self(value.0)
+    }
+}
+
 #[derive(Clone, Copy, Debug, serde::Deserialize, serde::Serialize)]
 #[serde(transparent)]
 pub struct L1CoreContractNonce(u64);