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,102 @@
+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::{info, instrument};
+
+use super::{BaseMetadataBuilder, MetadataBuilder};
+use ethers::abi::AbiDecode;
+use ethers::core::utils::hex::decode as hex_decode;
+use hyperlane_core::{HyperlaneMessage, RawHyperlaneMessage, H256};
+use regex::Regex;
+
+#[derive(Serialize, Deserialize)]
+struct OffchainResponse {
+    data: 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 response = ism
+            .get_offchain_verify_info(RawHyperlaneMessage::from(message).to_vec())
+            .await;
+        let info: OffchainLookup = match response {
+            Ok(_) => {
+                info!("incorrectly configured getOffchainVerifyInfo, expected revert");
+                return Ok(None);
+            }
+            Err(raw_error) => {
+                let matching_regex = Regex::new(r"0x[[:xdigit:]]+")?;
+                if let Some(matching) = &matching_regex.captures(&raw_error.to_string()) {
+                    OffchainLookup::decode(hex_decode(&matching[0][2..])?)?
+                } else {
+                    info!("unable to parse custom error out of revert");
+                    return Ok(None);
+                }
+            }
+        };
+
+        for url in info.urls.iter() {
+            let interpolated_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(interpolated_url)
+                    .header("Content-Type", "application/json")
+                    .json(&body)
+                    .send()
+                    .await?
+            } else {
+                reqwest::get(interpolated_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.data[2..])?;
+                    return Ok(Some(metadata));
+                }
+                Err(_err) => {
+                    // try the next URL
+                }
+            }
+        }
+
+        // No metadata endpoints or endpoints down
+        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,89 @@
+[
+  {
+    "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"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes",
+        "name": "_message",
+        "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": [
+      {
+        "internalType": "bytes",
+        "name": "_metadata",
+        "type": "bytes"
+      },
+      {
+        "internalType": "bytes",
+        "name": "_message",
+        "type": "bytes"
+      }
+    ],
+    "name": "verify",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]

rust/chains/hyperlane-ethereum/src/ccip_read_ism.rs

@@ -0,0 +1,110 @@
+#![allow(clippy::enum_variant_names)]
+#![allow(missing_docs)]
+
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use ethers::providers::Middleware;
+use tracing::instrument;
+
+use hyperlane_core::{
+    CcipReadIsm, ChainResult, ContractLocator, HyperlaneAbi, HyperlaneChain, HyperlaneContract,
+    HyperlaneDomain, HyperlaneProvider, H256,
+};
+
+pub use crate::contracts::i_ccip_read_ism::{
+    ICcipReadIsm as EthereumCcipReadIsmInternal, OffchainLookup, ICCIPREADISM_ABI,
+};
+use crate::trait_builder::BuildableWithProvider;
+use crate::EthereumProvider;
+
+pub struct CcipReadIsmBuilder {}
+
+#[async_trait]
+impl BuildableWithProvider for CcipReadIsmBuilder {
+    type Output = Box<dyn CcipReadIsm>;
+
+    async fn build_with_provider<M: Middleware + 'static>(
+        &self,
+        provider: M,
+        locator: &ContractLocator,
+    ) -> Self::Output {
+        Box::new(EthereumCcipReadIsm::new(Arc::new(provider), locator))
+    }
+}
+
+/// A reference to an CcipReadIsm contract on some Ethereum chain
+#[derive(Debug)]
+pub struct EthereumCcipReadIsm<M>
+where
+    M: Middleware,
+{
+    contract: Arc<EthereumCcipReadIsmInternal<M>>,
+    domain: HyperlaneDomain,
+}
+
+impl<M> EthereumCcipReadIsm<M>
+where
+    M: Middleware + 'static,
+{
+    /// Create a reference to a mailbox at a specific Ethereum address on some
+    /// chain
+    pub fn new(provider: Arc<M>, locator: &ContractLocator) -> Self {
+        Self {
+            contract: Arc::new(EthereumCcipReadIsmInternal::new(locator.address, provider)),
+            domain: locator.domain.clone(),
+        }
+    }
+}
+
+impl<M> HyperlaneChain for EthereumCcipReadIsm<M>
+where
+    M: Middleware + 'static,
+{
+    fn domain(&self) -> &HyperlaneDomain {
+        &self.domain
+    }
+
+    fn provider(&self) -> Box<dyn HyperlaneProvider> {
+        Box::new(EthereumProvider::new(
+            self.contract.client(),
+            self.domain.clone(),
+        ))
+    }
+}
+
+impl<M> HyperlaneContract for EthereumCcipReadIsm<M>
+where
+    M: Middleware + 'static,
+{
+    fn address(&self) -> H256 {
+        self.contract.address().into()
+    }
+}
+
+#[async_trait]
+impl<M> CcipReadIsm for EthereumCcipReadIsm<M>
+where
+    M: Middleware + 'static,
+{
+    #[instrument(err)]
+    async fn get_offchain_verify_info(&self, message: Vec<u8>) -> ChainResult<bool> {
+        let info: bool = self
+            .contract
+            .get_offchain_verify_info(message.into())
+            .call()
+            .await?;
+        Ok(info)
+    }
+}
+
+pub struct EthereumCcipReadIsmAbi;
+
+impl HyperlaneAbi for EthereumCcipReadIsmAbi {
+    const SELECTOR_SIZE_BYTES: usize = 4;
+
+    fn fn_map() -> HashMap<Vec<u8>, &'static str> {
+        super::extract_fn_map(&ICCIPREADISM_ABI)
+    }
+}

rust/chains/hyperlane-ethereum/src/lib.rs

@@ -10,9 +10,9 @@ use ethers::prelude::{abi, Lazy, Middleware};
 
 #[cfg(not(doctest))]
 pub use self::{
-    config::*, interchain_gas::*, interchain_security_module::*, mailbox::*, multisig_ism::*,
-    provider::*, routing_ism::*, rpc_clients::*, signers::*, singleton_signer::*, trait_builder::*,
-    validator_announce::*,
+    ccip_read_ism::*, config::*, interchain_gas::*, interchain_security_module::*, mailbox::*,
+    multisig_ism::*, provider::*, routing_ism::*, rpc_clients::*, signers::*, singleton_signer::*,
+    trait_builder::*, validator_announce::*,
 };
 
 #[cfg(not(doctest))]
@@ -45,6 +45,10 @@ mod multisig_ism;
 #[cfg(not(doctest))]
 mod routing_ism;
 
+/// CcipReadIsm abi
+#[cfg(not(doctest))]
+mod ccip_read_ism;
+
 /// ValidatorAnnounce abi
 #[cfg(not(doctest))]
 mod validator_announce;