fix: pr feedback

Author: troykessler

rust/main/agents/relayer/src/relay_api/handlers.rs

@@ -534,13 +534,18 @@ async fn create_relay(
             if let Some(blacklisted_address) =
                 blacklist.find_blacklisted_address(&extracted.message)
             {
+                // Log internally but don't expose the address in the API response
+                debug!(
+                    blacklisted_address = hex::encode(blacklisted_address),
+                    message_id = ?extracted.message_id,
+                    "Rejecting message involving blacklisted address"
+                );
                 if let Some(ref metrics) = state.metrics {
                     metrics.inc_failure("message_blacklisted_address");
                 }
-                return Err(ServerError::InvalidRequest(format!(
-                    "Message involves blacklisted address: {}",
-                    hex::encode(blacklisted_address)
-                )));
+                return Err(ServerError::InvalidRequest(
+                    "Message involves a blacklisted address".to_string(),
+                ));
             }
         }
 
@@ -611,8 +616,16 @@ async fn create_relay(
             );
         }
 
-        // Note: We don't update max_seen_nonce here because relay API bypasses indexer.
-        // The indexer will update max_seen_nonce when it catches up (even for duplicates).
+        // Update max_seen_nonce to prevent MessageDbLoader from reprocessing this message
+        // when the indexer catches up. The indexer will also update max_seen_nonce (idempotent).
+        if let Err(e) = origin_db.try_update_max_seen_message_nonce(extracted.message.nonce) {
+            warn!(
+                message_id = ?extracted.message_id,
+                nonce = extracted.message.nonce,
+                error = %e,
+                "Failed to update max_seen_nonce in DB"
+            );
+        }
 
         // Store dispatched block number (0 = relay API, real block number set by indexer later)
         if let Err(e) =

rust/main/hyperlane-base/src/db/rocks/hyperlane_db.rs

@@ -2,7 +2,7 @@ use std::ops::Add;
 
 use async_trait::async_trait;
 use eyre::{bail, Result};
-use tracing::{debug, instrument, trace};
+use tracing::{debug, instrument, trace, warn};
 
 use hyperlane_core::{
     identifiers::UniqueIdentifier, Decode, Encode, GasPaymentKey, HyperlaneDomain,
@@ -94,20 +94,52 @@ impl HyperlaneRocksDB {
             trace!(hyp_message=?message, "Message already stored in db");
             // Still update max_seen_nonce to track indexer progress, even if message
             // was already stored by relay API
-            self.try_update_max_seen_message_nonce(message.nonce)?;
+            if let Err(e) = self.try_update_max_seen_message_nonce(message.nonce) {
+                warn!(
+                    nonce = message.nonce,
+                    error = %e,
+                    "Failed to update max_seen_nonce for duplicate message (non-fatal)"
+                );
+            }
 
             // If the stored block number is 0 (from relay API) and we now have a real block number,
             // update it with the actual value from the indexer
-            if self
-                .retrieve_dispatched_block_number_by_nonce(&message.nonce)?
-                .unwrap_or(0)
-                == 0
-                && dispatched_block_number > 0
-            {
-                self.store_dispatched_block_number_by_nonce(
-                    &message.nonce,
-                    &dispatched_block_number,
-                )?;
+            match self.retrieve_dispatched_block_number_by_nonce(&message.nonce) {
+                Ok(Some(stored_block)) if stored_block == 0 && dispatched_block_number > 0 => {
+                    if let Err(e) = self.store_dispatched_block_number_by_nonce(
+                        &message.nonce,
+                        &dispatched_block_number,
+                    ) {
+                        warn!(
+                            nonce = message.nonce,
+                            error = %e,
+                            "Failed to update block number for duplicate message (non-fatal)"
+                        );
+                    }
+                }
+                Ok(None) if dispatched_block_number > 0 => {
+                    // No stored block number (shouldn't happen for duplicates, but handle it)
+                    if let Err(e) = self.store_dispatched_block_number_by_nonce(
+                        &message.nonce,
+                        &dispatched_block_number,
+                    ) {
+                        warn!(
+                            nonce = message.nonce,
+                            error = %e,
+                            "Failed to store block number for duplicate message (non-fatal)"
+                        );
+                    }
+                }
+                Err(e) => {
+                    warn!(
+                        nonce = message.nonce,
+                        error = %e,
+                        "Failed to retrieve block number for duplicate message (non-fatal)"
+                    );
+                }
+                _ => {
+                    // Block number already set or dispatched_block_number is 0, nothing to do
+                }
             }
 
             return Ok(false);