Merge main

.github/workflows/node.yml

@@ -115,7 +115,7 @@ jobs:
     strategy:
       matrix:
         environment: [testnet3, mainnet2]
-        module: [core, igp]
+        module: [core, igp, ica, iqs]
 
     steps:
       - uses: actions/checkout@v3

rust/Cargo.toml

@@ -39,6 +39,8 @@ eyre = "0.6"
 futures = "0.3"
 futures-util = "0.3"
 itertools = "0.10"
+num-derive = "0.3"
+num-traits = "0.2"
 paste = "1.0"
 prometheus = "0.13"
 reqwest = "0.11"

rust/agents/relayer/Cargo.toml

@@ -29,6 +29,8 @@ tracing.workspace = true
 hyperlane-core = { path = "../../hyperlane-core" }
 hyperlane-base = { path = "../../hyperlane-base" }
 hyperlane-ethereum = { path = "../../chains/hyperlane-ethereum" }
+num-derive.workspace = true
+num-traits.workspace = true
 
 [dev-dependencies]
 tokio-test = "0.4"
@@ -37,4 +39,4 @@ hyperlane-test = { path = "../../hyperlane-test" }
 [features]
 default = ["color-eyre", "oneline-errors"]
 oneline-errors = ["hyperlane-base/oneline-errors"]
-color-eyre = ["hyperlane-base/color-eyre"]
+color-eyre = ["hyperlane-base/color-eyre"]

rust/agents/relayer/src/msg/metadata_builder.rs

@@ -1,33 +1,57 @@
-use std::collections::HashMap;
+use async_trait::async_trait;
+use num_derive::FromPrimitive;
+use num_traits::FromPrimitive;
 use std::fmt::Debug;
 use std::str::FromStr;
 use std::sync::Arc;
+use std::{collections::HashMap, ops::Deref};
 
 use derive_new::new;
 use eyre::Context;
 use tokio::sync::RwLock;
 use tracing::{debug, info, instrument, warn};
 
 use hyperlane_base::{
-    CachingMailbox, ChainSetup, CheckpointSyncer, CheckpointSyncerConf, CoreMetrics,
-    MultisigCheckpointSyncer,
-};
-use hyperlane_core::{
-    HyperlaneChain, HyperlaneMessage, Mailbox, MultisigIsm, ValidatorAnnounce, H160, H256,
+    ChainSetup, CheckpointSyncer, CheckpointSyncerConf, CoreMetrics, MultisigCheckpointSyncer,
 };
+use hyperlane_core::{HyperlaneMessage, MultisigIsm, ValidatorAnnounce, H160, H256};
 
 use crate::merkle_tree_builder::MerkleTreeBuilder;
 
+#[derive(Debug, thiserror::Error)]
+pub enum MetadataBuilderError {
+    #[error("Unknown or invalid module type ({0})")]
+    UnsupportedModuleType(u8),
+}
+
+#[derive(FromPrimitive)]
+pub enum SupportedIsmTypes {
+    // Routing = 1,
+    // Aggregation = 2,
+    LegacyMultisig = 3,
+    // Multisig = 4,
+}
+
+#[async_trait]
+pub trait MetadataBuilder {
+    #[allow(clippy::async_yields_async)]
+    async fn build(
+        &self,
+        ism_address: H256,
+        message: &HyperlaneMessage,
+    ) -> eyre::Result<Option<Vec<u8>>>;
+}
+
 #[derive(Clone, new)]
