feat(tron): isms (#7830)

Author: yjamin

rust/main/chains/hyperlane-tron/src/ism.rs

@@ -0,0 +1,6 @@
+pub use {aggregation_ism::*, interchain_security_module::*, multisig_ism::*, routing_ism::*};
+
+mod aggregation_ism;
+mod interchain_security_module;
+mod multisig_ism;
+mod routing_ism;

rust/main/chains/hyperlane-tron/src/ism/aggregation_ism.rs

@@ -0,0 +1,67 @@
+#![allow(clippy::enum_variant_names)]
+#![allow(missing_docs)]
+
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use tracing::instrument;
+
+use hyperlane_core::{
+    AggregationIsm, ChainResult, ContractLocator, HyperlaneChain, HyperlaneContract,
+    HyperlaneDomain, HyperlaneMessage, HyperlaneProvider, RawHyperlaneMessage, H256,
+};
+
+use crate::{
+    interfaces::i_aggregation_ism::IAggregationIsm as TronAggregationIsmInternal, TronProvider,
+};
+
+/// A reference to an AggregationIsm contract on some Tron chain
+#[derive(Debug)]
+pub struct TronAggregationIsm {
+    contract: Arc<TronAggregationIsmInternal<TronProvider>>,
+    domain: HyperlaneDomain,
+}
+
+impl TronAggregationIsm {
+    /// Creates a new TronAggregationIsm instance
+    pub fn new(provider: TronProvider, locator: &ContractLocator) -> Self {
+        let provider = Arc::new(provider);
+        Self {
+            contract: Arc::new(TronAggregationIsmInternal::new(locator.address, provider)),
+            domain: locator.domain.clone(),
+        }
+    }
+}
+
+impl HyperlaneChain for TronAggregationIsm {
+    fn domain(&self) -> &HyperlaneDomain {
+        &self.domain
+    }
+
+    fn provider(&self) -> Box<dyn HyperlaneProvider> {
+        Box::new(self.contract.client().clone())
+    }
+}
+
+impl HyperlaneContract for TronAggregationIsm {
+    fn address(&self) -> H256 {
+        self.contract.address().into()
+    }
+}
+
+#[async_trait]
+impl AggregationIsm for TronAggregationIsm {
+    #[instrument(err, skip(self, message))]
+    async fn modules_and_threshold(
+        &self,
+        message: &HyperlaneMessage,
+    ) -> ChainResult<(Vec<H256>, u8)> {
+        let (isms, threshold) = self
+            .contract
+            .modules_and_threshold(RawHyperlaneMessage::from(message).to_vec().into())
+            .call()
+            .await?;
+        let isms_h256 = isms.iter().map(|address| (*address).into()).collect();
+        Ok((isms_h256, threshold))
+    }
+}

rust/main/chains/hyperlane-tron/src/ism/interchain_security_module.rs

@@ -0,0 +1,86 @@
+#![allow(clippy::enum_variant_names)]
+#![allow(missing_docs)]
+
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use tracing::{instrument, warn};
+
+use futures_util::future::try_join;
+use hyperlane_core::{
+    ChainResult, ContractLocator, HyperlaneChain, HyperlaneContract, HyperlaneDomain,
+    HyperlaneMessage, HyperlaneProvider, InterchainSecurityModule, Metadata, ModuleType,
+    RawHyperlaneMessage, H256, U256,
+};
+use num_traits::cast::FromPrimitive;
+
+use crate::interfaces::i_interchain_security_module::IInterchainSecurityModule as TronInterchainSecurityModuleInternal;
+use crate::TronProvider;
+
+/// A reference to an InterchainSecurityModule contract on some Tron chain
+#[derive(Debug)]
+pub struct TronInterchainSecurityModule {
+    contract: Arc<TronInterchainSecurityModuleInternal<TronProvider>>,
+    domain: HyperlaneDomain,
+}
+
+impl TronInterchainSecurityModule {
+    /// Creates a new TronInterchainSecurityModule instance
+    pub fn new(provider: TronProvider, locator: &ContractLocator) -> Self {
+        Self {
+            contract: Arc::new(TronInterchainSecurityModuleInternal::new(
+                locator.address,
+                Arc::new(provider),
+            )),
+            domain: locator.domain.clone(),
+        }
+    }
+}
+
+impl HyperlaneChain for TronInterchainSecurityModule {
+    fn domain(&self) -> &HyperlaneDomain {
+        &self.domain
+    }
+
+    fn provider(&self) -> Box<dyn HyperlaneProvider> {
+        Box::new(self.contract.client().clone())
+    }
+}
+
+impl HyperlaneContract for TronInterchainSecurityModule {
+    fn address(&self) -> H256 {
+        self.contract.address().into()
+    }
+}
+
+#[async_trait]
+impl InterchainSecurityModule for TronInterchainSecurityModule {
+    #[instrument]
+    async fn module_type(&self) -> ChainResult<ModuleType> {
+        let module = self.contract.module_type().call().await?;
+        if let Some(module_type) = ModuleType::from_u8(module) {
+            Ok(module_type)
+        } else {
+            warn!(%module, "Unknown module type");
+            Ok(ModuleType::Unused)
+        }
+    }
+
+    #[instrument]
+    async fn dry_run_verify(
+        &self,
+        message: &HyperlaneMessage,
+        metadata: &Metadata,
+    ) -> ChainResult<Option<U256>> {
+        let tx = self.contract.verify(
+            metadata.to_owned().into(),
+            RawHyperlaneMessage::from(message).to_vec().into(),
+        );
+        let (verifies, gas_estimate) = try_join(tx.call(), tx.estimate_gas()).await?;
+        if verifies {
+            Ok(Some(gas_estimate.into()))
+        } else {
+            Ok(None)
+        }
+    }
+}

rust/main/chains/hyperlane-tron/src/ism/multisig_ism.rs

@@ -0,0 +1,68 @@
+#![allow(clippy::enum_variant_names)]
+#![allow(missing_docs)]
+
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use tracing::instrument;
+
+use hyperlane_core::{
+    ChainResult, ContractLocator, HyperlaneChain, HyperlaneContract, HyperlaneDomain,
+    HyperlaneMessage, HyperlaneProvider, MultisigIsm, RawHyperlaneMessage, H256,
+};
+
+use crate::interfaces::i_multisig_ism::IMultisigIsm as TronMultisigIsmInternal;
+use crate::TronProvider;
+
+/// A reference to an MultisigIsm contract on some Tron chain
+#[derive(Debug)]
+pub struct TronMultisigIsm {
+    contract: Arc<TronMultisigIsmInternal<TronProvider>>,
+    domain: HyperlaneDomain,
+}
+
+impl TronMultisigIsm {
+    /// Creates a new TronMultisigIsm instance
+    pub fn new(provider: TronProvider, locator: &ContractLocator) -> Self {
+        Self {
+            contract: Arc::new(TronMultisigIsmInternal::new(
+                locator.address,
+                Arc::new(provider),
+            )),
+            domain: locator.domain.clone(),
+        }
+    }
+}
+
+impl HyperlaneChain for TronMultisigIsm {
+    fn domain(&self) -> &HyperlaneDomain {
+        &self.domain
+    }
+
+    fn provider(&self) -> Box<dyn HyperlaneProvider> {
+        Box::new(self.contract.client().clone())
+    }
+}
+
+impl HyperlaneContract for TronMultisigIsm {
+    fn address(&self) -> H256 {
+        self.contract.address().into()
+    }
+}
+
+#[async_trait]
+impl MultisigIsm for TronMultisigIsm {
+    #[instrument(err, skip(self, message))]
+    async fn validators_and_threshold(
+        &self,
+        message: &HyperlaneMessage,
+    ) -> ChainResult<(Vec<H256>, u8)> {
+        let (validator_addresses, threshold) = self
+            .contract
+            .validators_and_threshold(RawHyperlaneMessage::from(message).to_vec().into())
+            .call()
+            .await?;
+        let validators: Vec<H256> = validator_addresses.iter().map(|&x| H256::from(x)).collect();
+        Ok((validators, threshold))
+    }
+}

rust/main/chains/hyperlane-tron/src/ism/routing_ism.rs

@@ -0,0 +1,64 @@
+#![allow(clippy::enum_variant_names)]
+#![allow(missing_docs)]
+
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use tracing::instrument;
+
+use hyperlane_core::{
+    ChainResult, ContractLocator, HyperlaneChain, HyperlaneContract, HyperlaneDomain,
+    HyperlaneMessage, HyperlaneProvider, RawHyperlaneMessage, RoutingIsm, H256,
+};
+
+use crate::interfaces::i_routing_ism::IRoutingIsm as TronRoutingIsmInternal;
+use crate::TronProvider;
+
+/// A reference to an RoutingIsm contract on some Tron chain
+#[derive(Debug)]
+pub struct TronRoutingIsm {
+    contract: Arc<TronRoutingIsmInternal<TronProvider>>,
+    domain: HyperlaneDomain,
+}
+
+impl TronRoutingIsm {
+    /// Creates a new TronRoutingIsm instance
+    pub fn new(provider: TronProvider, locator: &ContractLocator) -> Self {
+        Self {
+            contract: Arc::new(TronRoutingIsmInternal::new(
+                locator.address,
+                Arc::new(provider),
+            )),
+            domain: locator.domain.clone(),
+        }
+    }
+}
+
+impl HyperlaneChain for TronRoutingIsm {
+    fn domain(&self) -> &HyperlaneDomain {
+        &self.domain
+    }
+
+    fn provider(&self) -> Box<dyn HyperlaneProvider> {
+        Box::new(self.contract.client().clone())
+    }
+}
+
+impl HyperlaneContract for TronRoutingIsm {
+    fn address(&self) -> H256 {
+        self.contract.address().into()
+    }
+}
+
+#[async_trait]
+impl RoutingIsm for TronRoutingIsm {
+    #[instrument(err, skip(self, message))]
+    async fn route(&self, message: &HyperlaneMessage) -> ChainResult<H256> {
+        let ism = self
+            .contract
+            .route(RawHyperlaneMessage::from(message).to_vec().into())
+            .call()
+            .await?;
+        Ok(ism.into())
+    }
+}

rust/main/chains/hyperlane-tron/src/lib.rs

@@ -9,12 +9,15 @@ use ethers_signers::LocalWallet;
 
 pub use {
     config::ConnectionConf, contracts::TronInterchainGasPaymaster, contracts::TronMailboxIndexer,
-    contracts::TronMerkleTreeHookIndexer, provider::TronProvider,
+    contracts::TronMerkleTreeHookIndexer, ism::TronAggregationIsm,
+    ism::TronInterchainSecurityModule, ism::TronMultisigIsm, ism::TronRoutingIsm,
+    provider::TronProvider,
 };
 
 mod config;
 mod contracts;
 mod error;
+mod ism;
 mod provider;
 mod utils;
 

rust/main/hyperlane-base/src/settings/chains.rs

@@ -1051,7 +1051,11 @@ impl ChainConf {
                 let ism = h_radix::RadixIsm::new(provider, &locator, conf)?;
                 Ok(Box::new(ism) as Box<dyn InterchainSecurityModule>)
             }
-            ChainConnectionConf::Tron(_) => todo!(),
+            ChainConnectionConf::Tron(conf) => {
+                let provider = build_tron_provider(self, conf, metrics, &locator, None)?;
+                let ism = h_tron::TronInterchainSecurityModule::new(provider, &locator);
+                Ok(Box::new(ism) as Box<dyn InterchainSecurityModule>)
+            }
             #[cfg(feature = "aleo")]
             ChainConnectionConf::Aleo(conf) => {
                 let provider = build_aleo_provider(self, conf, metrics, &locator, None)?;
@@ -1112,7 +1116,11 @@ impl ChainConf {
                 let ism = h_radix::RadixIsm::new(provider, &locator, conf)?;
                 Ok(Box::new(ism) as Box<dyn MultisigIsm>)
             }
-            ChainConnectionConf::Tron(_) => todo!(),
+            ChainConnectionConf::Tron(conf) => {
+                let provider = build_tron_provider(self, conf, metrics, &locator, None)?;
+                let ism = h_tron::TronMultisigIsm::new(provider, &locator);
+                Ok(Box::new(ism) as Box<dyn MultisigIsm>)
+            }
             #[cfg(feature = "aleo")]
             ChainConnectionConf::Aleo(conf) => {
                 let provider = build_aleo_provider(self, conf, metrics, &locator, None)?;
@@ -1168,7 +1176,11 @@ impl ChainConf {
                 let ism = h_radix::RadixIsm::new(provider, &locator, conf)?;
                 Ok(Box::new(ism) as Box<dyn RoutingIsm>)
             }
-            ChainConnectionConf::Tron(_) => todo!(),
+            ChainConnectionConf::Tron(conf) => {
+                let provider = build_tron_provider(self, conf, metrics, &locator, None)?;
+                let ism = h_tron::TronRoutingIsm::new(provider, &locator);
+                Ok(Box::new(ism) as Box<dyn RoutingIsm>)
+            }
             #[cfg(feature = "aleo")]
             ChainConnectionConf::Aleo(conf) => {
                 let provider = build_aleo_provider(self, conf, metrics, &locator, None)?;
@@ -1224,7 +1236,11 @@ impl ChainConf {
             ChainConnectionConf::Radix(_) => {
                 todo!("Radix aggregation ISM not yet implemented")
             }
-            ChainConnectionConf::Tron(_) => todo!(),
+            ChainConnectionConf::Tron(conf) => {
+                let provider = build_tron_provider(self, conf, metrics, &locator, None)?;
+                let ism = h_tron::TronAggregationIsm::new(provider, &locator);
+                Ok(Box::new(ism) as Box<dyn AggregationIsm>)
+            }
             #[cfg(feature = "aleo")]
             ChainConnectionConf::Aleo(_) => Err(eyre!("Aleo support missing")).context(ctx),
         }