apollo_l1_provider: add l1 msg hash to log (#13468)

Author: ShahakShama

Cargo.lock

@@ -239,7 +239,13 @@ impl L1Provider {
                 );
                 debug!(
                     "Returned L1Handler txs: {:?}",
-                    txs.iter().map(|tx| tx.tx_hash).collect::<Vec<_>>()
+                    txs.iter()
+                        .map(|tx| format!(
+                            "L2 tx hash: {}, L1-L2 msg hash: {}",
+                            tx.tx_hash,
+                            tx.tx.calc_msg_hash()
+                        ))
+                        .collect::<Vec<_>>()
                 );
                 Ok(txs)
             }

crates/apollo_l1_provider/src/l1_provider.rs

@@ -322,10 +322,20 @@ impl<BaseLayerType: BaseLayerContract + Send + Sync + Debug> L1Scraper<BaseLayer
             Event::L1HandlerTransaction { l1_handler_tx, .. } => Some(l1_handler_tx.tx_hash),
             _ => None,
         });
+        // Collect the L1-L2 message hashes (keccak) for L1 handler transactions.
+        let l1_msg_hashes = events.iter().filter_map(|event| match event {
+            Event::L1HandlerTransaction { l1_handler_tx, .. } => {
+                Some(l1_handler_tx.tx.calc_msg_hash())
+            }
+            _ => None,
+        });
 
