CCIP Read ISM

rust/agents/relayer/Cargo.toml

@@ -27,6 +27,7 @@ tokio = { workspace = true, features = ["rt", "macros", "parking_lot"] }
 tracing-futures.workspace = true
 tracing-subscriber.workspace = true
 tracing.workspace = true
+regex = "1.5"
 
 hyperlane-core = { path = "../../hyperlane-core" }
 hyperlane-base = { path = "../../hyperlane-base" }

rust/agents/relayer/src/msg/metadata/base.rs

@@ -13,15 +13,16 @@ use hyperlane_base::{
 };
 use hyperlane_core::accumulator::merkle::Proof;
 use hyperlane_core::{
-    Checkpoint, HyperlaneDomain, HyperlaneMessage, ModuleType, MultisigIsm, RoutingIsm,
-    ValidatorAnnounce, H160, H256,
+    CcipReadIsm, Checkpoint, HyperlaneDomain, HyperlaneMessage, ModuleType, MultisigIsm,
+    RoutingIsm, ValidatorAnnounce, H160, H256,
 };
 
 use crate::merkle_tree_builder::MerkleTreeBuilder;
 use crate::msg::metadata::multisig::{
     LegacyMultisigMetadataBuilder, MerkleRootMultisigMetadataBuilder,
     MessageIdMultisigMetadataBuilder,
 };
+use crate::msg::metadata::CcipReadIsmMetadataBuilder;
 use crate::msg::metadata::RoutingIsmMetadataBuilder;
 
 #[derive(Debug, thiserror::Error)]
@@ -87,6 +88,7 @@ impl MetadataBuilder for BaseMetadataBuilder {
             }
             ModuleType::MessageIdMultisig => Box::new(MessageIdMultisigMetadataBuilder::new(base)),
             ModuleType::Routing => Box::new(RoutingIsmMetadataBuilder::new(base)),
+            ModuleType::CcipRead => Box::new(CcipReadIsmMetadataBuilder::new(base)),
             _ => return Err(MetadataBuilderError::UnsupportedModuleType(module_type).into()),
         };
         metadata_builder
@@ -150,6 +152,12 @@ impl BaseMetadataBuilder {
             .await
     }
 
