chore(l1): move WARN logs to DEBUG when a tx is not able to be added to the mempool

crates/networking/p2p/rlpx/connection/server.rs

@@ -804,7 +804,7 @@ async fn handle_peer_message(state: &mut Established, message: Message) -> Resul
                     }
 
                     if let Err(e) = state.blockchain.add_transaction_to_pool(tx.clone()).await {
-                        log_peer_warn(&state.node, &format!("Error adding transaction: {e}"));
+                        log_peer_debug(&state.node, &format!("Error adding transaction: {e}"));
                         continue;
                     }
                 }

crates/networking/p2p/rlpx/eth/transactions.rs

@@ -12,7 +12,7 @@ use ethrex_rlp::{
 };
 use ethrex_storage::error::StoreError;
 
-use crate::rlpx::utils::{log_peer_debug, log_peer_warn};
+use crate::rlpx::utils::log_peer_debug;
 use crate::rlpx::{
     message::RLPxMessage,
     utils::{snappy_compress, snappy_decompress},
@@ -288,15 +288,15 @@ impl PooledTransactions {
                     .add_blob_transaction_to_pool(itx.tx, itx.blobs_bundle)
                     .await
                 {
-                    log_peer_warn(node, &format!("Error adding transaction: {e}"));
+                    log_peer_debug(node, &format!("Error adding transaction: {e}"));
                     continue;
                 }
             } else {
                 let regular_tx = tx
                     .try_into()
                     .map_err(|error| MempoolError::StoreError(StoreError::Custom(error)))?;
                 if let Err(e) = blockchain.add_transaction_to_pool(regular_tx).await {
-                    log_peer_warn(node, &format!("Error adding transaction: {e}"));
+                    log_peer_debug(node, &format!("Error adding transaction: {e}"));
                     continue;
                 }
             }

crates/networking/p2p/rlpx/utils.rs

@@ -83,14 +83,14 @@ pub fn snappy_decompress(msg_data: &[u8]) -> Result<Vec<u8>, RLPDecodeError> {
 }
 
 pub(crate) fn log_peer_debug(node: &Node, text: &str) {
-    debug!("[{0}]: {1}", node, text)
+    debug!("{0}/[{1}]: {2}", node.client_name(), node, text)
 }
 
 pub(crate) fn log_peer_error(node: &Node, text: &str) {
-    error!("[{0}]: {1}", node, text)
+    error!("{0}/[{1}]: {2}", node.client_name(), node, text)
 }
 pub(crate) fn log_peer_warn(node: &Node, text: &str) {
-    warn!("[{0}]: {1}", node, text)
+    warn!("{0}/[{1}]: {2}", node.client_name(), node, text)
 }
 
 #[cfg(test)]

crates/networking/p2p/types.rs

@@ -145,6 +145,19 @@ impl Node {
         }
     }
 
+    pub fn client_name(&self) -> &str {
+        self.version
+            .as_deref()
+            .and_then(|version| {
+                let base = version
+                    .split_once('/')
+                    .map(|(name, _)| name.trim())
+                    .unwrap_or_else(|| version.trim());
+                if base.is_empty() { None } else { Some(base) }
+            })
+            .unwrap_or("unknown")
+    }
+
     pub fn from_enode_url(enode: &str) -> Result<Self, NodeError> {
         let public_key = H512::from_str(&enode[8..136])
             .map_err(|_| NodeError::ParseError("Could not parse public_key".into()))?;