-        let formatted_pairs = zip_eq(l1_messages_info, l2_hashes)
-            .map(|((l1_hash, timestamp), l2_hash)| {
-                format!("L1 tx hash: {l1_hash:?}, L1 timestamp: {timestamp}, L2 tx hash: {l2_hash}")
+        let formatted_pairs = zip_eq(zip_eq(l1_messages_info, l2_hashes), l1_msg_hashes)
+            .map(|(((l1_hash, timestamp), l2_hash), l1_msg_hash)| {
+                format!(
+                    "L1 tx hash: {l1_hash:?}, L1 timestamp: {timestamp}, L2 tx hash: {l2_hash}, \
+                     L1-L2 msg hash: {l1_msg_hash}"
+                )
             })
             .collect::<Vec<_>>();
         if formatted_pairs.is_empty() {

crates/apollo_l1_provider/src/l1_scraper.rs

@@ -7,7 +7,6 @@ license-file.workspace = true
 description = "JSON-RPC server implementation for Starknet API."
 
 [dependencies]
-alloy-primitives.workspace = true
 anyhow.workspace = true
 apollo_class_manager_types.workspace = true
 apollo_config.workspace = true

crates/apollo_rpc/Cargo.toml

@@ -50,6 +50,7 @@ use starknet_api::core::{
     BLOCK_HASH_TABLE_ADDRESS,
 };
 use starknet_api::execution_utils::format_panic_data;
+use starknet_api::hash::{l1_handler_message_hash, L1L2MsgHash};
 use starknet_api::state::{StateNumber, StorageKey, ThinStateDiff as StarknetApiThinStateDiff};
 use starknet_api::transaction::fields::Fee;
 use starknet_api::transaction::{
@@ -99,8 +100,6 @@ use super::super::transaction::{
     get_block_txs_by_number,
     Event,
     GeneralTransactionReceipt,
-    L1HandlerMsgHash,
-    L1L2MsgHash,
     MessageFromL1,
     PendingTransactionFinalityStatus,
     PendingTransactionOutput,
@@ -1755,7 +1754,12 @@ fn client_receipt_to_rpc_pending_receipt(
     let starknet_api_output =
         client_transaction_receipt.into_starknet_api_transaction_output(client_transaction);
     let msg_hash = match client_transaction {
-        ClientTransaction::L1Handler(tx) => Some(tx.calc_msg_hash()),
+        ClientTransaction::L1Handler(tx) => Some(l1_handler_message_hash(
+            &tx.contract_address,
+            tx.nonce,
+            &tx.entry_point_selector,
+            &tx.calldata,
+        )),
         _ => None,
     };
     let output = PendingTransactionOutput::try_from(TransactionOutput::from((

crates/apollo_rpc/src/v0_8/api/api_impl.rs

@@ -100,6 +100,7 @@ use starknet_api::deprecated_contract_class::{
     FunctionAbiEntry,
     FunctionStateMutability,
 };
+use starknet_api::hash::{l1_handler_message_hash, L1L2MsgHash};
 use starknet_api::state::{SierraContractClass as StarknetApiContractClass, StateDiff};
 use starknet_api::transaction::{
     Event as StarknetApiEvent,
@@ -152,8 +153,6 @@ use super::super::transaction::{
     Event,
     GeneralTransactionReceipt,
     InvokeTransaction,
-    L1HandlerMsgHash,
-    L1L2MsgHash,
     PendingTransactionFinalityStatus,
     PendingTransactionOutput,
     PendingTransactionReceipt,
@@ -2219,7 +2218,12 @@ fn generate_client_transaction_client_receipt_rpc_transaction_and_rpc_receipt(
             .into_starknet_api_transaction_output(&client_transaction);
         let msg_hash = match &client_transaction {
             apollo_starknet_client::reader::objects::transaction::Transaction::L1Handler(tx) => {
-                Some(tx.calc_msg_hash())
+                Some(l1_handler_message_hash(
+                    &tx.contract_address,
+                    tx.nonce,
+                    &tx.entry_point_selector,
+                    &tx.calldata,
+                ))
             }
             _ => None,
         };

crates/apollo_rpc/src/v0_8/api/test.rs

@@ -7,14 +7,13 @@ use std::num::NonZeroU64;
 use std::ops::Add;
 use std::sync::Arc;
 
-use alloy_primitives::keccak256;
 use apollo_rpc_execution::objects::PriceUnit;
 use apollo_starknet_client::writer::objects::transaction as client_transaction;
 use apollo_storage::body::BodyStorageReader;
 use apollo_storage::db::TransactionKind;
 use apollo_storage::StorageTxn;
 use jsonrpsee::types::ErrorObjectOwned;
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde::{Deserialize, Serialize};
 use starknet_api::block::{BlockHash, BlockNumber, BlockStatus};
 use starknet_api::core::{
     ClassHash,
@@ -26,7 +25,7 @@ use starknet_api::core::{
 };
 use starknet_api::data_availability::DataAvailabilityMode;
 use starknet_api::execution_resources::GasAmount;
-use starknet_api::serde_utils::bytes_from_hex_str;
+use starknet_api::hash::L1L2MsgHash;
 use starknet_api::transaction::fields::{
     AccountDeploymentData,
     AllResourceBounds,
@@ -1198,92 +1197,6 @@ pub fn get_block_tx_hashes_by_number<Mode: TransactionKind>(
     Ok(transaction_hashes)
 }
 
-/// The hash of a L1 -> L2 message.
-// The hash is Keccak256, so it doesn't necessarily fit in a Felt.
-#[derive(Debug, Clone, Default, Eq, PartialEq, Hash, PartialOrd, Ord)]
-pub struct L1L2MsgHash(pub [u8; 32]);
-
-impl std::fmt::Display for L1L2MsgHash {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "0x{}", hex::encode(self.0))
-    }
-}
-
-impl Serialize for L1L2MsgHash {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(format!("{self}").as_str())
-    }
-}
-
-impl<'de> Deserialize<'de> for L1L2MsgHash {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        Ok(Self(bytes_from_hex_str::<32, true>(s.as_str()).map_err(serde::de::Error::custom)?))
-    }
-}
-
-pub trait L1HandlerMsgHash {
-    fn calc_msg_hash(&self) -> L1L2MsgHash;
-}
-
-impl L1HandlerMsgHash for L1HandlerTransaction {
-    fn calc_msg_hash(&self) -> L1L2MsgHash {
-        l1_handler_message_hash(
-            &self.contract_address,
-            self.nonce,
-            &self.entry_point_selector,
-            &self.calldata,
-        )
-    }
-}
-
-impl L1HandlerMsgHash
-    for apollo_starknet_client::reader::objects::transaction::L1HandlerTransaction
-{
-    fn calc_msg_hash(&self) -> L1L2MsgHash {
-        l1_handler_message_hash(
-            &self.contract_address,
-            self.nonce,
-            &self.entry_point_selector,
-            &self.calldata,
-        )
-    }
-}
-
-/// Calculating the message hash of  L1 -> L2 message.
-/// `<For more info: https://docs.starknet.io/documentation/architecture_and_concepts/Network_Architecture/messaging-mechanism/#structure_and_hashing_l1-l2>`
-fn l1_handler_message_hash(
-    contract_address: &ContractAddress,
-    nonce: Nonce,
-    entry_point_selector: &EntryPointSelector,
-    calldata: &Calldata,
-) -> L1L2MsgHash {
-    let (from_address, payload) =
-        calldata.0.split_first().expect("Invalid calldata, expected at least from_address");
-
-    let mut encoded = Vec::new();
-    encoded.extend(from_address.to_bytes_be());
-    encoded.extend(contract_address.0.key().to_bytes_be());
-    encoded.extend(nonce.to_bytes_be());
-    encoded.extend(entry_point_selector.0.to_bytes_be());
-
-    let payload_length_as_felt =
-        Felt::from(u64::try_from(payload.len()).expect("usize should fit in u64"));
-    encoded.extend(payload_length_as_felt.to_bytes_be());
-
-    for felt in payload {
-        encoded.extend(felt.to_bytes_be());
-    }
-
-    L1L2MsgHash(keccak256(&encoded).0)
-}
-
 #[derive(Debug, Clone, Default, PartialEq, Eq, Deserialize, Serialize)]
 pub struct MessageFromL1 {
     // TODO(Shahak): fix serialization of EthAddress in SN_API to fit the spec.

crates/apollo_rpc/src/v0_8/transaction.rs

@@ -8,6 +8,7 @@ use apollo_test_utils::{
 use pretty_assertions::assert_eq;
 use starknet_api::core::{ClassHash, ContractAddress, EntryPointSelector, Nonce};
 use starknet_api::data_availability::DataAvailabilityMode;
+use starknet_api::hash::L1L2MsgHash;
 use starknet_api::transaction::fields::{
     AccountDeploymentData,
     Calldata,
@@ -21,7 +22,6 @@ use starknet_api::transaction::fields::{
 use starknet_api::transaction::{L1HandlerTransaction, Transaction};
 use starknet_api::{calldata, contract_address, felt, nonce};
 
-use super::super::transaction::{L1HandlerMsgHash, L1L2MsgHash};
 use super::{
     DeployAccountTransaction,
     DeployAccountTransactionV1,

crates/apollo_rpc/src/v0_8/transaction_test.rs

@@ -1,11 +1,14 @@
-use std::fmt::Debug;
+use std::fmt::{Debug, Display, Formatter};
 
 use serde::{Deserialize, Serialize};
 use sha3::{Digest, Keccak256};
 use starknet_types_core::felt::{Felt, FromStrError};
 use starknet_types_core::hash::{Poseidon, StarkHash as StarkHashTrait};
 
-use crate::core::{GlobalRoot, GLOBAL_STATE_VERSION};
+use crate::core::{ContractAddress, EntryPointSelector, GlobalRoot, Nonce, GLOBAL_STATE_VERSION};
+use crate::serde_utils::bytes_from_hex_str;
+use crate::transaction::fields::Calldata;
+use crate::transaction::L1HandlerTransaction;
 
 pub type StarkHash = Felt;
 
@@ -108,3 +111,80 @@ impl StateRoots {
         ]))
     }
 }
+
+/// The hash of a L1 -> L2 message.
+// The hash is Keccak256, so it doesn't fit in a Felt.
+#[derive(Clone, Default, Eq, PartialEq, Hash, PartialOrd, Ord)]
+pub struct L1L2MsgHash(pub [u8; 32]);
+
+impl Display for L1L2MsgHash {
+    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(formatter, "0x{}", hex::encode(self.0))
+    }
+}
+
+impl Debug for L1L2MsgHash {
+    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(self, formatter)
+    }
+}
+
+impl Serialize for L1L2MsgHash {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(format!("{self}").as_str())
+    }
+}
+
+impl<'de> Deserialize<'de> for L1L2MsgHash {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        Ok(Self(bytes_from_hex_str::<32, true>(s.as_str()).map_err(serde::de::Error::custom)?))
+    }
+}
+
+impl L1HandlerTransaction {
+    pub fn calc_msg_hash(&self) -> L1L2MsgHash {
+        l1_handler_message_hash(
+            &self.contract_address,
+            self.nonce,
+            &self.entry_point_selector,
+            &self.calldata,
+        )
+    }
+}
+
+/// Calculating the message hash of L1 -> L2 message.
+/// For more info: <https://docs.starknet.io/documentation/architecture_and_concepts/Network_Architecture/messaging-mechanism/#structure_and_hashing_l1-l2>
+pub fn l1_handler_message_hash(
+    contract_address: &ContractAddress,
+    nonce: Nonce,
+    entry_point_selector: &EntryPointSelector,
+    calldata: &Calldata,
+) -> L1L2MsgHash {
+    let (from_address, payload) =
+        calldata.0.split_first().expect("Invalid calldata, expected at least from_address");
+
+    let mut encoded = Vec::new();
+    encoded.extend(from_address.to_bytes_be());
+    encoded.extend(contract_address.0.key().to_bytes_be());
+    encoded.extend(nonce.to_bytes_be());
+    encoded.extend(entry_point_selector.0.to_bytes_be());
+
+    let payload_length_as_felt =
+        Felt::from(u64::try_from(payload.len()).expect("usize should fit in u64"));
+    encoded.extend(payload_length_as_felt.to_bytes_be());
+
+    for felt in payload {
+        encoded.extend(felt.to_bytes_be());
+    }
+
+    let mut keccak = Keccak256::default();
+    keccak.update(&encoded);
+    L1L2MsgHash(keccak.finalize().into())
+}