+    pub async fn build_ccip_read_ism(&self, address: H256) -> Result<Box<dyn CcipReadIsm>> {
+        self.destination_chain_setup
+            .build_ccip_read_ism(address, &self.metrics)
+            .await
+    }
+
     pub async fn build_checkpoint_syncer(
         &self,
         validators: &[H256],

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

@@ -0,0 +1,105 @@
+use async_trait::async_trait;
+use hyperlane_ethereum::OffchainLookup;
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use std::ops::Deref;
+
+use derive_new::new;
+use eyre::Context;
+use tracing::instrument;
+
+use super::{BaseMetadataBuilder, MetadataBuilder};
+use ethers::abi::AbiDecode;
+use ethers::core::utils::hex::decode as hex_decode;
+use hyperlane_core::{ChainCommunicationError, HyperlaneMessage, H256};
+use regex::Regex;
+
+#[derive(Serialize, Deserialize)]
+struct OffchainResponse {
+    metadata: String,
+    message: String,
+}
+
+#[derive(Clone, Debug, new)]
+pub struct CcipReadIsmMetadataBuilder {
+    base: BaseMetadataBuilder,
+}
+
+impl Deref for CcipReadIsmMetadataBuilder {
+    type Target = BaseMetadataBuilder;
+
+    fn deref(&self) -> &Self::Target {
+        &self.base
+    }
+}
+
+#[async_trait]
+impl MetadataBuilder for CcipReadIsmMetadataBuilder {
+    #[instrument(err, skip(self))]
+    async fn build(
+        &self,
+        ism_address: H256,
+        message: &HyperlaneMessage,
+    ) -> eyre::Result<Option<Vec<u8>>> {
+        const CTX: &str = "When fetching CcipRead metadata";
+        let ism = self.build_ccip_read_ism(ism_address).await.context(CTX)?;
+        let info_result = ism.get_offchain_verify_info(message).await.context(CTX);
+
+        let info: OffchainLookup = match info_result {
+            Ok(_) => panic!("Shouldn't get here"),
+            Err(e) => match e.downcast_ref::<ChainCommunicationError>() {
+                Some(err) => {
+                    println!("err {:?}", err);
+                    let regex = Regex::new(r"0x[[:xdigit:]]+").unwrap();
+
+                    if let Some(capture) = regex.captures(&err.to_string()) {
+                        let extracted = &capture[0];
+
+                        let data = hex_decode(extracted.replace("0x", "")).unwrap();
+                        OffchainLookup::decode(data).unwrap()
+                    } else {
+                        panic!("Shouldn't get here");
+                        // Err(hyperlane_core::ChainCommunicationError::TransactionTimeout())
+                    }
+                }
+                None => panic!("Shouldn't get here"),
+            },
+        };
+
+        for url in info.urls.iter() {
+            let request_url = url
+                .replace("{sender}", &info.sender.to_string())
+                .replace("{data}", &info.call_data.to_string());
+            let res = if url.contains("{data}") {
+                let body = json!({
+                    "data": info.call_data.to_string(),
+                    "sender": info.sender.to_string(),
+                });
+                Client::new()
+                    .post(request_url)
+                    .header("Content-Type", "application/json")
+                    .json(&body)
+                    .send()
+                    .await?
+            } else {
+                reqwest::get(request_url).await?
+            };
+
+            let json: Result<OffchainResponse, reqwest::Error> = res.json().await;
+
+            match json {
+                Ok(result) => {
+                    // remove leading 0x which hex_decode doesn't like
+                    let metadata = hex_decode(&result.metadata[2..]).unwrap();
+                    return Ok(Some(metadata));
+                }
+                Err(_err) => {
+                    // let the next URL
+                }
+            }
+        }
+
+        Ok(None)
+    }
+}

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

@@ -1,7 +1,9 @@
 mod base;
+mod ccip_read;
 mod multisig;
 mod routing;
 
 pub(crate) use base::BaseMetadataBuilder;
 pub(crate) use base::MetadataBuilder;
+use ccip_read::CcipReadIsmMetadataBuilder;
 use routing::RoutingIsmMetadataBuilder;

rust/chains/hyperlane-ethereum/abis/ICcipReadIsm.abi.json

@@ -0,0 +1,221 @@
+[
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "sender",
+        "type": "address"
+      },
+      {
+        "internalType": "string[]",
+        "name": "urls",
+        "type": "string[]"
+      },
+      {
+        "internalType": "bytes",
+        "name": "callData",
+        "type": "bytes"
+      },
+      {
+        "internalType": "bytes4",
+        "name": "callbackFunction",
+        "type": "bytes4"
+      },
+      {
+        "internalType": "bytes",
+        "name": "extraData",
+        "type": "bytes"
+      }
+    ],
+    "name": "OffchainLookup",
+    "type": "error"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "bytes",
+        "name": "callData",
+        "type": "bytes"
+      }
+    ],
+    "name": "OffchainCallDataUpdated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "bytes",
+        "name": "extraData",
+        "type": "bytes"
+      }
+    ],
+    "name": "OffchainExtraDataUpdated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "string[]",
+        "name": "urls",
+        "type": "string[]"
+      }
+    ],
+    "name": "OffchainUrlsUpdated",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes",
+        "name": "",
+        "type": "bytes"
+      }
+    ],
+    "name": "getOffchainVerifyInfo",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "moduleType",
+    "outputs": [
+      {
+        "internalType": "uint8",
+        "name": "",
+        "type": "uint8"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "offchainCallData",
+    "outputs": [
+      {
+        "internalType": "bytes",
+        "name": "",
+        "type": "bytes"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "offchainExtraData",
+    "outputs": [
+      {
+        "internalType": "bytes",
+        "name": "",
+        "type": "bytes"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "name": "offchainUrls",
+    "outputs": [
+      {
+        "internalType": "string",
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes",
+        "name": "_message",
+        "type": "bytes"
+      }
+    ],
+    "name": "validatorsAndThreshold",
+    "outputs": [
+      {
+        "internalType": "address[]",
+        "name": "",
+        "type": "address[]"
+      },
+      {
+        "internalType": "uint8",
+        "name": "",
+        "type": "uint8"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes",
+        "name": "_metadata",
+        "type": "bytes"
+      },
+      {
+        "internalType": "bytes",
+        "name": "_message",
+        "type": "bytes"
+      }
+    ],
+    "name": "verify",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes",
+        "name": "response",
+        "type": "bytes"
+      },
+      {
+        "internalType": "bytes",
+        "name": "",
+        "type": "bytes"
+      }
+    ],
+    "name": "verifyWithProof",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]