Update CCIP implementation and improve error handling (#6)

Co-authored-by: Luc <[email protected]>

.gitignore

@@ -1,2 +1,3 @@
 /target
 Cargo.lock
+.idea/

Cargo.toml

@@ -18,25 +18,32 @@ exclude = [
 ]
 
 [dependencies]
+# Tracing
+tracing = "0.1.40"
+
 # Error handling
-thiserror = { version = "1.0.26", default-features = false }
+thiserror = { version = "1.0.50", default-features = false }
 
 # Serialization/deserialization
-serde_json = "1"
+serde_json = "1.0.108"
+serde = { version = "1.0.192", features = ["derive"] }
 
 # HTTP
-reqwest = "0.11"
+reqwest = "0.11.22"
 
 # Async
-async-recursion = "1.0.4"
-async-trait = { version = "0.1.50", default-features = false }
+async-recursion = "1.0.5"
+async-trait = { version = "0.1.74", default-features = false }
 
 # Ethers
-ethers-core = "2.0.4"
-ethers-providers = "2.0.4"
-futures-util = "0.3.28"
+ethers-core = "2.0.11"
+ethers-providers = "2.0.11"
+futures-util = "0.3.29"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+getrandom = { version = "0.2", features = ["js"] }
 
 [dev-dependencies]
-tokio = { version = "1.7.1", features = ["macros", "rt-multi-thread"] }
-ethers = "2.0.4"
-anyhow = "1.0"
+tokio = { version = "1.34.0", features = ["macros", "rt-multi-thread"] }
+ethers = "2.0.11"
+anyhow = "1.0.75"

examples/offchain.rs

@@ -1,7 +1,9 @@
+use std::convert::TryFrom;
+
 use anyhow::Result;
 use ethers::prelude::*;
+
 use ethers_ccip_read::CCIPReadMiddleware;
-use std::convert::TryFrom;
 
 #[tokio::main]
 async fn main() -> Result<()> {

src/ccip.rs

@@ -0,0 +1,133 @@
+use std::collections::{HashMap, HashSet};
+use std::hash::Hash;
+
+use ethers_core::types::transaction::eip2718::TypedTransaction;
+use ethers_core::types::{Address, Bytes};
+use ethers_core::utils::hex;
+use ethers_providers::Middleware;
+use reqwest::Response;
+use serde::Deserialize;
+
+use crate::errors::{CCIPFetchError, CCIPRequestError};
+use crate::utils::truncate_str;
+use crate::CCIPReadMiddlewareError;
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct CCIPResponse {
+    pub data: Option<String>,
+    pub message: Option<String>,
+}
+
+pub async fn handle_ccip_raw(
+    client: &reqwest::Client,
+    url: &str,
+    sender: &Address,
+    calldata: &[u8],
+) -> Result<Bytes, CCIPRequestError> {
+    tracing::debug!("making CCIP request to {url}");
+
+    let sender_hex = hex::encode_prefixed(sender.0);
+    let data_hex: String = hex::encode_prefixed(calldata);
+
+    tracing::debug!("sender: {}", sender_hex);
+    tracing::debug!("data: {}", truncate_str(&data_hex, 20));
+
+    let request = if url.contains("{data}") {
+        let href = url
+            .replace("{sender}", &sender_hex)
+            .replace("{data}", &data_hex);
+
+        client.get(href)
+    } else {
+        let body = serde_json::json!({
+            "data": data_hex,
+            "sender": sender_hex
+        });
+
+        client.post(url).json(&body)
+    };
+
+    let resp: Response = request.send().await?;
+
+    let resp_text = resp.text().await?;
+
+    // TODO: handle non-json responses
+    //  in case of erroneous responses, server can return Content-Type that is not application/json
+    //  in this case, we should read the response as text and perhaps treat that as the error
+    let result: CCIPResponse = serde_json::from_str(&resp_text).map_err(|err| {
+        CCIPRequestError::GatewayFormatError(format!(
+            "response format error: {err}, gateway returned: {resp_text}"
+        ))
+    })?;
+
+    if let Some(response_data) = result.data {
+        return hex::decode(response_data)
+            .map_err(|_| {
+                CCIPRequestError::GatewayFormatError(
+                    "response data is not a valid hex sequence".to_string(),
+                )
+            })
+            .map(Bytes::from);
+    };
+
+    if let Some(message) = result.message {
+        return Err(CCIPRequestError::GatewayError(message));
+    }
+
+    Err(CCIPRequestError::GatewayFormatError(
+        "response format error: invalid response".to_string(),
+    ))
+}
+
+/// This function makes a Cross-Chain Interoperability Protocol (CCIP-Read) request
+/// and returns the result as `Bytes` or an error message.
+///
+/// # Arguments
+///
+/// * `sender`: The sender's address.
+/// * `tx`: The typed transaction.
+/// * `calldata`: The function call data as bytes.
+/// * `urls`: A vector of Offchain Gateway URLs to send the request to.
+///
+/// # Returns
+///
+/// an opaque byte string to send to callbackFunction on Offchain Resolver contract.
+pub async fn handle_ccip<M: Middleware>(
+    client: &reqwest::Client,
+    sender: &Address,
+    tx: &TypedTransaction,
+    calldata: &[u8],
+    urls: Vec<String>,
+) -> Result<Bytes, CCIPReadMiddlewareError<M>> {
+    // If there are no URLs or the transaction's destination is empty, return an empty result
+    if urls.is_empty() || tx.to().is_none() {
+        return Ok(Bytes::new());
+    }
+
+    let urls = dedup_ord(&urls);
+
+    // url —> [error_message]
+    let mut errors: HashMap<String, Vec<String>> = HashMap::new();
+
+    for url in urls {
+        let result = handle_ccip_raw(client, &url, sender, calldata).await;
+
+        match result {
+            Ok(result) => return Ok(result),
+            Err(err) => {
+                errors.entry(url).or_default().push(err.to_string());
+            }
+        }
+    }
+
+    Err(CCIPReadMiddlewareError::FetchError(CCIPFetchError(errors)))
+}
+
+fn dedup_ord<T: Clone + Hash + Eq>(src: &[T]) -> Vec<T> {
+    let mut set = HashSet::new();
+
+    let mut copy = src.to_vec();
+    copy.retain(|item| set.insert(item.clone()));
+
+    copy
+}

src/errors.rs

@@ -1,6 +1,28 @@
+use ethers_core::utils::hex::FromHexError;
+use std::collections::HashMap;
+use std::fmt::Display;
+
 use ethers_providers::{Middleware, MiddlewareError};
 use thiserror::Error;
 
+#[allow(clippy::enum_variant_names)]
+#[derive(Error, Debug)]
+pub enum CCIPRequestError {
+    // gateway supplied error
+    #[error("Gateway error: {0}")]
+    GatewayError(String),
+
+    // when gateway either fails to respond with an expected format
+    #[error("Gateway format error: {0}")]
+    GatewayFormatError(String),
+
+    #[error("HTTP error: {0}")]
+    HTTPError(#[from] reqwest::Error),
+}
+
+#[derive(Debug)]
+pub struct CCIPFetchError(pub(crate) HashMap<String, Vec<String>>);
+
 /// Handle CCIP-Read middlware specific errors.
 #[derive(Error, Debug)]
 pub enum CCIPReadMiddlewareError<M: Middleware> {
@@ -9,14 +31,11 @@ pub enum CCIPReadMiddlewareError<M: Middleware> {
     MiddlewareError(M::Error),
 
     #[error("Error(s) during CCIP fetch: {0}")]
-    FetchError(String),
+    FetchError(CCIPFetchError),
 
     #[error("CCIP Read sender did not match {}", sender)]
     SenderError { sender: String },
 
-    #[error("Bad result from backend: {0}")]
-    GatewayError(String),
-
     #[error("CCIP Read no provided URLs")]
     GatewayNotFoundError,
 
@@ -33,6 +52,12 @@ pub enum CCIPReadMiddlewareError<M: Middleware> {
     #[error("Error(s) during NFT ownership verification: {0}")]
     NFTOwnerError(String),
 
+    #[error("Error(s) decoding revert bytes: {0}")]
+    HexDecodeError(#[from] FromHexError),
+
+    #[error("Error(s) decoding abi: {0}")]
+    AbiDecodeError(#[from] ethers_core::abi::Error),
+
     #[error("Unsupported URL scheme")]
     UnsupportedURLSchemeError,
 }
@@ -51,3 +76,15 @@ impl<M: Middleware> MiddlewareError for CCIPReadMiddlewareError<M> {
         }
     }
 }
+
+impl Display for CCIPFetchError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        let mut errors = f.debug_struct("CCIPFetchError");
+
+        for (url, messages) in self.0.iter() {
+            errors.field(url, messages);
+        }
+
+        errors.finish()
+    }
+}

src/lib.rs

@@ -1,10 +1,10 @@
 //! # Ethers CCIP-Read
 //!
 //! Provides an [ethers](https://docs.rs/ethers) compatible middleware for submitting
-mod middleware;
+pub use errors::CCIPReadMiddlewareError;
 pub use middleware::CCIPReadMiddleware;
 
+mod ccip;
 mod errors;
-pub use errors::CCIPReadMiddlewareError;
-
+mod middleware;
 pub mod utils;