fix(cosmos): simulating verify just means querying it

rust/chains/hyperlane-cosmos/src/aggregation_ism.rs

@@ -1,10 +1,8 @@
 use std::str::FromStr;
 
 use crate::{
-    address::CosmosAddress,
     grpc::WasmProvider,
     payloads::{
-        aggregate_ism::{self, ModulesAndThresholdRequest, ModulesAndThresholdResponse},
         ism_routes::QueryIsmGeneralRequest,
         multisig_ism::{VerifyInfoRequest, VerifyInfoRequestInner, VerifyInfoResponse},
     },
@@ -13,7 +11,7 @@ use crate::{
 use async_trait::async_trait;
 use hyperlane_core::{
     AggregationIsm, ChainResult, ContractLocator, HyperlaneChain, HyperlaneContract,
-    HyperlaneDomain, HyperlaneMessage, HyperlaneProvider, RawHyperlaneMessage, H160, H256,
+    HyperlaneDomain, HyperlaneMessage, HyperlaneProvider, RawHyperlaneMessage, H256,
 };
 use tracing::instrument;
 
@@ -87,6 +85,9 @@ impl AggregationIsm for CosmosAggregationIsm {
         let modules: ChainResult<Vec<H256>> = response
             .validators
             .iter()
+            // The returned values are Bech32-decoded Cosmos addresses.
+            // Since they are not EOAs but rather contracts, they are 32 bytes long and
+            // need to be parsed directly as an `H256`.
             .map(|module| H256::from_str(module).map_err(Into::into))
             .collect();
 

rust/chains/hyperlane-cosmos/src/interchain_security_module.rs

@@ -8,10 +8,9 @@ use hyperlane_core::{
 use crate::{
     grpc::WasmProvider,
     payloads::{
+        aggregate_ism::{VerifyRequest, VerifyRequestInner, VerifyResponse},
         general::EmptyStruct,
-        ism_routes::{
-            QueryIsmGeneralRequest, QueryIsmModuleTypeRequest, VerifyRequest, VerifyRequestInner,
-        },
+        ism_routes::{QueryIsmGeneralRequest, QueryIsmModuleTypeRequest},
     },
     types::IsmType,
     ConnectionConf, CosmosProvider, Signer,
@@ -94,23 +93,23 @@ impl InterchainSecurityModule for CosmosInterchainSecurityModule {
         message: &HyperlaneMessage,
         metadata: &[u8],
     ) -> ChainResult<Option<U256>> {
-        let process_message = VerifyRequest {
+        let payload = VerifyRequest {
             verify: VerifyRequestInner {
-                message: hex::encode(RawHyperlaneMessage::from(message)),
                 metadata: hex::encode(metadata),
+                message: hex::encode(RawHyperlaneMessage::from(message)),
             },
         };
-
-        let gas_estimate = self
+        let data = self
             .provider
             .grpc()
-            .wasm_estimate_gas(process_message)
+            .wasm_query(QueryIsmGeneralRequest { ism: payload }, None)
             .await?;
-        println!(
-            "~~~ successfully dryran verify, gas estimate: {}",
-            gas_estimate
-        );
-
-        Ok(Some(gas_estimate.into()))
+        let response: VerifyResponse = serde_json::from_slice(&data)?;
+        // We can't simulate the `verify` call in CosmWasm because
+        // it's not marked as an entrypoint. So we just use the query interface
+        // and hardcode a gas value - this can be inefficient if one ISM is
+        // vastly cheaper than another one.
+        let dummy_gas_value = U256::one();
+        Ok(response.verified.then_some(dummy_gas_value))
     }
 }

rust/chains/hyperlane-cosmos/src/payloads/aggregate_ism.rs

@@ -1,30 +1,17 @@
-use hyperlane_core::{HyperlaneMessage, RawHyperlaneMessage};
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug)]
-pub struct ModulesAndThresholdRequest {
-    modules_and_threshold: ModulesAndThresholdRequestInner,
-}
-
-impl ModulesAndThresholdRequest {
-    pub fn new(message: &HyperlaneMessage) -> Self {
-        Self {
-            modules_and_threshold: ModulesAndThresholdRequestInner {
-                message: hex::encode(RawHyperlaneMessage::from(message)),
-            },
-        }
-    }
+pub struct VerifyRequest {
+    pub verify: VerifyRequestInner,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
-struct ModulesAndThresholdRequestInner {
-    /// Hex-encoded Hyperlane message
+pub struct VerifyRequestInner {
+    pub metadata: String,
     pub message: String,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
-pub struct ModulesAndThresholdResponse {
-    pub threshold: u8,
-    /// Bech32-encoded module addresses
-    pub modules: Vec<String>,
+pub struct VerifyResponse {
+    pub verified: bool,
 }

rust/chains/hyperlane-cosmos/src/payloads/ism_routes.rs

@@ -31,22 +31,6 @@ pub struct QueryIsmGeneralRequest<T> {
     pub ism: T,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct VerifyRequest {
-    pub verify: VerifyRequestInner,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct VerifyRequestInner {
-    pub metadata: String,
-    pub message: String,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct VerifyResponse {
-    pub verified: bool,
-}
-
 #[derive(Serialize, Deserialize, Debug)]
 pub struct QueryIsmModuleTypeRequest {
     pub module_type: EmptyStruct,

rust/utils/run-locally/src/cosmos/link.rs

@@ -168,16 +168,6 @@ fn link_network(
         vec![],
     );
 
-    cli.wasm_execute(
-        &network.launch_resp.endpoint,
-        linker,
-        &network.deployments.ism_aggregate,
-        ism::aggregate::ExecuteMsg::SetIsms {
-            isms: vec![network.deployments.ism_multisig.clone()],
-        },
-        vec![],
-    );
-
     cli.wasm_execute(
         &network.launch_resp.endpoint,
         linker,