claude: address second round of review feedback

BLOCKING fixes:
- Fix warn! to error! for failed delivery tx storage
- Remove success/debug logging for delivery tx storage (follow log-after-action rule)
- Remove leftover debug warn! with ALL CAPS in hyperlane_db.rs
- Remove CORS from /reprocess_message (security: POST endpoints should not have permissive CORS)
- Remove unused origin_db_delivery field from MessageContext

MAJOR fixes:
- Remove duplicate tx->message_id reverse mapping from delivery_db.rs
  (origin-side mapping via HyperlaneDb is sufficient for /dispatched endpoint)
- Remove logging from low-level DB methods (let callers decide)

Simplifies delivery_db.rs to only store message_id -> delivery_tx mapping,
which is what the /delivered endpoint actually uses.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: danwt

rust/main/agents/relayer/src/msg/pending_message.rs

@@ -68,9 +68,7 @@ pub struct MessageContext {
     pub destination_mailbox: Arc<dyn Mailbox>,
     /// Origin chain database to verify gas payments.
     pub origin_db: Arc<dyn HyperlaneDb>,
-    /// Origin chain database for reverse lookup (tx_hash -> message_id).
-    pub origin_db_delivery: Arc<dyn DeliveryDb>,
-    /// Destination chain database for storing delivery info.
+    /// Destination chain database for storing delivery tx hashes.
     pub destination_db: Arc<dyn DeliveryDb>,
     /// Cache to store commonly used data calls.
     pub cache: OptionalCache<MeteredCache<LocalCache>>,
@@ -933,27 +931,14 @@ impl PendingMessage {
                 .destination_db
                 .store_delivery_tx(&message_id, &outcome.transaction_id)
             {
-                warn!(
+                error!(
                     message_id = ?message_id,
                     tx_id = ?outcome.transaction_id,
                     destination = ?self.message.destination,
                     error = %e,
-                    "DELIVERY_STORAGE: Failed to store delivery tx hash on destination"
-                );
-            } else {
-                warn!(
-                    message_id = ?message_id,
-                    tx_id = ?outcome.transaction_id,
-                    destination = ?self.message.destination,
-                    "DELIVERY_STORAGE: Successfully stored delivery tx hash on destination"
+                    "failed to store delivery tx hash"
                 );
             }
-        } else {
-            warn!(
-                message_id = ?self.message.id(),
-                destination = ?self.message.destination,
-                "DELIVERY_STORAGE: No submission_outcome available, cannot store delivery tx hash"
-            );
         }
 
         Ok(())

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

@@ -256,13 +256,9 @@ impl BaseAgent for Relayer {
                     origin_chain_setup.ignore_reorg_reports,
                 );
 
-                // Create destination_db for storing delivery info
+                // Create destination_db for storing delivery tx hashes
                 let destination_db: Arc<dyn DeliveryDb> =
                     Arc::new(destination.database.clone());
-                
-                // Create origin_db_delivery for reverse lookup (tx_hash -> message_id)
-                let origin_db_delivery: Arc<dyn DeliveryDb> =
-                    Arc::new(db.clone());
 
                 msg_ctxs.insert(
                     ContextKey {
@@ -272,7 +268,6 @@ impl BaseAgent for Relayer {
                     Arc::new(MessageContext {
                         destination_mailbox: destination_mailbox.clone(),
                         origin_db: Arc::new(db.clone()),
-                        origin_db_delivery,
                         destination_db,
                         cache: cache.clone(),
                         metadata_builder: Arc::new(metadata_builder),

rust/main/agents/relayer/src/server/operations/reprocess_message.rs

@@ -2,7 +2,6 @@ use std::{cmp::Reverse, collections::HashMap, str::FromStr, sync::Arc};
 
 use axum::{extract::State, http::StatusCode, routing, Json, Router};
 use derive_new::new;
-use tower_http::cors::{Any, CorsLayer};
 use hyperlane_base::{
     db::{HyperlaneDb, HyperlaneRocksDB},
     server::utils::{ServerErrorBody, ServerErrorResponse, ServerResult, ServerSuccessResponse},
@@ -24,14 +23,8 @@ pub struct ServerState {
 
 impl ServerState {
     pub fn router(self) -> Router {
-        let cors = CorsLayer::new()
-            .allow_origin(Any)
-            .allow_methods(Any)
-            .allow_headers(Any);
-
         Router::new()
             .route("/reprocess_message", routing::post(handler))
-            .layer(cors)
             .with_state(self)
     }
 }

rust/main/agents/relayer/src/test_utils/dummy_data.rs

@@ -118,7 +118,6 @@ pub fn dummy_message_context(
     MessageContext {
         destination_mailbox: Arc::new(MockMailboxContract::new_with_default_ism(H256::zero())),
         origin_db: Arc::new(db.clone()),
-        origin_db_delivery: Arc::new(db.clone()),
         destination_db: Arc::new(db.clone()),
         cache,
         metadata_builder: base_metadata_builder,

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

@@ -1,37 +1,21 @@
 use eyre::Result;
-use tracing::{debug, error};
 
 use hyperlane_core::{Encode, H256, H512};
 
 use super::HyperlaneRocksDB;
 
 const DELIVERY_TX: &str = "delivery_tx_";
-const MESSAGE_ID_BY_TX: &str = "message_id_by_tx_";
 
 /// Implementation of DeliveryDb for HyperlaneRocksDB
-/// Tracks delivery transaction hashes for all destination chains
+/// Tracks delivery transaction hashes for destination chains
 impl hyperlane_core::DeliveryDb for HyperlaneRocksDB {
     fn store_delivery_tx(&self, message_id: &H256, destination_tx: &H512) -> Result<()> {
         self.store_encodable(DELIVERY_TX, message_id.to_vec(), destination_tx)?;
-        self.store_encodable(MESSAGE_ID_BY_TX, destination_tx.to_vec(), message_id)?;
-        debug!(message_id = ?message_id, destination_tx = ?destination_tx, "stored delivery tx");
         Ok(())
     }
 
     fn retrieve_delivery_tx(&self, message_id: &H256) -> Result<Option<H512>> {
-        match self.retrieve_decodable(DELIVERY_TX, message_id.to_vec()) {
-            Ok(Some(tx)) => {
-                debug!(message_id = ?message_id, tx_hash = ?tx, "found delivery tx");
-                Ok(Some(tx))
-            }
-            Ok(None) => {
-                debug!(message_id = ?message_id, "no delivery tx found");
-                Ok(None)
-            }
-            Err(e) => {
-                error!(message_id = ?message_id, error = %e, "error retrieving delivery tx");
-                Err(e.into())
-            }
-        }
+        self.retrieve_decodable(DELIVERY_TX, message_id.to_vec())
+            .map_err(Into::into)
     }
 }

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

@@ -89,14 +89,6 @@ impl HyperlaneRocksDB {
         dispatch_tx_id: &H512,
     ) -> DbResult<bool> {
         self.store_message(message, dispatched_block_number)?;
-        // - `dispatch_tx_id` --> `message_id` (for /delivered/by_tx API)
-        warn!(
-            dispatch_tx_id = ?dispatch_tx_id,
-            message_id = ?message.id(),
-            origin_domain = %message.origin,
-            destination_domain = %message.destination,
-            "STORING MESSAGE ID BY DISPATCH TX"
-        );
         self.store_message_id_by_dispatch_tx(dispatch_tx_id, &message.id())?;
         Ok(true)
     }