feat: add get_messages_status

Author: jbcaron

madara/Cargo.lock

@@ -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/gateway/server/src/handler.rs

@@ -36,6 +36,7 @@ mp-convert = { workspace = true, default-features = true }
 mp-gateway = { workspace = true }
 mp-receipt = { workspace = true }
 mp-rpc = { workspace = true }
+mc-settlement-client = { workspace = true }
 mp-state-update = { workspace = true }
 mp-transactions = { workspace = true }
 mp-utils = { workspace = true }

madara/crates/client/rpc/Cargo.toml

@@ -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/lib.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/api.rs

@@ -0,0 +1,33 @@
+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;
+        results.push(TxnHashWithStatus { transaction_hash, finality_status });
+    }
+    Ok(results)
+}

madara/crates/client/rpc/src/versions/user/v0_8_1/methods/read/get_messages_status.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/rpc/src/versions/user/v0_8_1/methods/read/mod.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/client.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/error.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