-pub struct MetadataBuilder {
+pub struct BaseMetadataBuilder {
     chain_setup: ChainSetup,
     prover_sync: Arc<RwLock<MerkleTreeBuilder>>,
     validator_announce: Arc<dyn ValidatorAnnounce>,
     allow_local_checkpoint_syncers: bool,
     metrics: Arc<CoreMetrics>,
 }
 
-impl Debug for MetadataBuilder {
+impl Debug for BaseMetadataBuilder {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
@@ -37,39 +61,61 @@ impl Debug for MetadataBuilder {
     }
 }
 
-impl MetadataBuilder {
-    #[instrument(err, skip(mailbox))]
-    pub async fn fetch_metadata(
+#[async_trait]
+impl MetadataBuilder for BaseMetadataBuilder {
+    #[instrument(err)]
+    async fn build(
         &self,
+        ism_address: H256,
         message: &HyperlaneMessage,
-        mailbox: CachingMailbox,
     ) -> eyre::Result<Option<Vec<u8>>> {
-        const CTX: &str = "When fetching metadata";
-
-        // The Mailbox's `recipientIsm` function will revert if
-        // the recipient is not a contract. This can pose issues with
-        // our use of the RetryingProvider, which will continuously retry
-        // the eth_call to the `recipientIsm` function.
-        // As a workaround, we avoid the call entirely if the recipient is
-        // not a contract.
-        let provider = mailbox.provider();
-        if !provider
-            .is_contract(&message.recipient)
+        const CTX: &str = "When fetching module type";
+        let ism = self
+            .chain_setup
+            .build_ism(ism_address, &self.metrics)
             .await
-            .context(CTX)?
-        {
-            info!(
-                recipient=?message.recipient,
-                "Could not fetch metadata: Recipient is not a contract"
-            );
-            return Ok(None);
-        }
+            .context(CTX)?;
+        let module_type = ism.module_type().await.context(CTX)?;
+        let supported_type = SupportedIsmTypes::from_u8(module_type)
+            .ok_or(MetadataBuilderError::UnsupportedModuleType(module_type))
+            .context(CTX)?;
 
-        let ism_address = mailbox
-            .recipient_ism(message.recipient)
+        let metadata_builder = match supported_type {
+            SupportedIsmTypes::LegacyMultisig => {
+                LegacyMultisigIsmMetadataBuilder::new(self.clone())
+            }
+        };
+        metadata_builder
+            .build(ism_address, message)
             .await
-            .context(CTX)?;
+            .context(CTX)
+    }
+}
+
+#[derive(Clone, Debug, new)]
+pub struct LegacyMultisigIsmMetadataBuilder {
+    base: BaseMetadataBuilder,
+}
+
+impl Deref for LegacyMultisigIsmMetadataBuilder {
+    type Target = BaseMetadataBuilder;
+
+    fn deref(&self) -> &Self::Target {
+        &self.base
+    }
+}
+
+#[async_trait]
+impl MetadataBuilder for LegacyMultisigIsmMetadataBuilder {
+    #[instrument(err)]
+    async fn build(
+        &self,
+        ism_address: H256,
+        message: &HyperlaneMessage,
+    ) -> eyre::Result<Option<Vec<u8>>> {
+        const CTX: &str = "When fetching LegacyMultisigIsm metadata";
         let multisig_ism = self
+            .base
             .chain_setup
             .build_multisig_ism(ism_address, &self.metrics)
             .await
@@ -132,7 +178,9 @@ impl MetadataBuilder {
             Ok(None)
         }
     }
+}
 
+impl LegacyMultisigIsmMetadataBuilder {
     async fn build_checkpoint_syncer(
         &self,
         validators: &[H256],

rust/agents/relayer/src/msg/serial_submitter.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 use std::time::{Duration, Instant};
 
 use derive_new::new;
-use eyre::{bail, Result};
+use eyre::{bail, Context, Result};
 use prometheus::{IntCounter, IntGauge};
 use tokio::sync::mpsc::{self, error::TryRecvError};
 use tokio::task::JoinHandle;
@@ -15,7 +15,10 @@ use crate::msg::PendingMessage;
 use hyperlane_base::{CachingMailbox, CoreMetrics};
 use hyperlane_core::{db::HyperlaneDB, HyperlaneChain, HyperlaneDomain, Mailbox, U256};
 
-use super::{gas_payment::GasPaymentEnforcer, metadata_builder::MetadataBuilder};
+use super::{
+    gas_payment::GasPaymentEnforcer, metadata_builder::BaseMetadataBuilder,
+    metadata_builder::MetadataBuilder,
+};
 
 /// SerialSubmitter accepts undelivered messages over a channel from a
 /// MessageProcessor. It is responsible for executing the right strategy to
@@ -80,7 +83,7 @@ pub(crate) struct SerialSubmitter {
     /// Mailbox on the destination chain.
     mailbox: CachingMailbox,
     /// Used to construct the ISM metadata needed to verify a message.
-    metadata_builder: MetadataBuilder,
+    metadata_builder: BaseMetadataBuilder,
     /// Interface to agent rocks DB for e.g. writing delivery status upon
     /// completion.
     db: HyperlaneDB,
@@ -199,8 +202,34 @@ impl SerialSubmitter {
             return Ok(true);
         }
 
+        // The Mailbox's `recipientIsm` function will revert if
+        // the recipient is not a contract. This can pose issues with
+        // our use of the RetryingProvider, which will continuously retry
+        // the eth_call to the `recipientIsm` function.
+        // As a workaround, we avoid the call entirely if the recipient is
+        // not a contract.
+        const CTX: &str = "When fetching ISM";
+        let provider = self.mailbox.provider();
+        if !provider
+            .is_contract(&msg.message.recipient)
+            .await
+            .context(CTX)?
+        {
+            info!(
+                recipient=?msg.message.recipient,
+                "Could not fetch metadata: Recipient is not a contract"
+            );
+            return Ok(false);
+        }
+
+        let ism_address = self
+            .mailbox
+            .recipient_ism(msg.message.recipient)
+            .await
+            .context(CTX)?;
+
         let Some(metadata) = self.metadata_builder
-            .fetch_metadata(&msg.message, self.mailbox.clone())
+            .build(ism_address, &msg.message)
             .await?
         else {
             info!("Could not fetch metadata");

rust/agents/relayer/src/relayer.rs

@@ -21,7 +21,7 @@ use crate::{
     merkle_tree_builder::MerkleTreeBuilder,
     msg::{
         gas_payment::GasPaymentEnforcer,
-        metadata_builder::MetadataBuilder,
+        metadata_builder::BaseMetadataBuilder,
         processor::{MessageProcessor, MessageProcessorMetrics},
         serial_submitter::{SerialSubmitter, SerialSubmitterMetrics},
         PendingMessage,
@@ -182,7 +182,7 @@ impl BaseAgent for Relayer {
                 .clone();
 
             let txsubmission = chain_setup.txsubmission;
-            let metadata_builder = MetadataBuilder::new(
+            let metadata_builder = BaseMetadataBuilder::new(
                 chain_setup,
                 prover_sync.clone(),
                 self.validator_announce.clone(),
@@ -269,7 +269,7 @@ impl Relayer {
     fn run_destination_mailbox(
         &self,
         destination_mailbox: CachingMailbox,
-        metadata_builder: MetadataBuilder,
+        metadata_builder: BaseMetadataBuilder,
         tx_submission: TransactionSubmissionType,
         gas_payment_enforcer: Arc<GasPaymentEnforcer>,
         msg_receive: UnboundedReceiver<PendingMessage>,

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

@@ -0,0 +1,79 @@
+[
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "messageId",
+        "type": "bytes32"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "gasAmount",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "payment",
+        "type": "uint256"
+      }
+    ],
+    "name": "GasPayment",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes32",
+        "name": "_messageId",
+        "type": "bytes32"
+      },
+      {
+        "internalType": "uint32",
+        "name": "_destinationDomain",
+        "type": "uint32"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_gasAmount",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "_refundAddress",
+        "type": "address"
+      }
+    ],
+    "name": "payForGas",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint32",
+        "name": "_destinationDomain",
+        "type": "uint32"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_gasAmount",
+        "type": "uint256"
+      }
+    ],
+    "name": "quoteGasPayment",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]