Remove ChainHandle dependency from build_create_client_payload

crates/celestia/celestia-integration-tests/tests/celestia_integration_tests.rs

@@ -1,6 +1,5 @@
 #![recursion_limit = "256"]
 
-use core::time::Duration;
 use std::sync::Arc;
 
 use hermes_cosmos_chain_components::types::config::gas::dynamic_gas_config::DynamicGasConfig;
@@ -11,8 +10,6 @@ use hermes_cosmos_relayer::contexts::build::CosmosBuilder;
 use hermes_error::types::Error;
 use hermes_ibc_test_suite::tests::transfer::TestIbcTransfer;
 use hermes_test_components::setup::traits::run_test::CanRunTest;
-use ibc_relayer::chain::cosmos::client::Settings;
-use ibc_relayer_types::core::ics02_client::trust_threshold::TrustThreshold;
 use ibc_relayer_types::core::ics24_host::identifier::PortId;
 
 // FIXME: Celestia currently can only be bootstrapped using CosmosBootstrap.
@@ -53,16 +50,10 @@ fn celestia_integration_tests() -> Result<(), Error> {
         dynamic_gas: Some(DynamicGasConfig::default()),
     });
 
-    let create_client_settings = Settings {
-        max_clock_drift: Duration::from_secs(40),
-        trusting_period: Some(Duration::from_secs(60 * 60)),
-        trust_threshold: TrustThreshold::ONE_THIRD,
-    };
-
     let setup = CosmosBinaryChannelSetup {
         bootstrap_a: celestia_bootstrap,
         bootstrap_b: cosmos_bootstrap,
-        create_client_settings,
+        create_client_settings: Default::default(),
         init_connection_options: Default::default(),
         init_channel_options: Default::default(),
         port_id: PortId::transfer(),

crates/cli/cli/src/contexts/app.rs

@@ -42,6 +42,7 @@ use hermes_cli_components::traits::output::{
 use hermes_cli_components::traits::parse::ArgParserComponent;
 use hermes_cli_components::traits::types::config::ConfigTypeComponent;
 use hermes_cli_framework::output::Output;
+use hermes_cosmos_chain_components::types::payloads::client::CosmosCreateClientOptions;
 use hermes_cosmos_integration_tests::contexts::bootstrap::CosmosBootstrap;
 use hermes_cosmos_relayer::contexts::build::CosmosBuilder;
 use hermes_cosmos_relayer::contexts::chain::CosmosChain;
@@ -56,7 +57,6 @@ use hermes_runtime::types::runtime::HermesRuntime;
 use hermes_runtime_components::traits::runtime::{
     ProvideDefaultRuntimeField, RuntimeGetterComponent, RuntimeTypeComponent,
 };
-use ibc_relayer::chain::cosmos::client::Settings;
 use ibc_relayer::config::Config;
 use ibc_relayer::foreign_client::CreateOptions;
 use ibc_relayer_types::core::ics24_host::identifier::{ChainId, ClientId};
@@ -192,18 +192,30 @@ impl CreateClientOptionsParser<HermesApp, CreateClientArgs, 0, 1> for HermesAppC
         args: &CreateClientArgs,
         target_chain: &CosmosChain,
         counterparty_chain: &CosmosChain,
-    ) -> Result<((), Settings), Error> {
+    ) -> Result<((), CosmosCreateClientOptions), Error> {
         let options = CreateOptions {
             max_clock_drift: args.clock_drift.map(|d| d.into()),
             trusting_period: args.trusting_period.map(|d| d.into()),
             trust_threshold: args.trust_threshold,
         };
 
-        let settings = Settings::for_create_command(
-            options,
-            &target_chain.chain_config.clone(),
-            &counterparty_chain.chain_config.clone(),
-        );
+        let max_clock_drift = match options.max_clock_drift {
+            Some(input) => input,
+            None => {
+                target_chain.chain_config.clock_drift
+                    + counterparty_chain.chain_config.clock_drift
+                    + counterparty_chain.chain_config.max_block_time
+            }
+        };
+
+        let settings = CosmosCreateClientOptions {
+            max_clock_drift,
+            trusting_period: options.trusting_period.unwrap_or_default(),
+            trust_threshold: options
+                .trust_threshold
+                .map(|threshold| threshold.into())
+                .unwrap_or_default(),
+        };
 
         Ok(((), settings))
     }

crates/cosmos/cosmos-chain-components/src/components/client.rs

@@ -167,7 +167,9 @@ use crate::impls::types::chain::ProvideCosmosChainTypes;
 use crate::impls::types::client_state::ProvideAnyRawClientState;
 use crate::impls::types::consensus_state::ProvideAnyRawConsensusState;
 use crate::impls::types::payload::ProvideCosmosPayloadTypes;
+use crate::impls::unbonding_period::StakingParamsUnbondingPeriod;
 pub use crate::traits::abci_query::AbciQuerierComponent;
+pub use crate::traits::unbonding_period::UnbondingPeriodQuerierComponent;
 
 define_components! {
     CosmosClientComponents {
@@ -318,6 +320,8 @@ define_components! {
             QueryCometBlock,
         AbciQuerierComponent:
             QueryAbci,
+        UnbondingPeriodQuerierComponent:
+            StakingParamsUnbondingPeriod,
         [
             ConnectionEndQuerierComponent,
             ConnectionEndWithProofsQuerierComponent,

crates/cosmos/cosmos-chain-components/src/components/cosmos_to_cosmos.rs

@@ -36,7 +36,7 @@ use hermes_relayer_components::chain::traits::types::update_client::UpdateClient
 
 use crate::impls::channel::channel_handshake_message::BuildCosmosChannelHandshakeMessage;
 use crate::impls::client::create_client_message::BuildAnyCreateClientMessage;
-use crate::impls::client::create_client_payload::BuildCreateClientPayloadWithChainHandle;
+use crate::impls::client::create_client_payload::BuildCosmosCreateClientPayload;
 use crate::impls::client::update_client_message::BuildCosmosUpdateClientMessage;
 use crate::impls::client::update_client_payload::BuildTendermintUpdateClientPayload;
 use crate::impls::connection::connection_handshake_message::BuildCosmosConnectionHandshakeMessage;
@@ -86,7 +86,7 @@ define_components! {
         UpdateClientMessageBuilderComponent:
             BuildCosmosUpdateClientMessage,
         CreateClientPayloadBuilderComponent:
-            BuildCreateClientPayloadWithChainHandle,
+            BuildCosmosCreateClientPayload,
         UpdateClientPayloadBuilderComponent:
             BuildTendermintUpdateClientPayload,
         [

crates/cosmos/cosmos-chain-components/src/impls/client/create_client_payload.rs

@@ -1,62 +1,125 @@
 use cgp::core::error::CanRaiseError;
+
+use hermes_chain_type_components::traits::fields::chain_id::HasChainId;
+use hermes_comet_light_client_components::traits::fetch_light_block::CanFetchLightBlock;
+use hermes_comet_light_client_context::contexts::light_client::CometLightClient;
+use hermes_error::types::HermesError;
 use hermes_relayer_components::chain::traits::payload_builders::create_client::CreateClientPayloadBuilder;
+use hermes_relayer_components::chain::traits::queries::chain_status::{
+    CanQueryChainHeight, CanQueryChainStatus,
+};
 use hermes_relayer_components::chain::traits::types::create_client::{
     HasCreateClientPayloadOptionsType, HasCreateClientPayloadType,
 };
-use ibc_relayer::chain::client::ClientSettings;
-use ibc_relayer::chain::cosmos::client::Settings;
-use ibc_relayer::chain::handle::ChainHandle;
-use ibc_relayer::client_state::AnyClientState;
-use ibc_relayer::consensus_state::AnyConsensusState;
 
-use crate::traits::chain_handle::HasBlockingChainHandle;
-use crate::types::payloads::client::CosmosCreateClientPayload;
+use ibc_relayer_types::clients::ics07_tendermint::client_state::{AllowUpdate, ClientState};
+use ibc_relayer_types::clients::ics07_tendermint::consensus_state::ConsensusState;
+use ibc_relayer_types::clients::ics07_tendermint::error::Error as TendermintClientError;
+use ibc_relayer_types::core::ics23_commitment::commitment::CommitmentRoot;
+use ibc_relayer_types::core::ics24_host::identifier::ChainId;
+use ibc_relayer_types::Height;
+
+use tendermint::block::Height as TendermintHeight;
+use tendermint::error::Error as TendermintError;
+use tendermint_rpc::Client;
+use tendermint_rpc::Error as TendermintRpcError;
+
+use crate::traits::rpc_client::HasRpcClient;
+use crate::traits::unbonding_period::CanQueryUnbondingPeriod;
+use crate::types::payloads::client::{CosmosCreateClientOptions, CosmosCreateClientPayload};
+use crate::types::status::ChainStatus;
+use crate::types::tendermint::TendermintClientState;
 
-pub struct BuildCreateClientPayloadWithChainHandle;
+pub struct BuildCosmosCreateClientPayload;
 
 impl<Chain, Counterparty> CreateClientPayloadBuilder<Chain, Counterparty>
-    for BuildCreateClientPayloadWithChainHandle
+    for BuildCosmosCreateClientPayload
 where
-    Chain: HasCreateClientPayloadOptionsType<Counterparty, CreateClientPayloadOptions = Settings>
-        + HasCreateClientPayloadType<Counterparty, CreateClientPayload = CosmosCreateClientPayload>
-        + HasBlockingChainHandle
-        + CanRaiseError<eyre::Report>,
+    Chain: HasRpcClient
+        + HasCreateClientPayloadOptionsType<
+            Counterparty,
+            CreateClientPayloadOptions = CosmosCreateClientOptions,
+        > + HasCreateClientPayloadType<Counterparty, CreateClientPayload = CosmosCreateClientPayload>
+        + CanQueryUnbondingPeriod
+        + HasChainId<ChainId = ChainId>
+        + CanQueryChainHeight<Height = Height>
+        + CanQueryChainStatus<ChainStatus = ChainStatus>
+        + CanRaiseError<TendermintClientError>
+        + CanRaiseError<TendermintError>
+        + CanRaiseError<TendermintRpcError>
+        + CanRaiseError<String>
+        + CanRaiseError<HermesError>,
 {
     async fn build_create_client_payload(
         chain: &Chain,
-        create_client_options: &Settings,
+        create_client_options: &Chain::CreateClientPayloadOptions,
     ) -> Result<CosmosCreateClientPayload, Chain::Error> {
-        let client_settings = create_client_options.clone();
-
-        chain
-            .with_blocking_chain_handle(move |chain_handle| {
-                let height = chain_handle
-                    .query_latest_height()
-                    .map_err(Chain::raise_error)?;
-
-                let any_client_state = chain_handle
-                    .build_client_state(height, ClientSettings::Tendermint(client_settings))
-                    .map_err(Chain::raise_error)?;
-
-                let client_state = match &any_client_state {
-                    AnyClientState::Tendermint(client_state) => client_state.clone(),
-                };
-
-                let any_consensus_state = chain_handle
-                    .build_consensus_state(
-                        any_client_state.latest_height(),
-                        height,
-                        any_client_state,
-                    )
-                    .map_err(Chain::raise_error)?;
-
-                let AnyConsensusState::Tendermint(consensus_state) = any_consensus_state;
-
-                Ok(CosmosCreateClientPayload {
-                    client_state,
-                    consensus_state,
-                })
-            })
+        let latest_height = chain.query_chain_height().await?;
+
+        let unbonding_period = chain.query_unbonding_period().await?;
+
+        let trusting_period = create_client_options.trusting_period;
+        let trust_threshold = create_client_options
+            .trust_threshold
+            .try_into()
+            .map_err(|e| {
+                Chain::raise_error(format!(
+                    "failed to convert `Fraction` to  `TrustThreshold` for trust_threshold: {e}"
+                ))
+            })?;
+
+        #[allow(deprecated)]
+        let client_state = ClientState::new(
+            chain.chain_id().clone(),
+            trust_threshold,
+            trusting_period,
+            unbonding_period,
+            create_client_options.max_clock_drift,
+            latest_height,
+            Default::default(),
+            vec!["upgrade".to_string(), "upgradedIBCState".to_string()],
+            AllowUpdate {
+                after_expiry: true,
+                after_misbehaviour: true,
+            },
+        )
+        .map_err(Chain::raise_error)?;
+
+        let rpc_client = chain.rpc_client().clone();
+
+        let tendermint_latest_height = TendermintHeight::try_from(latest_height.revision_height())
+            .map_err(Chain::raise_error)?;
+
+        let status = rpc_client.status().await.map_err(Chain::raise_error)?;
+
+        let current_time = status.sync_info.latest_block_time;
+        let peer_id = status.node_info.id;
+
+        let light_client_options =
+            TendermintClientState::from(client_state.clone()).as_light_client_options();
+
+        let light_client = CometLightClient::new(
+            current_time,
+            peer_id,
+            rpc_client.clone(),
+            light_client_options,
+        );
+
+        let trusted_block = light_client
+            .fetch_light_block(&tendermint_latest_height)
             .await
+            .map_err(Chain::raise_error)?;
+
+        let consensus_state = ConsensusState {
+            root: CommitmentRoot::from_bytes(trusted_block.signed_header.header.app_hash.as_ref()),
+            timestamp: trusted_block.signed_header.header.time,
+            next_validators_hash: trusted_block.signed_header.header.next_validators_hash,
+        };
+
+        // Create client payload
+        Ok(CosmosCreateClientPayload {
+            client_state,
+            consensus_state,
+        })
     }
 }

crates/cosmos/cosmos-chain-components/src/impls/mod.rs

@@ -8,3 +8,4 @@ pub mod packet;
 pub mod queries;
 pub mod transaction;
 pub mod types;
+pub mod unbonding_period;

crates/cosmos/cosmos-chain-components/src/impls/types/create_client_options.rs

@@ -2,7 +2,8 @@ use cgp::prelude::Async;
 use hermes_relayer_components::chain::traits::types::create_client::{
     ProvideCreateClientMessageOptionsType, ProvideCreateClientPayloadOptionsType,
 };
-use ibc_relayer::chain::cosmos::client::Settings;
+
+use crate::types::payloads::client::CosmosCreateClientOptions;
 
 pub struct ProvideCosmosCreateClientSettings;
 
@@ -11,7 +12,7 @@ impl<Chain, Counterparty> ProvideCreateClientPayloadOptionsType<Chain, Counterpa
 where
     Chain: Async,
 {
-    type CreateClientPayloadOptions = Settings;
+    type CreateClientPayloadOptions = CosmosCreateClientOptions;
 }
 
 pub struct ProvideNoCreateClientMessageOptionsType;

crates/cosmos/cosmos-chain-components/src/impls/unbonding_period.rs

@@ -0,0 +1,52 @@
+use cgp::prelude::*;
+use core::time::Duration;
+use prost::{DecodeError, Message};
+
+use hermes_relayer_components::chain::traits::queries::chain_status::CanQueryChainHeight;
+use hermes_relayer_components::chain::traits::types::height::HasHeightType;
+
+use ibc_proto::cosmos::staking::v1beta1::QueryParamsResponse;
+use ibc_relayer_types::Height;
+
+use crate::traits::abci_query::CanQueryAbci;
+use crate::traits::unbonding_period::UnbondingPeriodQuerier;
+
+pub struct StakingParamsUnbondingPeriod;
+
+impl<Chain> UnbondingPeriodQuerier<Chain> for StakingParamsUnbondingPeriod
+where
+    Chain: CanQueryChainHeight
+        + CanQueryAbci
+        + HasHeightType<Height = Height>
+        + CanRaiseError<&'static str>
+        + CanRaiseError<DecodeError>,
+{
+    async fn query_unbonding_period(chain: &Chain) -> Result<Duration, Chain::Error> {
+        let latest_height = chain.query_chain_height().await?;
+
+        let query_staking_params_bytes = chain
+            .query_abci(
+                "/cosmos.staking.v1beta1.Query/Params",
+                &"".to_owned().into_bytes(),
+                &latest_height,
+            )
+            .await?;
+
+        let query_staking_params: QueryParamsResponse =
+            QueryParamsResponse::decode(query_staking_params_bytes.as_ref())
+                .map_err(Chain::raise_error)?;
+
+        let staking_params = query_staking_params
+            .params
+            .ok_or_else(|| Chain::raise_error("staking params is empty"))?;
+
+        let unbonding_time = staking_params
+            .unbonding_time
+            .ok_or_else(|| Chain::raise_error("unbonding time in staking params is empty"))?;
+
+        Ok(Duration::new(
+            unbonding_time.seconds as u64,
+            unbonding_time.nanos as u32,
+        ))
+    }
+}

crates/cosmos/cosmos-chain-components/src/traits/mod.rs

@@ -7,3 +7,4 @@ pub mod grpc_address;
 pub mod message;
 pub mod rpc_client;
 pub mod tx_extension_options;
+pub mod unbonding_period;

crates/cosmos/cosmos-chain-components/src/traits/unbonding_period.rs

@@ -0,0 +1,9 @@
+use core::time::Duration;
+
+use cgp::prelude::*;
+
+#[derive_component(UnbondingPeriodQuerierComponent, UnbondingPeriodQuerier<Chain>)]
+#[async_trait]
+pub trait CanQueryUnbondingPeriod: HasErrorType + Async {
+    async fn query_unbonding_period(&self) -> Result<Duration, Self::Error>;
+}