feat(submitter): Report reverted payload with success criteria (hyperlane-xyz#6170)

### Description

- Generate contract calls to check if a particular message was delivered
- Populate payload success criteria with serialized contract calls
- Check if success criteria is met at finality stage of Lander

### Backward compatibility

Yes

### Testing

None

---------

Co-authored-by: Danil Nemirovsky <4614623+ameten@users.noreply.github.com>

Author: ameten

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

@@ -384,6 +384,10 @@ pub mod test {
             todo!()
         }
 
+        fn success_criteria(&self) -> ChainResult<Option<Vec<u8>>> {
+            todo!()
+        }
+
         fn on_reprepare(
             &mut self,
             _err_msg: Option<String>,

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

@@ -661,14 +661,30 @@ async fn submit_via_lander(
         }
     };
 
+    let operation_success_criteria = match op.success_criteria() {
+        Ok(s) => s,
+        Err(e) => {
+            let reason = ReprepareReason::ErrorCreatingPayloadSuccessCriteria;
+            let msg = "Error creating payload success criteria";
+            prepare_op(op, prepare_queue, e, msg, reason).await;
+            return;
+        }
+    };
+
     let message_id = op.id();
     let metadata = format!("{message_id:?}");
     let mailbox = op
         .try_get_mailbox()
         .expect("Operation should contain Mailbox address")
         .address();
     let payload_id = PayloadId::random();
-    let payload = FullPayload::new(payload_id, metadata, operation_payload, mailbox);
+    let payload = FullPayload::new(
+        payload_id,
+        metadata,
+        operation_payload,
+        operation_success_criteria,
+        mailbox,
+    );
 
     if let Err(e) = entrypoint.send_payload(&payload).await {
         let reason = ReprepareReason::ErrorSubmitting;

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

@@ -552,6 +552,12 @@ impl PendingOperation for PendingMessage {
         Ok(payload)
     }
 
+    fn success_criteria(&self) -> ChainResult<Option<Vec<u8>>> {
+        let mailbox = &self.ctx.destination_mailbox;
+        let message = &self.message;
+        mailbox.delivered_calldata(message.id())
+    }
+
     fn on_reprepare(
         &mut self,
         err: Option<String>,

rust/main/chains/hyperlane-cosmos-native/src/mailbox.rs

@@ -182,4 +182,8 @@ impl Mailbox for CosmosNativeMailbox {
     ) -> ChainResult<Vec<u8>> {
         todo!() // we dont need this for now
     }
+
+    fn delivered_calldata(&self, _message_id: H256) -> ChainResult<Option<Vec<u8>>> {
+        todo!()
+    }
 }

rust/main/chains/hyperlane-cosmos/src/mailbox/contract.rs

@@ -1,4 +1,3 @@
-use std::num::NonZeroU64;
 use std::str::FromStr;
 
 use async_trait::async_trait;
@@ -18,7 +17,7 @@ use crate::payloads::mailbox::{
 };
 use crate::types::tx_response_to_outcome;
 use crate::utils::get_block_height_for_reorg_period;
-use crate::{payloads, ConnectionConf, CosmosAddress, CosmosProvider, Signer};
+use crate::{payloads, ConnectionConf, CosmosAddress, CosmosProvider};
 
 #[derive(Clone, Debug)]
 /// A reference to a Mailbox contract on some Cosmos chain
@@ -206,6 +205,10 @@ impl Mailbox for CosmosMailbox {
     ) -> ChainResult<Vec<u8>> {
         todo!() // not required
     }
+
+    fn delivered_calldata(&self, message_id: H256) -> ChainResult<Option<Vec<u8>>> {
+        todo!()
+    }
 }
 
 impl CosmosMailbox {

rust/main/chains/hyperlane-ethereum/src/contracts/mailbox.rs

@@ -14,17 +14,16 @@ use ethers_contract::builders::ContractCall;
 use ethers_contract::{Multicall, MulticallResult};
 use ethers_core::utils::WEI_IN_ETHER;
 use futures_util::future::join_all;
-use hyperlane_core::rpc_clients::call_and_retry_indefinitely;
-use hyperlane_core::{BatchResult, QueueOperation, ReorgPeriod, H512};
 use tokio::join;
 use tokio::sync::Mutex;
 use tracing::instrument;
 
 use hyperlane_core::{
-    utils::bytes_to_hex, BatchItem, ChainCommunicationError, ChainResult, ContractLocator,
-    HyperlaneAbi, HyperlaneChain, HyperlaneContract, HyperlaneDomain, HyperlaneMessage,
-    HyperlaneProtocolError, HyperlaneProvider, Indexed, Indexer, LogMeta, Mailbox,
-    RawHyperlaneMessage, SequenceAwareIndexer, TxCostEstimate, TxOutcome, H160, H256, U256,
+    rpc_clients::call_and_retry_indefinitely, utils::bytes_to_hex, BatchItem, BatchResult,
+    ChainCommunicationError, ChainResult, ContractLocator, HyperlaneAbi, HyperlaneChain,
+    HyperlaneContract, HyperlaneDomain, HyperlaneMessage, HyperlaneProtocolError,
+    HyperlaneProvider, Indexed, Indexer, LogMeta, Mailbox, QueueOperation, RawHyperlaneMessage,
+    ReorgPeriod, SequenceAwareIndexer, TxCostEstimate, TxOutcome, H160, H256, H512, U256,
 };
 
 use crate::error::HyperlaneEthereumError;
@@ -693,6 +692,13 @@ where
         let data = (contract_call.tx, contract_call.function);
         serde_json::to_vec(&data).map_err(Into::into)
     }
+
+    fn delivered_calldata(&self, message_id: H256) -> ChainResult<Option<Vec<u8>>> {
+        let call = self.contract.delivered(message_id.into());
+
+        let data = (call.tx, call.function);
+        serde_json::to_vec(&data).map(Some).map_err(Into::into)
+    }
 }
 
 pub struct EthereumMailboxAbi;

