fix: skip scraper lookup for txHash (#8517)

Author: troykessler

.changeset/odd-turtles-rhyme.md

@@ -0,0 +1,5 @@
+---
+"@hyperlane-xyz/ccip-server": patch
+---
+
+Added origin tx hash to skip scraper lookup for tx hash

rust/main/agents/relayer/src/msg/metadata/base_builder.rs

@@ -19,7 +19,7 @@ use hyperlane_base::{
 use hyperlane_core::{
     accumulator::merkle::Proof, AggregationIsm, CcipReadIsm, Checkpoint, HyperlaneDomain,
     HyperlaneMessage, InterchainSecurityModule, ModuleType, MultisigIsm, RoutingIsm,
-    ValidatorAnnounce, H160, H256,
+    ValidatorAnnounce, H160, H256, H512,
 };
 
 use crate::msg::metadata::base_builder::validator_announced_storages::fetch_storage_locations_helper;
@@ -85,6 +85,10 @@ pub trait BuildsBaseMetadata: Send + Sync + Debug {
     async fn highest_known_leaf_index(&self) -> Option<u32>;
     async fn get_merkle_leaf_id_by_message_id(&self, message_id: H256)
         -> eyre::Result<Option<u32>>;
+    async fn retrieve_origin_tx_hash_by_message_id(
+        &self,
+        message_id: H256,
+    ) -> eyre::Result<Option<H512>>;
     async fn build_ism(&self, address: H256) -> eyre::Result<Box<dyn InterchainSecurityModule>>;
     async fn build_routing_ism(&self, address: H256) -> eyre::Result<Box<dyn RoutingIsm>>;
     async fn build_multisig_ism(&self, address: H256) -> eyre::Result<Box<dyn MultisigIsm>>;
@@ -172,6 +176,15 @@ impl BuildsBaseMetadata for BaseMetadataBuilder {
         Ok(merkle_leaf)
     }
 
+    async fn retrieve_origin_tx_hash_by_message_id(
+        &self,
+        message_id: H256,
+    ) -> eyre::Result<Option<H512>> {
+        Ok(self
+            .db
+            .retrieve_dispatched_tx_hash_by_message_id(&message_id)?)
+    }
+
     async fn build_ism(&self, address: H256) -> eyre::Result<Box<dyn InterchainSecurityModule>> {
         self.destination_chain_setup
             .build_ism(address, &self.metrics)

rust/main/agents/relayer/src/msg/metadata/ccip_read/mod.rs

@@ -15,8 +15,8 @@ use sha3::{digest::Update, Digest, Keccak256};
 use tracing::{info, instrument, warn};
 
 use hyperlane_core::{
-    utils::bytes_to_hex, CcipReadIsm, HyperlaneMessage, HyperlaneSignerExt, Metadata, ModuleType,
-    RawHyperlaneMessage, Signable, H160, H256,
+    h512_to_bytes, utils::bytes_to_hex, CcipReadIsm, HyperlaneMessage, HyperlaneSignerExt,
+    Metadata, ModuleType, RawHyperlaneMessage, Signable, H160, H256,
 };
 use hyperlane_ethereum::{OffchainLookup, Signers};
 
@@ -37,6 +37,7 @@ struct OffchainLookupRequestBody {
     pub data: String,
     pub sender: String,
     pub signature: Option<String>,
+    pub origin_tx_hash: Option<String>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -223,6 +224,24 @@ async fn metadata_build(
         .call_get_offchain_verify_info(ism, message)
         .await?;
 
+    let origin_tx_hash = ism_builder
+        .base
+        .base_builder()
+        .retrieve_origin_tx_hash_by_message_id(message.id())
+        .await
+        .map_err(|err| {
+            warn!(error = %err, "Error retrieving origin tx hash for message {:?}", message.id());
+        })
+        .ok()
+        .flatten()
+        .map(|h| bytes_to_hex(&h512_to_bytes(&h)));
+    tracing::debug!(
+        message_id = ?message.id(),
+        origin_tx_hash = ?origin_tx_hash,
+        found_in_db = origin_tx_hash.is_some(),
+        "Origin tx hash lookup result",
+    );
+
     let ccip_url_regex = create_ccip_url_regex();
 
     for url in info.urls.iter() {
@@ -232,7 +251,7 @@ async fn metadata_build(
         }
 
         // if we fail, we want to try the other urls
-        match fetch_offchain_data(ism_builder, &info, url).await {
+        match fetch_offchain_data(ism_builder, &info, url, origin_tx_hash.clone()).await {
             Ok(data) => return Ok(data),
             Err(err) => {
                 tracing::warn!(?ism_address, url, ?err, "Failed to fetch offchain data");
@@ -250,6 +269,7 @@ async fn fetch_offchain_data(
     ism_builder: &CcipReadIsmMetadataBuilder,
     info: &OffchainLookup,
     url: &str,
+    origin_tx_hash: Option<String>,
 ) -> Result<Metadata, MetadataBuildError> {
     // Compute relayer authentication signature via EIP-191
     let maybe_signature_hex = if let Some(signer) = ism_builder.base.base_builder().get_signer() {
@@ -271,7 +291,13 @@ async fn fetch_offchain_data(
             sender: sender_as_bytes,
             data: data_as_bytes,
             signature: maybe_signature_hex,
+            origin_tx_hash,
         };
+        tracing::debug!(
+            url = interpolated_url,
+            ?body,
+            "Sending POST request to offchain lookup server"
+        );
         Client::new()
             .request(Method::POST, interpolated_url)
             .header(CONTENT_TYPE, "application/json")
@@ -301,6 +327,10 @@ async fn fetch_offchain_data(
         let error_msg = format!("Failed to read offchain lookup server response: ({err})");
         MetadataBuildError::FailedToBuild(error_msg)
     })?;
+    tracing::debug!(
+        response = response_body,
+        "Received response from offchain lookup server"
+    );
     let json: OffchainResponse = serde_json::from_str(&response_body).map_err(|err| {
         let error_msg = format!(
             "Failed to parse offchain lookup server json response: ({err}) ({response_body})"

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

@@ -10,7 +10,7 @@ use hyperlane_base::{
 };
 use hyperlane_core::{
     accumulator::merkle::Proof, AggregationIsm, CcipReadIsm, Checkpoint, HyperlaneDomain,
-    HyperlaneMessage, InterchainSecurityModule, Mailbox, MultisigIsm, RoutingIsm, H256,
+    HyperlaneMessage, InterchainSecurityModule, Mailbox, MultisigIsm, RoutingIsm, H256, H512,
 };
 use hyperlane_ethereum::Signers;
 use hyperlane_test::mocks::MockMailboxContract;
@@ -191,6 +191,12 @@ impl BuildsBaseMetadata for MockBaseMetadataBuilder {
             .pop_front()
             .expect("No mock get_merkle_leaf_id_by_message_id response set")
     }
+    async fn retrieve_origin_tx_hash_by_message_id(
+        &self,
+        _message_id: H256,
+    ) -> eyre::Result<Option<H512>> {
+        Ok(None)
+    }
     async fn build_ism(&self, address: H256) -> eyre::Result<Box<dyn InterchainSecurityModule>> {
         self.responses
             .build_ism

rust/main/hyperlane-base/src/db/mod.rs

@@ -5,7 +5,7 @@ pub use rocks::*;
 use hyperlane_core::{
     identifiers::UniqueIdentifier, GasPaymentKey, HyperlaneDomain, HyperlaneMessage,
     InterchainGasPayment, InterchainGasPaymentMeta, MerkleTreeInsertion, PendingOperationStatus,
-    H256,
+    H256, H512,
 };
 
 mod error;
@@ -161,6 +161,19 @@ pub trait HyperlaneDb: Send + Sync {
     /// Retrieve the nonce of the highest processed message we're aware of
     fn retrieve_highest_seen_message_nonce_number(&self) -> DbResult<Option<u32>>;
 
+    /// Store the origin transaction hash for a dispatched message by its message id
+    fn store_dispatched_tx_hash_by_message_id(
+        &self,
+        message_id: &H256,
+        tx_hash: &H512,
+    ) -> DbResult<()>;
+
+    /// Retrieve the origin transaction hash for a dispatched message by its message id
+    fn retrieve_dispatched_tx_hash_by_message_id(
+        &self,
+        message_id: &H256,
+    ) -> DbResult<Option<H512>>;
+
     /// Store payload uuid by message id
     fn store_payload_uuids_by_message_id(
         &self,

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

@@ -8,7 +8,7 @@ use hyperlane_core::{
     identifiers::UniqueIdentifier, Decode, Encode, GasPaymentKey, HyperlaneDomain,
     HyperlaneLogStore, HyperlaneMessage, HyperlaneSequenceAwareIndexerStoreReader,
     HyperlaneWatermarkedLogStore, Indexed, InterchainGasExpenditure, InterchainGasPayment,
-    InterchainGasPaymentMeta, LogMeta, MerkleTreeInsertion, PendingOperationStatus, H256,
+    InterchainGasPaymentMeta, LogMeta, MerkleTreeInsertion, PendingOperationStatus, H256, H512,
 };
 
 use crate::db::{
@@ -40,6 +40,7 @@ const MERKLE_TREE_INSERTION_BLOCK_NUMBER_BY_LEAF_INDEX: &str =
     "merkle_tree_insertion_block_number_by_leaf_index_";
 const LATEST_INDEXED_GAS_PAYMENT_BLOCK: &str = "latest_indexed_gas_payment_block";
 const PAYLOAD_UUIDS_BY_MESSAGE_ID: &str = "payload_uuids_by_message_id_";
+const MESSAGE_DISPATCHED_TX_HASH_BY_MESSAGE_ID: &str = "message_dispatched_tx_hash_by_message_id_";
 
 /// Rocks DB result type
 pub type DbResult<T> = std::result::Result<T, DbError>;
@@ -319,6 +320,10 @@ impl HyperlaneLogStore<HyperlaneMessage> for HyperlaneRocksDB {
             if stored_message {
                 stored = stored.saturating_add(1);
             }
+            self.store_dispatched_tx_hash_by_message_id(
+                &message.inner().id(),
+                &meta.transaction_id,
+            )?;
         }
         if stored > 0 {
             debug!(messages = stored, "Wrote new messages to database");
@@ -698,6 +703,25 @@ impl HyperlaneDb for HyperlaneRocksDB {
     ) -> DbResult<Option<Vec<UniqueIdentifier>>> {
         self.retrieve_value_by_key(PAYLOAD_UUIDS_BY_MESSAGE_ID, message_id)
     }
+
+    fn store_dispatched_tx_hash_by_message_id(
+        &self,
+        message_id: &H256,
+        tx_hash: &H512,
+    ) -> DbResult<()> {
+        self.store_value_by_key(
+            MESSAGE_DISPATCHED_TX_HASH_BY_MESSAGE_ID,
+            message_id,
+            tx_hash,
+        )
+    }
+
+    fn retrieve_dispatched_tx_hash_by_message_id(
+        &self,
+        message_id: &H256,
+    ) -> DbResult<Option<H512>> {
+        self.retrieve_value_by_key(MESSAGE_DISPATCHED_TX_HASH_BY_MESSAGE_ID, message_id)
+    }
 }
 
 impl HyperlaneRocksDB {

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

@@ -41,7 +41,7 @@ mod test {
         RawHyperlaneMessage, H256, H512, U256,
     };
 
-    use crate::db::HyperlaneRocksDB;
+    use crate::db::{HyperlaneDb, HyperlaneRocksDB};
 
     use super::*;
 
@@ -83,4 +83,44 @@ mod test {
         })
         .await;
     }
+
+    #[tokio::test]
+    async fn db_stores_and_retrieves_dispatched_tx_hash() {
+        run_test_db(|db| async move {
+            let db = HyperlaneRocksDB::new(
+                &HyperlaneDomain::new_test_domain("db_stores_and_retrieves_dispatched_tx_hash"),
+                db,
+            );
+
+            let m = HyperlaneMessage {
+                nonce: 42,
+                version: 3,
+                origin: 10,
+                sender: H256::from_low_u64_be(4),
+                destination: 12,
+                recipient: H256::from_low_u64_be(5),
+                body: vec![],
+            };
+            let tx_hash = H512::from_low_u64_be(0xdeadbeef);
+            let meta = LogMeta {
+                address: H256::from_low_u64_be(1),
+                block_number: 1,
+                block_hash: H256::from_low_u64_be(1),
+                transaction_id: tx_hash,
+                transaction_index: 0,
+                log_index: U256::from(0),
+            };
+
+            db.store_logs(&vec![(Indexed::new(m.clone()), meta)])
+                .await
+                .unwrap();
+
+            let retrieved = db
+                .retrieve_dispatched_tx_hash_by_message_id(&m.id())
+                .unwrap()
+                .unwrap();
+            assert_eq!(retrieved, tx_hash);
+        })
+        .await;
+    }
 }

rust/main/hyperlane-base/src/tests/mock_hyperlane_db.rs

@@ -4,7 +4,7 @@ use crate::db::{DbResult, HyperlaneDb, InterchainGasExpenditureData, InterchainG
 use hyperlane_core::{
     identifiers::UniqueIdentifier, GasPaymentKey, HyperlaneDomain, HyperlaneMessage,
     HyperlaneProvider, InterchainGasPayment, InterchainGasPaymentMeta, MerkleTreeInsertion,
-    PendingOperationStatus, H256,
+    PendingOperationStatus, H256, H512,
 };
 
 mockall::mock! {
@@ -123,5 +123,7 @@ mockall::mock! {
         fn retrieve_highest_seen_message_nonce_number(&self) -> DbResult<Option<u32>>;
         fn store_payload_uuids_by_message_id(&self, message_id: &H256, payload_uuids: Vec<UniqueIdentifier>) -> DbResult<()>;
         fn retrieve_payload_uuids_by_message_id(&self, message_id: &H256) -> DbResult<Option<Vec<UniqueIdentifier>>>;
+        fn store_dispatched_tx_hash_by_message_id(&self, message_id: &H256, tx_hash: &H512) -> DbResult<()>;
+        fn retrieve_dispatched_tx_hash_by_message_id(&self, message_id: &H256) -> DbResult<Option<H512>>;
     }
 }

typescript/ccip-server/src/services/CCTPService.ts

@@ -69,19 +69,25 @@ class CCTPService extends BaseService {
       createAbiHandler(
         CctpService__factory,
         'getCCTPAttestation',
-        this.getCCTPAttestation.bind(this),
+        (message: string, logger: Logger) =>
+          this.getCCTPAttestation(message, undefined, logger),
       ),
     );
 
     // CCIP-read spec: POST /getCctpAttestation
-    this.router.post(
-      '/getCctpAttestation',
-      createAbiHandler(
+    this.router.post('/getCctpAttestation', async (req, res) => {
+      const rawTxHash = req.body?.origin_tx_hash;
+      const originTxHash =
+        typeof rawTxHash === 'string' && ethers.utils.isHexString(rawTxHash, 32)
+          ? rawTxHash
+          : undefined;
+      return createAbiHandler(
         CctpService__factory,
         'getCCTPAttestation',
-        this.getCCTPAttestation.bind(this),
-      ),
-    );
+        (message: string, logger: Logger) =>
+          this.getCCTPAttestation(message, originTxHash, logger),
+      )(req, res);
+    });
   }
 
   async getCCTPMessageFromReceipt(
@@ -130,7 +136,11 @@ class CCTPService extends BaseService {
     throw new Error('Unable to find MessageSent event in logs');
   }
 
-  async getCCTPAttestation(message: string, logger: Logger) {
+  async getCCTPAttestation(
+    message: string,
+    originTxHash: string | undefined,
+    logger: Logger,
+  ) {
     const log = this.addLoggerServiceContext(logger);
 
     log.info(
@@ -141,11 +151,20 @@ class CCTPService extends BaseService {
     const messageId: string = ethers.utils.keccak256(message);
     log.info({ messageId, hyperlaneMessage: message }, 'Generated message ID');
 
-    const txHash =
-      await this.hyperlaneService.getOriginTransactionHashByMessageId(
+    let txHash: string | undefined = originTxHash;
+
+    if (txHash) {
+      log.info({ txHash, messageId }, 'Using tx hash provided by relayer');
+    } else {
+      log.info(
+        { messageId },
+        'No tx hash from relayer, falling back to scraper lookup',
+      );
+      txHash = await this.hyperlaneService.getOriginTransactionHashByMessageId(
         messageId,
         log,
       );
+    }
 
     if (!txHash) {
       throw new Error(`Invalid transaction hash: ${txHash}`);