rust/main/chains/hyperlane-ethereum/src/rpc_clients/provider.rs

@@ -35,17 +35,17 @@ pub struct EthereumProvider<M> {
 
 impl<M> EthereumProvider<M> {
     /// Create a ContractCall object for a given transaction and function.
-    pub fn build_contract_call(
+    pub fn build_contract_call<D>(
         &self,
         tx: TypedTransaction,
         function: Function,
-    ) -> ContractCall<M, ()> {
+    ) -> ContractCall<M, D> {
         ContractCall {
             tx,
             function,
             block: None,
             client: self.provider.clone(),
-            datatype: PhantomData::<()>,
+            datatype: PhantomData::<D>,
         }
     }
 }
@@ -93,6 +93,9 @@ pub trait EvmProviderForSubmitter: Send + Sync {
 
     /// Send transaction into blockchain
     async fn send(&self, tx: &TypedTransaction, function: &Function) -> ChainResult<H256>;
+
+    /// Read-only call into blockchain which returns a boolean
+    async fn check(&self, tx: &TypedTransaction, function: &Function) -> ChainResult<bool>;
 }
 
 #[async_trait]
@@ -133,20 +136,30 @@ where
         tx: &TypedTransaction,
         function: &Function,
     ) -> Result<U256, ChainCommunicationError> {
-        let contract_call = self.build_contract_call(tx.clone(), function.clone());
+        let contract_call = self.build_contract_call::<()>(tx.clone(), function.clone());
         let gas_limit = contract_call.estimate_gas().await?.into();
         Ok(gas_limit)
     }
 
     async fn send(&self, tx: &TypedTransaction, function: &Function) -> ChainResult<H256> {
-        let contract_call = self.build_contract_call(tx.clone(), function.clone());
+        let contract_call = self.build_contract_call::<()>(tx.clone(), function.clone());
         let pending = contract_call
             .send()
             .await
             .map_err(|e| ChainCommunicationError::CustomError(e.to_string()))?;
 
         Ok(pending.tx_hash().into())
     }
+
+    async fn check(&self, tx: &TypedTransaction, function: &Function) -> ChainResult<bool> {
+        let contract_call = self.build_contract_call::<bool>(tx.clone(), function.clone());
+        let success = contract_call
+            .call()
+            .await
+            .map_err(|e| ChainCommunicationError::CustomError(e.to_string()))?;
+
+        Ok(success)
+    }
 }
 
 #[async_trait]

rust/main/chains/hyperlane-fuel/src/mailbox.rs

@@ -220,6 +220,10 @@ impl Mailbox for FuelMailbox {
         // Seems like this is not needed for Fuel, as it's only used in mocks
         todo!()
     }
+
+    fn delivered_calldata(&self, message_id: H256) -> ChainResult<Option<Vec<u8>>> {
+        todo!()
+    }
 }
 
 /// Struct that retrieves event data for a Fuel Mailbox contract

rust/main/chains/hyperlane-sealevel/src/mailbox.rs

@@ -552,4 +552,8 @@ impl Mailbox for SealevelMailbox {
         let process_instruction = self.get_process_instruction(message, metadata).await?;
         serde_json::to_vec(&process_instruction).map_err(Into::into)
     }
+
+    fn delivered_calldata(&self, _message_id: H256) -> ChainResult<Option<Vec<u8>>> {
+        Ok(None)
+    }
 }

rust/main/hyperlane-core/src/traits/mailbox.rs

@@ -71,6 +71,9 @@ pub trait Mailbox: HyperlaneContract + Send + Sync + Debug {
         message: &HyperlaneMessage,
         metadata: &[u8],
     ) -> ChainResult<Vec<u8>>;
+
+    /// Get the calldata for a call which allows to check if a particular messages was delivered
+    fn delivered_calldata(&self, message_id: H256) -> ChainResult<Option<Vec<u8>>>;
 }
 
 /// The result of processing a batch of messages