From 67fc521dda4ec4aff7073eb9e6c9f4d2d173d393 Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Thu, 19 May 2022 10:47:29 -0400 Subject: [PATCH 01/19] Remove TODO --- proto/src/lib.rs | 20 -------------------- 1 file changed, 20 deletions(-) diff --git a/proto/src/lib.rs b/proto/src/lib.rs index 9caf330b71..8f9681344b 100644 --- a/proto/src/lib.rs +++ b/proto/src/lib.rs @@ -74,26 +74,6 @@ pub mod cosmos { pub mod v1beta1 { include_proto!("cosmos.base.query.v1beta1.rs"); } - - // TODO (BEFORE MERGING PR): Remove - pub mod pagination { - use super::v1beta1::PageRequest; - - pub fn all() -> Option { - Some(PageRequest { - limit: u64::MAX, - ..Default::default() - }) - } - - pub fn latest_limited(limit: u64) -> Option { - Some(PageRequest { - limit, - reverse: true, - ..Default::default() - }) - } - } } pub mod reflection { pub mod v1beta1 { From 1e188f96ef6d8ba13adc2f35cfaa2fb76c07a538 Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Thu, 19 May 2022 14:16:37 -0400 Subject: [PATCH 02/19] query_client_state consolidation --- relayer-cli/src/commands/create/channel.rs | 15 ++-- relayer-cli/src/commands/create/connection.rs | 15 ++-- relayer-cli/src/commands/misbehaviour.rs | 15 ++-- .../src/commands/query/channel_ends.rs | 21 +++-- relayer-cli/src/commands/query/channels.rs | 21 +++-- relayer-cli/src/commands/query/client.rs | 41 ++++++---- relayer-cli/src/commands/tx/client.rs | 28 ++++--- relayer-cli/src/commands/tx/transfer.rs | 15 ++-- relayer/src/chain.rs | 27 ++++--- relayer/src/chain/cosmos.rs | 48 ++++++------ relayer/src/chain/counterparty.rs | 32 ++++---- relayer/src/chain/handle.rs | 24 ++---- relayer/src/chain/handle/base.rs | 29 +++---- relayer/src/chain/handle/cache.rs | 56 +++++++------- relayer/src/chain/handle/counting.rs | 16 +--- relayer/src/chain/mock.rs | 15 +--- relayer/src/chain/requests.rs | 8 ++ relayer/src/chain/runtime.rs | 35 +++------ relayer/src/error.rs | 3 + relayer/src/foreign_client.rs | 76 +++++++++++-------- relayer/src/link/operational_data.rs | 25 +++--- relayer/src/object.rs | 15 ++-- relayer/src/supervisor/client_state_filter.rs | 54 ++++++++----- relayer/src/supervisor/scan.rs | 15 ++-- relayer/src/upgrade_chain.rs | 15 ++-- .../src/tests/client_settings.rs | 13 ++-- tools/test-framework/src/relayer/chain.rs | 15 +--- 27 files changed, 374 insertions(+), 318 deletions(-) diff --git a/relayer-cli/src/commands/create/channel.rs b/relayer-cli/src/commands/create/channel.rs index f26fa1fe2e..754fbdbdae 100644 --- a/relayer-cli/src/commands/create/channel.rs +++ b/relayer-cli/src/commands/create/channel.rs @@ -11,7 +11,7 @@ use ibc::core::ics04_channel::Version; use ibc::core::ics24_host::identifier::{ChainId, ConnectionId, PortId}; use ibc::Height; use ibc_relayer::chain::handle::ChainHandle; -use ibc_relayer::chain::requests::{QueryClientStateRequest, QueryConnectionRequest}; +use ibc_relayer::chain::requests::{IncludeProof, QueryClientStateRequest, QueryConnectionRequest}; use ibc_relayer::channel::Channel; use ibc_relayer::connection::Connection; use ibc_relayer::foreign_client::ForeignClient; @@ -196,11 +196,14 @@ impl CreateChannelCommand { // Query the client state, obtain the identifier of chain b. let chain_b = chain_a - .query_client_state(QueryClientStateRequest { - client_id: conn_end.client_id().clone(), - height, - }) - .map(|cs| cs.chain_id()) + .query_client_state( + QueryClientStateRequest { + client_id: conn_end.client_id().clone(), + height, + }, + IncludeProof::No, + ) + .map(|(cs, _)| cs.chain_id()) .unwrap_or_else(exit_with_unrecoverable_error); // Spawn the runtime for side b. diff --git a/relayer-cli/src/commands/create/connection.rs b/relayer-cli/src/commands/create/connection.rs index d8377287ea..f694a5538d 100644 --- a/relayer-cli/src/commands/create/connection.rs +++ b/relayer-cli/src/commands/create/connection.rs @@ -7,7 +7,7 @@ use ibc::core::ics02_client::client_state::ClientState; use ibc::core::ics24_host::identifier::{ChainId, ClientId}; use ibc::Height; use ibc_relayer::chain::handle::ChainHandle; -use ibc_relayer::chain::requests::QueryClientStateRequest; +use ibc_relayer::chain::requests::{IncludeProof, QueryClientStateRequest}; use ibc_relayer::connection::Connection; use ibc_relayer::foreign_client::ForeignClient; @@ -115,11 +115,14 @@ impl CreateConnectionCommand { // Query client state. Extract the target chain (chain_id which this client is verifying). let height = Height::new(chain_a.id().version(), 0); - let chain_b_id = match chain_a.query_client_state(QueryClientStateRequest { - client_id: client_a_id.clone(), - height, - }) { - Ok(cs) => cs.chain_id(), + let chain_b_id = match chain_a.query_client_state( + QueryClientStateRequest { + client_id: client_a_id.clone(), + height, + }, + IncludeProof::No, + ) { + Ok((cs, _)) => cs.chain_id(), Err(e) => Output::error(format!( "failed while querying client '{}' on chain '{}' with error: {}", client_a_id, self.chain_a_id, e diff --git a/relayer-cli/src/commands/misbehaviour.rs b/relayer-cli/src/commands/misbehaviour.rs index 2b33c5171d..db33522873 100644 --- a/relayer-cli/src/commands/misbehaviour.rs +++ b/relayer-cli/src/commands/misbehaviour.rs @@ -5,7 +5,7 @@ use ibc::core::ics02_client::height::Height; use ibc::core::ics24_host::identifier::{ChainId, ClientId}; use ibc::events::IbcEvent; use ibc_relayer::chain::handle::ChainHandle; -use ibc_relayer::chain::requests::QueryClientStateRequest; +use ibc_relayer::chain::requests::{IncludeProof, QueryClientStateRequest}; use ibc_relayer::config::Config; use ibc_relayer::foreign_client::{ForeignClient, MisbehaviourResults}; use std::ops::Deref; @@ -99,11 +99,14 @@ fn misbehaviour_handling( client_id: ClientId, update: Option, ) -> Result<(), Box> { - let client_state = chain - .query_client_state(QueryClientStateRequest { - client_id: client_id.clone(), - height: Height::zero(), - }) + let (client_state, _) = chain + .query_client_state( + QueryClientStateRequest { + client_id: client_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| format!("could not query client state for {}: {}", client_id, e))?; if client_state.is_frozen() { diff --git a/relayer-cli/src/commands/query/channel_ends.rs b/relayer-cli/src/commands/query/channel_ends.rs index 774ae64f6c..1c59922a1d 100644 --- a/relayer-cli/src/commands/query/channel_ends.rs +++ b/relayer-cli/src/commands/query/channel_ends.rs @@ -10,7 +10,7 @@ use ibc::core::ics24_host::identifier::{ChannelId, ClientId, ConnectionId, PortI use ibc::Height; use ibc_relayer::chain::handle::{BaseChainHandle, ChainHandle}; use ibc_relayer::chain::requests::{ - QueryChannelRequest, QueryClientStateRequest, QueryConnectionRequest, + IncludeProof, QueryChannelRequest, QueryClientStateRequest, QueryConnectionRequest, }; use ibc_relayer::registry::Registry; @@ -112,10 +112,13 @@ fn do_run(cmd: &QueryChannelEndsCmd) -> Result<(), Box(cmd: &QueryChannelEndsCmd) -> Result<(), Box( height: chain_height, })?; let client_id = connection_end.client_id().clone(); - let client_state = chain.query_client_state(QueryClientStateRequest { - client_id, - height: chain_height, - })?; + let (client_state, _) = chain.query_client_state( + QueryClientStateRequest { + client_id, + height: chain_height, + }, + IncludeProof::No, + )?; let counterparty_chain_id = client_state.chain_id(); if let Some(dst_chain_id) = destination_chain { @@ -179,11 +182,13 @@ fn query_channel_ends( height: counterparty_chain_height, })?; - let counterparty_client_state = - counterparty_chain.query_client_state(QueryClientStateRequest { + let (counterparty_client_state, _) = counterparty_chain.query_client_state( + QueryClientStateRequest { client_id: counterparty_client_id, height: counterparty_chain_height, - })?; + }, + IncludeProof::No, + )?; let counterparty_channel_end = counterparty_chain.query_channel(QueryChannelRequest { port_id: counterparty_port_id, diff --git a/relayer-cli/src/commands/query/client.rs b/relayer-cli/src/commands/query/client.rs index f23c0fc40b..8d0eb3256a 100644 --- a/relayer-cli/src/commands/query/client.rs +++ b/relayer-cli/src/commands/query/client.rs @@ -3,7 +3,7 @@ use alloc::sync::Arc; use abscissa_core::clap::Parser; use abscissa_core::{Command, Runnable}; use ibc_relayer::chain::requests::{ - PageRequest, QueryClientConnectionsRequest, QueryClientStateRequest, + IncludeProof, PageRequest, QueryClientConnectionsRequest, QueryClientStateRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, }; use tokio::runtime::Runtime as TokioRuntime; @@ -55,11 +55,14 @@ impl Runnable for QueryClientStateCmd { .unwrap_or_else(exit_with_unrecoverable_error); let height = ibc::Height::new(chain.id().version(), self.height.unwrap_or(0_u64)); - match chain.query_client_state(QueryClientStateRequest { - client_id: self.client_id.clone(), - height, - }) { - Ok(cs) => Output::success(cs).exit(), + match chain.query_client_state( + QueryClientStateRequest { + client_id: self.client_id.clone(), + height, + }, + IncludeProof::No, + ) { + Ok((cs, _)) => Output::success(cs).exit(), Err(e) => Output::error(format!("{}", e)).exit(), } } @@ -113,11 +116,14 @@ impl Runnable for QueryClientConsensusCmd { let chain = CosmosSdkChain::bootstrap(chain_config.clone(), rt) .unwrap_or_else(exit_with_unrecoverable_error); - let counterparty_chain = match chain.query_client_state(QueryClientStateRequest { - client_id: self.client_id.clone(), - height: Height::zero(), - }) { - Ok(cs) => cs.chain_id(), + let counterparty_chain = match chain.query_client_state( + QueryClientStateRequest { + client_id: self.client_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) { + Ok((cs, _)) => cs.chain_id(), Err(e) => Output::error(format!( "failed while querying client '{}' on chain '{}' with error: {}", self.client_id, self.chain_id, e @@ -199,11 +205,14 @@ impl Runnable for QueryClientHeaderCmd { let chain = CosmosSdkChain::bootstrap(chain_config.clone(), rt) .unwrap_or_else(exit_with_unrecoverable_error); - let counterparty_chain = match chain.query_client_state(QueryClientStateRequest { - client_id: self.client_id.clone(), - height: Height::zero(), - }) { - Ok(cs) => cs.chain_id(), + let counterparty_chain = match chain.query_client_state( + QueryClientStateRequest { + client_id: self.client_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) { + Ok((cs, _)) => cs.chain_id(), Err(e) => Output::error(format!( "failed while querying client '{}' on chain '{}' with error: {}", self.client_id, self.chain_id, e diff --git a/relayer-cli/src/commands/tx/client.rs b/relayer-cli/src/commands/tx/client.rs index 67b3030afe..e791ec21c7 100644 --- a/relayer-cli/src/commands/tx/client.rs +++ b/relayer-cli/src/commands/tx/client.rs @@ -8,7 +8,7 @@ use ibc::core::ics24_host::identifier::{ChainId, ClientId}; use ibc::events::IbcEvent; use ibc_relayer::chain::handle::ChainHandle; use ibc_relayer::chain::requests::{ - PageRequest, QueryClientStateRequest, QueryClientStatesRequest, + IncludeProof, PageRequest, QueryClientStateRequest, QueryClientStatesRequest, }; use ibc_relayer::config::Config; use ibc_relayer::foreign_client::{CreateOptions, ForeignClient}; @@ -116,11 +116,14 @@ impl Runnable for TxUpdateClientCmd { Err(e) => Output::error(format!("{}", e)).exit(), }; - let src_chain_id = match dst_chain.query_client_state(QueryClientStateRequest { - client_id: self.dst_client_id.clone(), - height: ibc::Height::zero(), - }) { - Ok(cs) => cs.chain_id(), + let src_chain_id = match dst_chain.query_client_state( + QueryClientStateRequest { + client_id: self.dst_client_id.clone(), + height: ibc::Height::zero(), + }, + IncludeProof::No, + ) { + Ok((cs, _)) => cs.chain_id(), Err(e) => { Output::error(format!( "Query of client '{}' on chain '{}' failed with error: {}", @@ -180,11 +183,14 @@ impl Runnable for TxUpgradeClientCmd { Err(e) => Output::error(format!("{}", e)).exit(), }; - let src_chain_id = match dst_chain.query_client_state(QueryClientStateRequest { - client_id: self.client_id.clone(), - height: ibc::Height::zero(), - }) { - Ok(cs) => cs.chain_id(), + let src_chain_id = match dst_chain.query_client_state( + QueryClientStateRequest { + client_id: self.client_id.clone(), + height: ibc::Height::zero(), + }, + IncludeProof::No, + ) { + Ok((cs, _)) => cs.chain_id(), Err(e) => { Output::error(format!( "Query of client '{}' on chain '{}' failed with error: {}", diff --git a/relayer-cli/src/commands/tx/transfer.rs b/relayer-cli/src/commands/tx/transfer.rs index 8875e19172..0932eb969a 100644 --- a/relayer-cli/src/commands/tx/transfer.rs +++ b/relayer-cli/src/commands/tx/transfer.rs @@ -12,7 +12,7 @@ use ibc::{ }; use ibc_relayer::chain::handle::ChainHandle; use ibc_relayer::chain::requests::{ - QueryChannelRequest, QueryClientStateRequest, QueryConnectionRequest, + IncludeProof, QueryChannelRequest, QueryClientStateRequest, QueryConnectionRequest, }; use ibc_relayer::transfer::Amount; use ibc_relayer::{ @@ -211,12 +211,15 @@ impl Runnable for TxIcs20MsgTransferCmd { debug!("connection hop underlying the channel: {:?}", conn_end); - let src_chain_client_state = chains + let (src_chain_client_state, _) = chains .src - .query_client_state(QueryClientStateRequest { - client_id: conn_end.client_id().clone(), - height: Height::zero(), - }) + .query_client_state( + QueryClientStateRequest { + client_id: conn_end.client_id().clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .unwrap_or_else(exit_with_unrecoverable_error); debug!( diff --git a/relayer/src/chain.rs b/relayer/src/chain.rs index 271cc224fc..2c3e13fbe2 100644 --- a/relayer/src/chain.rs +++ b/relayer/src/chain.rs @@ -31,14 +31,14 @@ use tendermint_rpc::endpoint::broadcast::tx_sync::Response as TxResponse; use crate::account::Balance; use crate::config::ChainConfig; use crate::connection::ConnectionMsgType; -use crate::error::Error; +use crate::error::{Error, QUERY_PROOF_EXPECT_MSG}; use crate::event::monitor::{EventReceiver, TxMonitorCmd}; use crate::keyring::{KeyEntry, KeyRing}; use crate::light_client::LightClient; use self::client::ClientSettings; use self::requests::{ - QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, + IncludeProof, QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, @@ -172,8 +172,11 @@ pub trait ChainEndpoint: Sized { request: QueryClientStatesRequest, ) -> Result, Error>; - fn query_client_state(&self, request: QueryClientStateRequest) - -> Result; + fn query_client_state( + &self, + request: QueryClientStateRequest, + include_proof: IncludeProof, + ) -> Result<(AnyClientState, Option), Error>; fn query_consensus_states( &self, @@ -276,12 +279,6 @@ pub trait ChainEndpoint: Sized { ) -> Result; // Provable queries - fn proven_client_state( - &self, - client_id: &ClientId, - height: ICSHeight, - ) -> Result<(AnyClientState, MerkleProof), Error>; - fn proven_connection( &self, connection_id: &ConnectionId, @@ -375,8 +372,14 @@ pub trait ChainEndpoint: Sized { match message_type { ConnectionMsgType::OpenTry | ConnectionMsgType::OpenAck => { - let (client_state_value, client_state_proof) = - self.proven_client_state(client_id, height)?; + let (client_state_value, maybe_client_state_proof) = self.query_client_state( + QueryClientStateRequest { + client_id: client_id.clone(), + height, + }, + IncludeProof::Yes, + )?; + let client_state_proof = maybe_client_state_proof.expect(QUERY_PROOF_EXPECT_MSG); client_proof = Some( CommitmentProofBytes::try_from(client_state_proof) diff --git a/relayer/src/chain/cosmos.rs b/relayer/src/chain/cosmos.rs index 05812c5607..f069902b05 100644 --- a/relayer/src/chain/cosmos.rs +++ b/relayer/src/chain/cosmos.rs @@ -79,7 +79,7 @@ use crate::light_client::tendermint::LightClient as TmLightClient; use crate::light_client::{LightClient, Verified}; use super::requests::{ - QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, + IncludeProof, QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, @@ -735,15 +735,34 @@ impl ChainEndpoint for CosmosSdkChain { fn query_client_state( &self, request: QueryClientStateRequest, - ) -> Result { + include_proof: IncludeProof, + ) -> Result<(AnyClientState, Option), Error> { crate::time!("query_client_state"); crate::telemetry!(query, self.id(), "query_client_state"); - let client_state = self - .query(ClientStatePath(request.client_id), request.height, false) - .and_then(|v| AnyClientState::decode_vec(&v.value).map_err(Error::decode))?; + match include_proof { + IncludeProof::Yes => { + let res = self.query( + ClientStatePath(request.client_id.clone()), + request.height, + true, + )?; - Ok(client_state) + let client_state = AnyClientState::decode_vec(&res.value).map_err(Error::decode)?; + + Ok(( + client_state, + Some(res.proof.ok_or_else(Error::empty_response_proof)?), + )) + } + IncludeProof::No => { + let client_state = self + .query(ClientStatePath(request.client_id), request.height, false) + .and_then(|v| AnyClientState::decode_vec(&v.value).map_err(Error::decode))?; + + Ok((client_state, None)) + } + } } fn query_upgraded_client_state( @@ -1338,23 +1357,6 @@ impl ChainEndpoint for CosmosSdkChain { Ok(response.block.header.into()) } - fn proven_client_state( - &self, - client_id: &ClientId, - height: ICSHeight, - ) -> Result<(AnyClientState, MerkleProof), Error> { - crate::time!("proven_client_state"); - - let res = self.query(ClientStatePath(client_id.clone()), height, true)?; - - let client_state = AnyClientState::decode_vec(&res.value).map_err(Error::decode)?; - - Ok(( - client_state, - res.proof.ok_or_else(Error::empty_response_proof)?, - )) - } - fn proven_client_consensus( &self, client_id: &ClientId, diff --git a/relayer/src/chain/counterparty.rs b/relayer/src/chain/counterparty.rs index 88a7307e79..83cb9e940d 100644 --- a/relayer/src/chain/counterparty.rs +++ b/relayer/src/chain/counterparty.rs @@ -5,9 +5,9 @@ use serde::{Deserialize, Serialize}; use tracing::{error, trace}; use super::requests::{ - PageRequest, QueryChannelRequest, QueryClientConnectionsRequest, QueryClientStateRequest, - QueryConnectionRequest, QueryPacketAcknowledgementsRequest, QueryUnreceivedAcksRequest, - QueryUnreceivedPacketsRequest, + IncludeProof, PageRequest, QueryChannelRequest, QueryClientConnectionsRequest, + QueryClientStateRequest, QueryConnectionRequest, QueryPacketAcknowledgementsRequest, + QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, }; use super::{ handle::ChainHandle, @@ -42,11 +42,14 @@ pub fn counterparty_chain_from_connection( .map_err(Error::relayer)?; let client_id = connection_end.client_id(); - let client_state = src_chain - .query_client_state(QueryClientStateRequest { - client_id: client_id.clone(), - height: Height::zero(), - }) + let (client_state, _) = src_chain + .query_client_state( + QueryClientStateRequest { + client_id: client_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(Error::relayer)?; trace!( @@ -181,11 +184,14 @@ pub fn channel_connection_client( } let client_id = connection_end.client_id(); - let client_state = chain - .query_client_state(QueryClientStateRequest { - client_id: client_id.clone(), - height: Height::zero(), - }) + let (client_state, _) = chain + .query_client_state( + QueryClientStateRequest { + client_id: client_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(Error::relayer)?; let client = IdentifiedAnyClientState::new(client_id.clone(), client_state); diff --git a/relayer/src/chain/handle.rs b/relayer/src/chain/handle.rs index 01b2c86d5e..1f217990bf 100644 --- a/relayer/src/chain/handle.rs +++ b/relayer/src/chain/handle.rs @@ -43,7 +43,7 @@ use crate::{ use super::{ client::ClientSettings, requests::{ - QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, + IncludeProof, QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, @@ -198,7 +198,8 @@ pub enum ChainRequest { QueryClientState { request: QueryClientStateRequest, - reply_to: ReplyTo, + include_proof: IncludeProof, + reply_to: ReplyTo<(AnyClientState, Option)>, }, QueryClientConnections { @@ -269,12 +270,6 @@ pub enum ChainRequest { reply_to: ReplyTo, }, - ProvenClientState { - client_id: ClientId, - height: Height, - reply_to: ReplyTo<(AnyClientState, MerkleProof)>, - }, - ProvenConnection { connection_id: ConnectionId, height: Height, @@ -396,8 +391,11 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { request: QueryClientStatesRequest, ) -> Result, Error>; - fn query_client_state(&self, request: QueryClientStateRequest) - -> Result; + fn query_client_state( + &self, + request: QueryClientStateRequest, + include_proof: IncludeProof, + ) -> Result<(AnyClientState, Option), Error>; fn query_client_connections( &self, @@ -457,12 +455,6 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { request: QueryChannelClientStateRequest, ) -> Result, Error>; - fn proven_client_state( - &self, - client_id: &ClientId, - height: Height, - ) -> Result<(AnyClientState, MerkleProof), Error>; - fn proven_connection( &self, connection_id: &ConnectionId, diff --git a/relayer/src/chain/handle/base.rs b/relayer/src/chain/handle/base.rs index a9e3a77f67..a7df574590 100644 --- a/relayer/src/chain/handle/base.rs +++ b/relayer/src/chain/handle/base.rs @@ -31,10 +31,10 @@ use crate::{ chain::{ client::ClientSettings, requests::{ - QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, - QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, - QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, - QueryConsensusStateRequest, QueryConsensusStatesRequest, + IncludeProof, QueryChannelClientStateRequest, QueryChannelRequest, + QueryChannelsRequest, QueryClientConnectionsRequest, QueryClientStateRequest, + QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, + QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, @@ -167,8 +167,13 @@ impl ChainHandle for BaseChainHandle { fn query_client_state( &self, request: QueryClientStateRequest, - ) -> Result { - self.send(|reply_to| ChainRequest::QueryClientState { request, reply_to }) + include_proof: IncludeProof, + ) -> Result<(AnyClientState, Option), Error> { + self.send(|reply_to| ChainRequest::QueryClientState { + request, + include_proof, + reply_to, + }) } fn query_client_connections( @@ -257,18 +262,6 @@ impl ChainHandle for BaseChainHandle { self.send(|reply_to| ChainRequest::QueryChannelClientState { request, reply_to }) } - fn proven_client_state( - &self, - client_id: &ClientId, - height: Height, - ) -> Result<(AnyClientState, MerkleProof), Error> { - self.send(|reply_to| ChainRequest::ProvenClientState { - client_id: client_id.clone(), - height, - reply_to, - }) - } - fn proven_connection( &self, connection_id: &ConnectionId, diff --git a/relayer/src/chain/handle/cache.rs b/relayer/src/chain/handle/cache.rs index 34199ea717..25ec5b15c8 100644 --- a/relayer/src/chain/handle/cache.rs +++ b/relayer/src/chain/handle/cache.rs @@ -30,7 +30,7 @@ use crate::cache::{Cache, CacheStatus}; use crate::chain::client::ClientSettings; use crate::chain::handle::{ChainHandle, ChainRequest, Subscription}; use crate::chain::requests::{ - QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, + IncludeProof, QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, @@ -162,25 +162,37 @@ impl ChainHandle for CachingChainHandle { fn query_client_state( &self, request: QueryClientStateRequest, - ) -> Result { + include_proof: IncludeProof, + ) -> Result<(AnyClientState, Option), Error> { let handle = self.inner(); - if request.height.is_zero() { - let (result, in_cache) = - self.cache - .get_or_try_insert_client_state_with(&request.client_id, || { - handle.query_client_state(QueryClientStateRequest { - client_id: request.client_id.clone(), - height: request.height, - }) - })?; - - if in_cache == CacheStatus::Hit { - telemetry!(query_cache_hit, &self.id(), "query_client_state"); + match include_proof { + IncludeProof::Yes => handle.query_client_state(request, include_proof), + IncludeProof::No => { + if request.height.is_zero() { + let (result, in_cache) = self.cache.get_or_try_insert_client_state_with( + &request.client_id, + || { + handle + .query_client_state( + QueryClientStateRequest { + client_id: request.client_id.clone(), + height: request.height, + }, + IncludeProof::No, + ) + .map(|(client_state, _)| client_state) + }, + )?; + + if in_cache == CacheStatus::Hit { + telemetry!(query_cache_hit, &self.id(), "query_client_state"); + } + + Ok((result, None)) + } else { + handle.query_client_state(request, include_proof) + } } - - Ok(result) - } else { - handle.query_client_state(request) } } @@ -299,14 +311,6 @@ impl ChainHandle for CachingChainHandle { self.inner().query_channel_client_state(request) } - fn proven_client_state( - &self, - client_id: &ClientId, - height: Height, - ) -> Result<(AnyClientState, MerkleProof), Error> { - self.inner().proven_client_state(client_id, height) - } - fn proven_connection( &self, connection_id: &ConnectionId, diff --git a/relayer/src/chain/handle/counting.rs b/relayer/src/chain/handle/counting.rs index df10b5790a..5f7449167a 100644 --- a/relayer/src/chain/handle/counting.rs +++ b/relayer/src/chain/handle/counting.rs @@ -30,7 +30,7 @@ use crate::account::Balance; use crate::chain::client::ClientSettings; use crate::chain::handle::{ChainHandle, ChainRequest, Subscription}; use crate::chain::requests::{ - QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, + IncludeProof, QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, @@ -182,12 +182,13 @@ impl ChainHandle for CountingChainHandle { fn query_client_state( &self, request: QueryClientStateRequest, - ) -> Result { + include_proof: IncludeProof, + ) -> Result<(AnyClientState, Option), Error> { self.inc_metric(&format!( "query_client_state({}, {})", request.client_id, request.height )); - self.inner().query_client_state(request) + self.inner().query_client_state(request, include_proof) } fn query_client_connections( @@ -290,15 +291,6 @@ impl ChainHandle for CountingChainHandle { self.inner().query_channel_client_state(request) } - fn proven_client_state( - &self, - client_id: &ClientId, - height: Height, - ) -> Result<(AnyClientState, MerkleProof), Error> { - self.inc_metric("proven_client_state"); - self.inner().proven_client_state(client_id, height) - } - fn proven_connection( &self, connection_id: &ConnectionId, diff --git a/relayer/src/chain/mock.rs b/relayer/src/chain/mock.rs index 79ee256e8c..bcf6f6e666 100644 --- a/relayer/src/chain/mock.rs +++ b/relayer/src/chain/mock.rs @@ -43,7 +43,7 @@ use crate::light_client::Verified; use crate::light_client::{mock::LightClient as MockLightClient, LightClient}; use super::requests::{ - QueryChannelsRequest, QueryClientConnectionsRequest, QueryClientStateRequest, + IncludeProof, QueryChannelsRequest, QueryClientConnectionsRequest, QueryClientStateRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, @@ -190,14 +190,15 @@ impl ChainEndpoint for MockChain { fn query_client_state( &self, request: QueryClientStateRequest, - ) -> Result { + _include_proof: IncludeProof, + ) -> Result<(AnyClientState, Option), Error> { // TODO: unclear what are the scenarios where we need to take height into account. let client_state = self .context .query_client_full_state(&request.client_id) .ok_or_else(Error::empty_response_value)?; - Ok(client_state) + Ok((client_state, None)) } fn query_upgraded_client_state( @@ -303,14 +304,6 @@ impl ChainEndpoint for MockChain { unimplemented!() } - fn proven_client_state( - &self, - _client_id: &ClientId, - _height: Height, - ) -> Result<(AnyClientState, MerkleProof), Error> { - unimplemented!() - } - fn proven_connection( &self, _connection_id: &ConnectionId, diff --git a/relayer/src/chain/requests.rs b/relayer/src/chain/requests.rs index 24a8405d9d..4de5365882 100644 --- a/relayer/src/chain/requests.rs +++ b/relayer/src/chain/requests.rs @@ -23,6 +23,14 @@ use ibc_proto::ibc::core::connection::v1::{ use serde::{Deserialize, Serialize}; +/// Defines a type to be used in select requests to specify whether or not a proof should be +/// returned along with the response. +#[derive(Clone, Copy, Debug, Serialize, Deserialize)] +pub enum IncludeProof { + Yes, + No, +} + #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] pub struct PageRequest { /// key is a value returned in PageResponse.next_key to begin diff --git a/relayer/src/chain/runtime.rs b/relayer/src/chain/runtime.rs index d142a0e256..b25ed8eecc 100644 --- a/relayer/src/chain/runtime.rs +++ b/relayer/src/chain/runtime.rs @@ -49,7 +49,7 @@ use super::{ client::ClientSettings, handle::{ChainHandle, ChainRequest, ReplyTo, Subscription}, requests::{ - QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, + IncludeProof, QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, @@ -317,8 +317,8 @@ where self.query_client_connections(request, reply_to)? }, - Ok(ChainRequest::QueryClientState { request, reply_to }) => { - self.query_client_state(request, reply_to)? + Ok(ChainRequest::QueryClientState { request, include_proof, reply_to }) => { + self.query_client_state(request, include_proof, reply_to)? }, Ok(ChainRequest::QueryConsensusStates { request, reply_to }) => { @@ -369,10 +369,6 @@ where self.query_channel_client_state(request, reply_to)? }, - Ok(ChainRequest::ProvenClientState { client_id, height, reply_to }) => { - self.proven_client_state(client_id, height, reply_to)? - }, - Ok(ChainRequest::ProvenConnection { connection_id, height, reply_to }) => { self.proven_connection(connection_id, height, reply_to)? }, @@ -620,14 +616,15 @@ where fn query_client_state( &self, request: QueryClientStateRequest, - reply_to: ReplyTo, + include_proof: IncludeProof, + reply_to: ReplyTo<(AnyClientState, Option)>, ) -> Result<(), Error> { - let client_state = self + let res = self .chain - .query_client_state(request) - .map(|cs| cs.wrap_any()); + .query_client_state(request, include_proof) + .map(|(cs, proof)| (cs.wrap_any(), proof)); - reply_to.send(client_state).map_err(Error::send) + reply_to.send(res).map_err(Error::send) } fn query_upgraded_client_state( @@ -739,20 +736,6 @@ where reply_to.send(result).map_err(Error::send) } - fn proven_client_state( - &self, - client_id: ClientId, - height: Height, - reply_to: ReplyTo<(AnyClientState, MerkleProof)>, - ) -> Result<(), Error> { - let result = self - .chain - .proven_client_state(&client_id, height) - .map(|(cs, mp)| (cs.wrap_any(), mp)); - - reply_to.send(result).map_err(Error::send) - } - fn proven_connection( &self, connection_id: ConnectionId, diff --git a/relayer/src/error.rs b/relayer/src/error.rs index 61e1e53b0a..704da24d5f 100644 --- a/relayer/src/error.rs +++ b/relayer/src/error.rs @@ -555,3 +555,6 @@ impl GrpcStatusSubdetail { .starts_with("account sequence mismatch") } } + +pub const QUERY_PROOF_EXPECT_MSG: &str = + "Internal error. Requested proof with query but no proof was returned."; diff --git a/relayer/src/foreign_client.rs b/relayer/src/foreign_client.rs index b87ef6f9d7..a19efbd3e4 100644 --- a/relayer/src/foreign_client.rs +++ b/relayer/src/foreign_client.rs @@ -38,8 +38,9 @@ use ibc::Height; use crate::chain::client::ClientSettings; use crate::chain::handle::ChainHandle; use crate::chain::requests::{ - PageRequest, QueryClientStateRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + IncludeProof, PageRequest, QueryClientStateRequest, QueryConsensusStateRequest, + QueryConsensusStatesRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }; use crate::chain::tracking::TrackedMsgs; use crate::error::Error as RelayerError; @@ -398,11 +399,14 @@ impl ForeignClient Result, ForeignClientError> { let height = Height::new(expected_target_chain.id().version(), 0); - match host_chain.query_client_state(QueryClientStateRequest { - client_id: client_id.clone(), - height, - }) { - Ok(cs) => { + match host_chain.query_client_state( + QueryClientStateRequest { + client_id: client_id.clone(), + height, + }, + IncludeProof::No, + ) { + Ok((cs, _)) => { if cs.chain_id() != expected_target_chain.id() { Err(ForeignClientError::mismatch_chain_id( client_id.clone(), @@ -651,12 +655,15 @@ impl ForeignClient Result<(AnyClientState, Option), ForeignClientError> { - let client_state = { + let (client_state, _) = { self.dst_chain - .query_client_state(QueryClientStateRequest { - client_id: self.id().clone(), - height: Height::zero(), - }) + .query_client_state( + QueryClientStateRequest { + client_id: self.id().clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| { ForeignClientError::client_refresh( self.id().clone(), @@ -1276,12 +1283,15 @@ impl ForeignClient relay_path .src_chain() - .query_client_state(QueryClientStateRequest { - client_id: relay_path.src_client_id().clone(), - height: Height::zero(), - }) + .query_client_state( + QueryClientStateRequest { + client_id: relay_path.src_client_id().clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| LinkError::query(relay_path.src_chain().id(), e))?, OperationalDataTarget::Destination => relay_path .dst_chain() - .query_client_state(QueryClientStateRequest { - client_id: relay_path.dst_client_id().clone(), - height: Height::zero(), - }) + .query_client_state( + QueryClientStateRequest { + client_id: relay_path.dst_client_id().clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| LinkError::query(relay_path.dst_chain().id(), e))?, }; diff --git a/relayer/src/object.rs b/relayer/src/object.rs index 1ddff6f077..ff74819a24 100644 --- a/relayer/src/object.rs +++ b/relayer/src/object.rs @@ -19,7 +19,7 @@ use crate::chain::{ counterparty_chain_from_connection, }, handle::ChainHandle, - requests::QueryClientStateRequest, + requests::{IncludeProof, QueryClientStateRequest}, }; use crate::error::Error as RelayerError; use crate::supervisor::Error as SupervisorError; @@ -303,11 +303,14 @@ impl Object { e: &UpdateClient, dst_chain: &impl ChainHandle, ) -> Result { - let client_state = dst_chain - .query_client_state(QueryClientStateRequest { - client_id: e.client_id().clone(), - height: Height::zero(), - }) + let (client_state, _) = dst_chain + .query_client_state( + QueryClientStateRequest { + client_id: e.client_id().clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(ObjectError::relayer)?; if client_state.refresh_period().is_none() { diff --git a/relayer/src/supervisor/client_state_filter.rs b/relayer/src/supervisor/client_state_filter.rs index 9658c5ad93..e81c9e2b7d 100644 --- a/relayer/src/supervisor/client_state_filter.rs +++ b/relayer/src/supervisor/client_state_filter.rs @@ -12,7 +12,7 @@ use ibc::Height; use crate::chain::handle::ChainHandle; use crate::chain::requests::{ - QueryChannelRequest, QueryClientStateRequest, QueryConnectionRequest, + IncludeProof, QueryChannelRequest, QueryClientStateRequest, QueryConnectionRequest, }; use crate::error::Error as RelayerError; use crate::object; @@ -110,12 +110,15 @@ impl FilterPolicy { .get_or_spawn(&counterparty_chain_id) .map_err(FilterError::spawn)?; let counterparty_client_id = connection.counterparty().client_id(); - let counterparty_client_state = { + let (counterparty_client_state, _) = { counterparty_chain - .query_client_state(QueryClientStateRequest { - client_id: counterparty_client_id.clone(), - height: Height::zero(), - }) + .query_client_state( + QueryClientStateRequest { + client_id: counterparty_client_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(FilterError::relayer)? }; @@ -225,11 +228,14 @@ impl FilterPolicy { obj.dst_chain_id ); - let client_state = chain - .query_client_state(QueryClientStateRequest { - client_id: obj.dst_client_id.clone(), - height: Height::zero(), - }) + let (client_state, _) = chain + .query_client_state( + QueryClientStateRequest { + client_id: obj.dst_client_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(FilterError::relayer)?; Ok(self.control_client(&obj.dst_chain_id, &obj.dst_client_id, &client_state)) @@ -271,11 +277,14 @@ impl FilterPolicy { }) .map_err(FilterError::relayer)?; - let client_state = src_chain - .query_client_state(QueryClientStateRequest { - client_id: connection_end.client_id().clone(), - height: Height::zero(), - }) + let (client_state, _) = src_chain + .query_client_state( + QueryClientStateRequest { + client_id: connection_end.client_id().clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(FilterError::relayer)?; self.control_connection_end_and_client( @@ -333,11 +342,14 @@ impl FilterPolicy { }) .map_err(FilterError::relayer)?; - let client_state = src_chain - .query_client_state(QueryClientStateRequest { - client_id: connection_end.client_id().clone(), - height: Height::zero(), - }) + let (client_state, _) = src_chain + .query_client_state( + QueryClientStateRequest { + client_id: connection_end.client_id().clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(FilterError::relayer)?; let permission = self.control_connection_end_and_client( diff --git a/relayer/src/supervisor/scan.rs b/relayer/src/supervisor/scan.rs index b745c8dc10..39d8b9a8cf 100644 --- a/relayer/src/supervisor/scan.rs +++ b/relayer/src/supervisor/scan.rs @@ -22,7 +22,7 @@ use crate::{ counterparty::{channel_on_destination, connection_state_on_destination}, handle::ChainHandle, requests::{ - PageRequest, QueryChannelRequest, QueryClientConnectionsRequest, + IncludeProof, PageRequest, QueryChannelRequest, QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, }, @@ -697,11 +697,14 @@ fn query_client( chain: &Chain, client_id: &ClientId, ) -> Result { - let client = chain - .query_client_state(QueryClientStateRequest { - client_id: client_id.clone(), - height: Height::zero(), - }) + let (client, _) = chain + .query_client_state( + QueryClientStateRequest { + client_id: client_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(Error::query)?; Ok(IdentifiedAnyClientState::new(client_id.clone(), client)) diff --git a/relayer/src/upgrade_chain.rs b/relayer/src/upgrade_chain.rs index fcaff1d5d0..a938e54909 100644 --- a/relayer/src/upgrade_chain.rs +++ b/relayer/src/upgrade_chain.rs @@ -18,7 +18,7 @@ use ibc_proto::cosmos::upgrade::v1beta1::Plan; use ibc_proto::google::protobuf::Any; use ibc_proto::ibc::core::client::v1::UpgradeProposal; -use crate::chain::requests::QueryClientStateRequest; +use crate::chain::requests::{IncludeProof, QueryClientStateRequest}; use crate::chain::tracking::TrackedMsgs; use crate::chain::{ChainEndpoint, CosmosSdkChain}; use crate::config::ChainConfig; @@ -75,11 +75,14 @@ pub fn build_and_send_ibc_upgrade_proposal( .map_err(UpgradeChainError::query)? .add(opts.height_offset); - let client_state = src_chain - .query_client_state(QueryClientStateRequest { - client_id: opts.src_client_id.clone(), - height: Height::zero(), - }) + let (client_state, _) = src_chain + .query_client_state( + QueryClientStateRequest { + client_id: opts.src_client_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(UpgradeChainError::query)?; let client_state = downcast!(client_state => AnyClientState::Tendermint) diff --git a/tools/integration-test/src/tests/client_settings.rs b/tools/integration-test/src/tests/client_settings.rs index cc438b49d4..6aa2074552 100644 --- a/tools/integration-test/src/tests/client_settings.rs +++ b/tools/integration-test/src/tests/client_settings.rs @@ -5,7 +5,7 @@ use ibc::core::ics02_client::trust_threshold::TrustThreshold; use ibc::clients::ics07_tendermint::client_state::ClientState as TendermintClientState; use ibc::core::ics02_client::client_state::AnyClientState; use ibc::Height; -use ibc_relayer::chain::requests::QueryClientStateRequest; +use ibc_relayer::chain::requests::{IncludeProof, QueryClientStateRequest}; use ibc_relayer::foreign_client::CreateOptions; use ibc_test_framework::prelude::*; @@ -106,10 +106,13 @@ fn query_client_state( handle: Chain, id: &ClientId, ) -> Result { - let state = handle.query_client_state(QueryClientStateRequest { - client_id: id.clone(), - height: Height::zero(), - })?; + let (state, _) = handle.query_client_state( + QueryClientStateRequest { + client_id: id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + )?; #[allow(unreachable_patterns)] match state { AnyClientState::Tendermint(state) => Ok(state), diff --git a/tools/test-framework/src/relayer/chain.rs b/tools/test-framework/src/relayer/chain.rs index ad69229cbd..10c2860773 100644 --- a/tools/test-framework/src/relayer/chain.rs +++ b/tools/test-framework/src/relayer/chain.rs @@ -49,7 +49,7 @@ use ibc_relayer::account::Balance; use ibc_relayer::chain::client::ClientSettings; use ibc_relayer::chain::handle::{ChainHandle, ChainRequest, Subscription}; use ibc_relayer::chain::requests::{ - QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, + IncludeProof, QueryChannelClientStateRequest, QueryChannelRequest, QueryChannelsRequest, QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, @@ -147,8 +147,9 @@ where fn query_client_state( &self, request: QueryClientStateRequest, - ) -> Result { - self.value().query_client_state(request) + include_proof: IncludeProof, + ) -> Result<(AnyClientState, Option), Error> { + self.value().query_client_state(request, include_proof) } fn query_client_connections( @@ -237,14 +238,6 @@ where self.value().query_channel_client_state(request) } - fn proven_client_state( - &self, - client_id: &ClientId, - height: Height, - ) -> Result<(AnyClientState, MerkleProof), Error> { - self.value().proven_client_state(client_id, height) - } - fn proven_connection( &self, connection_id: &ConnectionId, From cbf58a64ee64f8796db96b30696bdd23f1edcdf8 Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Thu, 19 May 2022 15:06:49 -0400 Subject: [PATCH 03/19] query_connection consolidation --- relayer-cli/src/commands/create/channel.rs | 13 +- .../src/commands/query/channel_ends.rs | 19 +-- relayer-cli/src/commands/query/channels.rs | 19 +-- relayer-cli/src/commands/query/connection.rs | 15 ++- relayer-cli/src/commands/tx/channel.rs | 28 +++-- relayer-cli/src/commands/tx/transfer.rs | 13 +- relayer/src/chain.rs | 21 ++-- relayer/src/chain/cosmos.rs | 44 ++++--- relayer/src/chain/counterparty.rs | 52 ++++---- relayer/src/chain/handle.rs | 21 ++-- relayer/src/chain/handle/base.rs | 24 ++-- relayer/src/chain/handle/cache.rs | 58 +++++---- relayer/src/chain/handle/counting.rs | 17 +-- relayer/src/chain/mock.rs | 14 +-- relayer/src/chain/runtime.rs | 23 +--- relayer/src/channel.rs | 73 ++++++----- relayer/src/connection.rs | 113 +++++++++++------- relayer/src/link.rs | 15 ++- relayer/src/supervisor/client_state_filter.rs | 26 ++-- relayer/src/supervisor/scan.rs | 13 +- tools/test-framework/src/relayer/chain.rs | 16 +-- .../test-framework/src/relayer/connection.rs | 24 ++-- 22 files changed, 369 insertions(+), 292 deletions(-) diff --git a/relayer-cli/src/commands/create/channel.rs b/relayer-cli/src/commands/create/channel.rs index 754fbdbdae..837724b457 100644 --- a/relayer-cli/src/commands/create/channel.rs +++ b/relayer-cli/src/commands/create/channel.rs @@ -187,11 +187,14 @@ impl CreateChannelCommand { // Query the connection end. let height = Height::new(chain_a.id().version(), 0); - let conn_end = chain_a - .query_connection(QueryConnectionRequest { - connection_id: connection_a.clone(), - height, - }) + let (conn_end, _) = chain_a + .query_connection( + QueryConnectionRequest { + connection_id: connection_a.clone(), + height, + }, + IncludeProof::No, + ) .unwrap_or_else(exit_with_unrecoverable_error); // Query the client state, obtain the identifier of chain b. diff --git a/relayer-cli/src/commands/query/channel_ends.rs b/relayer-cli/src/commands/query/channel_ends.rs index 1c59922a1d..8ee954b56e 100644 --- a/relayer-cli/src/commands/query/channel_ends.rs +++ b/relayer-cli/src/commands/query/channel_ends.rs @@ -105,10 +105,13 @@ fn do_run(cmd: &QueryChannelEndsCmd) -> Result<(), Box(cmd: &QueryChannelEndsCmd) -> Result<(), Box( channel_id: ChannelId, chain_height: Height, ) -> Result> { - let connection_end = chain.query_connection(QueryConnectionRequest { - connection_id: connection_id.clone(), - height: chain_height, - })?; + let (connection_end, _) = chain.query_connection( + QueryConnectionRequest { + connection_id: connection_id.clone(), + height: chain_height, + }, + IncludeProof::No, + )?; let client_id = connection_end.client_id().clone(); let (client_state, _) = chain.query_client_state( QueryClientStateRequest { @@ -176,11 +179,13 @@ fn query_channel_ends( let counterparty_chain = registry.get_or_spawn(&counterparty_chain_id)?; let counterparty_chain_height = counterparty_chain.query_latest_height()?; - let counterparty_connection_end = - counterparty_chain.query_connection(QueryConnectionRequest { + let (counterparty_connection_end, _) = counterparty_chain.query_connection( + QueryConnectionRequest { connection_id: counterparty_connection_id, height: counterparty_chain_height, - })?; + }, + IncludeProof::No, + )?; let (counterparty_client_state, _) = counterparty_chain.query_client_state( QueryClientStateRequest { diff --git a/relayer-cli/src/commands/query/connection.rs b/relayer-cli/src/commands/query/connection.rs index ea1288dddb..99fcdfb09b 100644 --- a/relayer-cli/src/commands/query/connection.rs +++ b/relayer-cli/src/commands/query/connection.rs @@ -3,7 +3,7 @@ use alloc::sync::Arc; use abscissa_core::clap::Parser; use abscissa_core::{Command, Runnable}; use ibc_relayer::chain::requests::{ - PageRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, + IncludeProof, PageRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, }; use tokio::runtime::Runtime as TokioRuntime; @@ -51,12 +51,15 @@ impl Runnable for QueryConnectionEndCmd { .unwrap_or_else(exit_with_unrecoverable_error); let height = ibc::Height::new(chain.id().version(), self.height.unwrap_or(0_u64)); - let res = chain.query_connection(QueryConnectionRequest { - connection_id: self.connection_id.clone(), - height, - }); + let res = chain.query_connection( + QueryConnectionRequest { + connection_id: self.connection_id.clone(), + height, + }, + IncludeProof::No, + ); match res { - Ok(connection_end) => { + Ok((connection_end, _)) => { if connection_end.state_matches(&State::Uninitialized) { Output::error(format!( "connection '{}' does not exist", diff --git a/relayer-cli/src/commands/tx/channel.rs b/relayer-cli/src/commands/tx/channel.rs index 3aa61c2fe7..d0c2187b34 100644 --- a/relayer-cli/src/commands/tx/channel.rs +++ b/relayer-cli/src/commands/tx/channel.rs @@ -7,7 +7,7 @@ use ibc::core::ics24_host::identifier::{ChainId, ChannelId, ClientId, Connection use ibc::events::IbcEvent; use ibc::Height; use ibc_relayer::chain::handle::ChainHandle; -use ibc_relayer::chain::requests::QueryConnectionRequest; +use ibc_relayer::chain::requests::{IncludeProof, QueryConnectionRequest}; use ibc_relayer::channel::{Channel, ChannelSide}; use crate::cli_utils::ChainHandlePair; @@ -26,11 +26,14 @@ macro_rules! tx_chan_cmd { }; // Retrieve the connection - let dst_connection = match chains.dst.query_connection(QueryConnectionRequest { - connection_id: $self.dst_conn_id.clone(), - height: Height::default(), - }) { - Ok(connection) => connection, + let dst_connection = match chains.dst.query_connection( + QueryConnectionRequest { + connection_id: $self.dst_conn_id.clone(), + height: Height::default(), + }, + IncludeProof::No, + ) { + Ok((connection, _)) => connection, Err(e) => Output::error(format!("{}", e)).exit(), }; @@ -83,11 +86,14 @@ impl Runnable for TxRawChanOpenInitCmd { }; // Retrieve the connection - let dst_connection = match chains.dst.query_connection(QueryConnectionRequest { - connection_id: self.dst_conn_id.clone(), - height: Height::default(), - }) { - Ok(connection) => connection, + let dst_connection = match chains.dst.query_connection( + QueryConnectionRequest { + connection_id: self.dst_conn_id.clone(), + height: Height::default(), + }, + IncludeProof::No, + ) { + Ok((connection, _)) => connection, Err(e) => Output::error(format!("{}", e)).exit(), }; diff --git a/relayer-cli/src/commands/tx/transfer.rs b/relayer-cli/src/commands/tx/transfer.rs index 0932eb969a..c5ffdc44a6 100644 --- a/relayer-cli/src/commands/tx/transfer.rs +++ b/relayer-cli/src/commands/tx/transfer.rs @@ -201,12 +201,15 @@ impl Runnable for TxIcs20MsgTransferCmd { Some(cid) => cid, }; - let conn_end = chains + let (conn_end, _) = chains .src - .query_connection(QueryConnectionRequest { - connection_id: conn_id.clone(), - height: Height::zero(), - }) + .query_connection( + QueryConnectionRequest { + connection_id: conn_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .unwrap_or_else(exit_with_unrecoverable_error); debug!("connection hop underlying the channel: {:?}", conn_end); diff --git a/relayer/src/chain.rs b/relayer/src/chain.rs index 2c3e13fbe2..f95961b8cb 100644 --- a/relayer/src/chain.rs +++ b/relayer/src/chain.rs @@ -212,7 +212,11 @@ pub trait ChainEndpoint: Sized { request: QueryClientConnectionsRequest, ) -> Result, Error>; - fn query_connection(&self, request: QueryConnectionRequest) -> Result; + fn query_connection( + &self, + request: QueryConnectionRequest, + include_proof: IncludeProof, + ) -> Result<(ConnectionEnd, Option), Error>; /// Performs a query to retrieve the identifiers of all channels associated with a connection. fn query_connection_channels( @@ -279,12 +283,6 @@ pub trait ChainEndpoint: Sized { ) -> Result; // Provable queries - fn proven_connection( - &self, - connection_id: &ConnectionId, - height: ICSHeight, - ) -> Result<(ConnectionEnd, MerkleProof), Error>; - fn proven_client_consensus( &self, client_id: &ClientId, @@ -341,7 +339,14 @@ pub trait ChainEndpoint: Sized { client_id: &ClientId, height: ICSHeight, ) -> Result<(Option, Proofs), Error> { - let (connection_end, connection_proof) = self.proven_connection(connection_id, height)?; + let (connection_end, maybe_connection_proof) = self.query_connection( + QueryConnectionRequest { + connection_id: connection_id.clone(), + height, + }, + IncludeProof::Yes, + )?; + let connection_proof = maybe_connection_proof.expect(QUERY_PROOF_EXPECT_MSG); // Check that the connection state is compatible with the message match message_type { diff --git a/relayer/src/chain/cosmos.rs b/relayer/src/chain/cosmos.rs index f069902b05..103f647c91 100644 --- a/relayer/src/chain/cosmos.rs +++ b/relayer/src/chain/cosmos.rs @@ -925,7 +925,11 @@ impl ChainEndpoint for CosmosSdkChain { Ok(connections) } - fn query_connection(&self, request: QueryConnectionRequest) -> Result { + fn query_connection( + &self, + request: QueryConnectionRequest, + include_proof: IncludeProof, + ) -> Result<(ConnectionEnd, Option), Error> { crate::time!("query_connection"); crate::telemetry!(query, self.id(), "query_connection"); @@ -978,9 +982,27 @@ impl ChainEndpoint for CosmosSdkChain { } } - self.block_on(async { - do_query_connection(self, &request.connection_id, request.height).await - }) + match include_proof { + IncludeProof::Yes => { + let res = self.query( + ConnectionsPath(request.connection_id.clone()), + request.height, + true, + )?; + let connection_end = + ConnectionEnd::decode_vec(&res.value).map_err(Error::decode)?; + + Ok(( + connection_end, + Some(res.proof.ok_or_else(Error::empty_response_proof)?), + )) + } + IncludeProof::No => self + .block_on(async { + do_query_connection(self, &request.connection_id, request.height).await + }) + .map(|conn_end| (conn_end, None)), + } } fn query_connection_channels( @@ -1389,20 +1411,6 @@ impl ChainEndpoint for CosmosSdkChain { Ok((consensus_state, proof)) } - fn proven_connection( - &self, - connection_id: &ConnectionId, - height: ICSHeight, - ) -> Result<(ConnectionEnd, MerkleProof), Error> { - let res = self.query(ConnectionsPath(connection_id.clone()), height, true)?; - let connection_end = ConnectionEnd::decode_vec(&res.value).map_err(Error::decode)?; - - Ok(( - connection_end, - res.proof.ok_or_else(Error::empty_response_proof)?, - )) - } - fn proven_channel( &self, port_id: &PortId, diff --git a/relayer/src/chain/counterparty.rs b/relayer/src/chain/counterparty.rs index 83cb9e940d..e7f9b23749 100644 --- a/relayer/src/chain/counterparty.rs +++ b/relayer/src/chain/counterparty.rs @@ -34,11 +34,14 @@ pub fn counterparty_chain_from_connection( src_chain: &impl ChainHandle, src_connection_id: &ConnectionId, ) -> Result { - let connection_end = src_chain - .query_connection(QueryConnectionRequest { - connection_id: src_connection_id.clone(), - height: Height::zero(), - }) + let (connection_end, _) = src_chain + .query_connection( + QueryConnectionRequest { + connection_id: src_connection_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(Error::relayer)?; let client_id = connection_end.client_id(); @@ -71,11 +74,14 @@ fn connection_on_destination( .map_err(Error::relayer)?; for counterparty_connection in counterparty_connections.into_iter() { - let counterparty_connection_end = counterparty_chain - .query_connection(QueryConnectionRequest { - connection_id: counterparty_connection.clone(), - height: Height::zero(), - }) + let (counterparty_connection_end, _) = counterparty_chain + .query_connection( + QueryConnectionRequest { + connection_id: counterparty_connection.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(Error::relayer)?; let local_connection_end = &counterparty_connection_end.counterparty(); @@ -93,11 +99,14 @@ pub fn connection_state_on_destination( counterparty_chain: &impl ChainHandle, ) -> Result { if let Some(remote_connection_id) = connection.connection_end.counterparty().connection_id() { - let connection_end = counterparty_chain - .query_connection(QueryConnectionRequest { - connection_id: remote_connection_id.clone(), - height: Height::zero(), - }) + let (connection_end, _) = counterparty_chain + .query_connection( + QueryConnectionRequest { + connection_id: remote_connection_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(Error::relayer)?; Ok(connection_end.state) @@ -168,11 +177,14 @@ pub fn channel_connection_client( .first() .ok_or_else(|| Error::missing_connection_hops(*channel_id, chain.id()))?; - let connection_end = chain - .query_connection(QueryConnectionRequest { - connection_id: connection_id.clone(), - height: Height::zero(), - }) + let (connection_end, _) = chain + .query_connection( + QueryConnectionRequest { + connection_id: connection_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(Error::relayer)?; if !connection_end.is_open() { diff --git a/relayer/src/chain/handle.rs b/relayer/src/chain/handle.rs index 1f217990bf..e72b38a8b7 100644 --- a/relayer/src/chain/handle.rs +++ b/relayer/src/chain/handle.rs @@ -237,7 +237,8 @@ pub enum ChainRequest { QueryConnection { request: QueryConnectionRequest, - reply_to: ReplyTo, + include_proof: IncludeProof, + reply_to: ReplyTo<(ConnectionEnd, Option)>, }, QueryConnections { @@ -270,12 +271,6 @@ pub enum ChainRequest { reply_to: ReplyTo, }, - ProvenConnection { - connection_id: ConnectionId, - height: Height, - reply_to: ReplyTo<(ConnectionEnd, MerkleProof)>, - }, - ProvenClientConsensus { client_id: ClientId, consensus_height: Height, @@ -426,7 +421,11 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { fn query_compatible_versions(&self) -> Result, Error>; - fn query_connection(&self, request: QueryConnectionRequest) -> Result; + fn query_connection( + &self, + request: QueryConnectionRequest, + include_proof: IncludeProof, + ) -> Result<(ConnectionEnd, Option), Error>; fn query_connections( &self, @@ -455,12 +454,6 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { request: QueryChannelClientStateRequest, ) -> Result, Error>; - fn proven_connection( - &self, - connection_id: &ConnectionId, - height: Height, - ) -> Result<(ConnectionEnd, MerkleProof), Error>; - fn proven_client_consensus( &self, client_id: &ClientId, diff --git a/relayer/src/chain/handle/base.rs b/relayer/src/chain/handle/base.rs index a7df574590..456bf95724 100644 --- a/relayer/src/chain/handle/base.rs +++ b/relayer/src/chain/handle/base.rs @@ -219,8 +219,16 @@ impl ChainHandle for BaseChainHandle { self.send(|reply_to| ChainRequest::QueryCompatibleVersions { reply_to }) } - fn query_connection(&self, request: QueryConnectionRequest) -> Result { - self.send(|reply_to| ChainRequest::QueryConnection { request, reply_to }) + fn query_connection( + &self, + request: QueryConnectionRequest, + include_proof: IncludeProof, + ) -> Result<(ConnectionEnd, Option), Error> { + self.send(|reply_to| ChainRequest::QueryConnection { + request, + include_proof, + reply_to, + }) } fn query_connections( @@ -262,18 +270,6 @@ impl ChainHandle for BaseChainHandle { self.send(|reply_to| ChainRequest::QueryChannelClientState { request, reply_to }) } - fn proven_connection( - &self, - connection_id: &ConnectionId, - height: Height, - ) -> Result<(ConnectionEnd, MerkleProof), Error> { - self.send(|reply_to| ChainRequest::ProvenConnection { - connection_id: connection_id.clone(), - height, - reply_to, - }) - } - fn proven_client_consensus( &self, client_id: &ClientId, diff --git a/relayer/src/chain/handle/cache.rs b/relayer/src/chain/handle/cache.rs index 25ec5b15c8..47283ef614 100644 --- a/relayer/src/chain/handle/cache.rs +++ b/relayer/src/chain/handle/cache.rs @@ -166,20 +166,14 @@ impl ChainHandle for CachingChainHandle { ) -> Result<(AnyClientState, Option), Error> { let handle = self.inner(); match include_proof { - IncludeProof::Yes => handle.query_client_state(request, include_proof), + IncludeProof::Yes => handle.query_client_state(request, IncludeProof::Yes), IncludeProof::No => { if request.height.is_zero() { let (result, in_cache) = self.cache.get_or_try_insert_client_state_with( &request.client_id, || { handle - .query_client_state( - QueryClientStateRequest { - client_id: request.client_id.clone(), - height: request.height, - }, - IncludeProof::No, - ) + .query_client_state(request.clone(), IncludeProof::No) .map(|(client_state, _)| client_state) }, )?; @@ -190,7 +184,7 @@ impl ChainHandle for CachingChainHandle { Ok((result, None)) } else { - handle.query_client_state(request, include_proof) + handle.query_client_state(request, IncludeProof::No) } } } @@ -239,22 +233,34 @@ impl ChainHandle for CachingChainHandle { self.inner().query_compatible_versions() } - fn query_connection(&self, request: QueryConnectionRequest) -> Result { + fn query_connection( + &self, + request: QueryConnectionRequest, + include_proof: IncludeProof, + ) -> Result<(ConnectionEnd, Option), Error> { let handle = self.inner(); - if request.height.is_zero() { - let (result, in_cache) = self - .cache - .get_or_try_insert_connection_with(&request.connection_id, || { - handle.query_connection(request.clone()) - })?; + match include_proof { + IncludeProof::Yes => handle.query_connection(request, IncludeProof::Yes), + IncludeProof::No => { + if request.height.is_zero() { + let (result, in_cache) = self.cache.get_or_try_insert_connection_with( + &request.connection_id, + || { + handle + .query_connection(request.clone(), IncludeProof::No) + .map(|(conn_end, _)| conn_end) + }, + )?; - if in_cache == CacheStatus::Hit { - telemetry!(query_cache_hit, &self.id(), "query_connection"); - } + if in_cache == CacheStatus::Hit { + telemetry!(query_cache_hit, &self.id(), "query_connection"); + } - Ok(result) - } else { - handle.query_connection(request) + Ok((result, None)) + } else { + handle.query_connection(request, IncludeProof::No) + } + } } } @@ -311,14 +317,6 @@ impl ChainHandle for CachingChainHandle { self.inner().query_channel_client_state(request) } - fn proven_connection( - &self, - connection_id: &ConnectionId, - height: Height, - ) -> Result<(ConnectionEnd, MerkleProof), Error> { - self.inner().proven_connection(connection_id, height) - } - fn proven_client_consensus( &self, client_id: &ClientId, diff --git a/relayer/src/chain/handle/counting.rs b/relayer/src/chain/handle/counting.rs index 5f7449167a..b6f59d4b52 100644 --- a/relayer/src/chain/handle/counting.rs +++ b/relayer/src/chain/handle/counting.rs @@ -241,9 +241,13 @@ impl ChainHandle for CountingChainHandle { self.inner().query_compatible_versions() } - fn query_connection(&self, request: QueryConnectionRequest) -> Result { + fn query_connection( + &self, + request: QueryConnectionRequest, + include_proof: IncludeProof, + ) -> Result<(ConnectionEnd, Option), Error> { self.inc_metric("query_connection"); - self.inner().query_connection(request) + self.inner().query_connection(request, include_proof) } fn query_connections( @@ -291,15 +295,6 @@ impl ChainHandle for CountingChainHandle { self.inner().query_channel_client_state(request) } - fn proven_connection( - &self, - connection_id: &ConnectionId, - height: Height, - ) -> Result<(ConnectionEnd, MerkleProof), Error> { - self.inc_metric("proven_connection"); - self.inner().proven_connection(connection_id, height) - } - fn proven_client_consensus( &self, client_id: &ClientId, diff --git a/relayer/src/chain/mock.rs b/relayer/src/chain/mock.rs index bcf6f6e666..32e1a16b48 100644 --- a/relayer/src/chain/mock.rs +++ b/relayer/src/chain/mock.rs @@ -208,7 +208,11 @@ impl ChainEndpoint for MockChain { unimplemented!() } - fn query_connection(&self, _request: QueryConnectionRequest) -> Result { + fn query_connection( + &self, + _request: QueryConnectionRequest, + _include_proof: IncludeProof, + ) -> Result<(ConnectionEnd, Option), Error> { unimplemented!() } @@ -304,14 +308,6 @@ impl ChainEndpoint for MockChain { unimplemented!() } - fn proven_connection( - &self, - _connection_id: &ConnectionId, - _height: Height, - ) -> Result<(ConnectionEnd, MerkleProof), Error> { - unimplemented!() - } - fn proven_client_consensus( &self, _client_id: &ClientId, diff --git a/relayer/src/chain/runtime.rs b/relayer/src/chain/runtime.rs index b25ed8eecc..0323801842 100644 --- a/relayer/src/chain/runtime.rs +++ b/relayer/src/chain/runtime.rs @@ -345,8 +345,8 @@ where self.query_compatible_versions(reply_to)? }, - Ok(ChainRequest::QueryConnection { request, reply_to }) => { - self.query_connection(request, reply_to)? + Ok(ChainRequest::QueryConnection { request, include_proof, reply_to }) => { + self.query_connection(request, include_proof, reply_to)? }, Ok(ChainRequest::QueryConnections { request, reply_to }) => { @@ -369,10 +369,6 @@ where self.query_channel_client_state(request, reply_to)? }, - Ok(ChainRequest::ProvenConnection { connection_id, height, reply_to }) => { - self.proven_connection(connection_id, height, reply_to)? - }, - Ok(ChainRequest::ProvenClientConsensus { client_id, consensus_height, height, reply_to }) => { self.proven_client_consensus(client_id, consensus_height, height, reply_to)? }, @@ -685,9 +681,10 @@ where fn query_connection( &self, request: QueryConnectionRequest, - reply_to: ReplyTo, + include_proof: IncludeProof, + reply_to: ReplyTo<(ConnectionEnd, Option)>, ) -> Result<(), Error> { - let connection_end = self.chain.query_connection(request); + let connection_end = self.chain.query_connection(request, include_proof); reply_to.send(connection_end).map_err(Error::send) } @@ -736,16 +733,6 @@ where reply_to.send(result).map_err(Error::send) } - fn proven_connection( - &self, - connection_id: ConnectionId, - height: Height, - reply_to: ReplyTo<(ConnectionEnd, MerkleProof)>, - ) -> Result<(), Error> { - let result = self.chain.proven_connection(&connection_id, height); - reply_to.send(result).map_err(Error::send) - } - fn proven_client_consensus( &self, client_id: ClientId, diff --git a/relayer/src/channel.rs b/relayer/src/channel.rs index 506e57ed89..1488dadce9 100644 --- a/relayer/src/channel.rs +++ b/relayer/src/channel.rs @@ -23,7 +23,8 @@ use ibc::Height; use crate::chain::counterparty::{channel_connection_client, channel_state_on_destination}; use crate::chain::handle::ChainHandle; use crate::chain::requests::{ - PageRequest, QueryChannelRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, + IncludeProof, PageRequest, QueryChannelRequest, QueryConnectionChannelsRequest, + QueryConnectionRequest, }; use crate::chain::tracking::TrackedMsgs; use crate::connection::Connection; @@ -206,11 +207,14 @@ impl Channel { let channel_id = channel_event_attributes.channel_id; let connection_id = channel_event_attributes.connection_id.clone(); - let connection = chain - .query_connection(QueryConnectionRequest { - connection_id: connection_id.clone(), - height: Height::zero(), - }) + let (connection, _) = chain + .query_connection( + QueryConnectionRequest { + connection_id: connection_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(ChannelError::relayer)?; let connection_counterparty = connection.counterparty(); @@ -269,11 +273,14 @@ impl Channel { )) })?; - let a_connection = chain - .query_connection(QueryConnectionRequest { - connection_id: a_connection_id.clone(), - height: Height::zero(), - }) + let (a_connection, _) = chain + .query_connection( + QueryConnectionRequest { + connection_id: a_connection_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(ChannelError::relayer)?; let b_connection_id = a_connection @@ -891,10 +898,13 @@ impl Channel { // Connection must exist on destination self.dst_chain() - .query_connection(QueryConnectionRequest { - connection_id: self.dst_connection_id().clone(), - height: Height::zero(), - }) + .query_connection( + QueryConnectionRequest { + connection_id: self.dst_connection_id().clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ChannelError::query(self.dst_chain().id(), e))?; let query_height = self @@ -1002,10 +1012,13 @@ impl Channel { // Connection must exist on destination self.dst_chain() - .query_connection(QueryConnectionRequest { - connection_id: self.dst_connection_id().clone(), - height: Height::zero(), - }) + .query_connection( + QueryConnectionRequest { + connection_id: self.dst_connection_id().clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ChannelError::query(self.dst_chain().id(), e))?; let query_height = self @@ -1109,10 +1122,13 @@ impl Channel { // Connection must exist on destination self.dst_chain() - .query_connection(QueryConnectionRequest { - connection_id: self.dst_connection_id().clone(), - height: Height::zero(), - }) + .query_connection( + QueryConnectionRequest { + connection_id: self.dst_connection_id().clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ChannelError::query(self.dst_chain().id(), e))?; let query_height = self @@ -1268,10 +1284,13 @@ impl Channel { // Connection must exist on destination self.dst_chain() - .query_connection(QueryConnectionRequest { - connection_id: self.dst_connection_id().clone(), - height: Height::zero(), - }) + .query_connection( + QueryConnectionRequest { + connection_id: self.dst_connection_id().clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ChannelError::query(self.dst_chain().id(), e))?; let query_height = self diff --git a/relayer/src/connection.rs b/relayer/src/connection.rs index d76cc840f3..52566c6b59 100644 --- a/relayer/src/connection.rs +++ b/relayer/src/connection.rs @@ -1,7 +1,9 @@ use core::time::Duration; use crate::chain::counterparty::connection_state_on_destination; -use crate::chain::requests::{PageRequest, QueryConnectionRequest, QueryConnectionsRequest}; +use crate::chain::requests::{ + IncludeProof, PageRequest, QueryConnectionRequest, QueryConnectionsRequest, +}; use crate::chain::tracking::TrackedMsgs; use crate::util::retry::RetryResult; use flex_error::define_error; @@ -337,11 +339,14 @@ impl Connection { connection: WorkerConnectionObject, height: Height, ) -> Result<(Connection, State), ConnectionError> { - let a_connection = chain - .query_connection(QueryConnectionRequest { - connection_id: connection.src_connection_id.clone(), - height, - }) + let (a_connection, _) = chain + .query_connection( + QueryConnectionRequest { + connection_id: connection.src_connection_id.clone(), + height, + }, + IncludeProof::No, + ) .map_err(ConnectionError::relayer)?; let client_id = a_connection.client_id(); @@ -553,22 +558,31 @@ impl Connection { .ok_or_else(ConnectionError::missing_counterparty_connection_id)?; // Continue loop if query error - let a_connection = a_chain.query_connection(QueryConnectionRequest { - connection_id: src_connection_id.clone(), - height: Height::zero(), - }); - if a_connection.is_err() { + let a_connection_res = a_chain.query_connection( + QueryConnectionRequest { + connection_id: src_connection_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ); + if a_connection_res.is_err() { continue; } - let b_connection = b_chain.query_connection(QueryConnectionRequest { - connection_id: dst_connection_id.clone(), - height: Height::zero(), - }); - if b_connection.is_err() { + let b_connection_res = b_chain.query_connection( + QueryConnectionRequest { + connection_id: dst_connection_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ); + if b_connection_res.is_err() { continue; } - match (a_connection.unwrap().state(), b_connection.unwrap().state()) { + match ( + a_connection_res.unwrap().0.state(), + b_connection_res.unwrap().0.state(), + ) { (State::Init, State::TryOpen) | (State::TryOpen, State::TryOpen) => { // Ack to a_chain match self.flipped().build_conn_ack_and_send() { @@ -616,12 +630,15 @@ impl Connection { .src_connection_id() .ok_or_else(ConnectionError::missing_local_connection_id)?; - let connection_end = self + let (connection_end, _) = self .src_chain() - .query_connection(QueryConnectionRequest { - connection_id: connection_id.clone(), - height: Height::zero(), - }) + .query_connection( + QueryConnectionRequest { + connection_id: connection_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ConnectionError::connection_query(connection_id.clone(), e))?; let connection = IdentifiedConnectionEnd { @@ -736,12 +753,15 @@ impl Connection { ); // Retrieve existing connection if any - let dst_connection = self + let (dst_connection, _) = self .dst_chain() - .query_connection(QueryConnectionRequest { - connection_id: dst_connection_id.clone(), - height: Height::zero(), - }) + .query_connection( + QueryConnectionRequest { + connection_id: dst_connection_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ConnectionError::chain_query(self.dst_chain().id(), e))?; // Check if a connection is expected to exist on destination chain @@ -848,12 +868,15 @@ impl Connection { .src_connection_id() .ok_or_else(ConnectionError::missing_local_connection_id)?; - let src_connection = self + let (src_connection, _) = self .src_chain() - .query_connection(QueryConnectionRequest { - connection_id: src_connection_id.clone(), - height: Height::zero(), - }) + .query_connection( + QueryConnectionRequest { + connection_id: src_connection_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ConnectionError::chain_query(self.src_chain().id(), e))?; // TODO - check that the src connection is consistent with the try options @@ -988,12 +1011,15 @@ impl Connection { let _expected_dst_connection = self.validated_expected_connection(ConnectionMsgType::OpenAck)?; - let src_connection = self + let (src_connection, _) = self .src_chain() - .query_connection(QueryConnectionRequest { - connection_id: src_connection_id.clone(), - height: Height::zero(), - }) + .query_connection( + QueryConnectionRequest { + connection_id: src_connection_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ConnectionError::chain_query(self.src_chain().id(), e))?; // TODO - check that the src connection is consistent with the ack options @@ -1093,12 +1119,15 @@ impl Connection { .query_latest_height() .map_err(|e| ConnectionError::chain_query(self.src_chain().id(), e))?; - let _src_connection = self + let (_src_connection, _) = self .src_chain() - .query_connection(QueryConnectionRequest { - connection_id: src_connection_id.clone(), - height: query_height, - }) + .query_connection( + QueryConnectionRequest { + connection_id: src_connection_id.clone(), + height: query_height, + }, + IncludeProof::No, + ) .map_err(|e| ConnectionError::connection_query(src_connection_id.clone(), e))?; // TODO - check that the src connection is consistent with the confirm options diff --git a/relayer/src/link.rs b/relayer/src/link.rs index b95cf6a36e..1ffddd2d1d 100644 --- a/relayer/src/link.rs +++ b/relayer/src/link.rs @@ -7,9 +7,9 @@ use ibc::{ Height, }; -use crate::chain::handle::ChainHandle; use crate::chain::requests::QueryChannelRequest; use crate::chain::{counterparty::check_channel_counterparty, requests::QueryConnectionRequest}; +use crate::chain::{handle::ChainHandle, requests::IncludeProof}; use crate::channel::{Channel, ChannelSide}; use crate::link::error::LinkError; @@ -104,11 +104,14 @@ impl Link { // Check the underlying connection let a_connection_id = a_channel.connection_hops()[0].clone(); - let a_connection = a_chain - .query_connection(QueryConnectionRequest { - connection_id: a_connection_id.clone(), - height: Height::zero(), - }) + let (a_connection, _) = a_chain + .query_connection( + QueryConnectionRequest { + connection_id: a_connection_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(LinkError::relayer)?; if !a_connection.state_matches(&ConnectionState::Open) { diff --git a/relayer/src/supervisor/client_state_filter.rs b/relayer/src/supervisor/client_state_filter.rs index e81c9e2b7d..944718e70c 100644 --- a/relayer/src/supervisor/client_state_filter.rs +++ b/relayer/src/supervisor/client_state_filter.rs @@ -270,11 +270,14 @@ impl FilterPolicy { obj.src_chain_id ); - let connection_end = src_chain - .query_connection(QueryConnectionRequest { - connection_id: obj.src_connection_id.clone(), - height: Height::zero(), - }) + let (connection_end, _) = src_chain + .query_connection( + QueryConnectionRequest { + connection_id: obj.src_connection_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(FilterError::relayer)?; let (client_state, _) = src_chain @@ -335,11 +338,14 @@ impl FilterPolicy { )) })?; - let connection_end = src_chain - .query_connection(QueryConnectionRequest { - connection_id: conn_id.clone(), - height: Height::zero(), - }) + let (connection_end, _) = src_chain + .query_connection( + QueryConnectionRequest { + connection_id: conn_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(FilterError::relayer)?; let (client_state, _) = src_chain diff --git a/relayer/src/supervisor/scan.rs b/relayer/src/supervisor/scan.rs index 39d8b9a8cf..7128606e0a 100644 --- a/relayer/src/supervisor/scan.rs +++ b/relayer/src/supervisor/scan.rs @@ -784,11 +784,14 @@ fn query_connection( chain: &Chain, connection_id: &ConnectionId, ) -> Result { - let connection_end = chain - .query_connection(QueryConnectionRequest { - connection_id: connection_id.clone(), - height: Height::zero(), - }) + let (connection_end, _) = chain + .query_connection( + QueryConnectionRequest { + connection_id: connection_id.clone(), + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(Error::query)?; Ok(IdentifiedConnectionEnd { diff --git a/tools/test-framework/src/relayer/chain.rs b/tools/test-framework/src/relayer/chain.rs index 10c2860773..ec5d0e5e22 100644 --- a/tools/test-framework/src/relayer/chain.rs +++ b/tools/test-framework/src/relayer/chain.rs @@ -195,8 +195,12 @@ where self.value().query_compatible_versions() } - fn query_connection(&self, request: QueryConnectionRequest) -> Result { - self.value().query_connection(request) + fn query_connection( + &self, + request: QueryConnectionRequest, + include_proof: IncludeProof, + ) -> Result<(ConnectionEnd, Option), Error> { + self.value().query_connection(request, include_proof) } fn query_connections( @@ -238,14 +242,6 @@ where self.value().query_channel_client_state(request) } - fn proven_connection( - &self, - connection_id: &ConnectionId, - height: Height, - ) -> Result<(ConnectionEnd, MerkleProof), Error> { - self.value().proven_connection(connection_id, height) - } - fn proven_client_consensus( &self, client_id: &ClientId, diff --git a/tools/test-framework/src/relayer/connection.rs b/tools/test-framework/src/relayer/connection.rs index cdacfa7e6d..757e1d8091 100644 --- a/tools/test-framework/src/relayer/connection.rs +++ b/tools/test-framework/src/relayer/connection.rs @@ -9,7 +9,7 @@ use ibc::core::ics03_connection::connection::{ConnectionEnd, IdentifiedConnectio use ibc::timestamp::ZERO_DURATION; use ibc::Height; use ibc_relayer::chain::handle::ChainHandle; -use ibc_relayer::chain::requests::QueryConnectionRequest; +use ibc_relayer::chain::requests::{IncludeProof, QueryConnectionRequest}; use ibc_relayer::connection::{extract_connection_id, Connection, ConnectionSide}; use crate::error::Error; @@ -89,10 +89,13 @@ pub fn query_connection_end( handle: &ChainA, connection_id: &TaggedConnectionIdRef, ) -> Result, Error> { - let connection_end = handle.query_connection(QueryConnectionRequest { - connection_id: connection_id.into_value().clone(), - height: Height::zero(), - })?; + let (connection_end, _) = handle.query_connection( + QueryConnectionRequest { + connection_id: connection_id.into_value().clone(), + height: Height::zero(), + }, + IncludeProof::No, + )?; Ok(DualTagged::new(connection_end)) } @@ -101,10 +104,13 @@ pub fn query_identified_connection_end( handle: &ChainA, connection_id: TaggedConnectionIdRef, ) -> Result, Error> { - let connection_end = handle.query_connection(QueryConnectionRequest { - connection_id: connection_id.into_value().clone(), - height: Height::zero(), - })?; + let (connection_end, _) = handle.query_connection( + QueryConnectionRequest { + connection_id: connection_id.into_value().clone(), + height: Height::zero(), + }, + IncludeProof::No, + )?; Ok(DualTagged::new(IdentifiedConnectionEnd::new( connection_id.into_value().clone(), connection_end, From 2c0292c9a1a322f6cb2971934e750169737a1478 Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Thu, 19 May 2022 15:59:00 -0400 Subject: [PATCH 04/19] query_channel consolidation --- relayer-cli/src/commands/query/channel.rs | 17 ++- .../src/commands/query/channel_ends.rs | 26 ++-- relayer-cli/src/commands/query/channels.rs | 13 +- relayer-cli/src/commands/tx/transfer.rs | 15 +- relayer/src/chain.rs | 45 +++--- relayer/src/chain/cosmos.rs | 54 ++++---- relayer/src/chain/counterparty.rs | 45 +++--- relayer/src/chain/handle.rs | 9 +- relayer/src/chain/handle/base.rs | 12 +- relayer/src/chain/handle/cache.rs | 39 ++++-- relayer/src/chain/handle/counting.rs | 8 +- relayer/src/chain/mock.rs | 15 +- relayer/src/chain/runtime.rs | 9 +- relayer/src/channel.rs | 129 +++++++++++------- relayer/src/link.rs | 15 +- relayer/src/link/relay_path.rs | 29 ++-- relayer/src/supervisor/client_state_filter.rs | 15 +- relayer/src/supervisor/scan.rs | 15 +- tools/test-framework/src/relayer/chain.rs | 8 +- tools/test-framework/src/relayer/channel.rs | 28 ++-- 20 files changed, 333 insertions(+), 213 deletions(-) diff --git a/relayer-cli/src/commands/query/channel.rs b/relayer-cli/src/commands/query/channel.rs index 24cef1d005..460e0031dd 100644 --- a/relayer-cli/src/commands/query/channel.rs +++ b/relayer-cli/src/commands/query/channel.rs @@ -6,7 +6,7 @@ use tokio::runtime::Runtime as TokioRuntime; use ibc::core::ics24_host::identifier::ChainId; use ibc::core::ics24_host::identifier::{ChannelId, PortId}; -use ibc_relayer::chain::requests::QueryChannelRequest; +use ibc_relayer::chain::requests::{IncludeProof, QueryChannelRequest}; use ibc_relayer::chain::{ChainEndpoint, CosmosSdkChain}; use crate::conclude::{exit_with_unrecoverable_error, Output}; @@ -47,13 +47,16 @@ impl Runnable for QueryChannelEndCmd { let chain = CosmosSdkChain::bootstrap(chain_config.clone(), rt) .unwrap_or_else(exit_with_unrecoverable_error); - let res = chain.query_channel(QueryChannelRequest { - port_id: self.port_id.clone(), - channel_id: self.channel_id, - height: ibc::Height::new(chain.id().version(), self.height.unwrap_or(0_u64)), - }); + let res = chain.query_channel( + QueryChannelRequest { + port_id: self.port_id.clone(), + channel_id: self.channel_id, + height: ibc::Height::new(chain.id().version(), self.height.unwrap_or(0_u64)), + }, + IncludeProof::No, + ); match res { - Ok(channel_end) => { + Ok((channel_end, _)) => { if channel_end.state_matches(&State::Uninitialized) { Output::error(format!( "port '{}' & channel '{}' does not exist", diff --git a/relayer-cli/src/commands/query/channel_ends.rs b/relayer-cli/src/commands/query/channel_ends.rs index 8ee954b56e..c38e21b9e0 100644 --- a/relayer-cli/src/commands/query/channel_ends.rs +++ b/relayer-cli/src/commands/query/channel_ends.rs @@ -81,11 +81,14 @@ fn do_run(cmd: &QueryChannelEndsCmd) -> Result<(), Box chain.query_latest_height()?, }; - let channel_end = chain.query_channel(QueryChannelRequest { - port_id: port_id.clone(), - channel_id, - height: chain_height, - })?; + let (channel_end, _) = chain.query_channel( + QueryChannelRequest { + port_id: port_id.clone(), + channel_id, + height: chain_height, + }, + IncludeProof::No, + )?; if channel_end.state_matches(&State::Uninitialized) { return Err(format!( "{}/{} on chain {} @ {:?} is uninitialized", @@ -167,11 +170,14 @@ fn do_run(cmd: &QueryChannelEndsCmd) -> Result<(), Box( IncludeProof::No, )?; - let counterparty_channel_end = counterparty_chain.query_channel(QueryChannelRequest { - port_id: counterparty_port_id, - channel_id: counterparty_channel_id, - height: counterparty_chain_height, - })?; + let (counterparty_channel_end, _) = counterparty_chain.query_channel( + QueryChannelRequest { + port_id: counterparty_port_id, + channel_id: counterparty_channel_id, + height: counterparty_chain_height, + }, + IncludeProof::No, + )?; Ok(ChannelEnds { channel_end, diff --git a/relayer-cli/src/commands/tx/transfer.rs b/relayer-cli/src/commands/tx/transfer.rs index c5ffdc44a6..905593de5b 100644 --- a/relayer-cli/src/commands/tx/transfer.rs +++ b/relayer-cli/src/commands/tx/transfer.rs @@ -171,13 +171,16 @@ impl Runnable for TxIcs20MsgTransferCmd { // To do this, fetch from the source chain the channel end, then the associated connection // end, and then the underlying client state; finally, check that this client is verifying // headers for the destination chain. - let channel_end_src = chains + let (channel_end_src, _) = chains .src - .query_channel(QueryChannelRequest { - port_id: opts.packet_src_port_id.clone(), - channel_id: opts.packet_src_channel_id, - height: Height::zero(), - }) + .query_channel( + QueryChannelRequest { + port_id: opts.packet_src_port_id.clone(), + channel_id: opts.packet_src_channel_id, + height: Height::zero(), + }, + IncludeProof::No, + ) .unwrap_or_else(exit_with_unrecoverable_error); if !channel_end_src.is_open() { Output::error(format!( diff --git a/relayer/src/chain.rs b/relayer/src/chain.rs index f95961b8cb..d7900fb174 100644 --- a/relayer/src/chain.rs +++ b/relayer/src/chain.rs @@ -230,7 +230,11 @@ pub trait ChainEndpoint: Sized { request: QueryChannelsRequest, ) -> Result, Error>; - fn query_channel(&self, request: QueryChannelRequest) -> Result; + fn query_channel( + &self, + request: QueryChannelRequest, + include_proof: IncludeProof, + ) -> Result<(ChannelEnd, Option), Error>; fn query_channel_client_state( &self, @@ -290,13 +294,6 @@ pub trait ChainEndpoint: Sized { height: ICSHeight, ) -> Result<(AnyConsensusState, MerkleProof), Error>; - fn proven_channel( - &self, - port_id: &PortId, - channel_id: &ChannelId, - height: ICSHeight, - ) -> Result<(ChannelEnd, MerkleProof), Error>; - fn proven_packet( &self, packet_type: PacketMsgType, @@ -430,11 +427,19 @@ pub trait ChainEndpoint: Sized { height: ICSHeight, ) -> Result { // Collect all proofs as required - let channel_proof = - CommitmentProofBytes::try_from(self.proven_channel(port_id, channel_id, height)?.1) - .map_err(Error::malformed_proof)?; + let (_, maybe_channel_proof) = self.query_channel( + QueryChannelRequest { + port_id: port_id.clone(), + channel_id: *channel_id, + height, + }, + IncludeProof::Yes, + )?; + let channel_proof = maybe_channel_proof.expect(QUERY_PROOF_EXPECT_MSG); + let channel_proof_bytes = + CommitmentProofBytes::try_from(channel_proof).map_err(Error::malformed_proof)?; - Proofs::new(channel_proof, None, None, None, height.increment()) + Proofs::new(channel_proof_bytes, None, None, None, height.increment()) .map_err(Error::malformed_proof) } @@ -448,12 +453,16 @@ pub trait ChainEndpoint: Sized { height: ICSHeight, ) -> Result<(Vec, Proofs), Error> { let channel_proof = if packet_type == PacketMsgType::TimeoutOnClose { - Some( - CommitmentProofBytes::try_from( - self.proven_channel(&port_id, &channel_id, height)?.1, - ) - .map_err(Error::malformed_proof)?, - ) + let (_, maybe_channel_proof) = self.query_channel( + QueryChannelRequest { + port_id: port_id.clone(), + channel_id, + height, + }, + IncludeProof::Yes, + )?; + let channel_proof = maybe_channel_proof.expect(QUERY_PROOF_EXPECT_MSG); + Some(CommitmentProofBytes::try_from(channel_proof).map_err(Error::malformed_proof)?) } else { None }; diff --git a/relayer/src/chain/cosmos.rs b/relayer/src/chain/cosmos.rs index 103f647c91..bb2c8edfed 100644 --- a/relayer/src/chain/cosmos.rs +++ b/relayer/src/chain/cosmos.rs @@ -1068,18 +1068,40 @@ impl ChainEndpoint for CosmosSdkChain { Ok(channels) } - fn query_channel(&self, request: QueryChannelRequest) -> Result { + fn query_channel( + &self, + request: QueryChannelRequest, + include_proof: IncludeProof, + ) -> Result<(ChannelEnd, Option), Error> { crate::time!("query_channel"); crate::telemetry!(query, self.id(), "query_channel"); - let res = self.query( - ChannelEndsPath(request.port_id, request.channel_id), - request.height, - false, - )?; - let channel_end = ChannelEnd::decode_vec(&res.value).map_err(Error::decode)?; + match include_proof { + IncludeProof::Yes => { + let res = self.query( + ChannelEndsPath(request.port_id, request.channel_id), + request.height, + true, + )?; - Ok(channel_end) + let channel_end = ChannelEnd::decode_vec(&res.value).map_err(Error::decode)?; + + Ok(( + channel_end, + Some(res.proof.ok_or_else(Error::empty_response_proof)?), + )) + } + IncludeProof::No => { + let res = self.query( + ChannelEndsPath(request.port_id, request.channel_id), + request.height, + false, + )?; + let channel_end = ChannelEnd::decode_vec(&res.value).map_err(Error::decode)?; + + Ok((channel_end, None)) + } + } } fn query_channel_client_state( @@ -1411,22 +1433,6 @@ impl ChainEndpoint for CosmosSdkChain { Ok((consensus_state, proof)) } - fn proven_channel( - &self, - port_id: &PortId, - channel_id: &ChannelId, - height: ICSHeight, - ) -> Result<(ChannelEnd, MerkleProof), Error> { - let res = self.query(ChannelEndsPath(port_id.clone(), *channel_id), height, true)?; - - let channel_end = ChannelEnd::decode_vec(&res.value).map_err(Error::decode)?; - - Ok(( - channel_end, - res.proof.ok_or_else(Error::empty_response_proof)?, - )) - } - fn proven_packet( &self, packet_type: PacketMsgType, diff --git a/relayer/src/chain/counterparty.rs b/relayer/src/chain/counterparty.rs index e7f9b23749..f8a91832ba 100644 --- a/relayer/src/chain/counterparty.rs +++ b/relayer/src/chain/counterparty.rs @@ -156,12 +156,15 @@ pub fn channel_connection_client( port_id: &PortId, channel_id: &ChannelId, ) -> Result { - let channel_end = chain - .query_channel(QueryChannelRequest { - port_id: port_id.clone(), - channel_id: *channel_id, - height: Height::zero(), - }) + let (channel_end, _) = chain + .query_channel( + QueryChannelRequest { + port_id: port_id.clone(), + channel_id: *channel_id, + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(Error::relayer)?; if channel_end.state_matches(&State::Uninitialized) { @@ -265,12 +268,15 @@ pub fn channel_on_destination( ) -> Result, Error> { if let Some(remote_channel_id) = channel.channel_end.counterparty().channel_id() { let counterparty = counterparty_chain - .query_channel(QueryChannelRequest { - port_id: channel.channel_end.counterparty().port_id().clone(), - channel_id: *remote_channel_id, - height: Height::zero(), - }) - .map(|c| IdentifiedChannelEnd { + .query_channel( + QueryChannelRequest { + port_id: channel.channel_end.counterparty().port_id().clone(), + channel_id: *remote_channel_id, + height: Height::zero(), + }, + IncludeProof::No, + ) + .map(|(c, _)| IdentifiedChannelEnd { port_id: channel.channel_end.counterparty().port_id().clone(), channel_id: *remote_channel_id, channel_end: c, @@ -299,12 +305,15 @@ pub fn check_channel_counterparty( target_pchan: &PortChannelId, expected: &PortChannelId, ) -> Result<(), ChannelError> { - let channel_end_dst = target_chain - .query_channel(QueryChannelRequest { - port_id: target_pchan.port_id.clone(), - channel_id: target_pchan.channel_id, - height: Height::zero(), - }) + let (channel_end_dst, _) = target_chain + .query_channel( + QueryChannelRequest { + port_id: target_pchan.port_id.clone(), + channel_id: target_pchan.channel_id, + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ChannelError::query(target_chain.id(), e))?; let counterparty = channel_end_dst.remote; diff --git a/relayer/src/chain/handle.rs b/relayer/src/chain/handle.rs index e72b38a8b7..74e0cdf719 100644 --- a/relayer/src/chain/handle.rs +++ b/relayer/src/chain/handle.rs @@ -258,7 +258,8 @@ pub enum ChainRequest { QueryChannel { request: QueryChannelRequest, - reply_to: ReplyTo, + include_proof: IncludeProof, + reply_to: ReplyTo<(ChannelEnd, Option)>, }, QueryChannelClientState { @@ -447,7 +448,11 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { request: QueryChannelsRequest, ) -> Result, Error>; - fn query_channel(&self, request: QueryChannelRequest) -> Result; + fn query_channel( + &self, + request: QueryChannelRequest, + include_proof: IncludeProof, + ) -> Result<(ChannelEnd, Option), Error>; fn query_channel_client_state( &self, diff --git a/relayer/src/chain/handle/base.rs b/relayer/src/chain/handle/base.rs index 456bf95724..36b056fedc 100644 --- a/relayer/src/chain/handle/base.rs +++ b/relayer/src/chain/handle/base.rs @@ -259,8 +259,16 @@ impl ChainHandle for BaseChainHandle { self.send(|reply_to| ChainRequest::QueryChannels { request, reply_to }) } - fn query_channel(&self, request: QueryChannelRequest) -> Result { - self.send(|reply_to| ChainRequest::QueryChannel { request, reply_to }) + fn query_channel( + &self, + request: QueryChannelRequest, + include_proof: IncludeProof, + ) -> Result<(ChannelEnd, Option), Error> { + self.send(|reply_to| ChainRequest::QueryChannel { + request, + include_proof, + reply_to, + }) } fn query_channel_client_state( diff --git a/relayer/src/chain/handle/cache.rs b/relayer/src/chain/handle/cache.rs index 47283ef614..649466e155 100644 --- a/relayer/src/chain/handle/cache.rs +++ b/relayer/src/chain/handle/cache.rs @@ -292,21 +292,34 @@ impl ChainHandle for CachingChainHandle { self.inner().query_channels(request) } - fn query_channel(&self, request: QueryChannelRequest) -> Result { + fn query_channel( + &self, + request: QueryChannelRequest, + include_proof: IncludeProof, + ) -> Result<(ChannelEnd, Option), Error> { let handle = self.inner(); - if request.height.is_zero() { - let (result, in_cache) = self.cache.get_or_try_insert_channel_with( - &PortChannelId::new(request.channel_id, request.port_id.clone()), - || handle.query_channel(request), - )?; - - if in_cache == CacheStatus::Hit { - telemetry!(query_cache_hit, &self.id(), "query_channel"); - } + match include_proof { + IncludeProof::Yes => handle.query_channel(request, IncludeProof::Yes), + IncludeProof::No => { + if request.height.is_zero() { + let (result, in_cache) = self.cache.get_or_try_insert_channel_with( + &PortChannelId::new(request.channel_id, request.port_id.clone()), + || { + handle + .query_channel(request, IncludeProof::No) + .map(|(channel_end, _)| channel_end) + }, + )?; + + if in_cache == CacheStatus::Hit { + telemetry!(query_cache_hit, &self.id(), "query_channel"); + } - Ok(result) - } else { - handle.query_channel(request) + Ok((result, None)) + } else { + handle.query_channel(request, IncludeProof::No) + } + } } } diff --git a/relayer/src/chain/handle/counting.rs b/relayer/src/chain/handle/counting.rs index b6f59d4b52..c264975a14 100644 --- a/relayer/src/chain/handle/counting.rs +++ b/relayer/src/chain/handle/counting.rs @@ -282,9 +282,13 @@ impl ChainHandle for CountingChainHandle { self.inner().query_channels(request) } - fn query_channel(&self, request: QueryChannelRequest) -> Result { + fn query_channel( + &self, + request: QueryChannelRequest, + include_proof: IncludeProof, + ) -> Result<(ChannelEnd, Option), Error> { self.inc_metric("query_channel"); - self.inner().query_channel(request) + self.inner().query_channel(request, include_proof) } fn query_channel_client_state( diff --git a/relayer/src/chain/mock.rs b/relayer/src/chain/mock.rs index 32e1a16b48..a682c25b25 100644 --- a/relayer/src/chain/mock.rs +++ b/relayer/src/chain/mock.rs @@ -244,7 +244,11 @@ impl ChainEndpoint for MockChain { unimplemented!() } - fn query_channel(&self, _request: QueryChannelRequest) -> Result { + fn query_channel( + &self, + _request: QueryChannelRequest, + _include_proof: IncludeProof, + ) -> Result<(ChannelEnd, Option), Error> { unimplemented!() } @@ -317,15 +321,6 @@ impl ChainEndpoint for MockChain { unimplemented!() } - fn proven_channel( - &self, - _port_id: &PortId, - _channel_id: &ChannelId, - _height: Height, - ) -> Result<(ChannelEnd, MerkleProof), Error> { - unimplemented!() - } - fn proven_packet( &self, _packet_type: PacketMsgType, diff --git a/relayer/src/chain/runtime.rs b/relayer/src/chain/runtime.rs index 0323801842..e052bddff5 100644 --- a/relayer/src/chain/runtime.rs +++ b/relayer/src/chain/runtime.rs @@ -361,8 +361,8 @@ where self.query_channels(request, reply_to)? }, - Ok(ChainRequest::QueryChannel { request, reply_to }) => { - self.query_channel(request, reply_to)? + Ok(ChainRequest::QueryChannel { request, include_proof, reply_to }) => { + self.query_channel(request, include_proof, reply_to)? }, Ok(ChainRequest::QueryChannelClientState { request, reply_to }) => { @@ -718,9 +718,10 @@ where fn query_channel( &self, request: QueryChannelRequest, - reply_to: ReplyTo, + include_proof: IncludeProof, + reply_to: ReplyTo<(ChannelEnd, Option)>, ) -> Result<(), Error> { - let result = self.chain.query_channel(request); + let result = self.chain.query_channel(request, include_proof); reply_to.send(result).map_err(Error::send) } diff --git a/relayer/src/channel.rs b/relayer/src/channel.rs index 1488dadce9..46b7e1b639 100644 --- a/relayer/src/channel.rs +++ b/relayer/src/channel.rs @@ -258,12 +258,15 @@ impl Channel { channel: WorkerChannelObject, height: Height, ) -> Result<(Channel, State), ChannelError> { - let a_channel = chain - .query_channel(QueryChannelRequest { - port_id: channel.src_port_id.clone(), - channel_id: channel.src_channel_id, - height, - }) + let (a_channel, _) = chain + .query_channel( + QueryChannelRequest { + port_id: channel.src_port_id.clone(), + channel_id: channel.src_channel_id, + height, + }, + IncludeProof::No, + ) .map_err(ChannelError::relayer)?; let a_connection_id = a_channel.connection_hops().first().ok_or_else(|| { @@ -492,13 +495,16 @@ impl Channel { ); // Continue loop if query error - let a_channel = channel + let (a_channel, _) = channel .src_chain() - .query_channel(QueryChannelRequest { - port_id: channel.src_port_id().clone(), - channel_id: *src_channel_id, - height: Height::zero(), - }) + .query_channel( + QueryChannelRequest { + port_id: channel.src_port_id().clone(), + channel_id: *src_channel_id, + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| { ChannelError::handshake_finalize( channel.src_port_id().clone(), @@ -508,13 +514,16 @@ impl Channel { ) })?; - let b_channel = channel + let (b_channel, _) = channel .dst_chain() - .query_channel(QueryChannelRequest { - port_id: channel.dst_port_id().clone(), - channel_id: *dst_channel_id, - height: Height::zero(), - }) + .query_channel( + QueryChannelRequest { + port_id: channel.dst_port_id().clone(), + channel_id: *dst_channel_id, + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| { ChannelError::handshake_finalize( channel.dst_port_id().clone(), @@ -846,13 +855,16 @@ impl Channel { ); // Retrieve existing channel - let dst_channel = self + let (dst_channel, _) = self .dst_chain() - .query_channel(QueryChannelRequest { - port_id: self.dst_port_id().clone(), - channel_id: *dst_channel_id, - height: Height::zero(), - }) + .query_channel( + QueryChannelRequest { + port_id: self.dst_port_id().clone(), + channel_id: *dst_channel_id, + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ChannelError::query(self.dst_chain().id(), e))?; // Check if a channel is expected to exist on destination chain @@ -877,13 +889,16 @@ impl Channel { .ok_or_else(ChannelError::missing_local_channel_id)?; // Channel must exist on source - let src_channel = self + let (src_channel, _) = self .src_chain() - .query_channel(QueryChannelRequest { - port_id: self.src_port_id().clone(), - channel_id: *src_channel_id, - height: Height::zero(), - }) + .query_channel( + QueryChannelRequest { + port_id: self.src_port_id().clone(), + channel_id: *src_channel_id, + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ChannelError::query(self.src_chain().id(), e))?; if src_channel.counterparty().port_id() != self.dst_port_id() { @@ -1001,13 +1016,16 @@ impl Channel { self.validated_expected_channel(ChannelMsgType::OpenAck)?; // Channel must exist on source - let src_channel = self + let (src_channel, _) = self .src_chain() - .query_channel(QueryChannelRequest { - port_id: self.src_port_id().clone(), - channel_id: *src_channel_id, - height: Height::zero(), - }) + .query_channel( + QueryChannelRequest { + port_id: self.src_port_id().clone(), + channel_id: *src_channel_id, + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ChannelError::query(self.src_chain().id(), e))?; // Connection must exist on destination @@ -1113,11 +1131,14 @@ impl Channel { // Channel must exist on source self.src_chain() - .query_channel(QueryChannelRequest { - port_id: self.src_port_id().clone(), - channel_id: *src_channel_id, - height: Height::zero(), - }) + .query_channel( + QueryChannelRequest { + port_id: self.src_port_id().clone(), + channel_id: *src_channel_id, + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ChannelError::query(self.src_chain().id(), e))?; // Connection must exist on destination @@ -1211,11 +1232,14 @@ impl Channel { // Channel must exist on destination self.dst_chain() - .query_channel(QueryChannelRequest { - port_id: self.dst_port_id().clone(), - channel_id: *dst_channel_id, - height: Height::zero(), - }) + .query_channel( + QueryChannelRequest { + port_id: self.dst_port_id().clone(), + channel_id: *dst_channel_id, + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ChannelError::query(self.dst_chain().id(), e))?; let signer = self @@ -1275,11 +1299,14 @@ impl Channel { // Channel must exist on source self.src_chain() - .query_channel(QueryChannelRequest { - port_id: self.src_port_id().clone(), - channel_id: *src_channel_id, - height: Height::zero(), - }) + .query_channel( + QueryChannelRequest { + port_id: self.src_port_id().clone(), + channel_id: *src_channel_id, + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| ChannelError::query(self.src_chain().id(), e))?; // Connection must exist on destination diff --git a/relayer/src/link.rs b/relayer/src/link.rs index 1ffddd2d1d..f5854116f3 100644 --- a/relayer/src/link.rs +++ b/relayer/src/link.rs @@ -60,12 +60,15 @@ impl Link { // Check that the packet's channel on source chain is Open let a_channel_id = &opts.src_channel_id; let a_port_id = &opts.src_port_id; - let a_channel = a_chain - .query_channel(QueryChannelRequest { - port_id: opts.src_port_id.clone(), - channel_id: opts.src_channel_id, - height: Height::default(), - }) + let (a_channel, _) = a_chain + .query_channel( + QueryChannelRequest { + port_id: opts.src_port_id.clone(), + channel_id: opts.src_channel_id, + height: Height::default(), + }, + IncludeProof::No, + ) .map_err(|e| { LinkError::channel_not_found(a_port_id.clone(), *a_channel_id, a_chain.id(), e) })?; diff --git a/relayer/src/link/relay_path.rs b/relayer/src/link/relay_path.rs index 96fce59f1f..92b3697d8c 100644 --- a/relayer/src/link/relay_path.rs +++ b/relayer/src/link/relay_path.rs @@ -10,6 +10,7 @@ use tracing::{debug, error, info, span, trace, warn, Level}; use crate::chain::counterparty::unreceived_acknowledgements; use crate::chain::counterparty::unreceived_packets; use crate::chain::handle::ChainHandle; +use crate::chain::requests::IncludeProof; use crate::chain::requests::QueryChannelRequest; use crate::chain::requests::QueryHostConsensusStateRequest; use crate::chain::requests::QueryNextSequenceReceiveRequest; @@ -200,21 +201,29 @@ impl RelayPath { fn src_channel(&self, height: Height) -> Result { self.src_chain() - .query_channel(QueryChannelRequest { - port_id: self.src_port_id().clone(), - channel_id: *self.src_channel_id(), - height, - }) + .query_channel( + QueryChannelRequest { + port_id: self.src_port_id().clone(), + channel_id: *self.src_channel_id(), + height, + }, + IncludeProof::No, + ) + .map(|(channel_end, _)| channel_end) .map_err(|e| LinkError::channel(ChannelError::query(self.src_chain().id(), e))) } fn dst_channel(&self, height: Height) -> Result { self.dst_chain() - .query_channel(QueryChannelRequest { - port_id: self.dst_port_id().clone(), - channel_id: *self.dst_channel_id(), - height, - }) + .query_channel( + QueryChannelRequest { + port_id: self.dst_port_id().clone(), + channel_id: *self.dst_channel_id(), + height, + }, + IncludeProof::No, + ) + .map(|(channel_end, _)| channel_end) .map_err(|e| LinkError::channel(ChannelError::query(self.dst_chain().id(), e))) } diff --git a/relayer/src/supervisor/client_state_filter.rs b/relayer/src/supervisor/client_state_filter.rs index 944718e70c..069454c8ce 100644 --- a/relayer/src/supervisor/client_state_filter.rs +++ b/relayer/src/supervisor/client_state_filter.rs @@ -323,12 +323,15 @@ impl FilterPolicy { .get_or_spawn(chain_id) .map_err(FilterError::spawn)?; - let channel_end = src_chain - .query_channel(QueryChannelRequest { - port_id: port_id.clone(), - channel_id: *channel_id, - height: Height::zero(), - }) + let (channel_end, _) = src_chain + .query_channel( + QueryChannelRequest { + port_id: port_id.clone(), + channel_id: *channel_id, + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(FilterError::relayer)?; let conn_id = channel_end.connection_hops.first().ok_or_else(|| { diff --git a/relayer/src/supervisor/scan.rs b/relayer/src/supervisor/scan.rs index 7128606e0a..cc54d14f0f 100644 --- a/relayer/src/supervisor/scan.rs +++ b/relayer/src/supervisor/scan.rs @@ -715,12 +715,15 @@ fn query_channel( port_id: &PortId, channel_id: &ChannelId, ) -> Result { - let channel_end = chain - .query_channel(QueryChannelRequest { - port_id: port_id.clone(), - channel_id: *channel_id, - height: Height::zero(), - }) + let (channel_end, _) = chain + .query_channel( + QueryChannelRequest { + port_id: port_id.clone(), + channel_id: *channel_id, + height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(Error::query)?; Ok(IdentifiedChannelEnd::new( diff --git a/tools/test-framework/src/relayer/chain.rs b/tools/test-framework/src/relayer/chain.rs index ec5d0e5e22..8230914ce8 100644 --- a/tools/test-framework/src/relayer/chain.rs +++ b/tools/test-framework/src/relayer/chain.rs @@ -231,8 +231,12 @@ where self.value().query_channels(request) } - fn query_channel(&self, request: QueryChannelRequest) -> Result { - self.value().query_channel(request) + fn query_channel( + &self, + request: QueryChannelRequest, + include_proof: IncludeProof, + ) -> Result<(ChannelEnd, Option), Error> { + self.value().query_channel(request, include_proof) } fn query_channel_client_state( diff --git a/tools/test-framework/src/relayer/channel.rs b/tools/test-framework/src/relayer/channel.rs index b7830422c3..560c6d369b 100644 --- a/tools/test-framework/src/relayer/channel.rs +++ b/tools/test-framework/src/relayer/channel.rs @@ -4,7 +4,7 @@ use ibc::core::ics04_channel::channel::State as ChannelState; use ibc::core::ics04_channel::channel::{ChannelEnd, IdentifiedChannelEnd, Order}; use ibc::Height; use ibc_relayer::chain::handle::ChainHandle; -use ibc_relayer::chain::requests::QueryChannelRequest; +use ibc_relayer::chain::requests::{IncludeProof, QueryChannelRequest}; use ibc_relayer::channel::{extract_channel_id, Channel, ChannelSide}; use crate::error::Error; @@ -77,11 +77,14 @@ pub fn query_channel_end( channel_id: &TaggedChannelIdRef, port_id: &TaggedPortIdRef, ) -> Result, Error> { - let channel_end = handle.query_channel(QueryChannelRequest { - port_id: port_id.into_value().clone(), - channel_id: *channel_id.into_value(), - height: Height::zero(), - })?; + let (channel_end, _) = handle.query_channel( + QueryChannelRequest { + port_id: port_id.into_value().clone(), + channel_id: *channel_id.into_value(), + height: Height::zero(), + }, + IncludeProof::No, + )?; Ok(DualTagged::new(channel_end)) } @@ -91,11 +94,14 @@ pub fn query_identified_channel_end( channel_id: TaggedChannelIdRef, port_id: TaggedPortIdRef, ) -> Result, Error> { - let channel_end = handle.query_channel(QueryChannelRequest { - port_id: port_id.into_value().clone(), - channel_id: *channel_id.into_value(), - height: Height::zero(), - })?; + let (channel_end, _) = handle.query_channel( + QueryChannelRequest { + port_id: port_id.into_value().clone(), + channel_id: *channel_id.into_value(), + height: Height::zero(), + }, + IncludeProof::No, + )?; Ok(DualTagged::new(IdentifiedChannelEnd::new( port_id.into_value().clone(), *channel_id.into_value(), From 69891bb1556dc84eaf56fb5bb841b6e28b7114bb Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Thu, 26 May 2022 15:15:34 -0400 Subject: [PATCH 05/19] query_packet_commitment function --- relayer/src/chain.rs | 11 ++++++-- relayer/src/chain/cosmos.rs | 33 +++++++++++++++++++++-- relayer/src/chain/handle.rs | 17 ++++++++++-- relayer/src/chain/handle/base.rs | 19 ++++++++++--- relayer/src/chain/handle/cache.rs | 13 +++++++-- relayer/src/chain/handle/counting.rs | 14 ++++++++-- relayer/src/chain/mock.rs | 13 +++++++-- relayer/src/chain/requests.rs | 8 ++++++ relayer/src/chain/runtime.rs | 19 +++++++++++-- tools/test-framework/src/relayer/chain.rs | 13 +++++++-- 10 files changed, 141 insertions(+), 19 deletions(-) diff --git a/relayer/src/chain.rs b/relayer/src/chain.rs index d7900fb174..44df2b2585 100644 --- a/relayer/src/chain.rs +++ b/relayer/src/chain.rs @@ -43,8 +43,9 @@ use self::requests::{ QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }; use self::tracking::TrackedMsgs; @@ -241,6 +242,12 @@ pub trait ChainEndpoint: Sized { request: QueryChannelClientStateRequest, ) -> Result, Error>; + fn query_packet_commitment( + &self, + request: QueryPacketCommitmentRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error>; + /// Queries all the packet commitments hashes associated with a channel. /// Returns the corresponding packet sequence numbers. fn query_packet_commitments( diff --git a/relayer/src/chain/cosmos.rs b/relayer/src/chain/cosmos.rs index bb2c8edfed..f6aefe84e9 100644 --- a/relayer/src/chain/cosmos.rs +++ b/relayer/src/chain/cosmos.rs @@ -84,8 +84,9 @@ use super::requests::{ QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }; pub mod batch; @@ -1133,6 +1134,34 @@ impl ChainEndpoint for CosmosSdkChain { Ok(client_state) } + fn query_packet_commitment( + &self, + request: QueryPacketCommitmentRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + let data: Path = CommitmentsPath { + port_id: request.port_id, + channel_id: request.channel_id, + sequence: request.sequence, + } + .into(); + + match include_proof { + IncludeProof::Yes => { + let res = self.query(data, request.height, true)?; + + let commitment_proof_bytes = res.proof.ok_or_else(Error::empty_response_proof)?; + + Ok((res.value, Some(commitment_proof_bytes))) + } + IncludeProof::No => { + let res = self.query(data, request.height, false)?; + + Ok((res.value, None)) + } + } + } + /// Queries the packet commitment hashes associated with a channel. fn query_packet_commitments( &self, diff --git a/relayer/src/chain/handle.rs b/relayer/src/chain/handle.rs index 74e0cdf719..f3123226e5 100644 --- a/relayer/src/chain/handle.rs +++ b/relayer/src/chain/handle.rs @@ -48,8 +48,9 @@ use super::{ QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }, tracking::TrackedMsgs, }; @@ -295,6 +296,12 @@ pub enum ChainRequest { reply_to: ReplyTo<(Vec, Proofs)>, }, + QueryPacketCommitment { + request: QueryPacketCommitmentRequest, + include_proof: IncludeProof, + reply_to: ReplyTo<(Vec, Option)>, + }, + QueryPacketCommitments { request: QueryPacketCommitmentsRequest, reply_to: ReplyTo<(Vec, Height)>, @@ -518,6 +525,12 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { height: Height, ) -> Result<(Vec, Proofs), Error>; + fn query_packet_commitment( + &self, + request: QueryPacketCommitmentRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error>; + fn query_packet_commitments( &self, request: QueryPacketCommitmentsRequest, diff --git a/relayer/src/chain/handle/base.rs b/relayer/src/chain/handle/base.rs index 36b056fedc..24219f0914 100644 --- a/relayer/src/chain/handle/base.rs +++ b/relayer/src/chain/handle/base.rs @@ -36,9 +36,10 @@ use crate::{ QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, - QueryPacketAcknowledgementsRequest, QueryPacketCommitmentsRequest, - QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, + QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }, tracking::TrackedMsgs, ChainStatus, @@ -394,6 +395,18 @@ impl ChainHandle for BaseChainHandle { }) } + fn query_packet_commitment( + &self, + request: QueryPacketCommitmentRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + self.send(|reply_to| ChainRequest::QueryPacketCommitment { + request, + include_proof, + reply_to, + }) + } + fn query_packet_commitments( &self, request: QueryPacketCommitmentsRequest, diff --git a/relayer/src/chain/handle/cache.rs b/relayer/src/chain/handle/cache.rs index 649466e155..409a69b339 100644 --- a/relayer/src/chain/handle/cache.rs +++ b/relayer/src/chain/handle/cache.rs @@ -35,8 +35,9 @@ use crate::chain::requests::{ QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }; use crate::chain::tracking::TrackedMsgs; use crate::chain::{ChainStatus, HealthCheck}; @@ -415,6 +416,14 @@ impl ChainHandle for CachingChainHandle { .build_packet_proofs(packet_type, port_id, channel_id, sequence, height) } + fn query_packet_commitment( + &self, + request: QueryPacketCommitmentRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + self.inner().query_packet_commitment(request, include_proof) + } + fn query_packet_commitments( &self, request: QueryPacketCommitmentsRequest, diff --git a/relayer/src/chain/handle/counting.rs b/relayer/src/chain/handle/counting.rs index c264975a14..49c4d11197 100644 --- a/relayer/src/chain/handle/counting.rs +++ b/relayer/src/chain/handle/counting.rs @@ -35,8 +35,9 @@ use crate::chain::requests::{ QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }; use crate::chain::tracking::TrackedMsgs; use crate::chain::{ChainStatus, HealthCheck}; @@ -392,6 +393,15 @@ impl ChainHandle for CountingChainHandle { .build_packet_proofs(packet_type, port_id, channel_id, sequence, height) } + fn query_packet_commitment( + &self, + request: QueryPacketCommitmentRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + self.inc_metric("query_packet_commitment"); + self.inner().query_packet_commitment(request, include_proof) + } + fn query_packet_commitments( &self, request: QueryPacketCommitmentsRequest, diff --git a/relayer/src/chain/mock.rs b/relayer/src/chain/mock.rs index a682c25b25..834cf2ed92 100644 --- a/relayer/src/chain/mock.rs +++ b/relayer/src/chain/mock.rs @@ -47,8 +47,9 @@ use super::requests::{ QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }; use super::tracking::TrackedMsgs; use super::HealthCheck; @@ -259,6 +260,14 @@ impl ChainEndpoint for MockChain { unimplemented!() } + fn query_packet_commitment( + &self, + _request: QueryPacketCommitmentRequest, + _include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + unimplemented!() + } + fn query_packet_commitments( &self, _request: QueryPacketCommitmentsRequest, diff --git a/relayer/src/chain/requests.rs b/relayer/src/chain/requests.rs index 4de5365882..8596898622 100644 --- a/relayer/src/chain/requests.rs +++ b/relayer/src/chain/requests.rs @@ -207,6 +207,14 @@ impl From for RawQueryChannelClientStateRequest } } +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct QueryPacketCommitmentRequest { + pub port_id: PortId, + pub channel_id: ChannelId, + pub sequence: Sequence, + pub height: Height, +} + #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] pub struct QueryPacketCommitmentsRequest { pub port_id: PortId, diff --git a/relayer/src/chain/runtime.rs b/relayer/src/chain/runtime.rs index e052bddff5..92c87f7842 100644 --- a/relayer/src/chain/runtime.rs +++ b/relayer/src/chain/runtime.rs @@ -54,8 +54,9 @@ use super::{ QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }, tracking::TrackedMsgs, ChainEndpoint, ChainStatus, HealthCheck, @@ -377,6 +378,10 @@ where self.build_packet_proofs(packet_type, port_id, channel_id, sequence, height, reply_to)? }, + Ok(ChainRequest::QueryPacketCommitment { request, include_proof, reply_to }) => { + self.query_packet_commitment(request, include_proof, reply_to)? + }, + Ok(ChainRequest::QueryPacketCommitments { request, reply_to }) => { self.query_packet_commitments(request, reply_to)? }, @@ -779,6 +784,16 @@ where reply_to.send(result).map_err(Error::send) } + fn query_packet_commitment( + &self, + request: QueryPacketCommitmentRequest, + include_proof: IncludeProof, + reply_to: ReplyTo<(Vec, Option)>, + ) -> Result<(), Error> { + let result = self.chain.query_packet_commitment(request, include_proof); + reply_to.send(result).map_err(Error::send) + } + fn query_packet_commitments( &self, request: QueryPacketCommitmentsRequest, diff --git a/tools/test-framework/src/relayer/chain.rs b/tools/test-framework/src/relayer/chain.rs index 8230914ce8..b50abdcda0 100644 --- a/tools/test-framework/src/relayer/chain.rs +++ b/tools/test-framework/src/relayer/chain.rs @@ -54,8 +54,9 @@ use ibc_relayer::chain::requests::{ QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }; use ibc_relayer::chain::tracking::TrackedMsgs; use ibc_relayer::chain::{ChainStatus, HealthCheck}; @@ -331,6 +332,14 @@ where .build_packet_proofs(packet_type, port_id, channel_id, sequence, height) } + fn query_packet_commitment( + &self, + request: QueryPacketCommitmentRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + self.value().query_packet_commitment(request, include_proof) + } + fn query_packet_commitments( &self, request: QueryPacketCommitmentsRequest, From 76002e364d3062e51c1f1d564ecd1ca2cbd656e0 Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Thu, 26 May 2022 15:38:19 -0400 Subject: [PATCH 06/19] query_packet_acknowledgement --- relayer/src/chain.rs | 14 ++++++--- relayer/src/chain/cosmos.rs | 36 ++++++++++++++++++++--- relayer/src/chain/handle.rs | 20 ++++++++++--- relayer/src/chain/handle/base.rs | 22 ++++++++++---- relayer/src/chain/handle/cache.rs | 17 ++++++++--- relayer/src/chain/handle/counting.rs | 18 +++++++++--- relayer/src/chain/mock.rs | 16 +++++++--- relayer/src/chain/requests.rs | 8 +++++ relayer/src/chain/runtime.rs | 26 ++++++++++++---- tools/test-framework/src/relayer/chain.rs | 17 ++++++++--- 10 files changed, 156 insertions(+), 38 deletions(-) diff --git a/relayer/src/chain.rs b/relayer/src/chain.rs index 44df2b2585..0759ae800f 100644 --- a/relayer/src/chain.rs +++ b/relayer/src/chain.rs @@ -42,10 +42,10 @@ use self::requests::{ QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, - QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, - QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, - QueryUpgradedConsensusStateRequest, + QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, + QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, + QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, + QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, }; use self::tracking::TrackedMsgs; @@ -262,6 +262,12 @@ pub trait ChainEndpoint: Sized { request: QueryUnreceivedPacketsRequest, ) -> Result, Error>; + fn query_packet_acknowledgement( + &self, + request: QueryPacketAcknowledgementRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error>; + /// Queries all the packet acknowledgements associated with a channel. /// Returns the corresponding packet sequence numbers. fn query_packet_acknowledgements( diff --git a/relayer/src/chain/cosmos.rs b/relayer/src/chain/cosmos.rs index f6aefe84e9..ab9b9f031d 100644 --- a/relayer/src/chain/cosmos.rs +++ b/relayer/src/chain/cosmos.rs @@ -83,10 +83,10 @@ use super::requests::{ QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, - QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, - QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, - QueryUpgradedConsensusStateRequest, + QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, + QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, + QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, + QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, }; pub mod batch; @@ -1231,6 +1231,34 @@ impl ChainEndpoint for CosmosSdkChain { .collect()) } + fn query_packet_acknowledgement( + &self, + request: QueryPacketAcknowledgementRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + let data: Path = AcksPath { + port_id: request.port_id, + channel_id: request.channel_id, + sequence: request.sequence, + } + .into(); + + match include_proof { + IncludeProof::Yes => { + let res = self.query(data, request.height, true)?; + + let commitment_proof_bytes = res.proof.ok_or_else(Error::empty_response_proof)?; + + Ok((res.value, Some(commitment_proof_bytes))) + } + IncludeProof::No => { + let res = self.query(data, request.height, false)?; + + Ok((res.value, None)) + } + } + } + /// Queries the packet acknowledgment hashes associated with a channel. fn query_packet_acknowledgements( &self, diff --git a/relayer/src/chain/handle.rs b/relayer/src/chain/handle.rs index f3123226e5..75abb66035 100644 --- a/relayer/src/chain/handle.rs +++ b/relayer/src/chain/handle.rs @@ -47,10 +47,10 @@ use super::{ QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, - QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, - QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, - QueryUpgradedConsensusStateRequest, + QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, + QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, + QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, + QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, }, tracking::TrackedMsgs, }; @@ -313,6 +313,12 @@ pub enum ChainRequest { }, QueryPacketAcknowledgement { + request: QueryPacketAcknowledgementRequest, + include_proof: IncludeProof, + reply_to: ReplyTo<(Vec, Option)>, + }, + + QueryPacketAcknowledgements { request: QueryPacketAcknowledgementsRequest, reply_to: ReplyTo<(Vec, Height)>, }, @@ -541,6 +547,12 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { request: QueryUnreceivedPacketsRequest, ) -> Result, Error>; + fn query_packet_acknowledgement( + &self, + request: QueryPacketAcknowledgementRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error>; + fn query_packet_acknowledgements( &self, request: QueryPacketAcknowledgementsRequest, diff --git a/relayer/src/chain/handle/base.rs b/relayer/src/chain/handle/base.rs index 24219f0914..32548a04a9 100644 --- a/relayer/src/chain/handle/base.rs +++ b/relayer/src/chain/handle/base.rs @@ -36,10 +36,10 @@ use crate::{ QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, - QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, - QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, - QueryUpgradedConsensusStateRequest, + QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementsRequest, + QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, + QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, + QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, }, tracking::TrackedMsgs, ChainStatus, @@ -421,11 +421,23 @@ impl ChainHandle for BaseChainHandle { self.send(|reply_to| ChainRequest::QueryUnreceivedPackets { request, reply_to }) } + fn query_packet_acknowledgement( + &self, + request: QueryPacketAcknowledgementRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + self.send(|reply_to| ChainRequest::QueryPacketAcknowledgement { + request, + include_proof, + reply_to, + }) + } + fn query_packet_acknowledgements( &self, request: QueryPacketAcknowledgementsRequest, ) -> Result<(Vec, Height), Error> { - self.send(|reply_to| ChainRequest::QueryPacketAcknowledgement { request, reply_to }) + self.send(|reply_to| ChainRequest::QueryPacketAcknowledgements { request, reply_to }) } fn query_unreceived_acknowledgement( diff --git a/relayer/src/chain/handle/cache.rs b/relayer/src/chain/handle/cache.rs index 409a69b339..9bf3849407 100644 --- a/relayer/src/chain/handle/cache.rs +++ b/relayer/src/chain/handle/cache.rs @@ -34,10 +34,10 @@ use crate::chain::requests::{ QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, - QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, - QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, - QueryUpgradedConsensusStateRequest, + QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, + QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, + QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, + QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, }; use crate::chain::tracking::TrackedMsgs; use crate::chain::{ChainStatus, HealthCheck}; @@ -438,6 +438,15 @@ impl ChainHandle for CachingChainHandle { self.inner().query_unreceived_packets(request) } + fn query_packet_acknowledgement( + &self, + request: QueryPacketAcknowledgementRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + self.inner() + .query_packet_acknowledgement(request, include_proof) + } + fn query_packet_acknowledgements( &self, request: QueryPacketAcknowledgementsRequest, diff --git a/relayer/src/chain/handle/counting.rs b/relayer/src/chain/handle/counting.rs index 49c4d11197..3606bbcf44 100644 --- a/relayer/src/chain/handle/counting.rs +++ b/relayer/src/chain/handle/counting.rs @@ -34,10 +34,10 @@ use crate::chain::requests::{ QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, - QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, - QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, - QueryUpgradedConsensusStateRequest, + QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, + QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, + QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, + QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, }; use crate::chain::tracking::TrackedMsgs; use crate::chain::{ChainStatus, HealthCheck}; @@ -418,6 +418,16 @@ impl ChainHandle for CountingChainHandle { self.inner().query_unreceived_packets(request) } + fn query_packet_acknowledgement( + &self, + request: QueryPacketAcknowledgementRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + self.inc_metric("query_packet_acknowledgement"); + self.inner() + .query_packet_acknowledgement(request, include_proof) + } + fn query_packet_acknowledgements( &self, request: QueryPacketAcknowledgementsRequest, diff --git a/relayer/src/chain/mock.rs b/relayer/src/chain/mock.rs index 834cf2ed92..f2dc45186b 100644 --- a/relayer/src/chain/mock.rs +++ b/relayer/src/chain/mock.rs @@ -46,10 +46,10 @@ use super::requests::{ IncludeProof, QueryChannelsRequest, QueryClientConnectionsRequest, QueryClientStateRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, - QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, - QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, - QueryUpgradedConsensusStateRequest, + QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, + QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, + QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, + QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, }; use super::tracking::TrackedMsgs; use super::HealthCheck; @@ -282,6 +282,14 @@ impl ChainEndpoint for MockChain { unimplemented!() } + fn query_packet_acknowledgement( + &self, + _request: QueryPacketAcknowledgementRequest, + _include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + unimplemented!() + } + fn query_packet_acknowledgements( &self, _request: QueryPacketAcknowledgementsRequest, diff --git a/relayer/src/chain/requests.rs b/relayer/src/chain/requests.rs index 8596898622..09c7c4e8ed 100644 --- a/relayer/src/chain/requests.rs +++ b/relayer/src/chain/requests.rs @@ -253,6 +253,14 @@ impl From for RawQueryUnreceivedPacketsRequest { } } +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct QueryPacketAcknowledgementRequest { + pub port_id: PortId, + pub channel_id: ChannelId, + pub sequence: Sequence, + pub height: Height, +} + #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] pub struct QueryPacketAcknowledgementsRequest { pub port_id: PortId, diff --git a/relayer/src/chain/runtime.rs b/relayer/src/chain/runtime.rs index 92c87f7842..8c0baa4dcd 100644 --- a/relayer/src/chain/runtime.rs +++ b/relayer/src/chain/runtime.rs @@ -53,10 +53,10 @@ use super::{ QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, - QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, - QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, - QueryUpgradedConsensusStateRequest, + QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, + QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, + QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, + QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, }, tracking::TrackedMsgs, ChainEndpoint, ChainStatus, HealthCheck, @@ -390,7 +390,11 @@ where self.query_unreceived_packets(request, reply_to)? }, - Ok(ChainRequest::QueryPacketAcknowledgement { request, reply_to }) => { + Ok(ChainRequest::QueryPacketAcknowledgement { request, include_proof, reply_to }) => { + self.query_packet_acknowledgement(request, include_proof, reply_to)? + }, + + Ok(ChainRequest::QueryPacketAcknowledgements { request, reply_to }) => { self.query_packet_acknowledgements(request, reply_to)? }, @@ -812,6 +816,18 @@ where reply_to.send(result).map_err(Error::send) } + fn query_packet_acknowledgement( + &self, + request: QueryPacketAcknowledgementRequest, + include_proof: IncludeProof, + reply_to: ReplyTo<(Vec, Option)>, + ) -> Result<(), Error> { + let result = self + .chain + .query_packet_acknowledgement(request, include_proof); + reply_to.send(result).map_err(Error::send) + } + fn query_packet_acknowledgements( &self, request: QueryPacketAcknowledgementsRequest, diff --git a/tools/test-framework/src/relayer/chain.rs b/tools/test-framework/src/relayer/chain.rs index b50abdcda0..48066314de 100644 --- a/tools/test-framework/src/relayer/chain.rs +++ b/tools/test-framework/src/relayer/chain.rs @@ -53,10 +53,10 @@ use ibc_relayer::chain::requests::{ QueryClientConnectionsRequest, QueryClientStateRequest, QueryClientStatesRequest, QueryConnectionChannelsRequest, QueryConnectionRequest, QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, - QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, - QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, - QueryUpgradedConsensusStateRequest, + QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, + QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, + QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, + QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, }; use ibc_relayer::chain::tracking::TrackedMsgs; use ibc_relayer::chain::{ChainStatus, HealthCheck}; @@ -354,6 +354,15 @@ where self.value().query_unreceived_packets(request) } + fn query_packet_acknowledgement( + &self, + request: QueryPacketAcknowledgementRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + self.value() + .query_packet_acknowledgement(request, include_proof) + } + fn query_packet_acknowledgements( &self, request: QueryPacketAcknowledgementsRequest, From 3f8f927a96236fbb03812227d5271adbf5568ac2 Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Thu, 26 May 2022 15:54:12 -0400 Subject: [PATCH 07/19] query_packet_receipt --- relayer/src/chain.rs | 11 ++++++-- relayer/src/chain/cosmos.rs | 33 +++++++++++++++++++++-- relayer/src/chain/handle.rs | 17 ++++++++++-- relayer/src/chain/handle/base.rs | 14 +++++++++- relayer/src/chain/handle/cache.rs | 13 +++++++-- relayer/src/chain/handle/counting.rs | 14 ++++++++-- relayer/src/chain/mock.rs | 13 +++++++-- relayer/src/chain/requests.rs | 8 ++++++ relayer/src/chain/runtime.rs | 19 +++++++++++-- tools/test-framework/src/relayer/chain.rs | 13 +++++++-- 10 files changed, 138 insertions(+), 17 deletions(-) diff --git a/relayer/src/chain.rs b/relayer/src/chain.rs index 0759ae800f..9b9514436f 100644 --- a/relayer/src/chain.rs +++ b/relayer/src/chain.rs @@ -44,8 +44,9 @@ use self::requests::{ QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentsRequest, QueryPacketReceiptRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }; use self::tracking::TrackedMsgs; @@ -255,6 +256,12 @@ pub trait ChainEndpoint: Sized { request: QueryPacketCommitmentsRequest, ) -> Result<(Vec, ICSHeight), Error>; + fn query_packet_receipt( + &self, + request: QueryPacketReceiptRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error>; + /// Queries all the unreceived IBC packets associated with a channel and packet commit sequences. /// Returns the corresponding packet sequence numbers. fn query_unreceived_packets( diff --git a/relayer/src/chain/cosmos.rs b/relayer/src/chain/cosmos.rs index ab9b9f031d..eeca28760e 100644 --- a/relayer/src/chain/cosmos.rs +++ b/relayer/src/chain/cosmos.rs @@ -85,8 +85,9 @@ use super::requests::{ QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentsRequest, QueryPacketReceiptRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }; pub mod batch; @@ -1200,6 +1201,34 @@ impl ChainEndpoint for CosmosSdkChain { Ok((commitment_sequences, height)) } + fn query_packet_receipt( + &self, + request: QueryPacketReceiptRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + let data: Path = ReceiptsPath { + port_id: request.port_id, + channel_id: request.channel_id, + sequence: request.sequence, + } + .into(); + + match include_proof { + IncludeProof::Yes => { + let res = self.query(data, request.height, true)?; + + let commitment_proof_bytes = res.proof.ok_or_else(Error::empty_response_proof)?; + + Ok((res.value, Some(commitment_proof_bytes))) + } + IncludeProof::No => { + let res = self.query(data, request.height, false)?; + + Ok((res.value, None)) + } + } + } + /// Queries the unreceived packet sequences associated with a channel. fn query_unreceived_packets( &self, diff --git a/relayer/src/chain/handle.rs b/relayer/src/chain/handle.rs index 75abb66035..fd9d11e08c 100644 --- a/relayer/src/chain/handle.rs +++ b/relayer/src/chain/handle.rs @@ -49,8 +49,9 @@ use super::{ QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentsRequest, QueryPacketReceiptRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }, tracking::TrackedMsgs, }; @@ -307,6 +308,12 @@ pub enum ChainRequest { reply_to: ReplyTo<(Vec, Height)>, }, + QueryPacketReceipt { + request: QueryPacketReceiptRequest, + include_proof: IncludeProof, + reply_to: ReplyTo<(Vec, Option)>, + }, + QueryUnreceivedPackets { request: QueryUnreceivedPacketsRequest, reply_to: ReplyTo>, @@ -542,6 +549,12 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { request: QueryPacketCommitmentsRequest, ) -> Result<(Vec, Height), Error>; + fn query_packet_receipt( + &self, + request: QueryPacketReceiptRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error>; + fn query_unreceived_packets( &self, request: QueryUnreceivedPacketsRequest, diff --git a/relayer/src/chain/handle/base.rs b/relayer/src/chain/handle/base.rs index 32548a04a9..f6000a9cf4 100644 --- a/relayer/src/chain/handle/base.rs +++ b/relayer/src/chain/handle/base.rs @@ -37,7 +37,7 @@ use crate::{ QueryConnectionsRequest, QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementsRequest, - QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, + QueryPacketCommitmentRequest, QueryPacketCommitmentsRequest, QueryPacketReceiptRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, }, @@ -414,6 +414,18 @@ impl ChainHandle for BaseChainHandle { self.send(|reply_to| ChainRequest::QueryPacketCommitments { request, reply_to }) } + fn query_packet_receipt( + &self, + request: QueryPacketReceiptRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + self.send(|reply_to| ChainRequest::QueryPacketReceipt { + request, + include_proof, + reply_to, + }) + } + fn query_unreceived_packets( &self, request: QueryUnreceivedPacketsRequest, diff --git a/relayer/src/chain/handle/cache.rs b/relayer/src/chain/handle/cache.rs index 9bf3849407..8edf458e12 100644 --- a/relayer/src/chain/handle/cache.rs +++ b/relayer/src/chain/handle/cache.rs @@ -36,8 +36,9 @@ use crate::chain::requests::{ QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentsRequest, QueryPacketReceiptRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }; use crate::chain::tracking::TrackedMsgs; use crate::chain::{ChainStatus, HealthCheck}; @@ -431,6 +432,14 @@ impl ChainHandle for CachingChainHandle { self.inner().query_packet_commitments(request) } + fn query_packet_receipt( + &self, + request: QueryPacketReceiptRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + self.inner().query_packet_receipt(request, include_proof) + } + fn query_unreceived_packets( &self, request: QueryUnreceivedPacketsRequest, diff --git a/relayer/src/chain/handle/counting.rs b/relayer/src/chain/handle/counting.rs index 3606bbcf44..f9885004f2 100644 --- a/relayer/src/chain/handle/counting.rs +++ b/relayer/src/chain/handle/counting.rs @@ -36,8 +36,9 @@ use crate::chain::requests::{ QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentsRequest, QueryPacketReceiptRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }; use crate::chain::tracking::TrackedMsgs; use crate::chain::{ChainStatus, HealthCheck}; @@ -410,6 +411,15 @@ impl ChainHandle for CountingChainHandle { self.inner().query_packet_commitments(request) } + fn query_packet_receipt( + &self, + request: QueryPacketReceiptRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + self.inc_metric("query_packet_receipt"); + self.inner().query_packet_receipt(request, include_proof) + } + fn query_unreceived_packets( &self, request: QueryUnreceivedPacketsRequest, diff --git a/relayer/src/chain/mock.rs b/relayer/src/chain/mock.rs index f2dc45186b..8549cb3274 100644 --- a/relayer/src/chain/mock.rs +++ b/relayer/src/chain/mock.rs @@ -48,8 +48,9 @@ use super::requests::{ QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentsRequest, QueryPacketReceiptRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }; use super::tracking::TrackedMsgs; use super::HealthCheck; @@ -275,6 +276,14 @@ impl ChainEndpoint for MockChain { unimplemented!() } + fn query_packet_receipt( + &self, + _request: QueryPacketReceiptRequest, + _include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + unimplemented!() + } + fn query_unreceived_packets( &self, _request: QueryUnreceivedPacketsRequest, diff --git a/relayer/src/chain/requests.rs b/relayer/src/chain/requests.rs index 09c7c4e8ed..98cbd2058c 100644 --- a/relayer/src/chain/requests.rs +++ b/relayer/src/chain/requests.rs @@ -232,6 +232,14 @@ impl From for RawQueryPacketCommitmentsRequest { } } +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct QueryPacketReceiptRequest { + pub port_id: PortId, + pub channel_id: ChannelId, + pub sequence: Sequence, + pub height: Height, +} + #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] pub struct QueryUnreceivedPacketsRequest { pub port_id: PortId, diff --git a/relayer/src/chain/runtime.rs b/relayer/src/chain/runtime.rs index 8c0baa4dcd..87e45eb1d4 100644 --- a/relayer/src/chain/runtime.rs +++ b/relayer/src/chain/runtime.rs @@ -55,8 +55,9 @@ use super::{ QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentsRequest, QueryPacketReceiptRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }, tracking::TrackedMsgs, ChainEndpoint, ChainStatus, HealthCheck, @@ -386,6 +387,10 @@ where self.query_packet_commitments(request, reply_to)? }, + Ok(ChainRequest::QueryPacketReceipt { request, include_proof, reply_to }) => { + self.query_packet_receipt(request, include_proof, reply_to)? + }, + Ok(ChainRequest::QueryUnreceivedPackets { request, reply_to }) => { self.query_unreceived_packets(request, reply_to)? }, @@ -807,6 +812,16 @@ where reply_to.send(result).map_err(Error::send) } + fn query_packet_receipt( + &self, + request: QueryPacketReceiptRequest, + include_proof: IncludeProof, + reply_to: ReplyTo<(Vec, Option)>, + ) -> Result<(), Error> { + let result = self.chain.query_packet_receipt(request, include_proof); + reply_to.send(result).map_err(Error::send) + } + fn query_unreceived_packets( &self, request: QueryUnreceivedPacketsRequest, diff --git a/tools/test-framework/src/relayer/chain.rs b/tools/test-framework/src/relayer/chain.rs index 48066314de..c3491846e4 100644 --- a/tools/test-framework/src/relayer/chain.rs +++ b/tools/test-framework/src/relayer/chain.rs @@ -55,8 +55,9 @@ use ibc_relayer::chain::requests::{ QueryConsensusStateRequest, QueryConsensusStatesRequest, QueryHostConsensusStateRequest, QueryNextSequenceReceiveRequest, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementsRequest, QueryPacketCommitmentRequest, - QueryPacketCommitmentsRequest, QueryUnreceivedAcksRequest, QueryUnreceivedPacketsRequest, - QueryUpgradedClientStateRequest, QueryUpgradedConsensusStateRequest, + QueryPacketCommitmentsRequest, QueryPacketReceiptRequest, QueryUnreceivedAcksRequest, + QueryUnreceivedPacketsRequest, QueryUpgradedClientStateRequest, + QueryUpgradedConsensusStateRequest, }; use ibc_relayer::chain::tracking::TrackedMsgs; use ibc_relayer::chain::{ChainStatus, HealthCheck}; @@ -347,6 +348,14 @@ where self.value().query_packet_commitments(request) } + fn query_packet_receipt( + &self, + request: QueryPacketReceiptRequest, + include_proof: IncludeProof, + ) -> Result<(Vec, Option), Error> { + self.value().query_packet_receipt(request, include_proof) + } + fn query_unreceived_packets( &self, request: QueryUnreceivedPacketsRequest, From 5d296ead195d271ed575db41420e02d52ab44c1e Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Fri, 27 May 2022 13:53:17 -0400 Subject: [PATCH 08/19] query_next_sequence_receive --- relayer/src/chain.rs | 3 +- relayer/src/chain/cosmos.rs | 49 ++++++++++++++++------- relayer/src/chain/handle.rs | 6 ++- relayer/src/chain/handle/base.rs | 9 ++++- relayer/src/chain/handle/cache.rs | 6 ++- relayer/src/chain/handle/counting.rs | 6 ++- relayer/src/chain/mock.rs | 3 +- relayer/src/chain/requests.rs | 1 + relayer/src/chain/runtime.rs | 11 +++-- relayer/src/link/relay_path.rs | 15 ++++--- tools/test-framework/src/relayer/chain.rs | 6 ++- 11 files changed, 80 insertions(+), 35 deletions(-) diff --git a/relayer/src/chain.rs b/relayer/src/chain.rs index 9b9514436f..013b3183ad 100644 --- a/relayer/src/chain.rs +++ b/relayer/src/chain.rs @@ -292,7 +292,8 @@ pub trait ChainEndpoint: Sized { fn query_next_sequence_receive( &self, request: QueryNextSequenceReceiveRequest, - ) -> Result; + include_proof: IncludeProof, + ) -> Result<(Sequence, Option), Error>; fn query_txs(&self, request: QueryTxRequest) -> Result, Error>; diff --git a/relayer/src/chain/cosmos.rs b/relayer/src/chain/cosmos.rs index eeca28760e..ed14571e07 100644 --- a/relayer/src/chain/cosmos.rs +++ b/relayer/src/chain/cosmos.rs @@ -1,4 +1,5 @@ use alloc::sync::Arc; +use bytes::{Buf, Bytes}; use core::{ convert::{TryFrom, TryInto}, future::Future, @@ -1359,26 +1360,46 @@ impl ChainEndpoint for CosmosSdkChain { fn query_next_sequence_receive( &self, request: QueryNextSequenceReceiveRequest, - ) -> Result { + include_proof: IncludeProof, + ) -> Result<(Sequence, Option), Error> { crate::time!("query_next_sequence_receive"); crate::telemetry!(query, self.id(), "query_next_sequence_receive"); - let mut client = self - .block_on( - ibc_proto::ibc::core::channel::v1::query_client::QueryClient::connect( - self.grpc_addr.clone(), - ), - ) - .map_err(Error::grpc_transport)?; + match include_proof { + IncludeProof::Yes => { + let data: Path = SeqRecvsPath(request.port_id, request.channel_id).into(); - let request = tonic::Request::new(request.into()); + let res = self.query(data, request.height, true)?; + // Note: We expect the return to be a u64 encoded in big-endian. Refer to ibc-go: + // https://github.com/cosmos/ibc-go/blob/25767f6bdb5bab2c2a116b41d92d753c93e18121/modules/core/04-channel/client/utils/utils.go#L191 + if res.value.len() != 8 { + return Err(Error::query("next_sequence_receive".into())); + } + let seq: Sequence = Bytes::from(res.value).get_u64().into(); - let response = self - .block_on(client.next_sequence_receive(request)) - .map_err(Error::grpc_status)? - .into_inner(); + let commitment_proof_bytes = res.proof.ok_or_else(Error::empty_response_proof)?; + + Ok((seq, Some(commitment_proof_bytes))) + } + IncludeProof::No => { + let mut client = self + .block_on( + ibc_proto::ibc::core::channel::v1::query_client::QueryClient::connect( + self.grpc_addr.clone(), + ), + ) + .map_err(Error::grpc_transport)?; + + let request = tonic::Request::new(request.into()); - Ok(Sequence::from(response.next_sequence_receive)) + let response = self + .block_on(client.next_sequence_receive(request)) + .map_err(Error::grpc_status)? + .into_inner(); + + Ok((Sequence::from(response.next_sequence_receive), None)) + } + } } /// This function queries transactions for events matching certain criteria. diff --git a/relayer/src/chain/handle.rs b/relayer/src/chain/handle.rs index fd9d11e08c..e8d7b51d1d 100644 --- a/relayer/src/chain/handle.rs +++ b/relayer/src/chain/handle.rs @@ -271,7 +271,8 @@ pub enum ChainRequest { QueryNextSequenceReceive { request: QueryNextSequenceReceiveRequest, - reply_to: ReplyTo, + include_proof: IncludeProof, + reply_to: ReplyTo<(Sequence, Option)>, }, ProvenClientConsensus { @@ -461,7 +462,8 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { fn query_next_sequence_receive( &self, request: QueryNextSequenceReceiveRequest, - ) -> Result; + include_proof: IncludeProof, + ) -> Result<(Sequence, Option), Error>; fn query_channels( &self, diff --git a/relayer/src/chain/handle/base.rs b/relayer/src/chain/handle/base.rs index f6000a9cf4..7b14e95aae 100644 --- a/relayer/src/chain/handle/base.rs +++ b/relayer/src/chain/handle/base.rs @@ -249,8 +249,13 @@ impl ChainHandle for BaseChainHandle { fn query_next_sequence_receive( &self, request: QueryNextSequenceReceiveRequest, - ) -> Result { - self.send(|reply_to| ChainRequest::QueryNextSequenceReceive { request, reply_to }) + include_proof: IncludeProof, + ) -> Result<(Sequence, Option), Error> { + self.send(|reply_to| ChainRequest::QueryNextSequenceReceive { + request, + include_proof, + reply_to, + }) } fn query_channels( diff --git a/relayer/src/chain/handle/cache.rs b/relayer/src/chain/handle/cache.rs index 8edf458e12..0b01e3cd33 100644 --- a/relayer/src/chain/handle/cache.rs +++ b/relayer/src/chain/handle/cache.rs @@ -283,8 +283,10 @@ impl ChainHandle for CachingChainHandle { fn query_next_sequence_receive( &self, request: QueryNextSequenceReceiveRequest, - ) -> Result { - self.inner().query_next_sequence_receive(request) + include_proof: IncludeProof, + ) -> Result<(Sequence, Option), Error> { + self.inner() + .query_next_sequence_receive(request, include_proof) } fn query_channels( diff --git a/relayer/src/chain/handle/counting.rs b/relayer/src/chain/handle/counting.rs index f9885004f2..54dde6f5f6 100644 --- a/relayer/src/chain/handle/counting.rs +++ b/relayer/src/chain/handle/counting.rs @@ -271,9 +271,11 @@ impl ChainHandle for CountingChainHandle { fn query_next_sequence_receive( &self, request: QueryNextSequenceReceiveRequest, - ) -> Result { + include_proof: IncludeProof, + ) -> Result<(Sequence, Option), Error> { self.inc_metric("query_next_sequence_receive"); - self.inner().query_next_sequence_receive(request) + self.inner() + .query_next_sequence_receive(request, include_proof) } fn query_channels( diff --git a/relayer/src/chain/mock.rs b/relayer/src/chain/mock.rs index 8549cb3274..121a818562 100644 --- a/relayer/src/chain/mock.rs +++ b/relayer/src/chain/mock.rs @@ -316,7 +316,8 @@ impl ChainEndpoint for MockChain { fn query_next_sequence_receive( &self, _request: QueryNextSequenceReceiveRequest, - ) -> Result { + _include_proof: IncludeProof, + ) -> Result<(Sequence, Option), Error> { unimplemented!() } diff --git a/relayer/src/chain/requests.rs b/relayer/src/chain/requests.rs index 98cbd2058c..027df4e3d4 100644 --- a/relayer/src/chain/requests.rs +++ b/relayer/src/chain/requests.rs @@ -317,6 +317,7 @@ impl From for RawQueryUnreceivedAcksRequest { pub struct QueryNextSequenceReceiveRequest { pub port_id: PortId, pub channel_id: ChannelId, + pub height: Height, } impl From for RawQueryNextSequenceReceiveRequest { diff --git a/relayer/src/chain/runtime.rs b/relayer/src/chain/runtime.rs index 87e45eb1d4..d113574750 100644 --- a/relayer/src/chain/runtime.rs +++ b/relayer/src/chain/runtime.rs @@ -407,8 +407,8 @@ where self.query_unreceived_acknowledgement(request, reply_to)? }, - Ok(ChainRequest::QueryNextSequenceReceive { request, reply_to }) => { - self.query_next_sequence_receive(request, reply_to)? + Ok(ChainRequest::QueryNextSequenceReceive { request, include_proof, reply_to }) => { + self.query_next_sequence_receive(request, include_proof, reply_to)? }, Ok(ChainRequest::QueryPacketEventDataFromTxs { request, reply_to }) => { @@ -864,9 +864,12 @@ where fn query_next_sequence_receive( &self, request: QueryNextSequenceReceiveRequest, - reply_to: ReplyTo, + include_proof: IncludeProof, + reply_to: ReplyTo<(Sequence, Option)>, ) -> Result<(), Error> { - let result = self.chain.query_next_sequence_receive(request); + let result = self + .chain + .query_next_sequence_receive(request, include_proof); reply_to.send(result).map_err(Error::send) } diff --git a/relayer/src/link/relay_path.rs b/relayer/src/link/relay_path.rs index 92b3697d8c..870a8d9516 100644 --- a/relayer/src/link/relay_path.rs +++ b/relayer/src/link/relay_path.rs @@ -1185,13 +1185,18 @@ impl RelayPath { debug!("build timeout for channel"); let (packet_type, next_sequence_received) = if self.ordered_channel() { - let next_seq = self + let (next_seq, _) = self .dst_chain() - .query_next_sequence_receive(QueryNextSequenceReceiveRequest { - port_id: self.dst_port_id().clone(), - channel_id: *dst_channel_id, - }) + .query_next_sequence_receive( + QueryNextSequenceReceiveRequest { + port_id: self.dst_port_id().clone(), + channel_id: *dst_channel_id, + height, + }, + IncludeProof::No, + ) .map_err(|e| LinkError::query(self.dst_chain().id(), e))?; + (PacketMsgType::TimeoutOrdered, next_seq) } else { (PacketMsgType::TimeoutUnordered, packet.sequence) diff --git a/tools/test-framework/src/relayer/chain.rs b/tools/test-framework/src/relayer/chain.rs index c3491846e4..3201258543 100644 --- a/tools/test-framework/src/relayer/chain.rs +++ b/tools/test-framework/src/relayer/chain.rs @@ -222,8 +222,10 @@ where fn query_next_sequence_receive( &self, request: QueryNextSequenceReceiveRequest, - ) -> Result { - self.value().query_next_sequence_receive(request) + include_proof: IncludeProof, + ) -> Result<(Sequence, Option), Error> { + self.value() + .query_next_sequence_receive(request, include_proof) } fn query_channels( From a7ec4bb12471de6c35c6f7ca21daa557e2b52e3e Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Fri, 27 May 2022 14:10:36 -0400 Subject: [PATCH 09/19] use request instead of build_packet_proofs where appropriate --- relayer-cli/src/commands/query/packet/ack.rs | 20 ++++++++++--------- .../src/commands/query/packet/commitment.rs | 20 ++++++++++--------- relayer/src/link/relay_path.rs | 15 ++++++++------ 3 files changed, 31 insertions(+), 24 deletions(-) diff --git a/relayer-cli/src/commands/query/packet/ack.rs b/relayer-cli/src/commands/query/packet/ack.rs index afbbd07c99..cfd45e3b3f 100644 --- a/relayer-cli/src/commands/query/packet/ack.rs +++ b/relayer-cli/src/commands/query/packet/ack.rs @@ -1,8 +1,9 @@ use abscissa_core::clap::Parser; use abscissa_core::{Command, Runnable}; +use ibc_relayer::chain::requests::{IncludeProof, QueryPacketAcknowledgementRequest}; use subtle_encoding::{Encoding, Hex}; -use ibc::core::ics04_channel::packet::{PacketMsgType, Sequence}; +use ibc::core::ics04_channel::packet::Sequence; use ibc::core::ics24_host::identifier::{ChainId, ChannelId, PortId}; use ibc::Height; use ibc_relayer::chain::handle::ChainHandle; @@ -39,16 +40,17 @@ impl QueryPacketAcknowledgmentCmd { let chain = spawn_chain_runtime(&config, &self.chain_id)?; chain - .build_packet_proofs( - PacketMsgType::Ack, - &self.port_id, - &self.channel_id, - self.sequence, - Height::new(chain.id().version(), self.height.unwrap_or(0_u64)), + .query_packet_acknowledgement( + QueryPacketAcknowledgementRequest { + port_id: self.port_id.clone(), + channel_id: self.channel_id, + sequence: self.sequence, + height: Height::new(chain.id().version(), self.height.unwrap_or(0_u64)), + }, + IncludeProof::No, ) .map_err(Error::relayer) - .map(|(b, _)| b) - .map(|bytes| { + .map(|(bytes, _)| { Hex::upper_case() .encode_to_string(bytes.clone()) .unwrap_or_else(|_| format!("{:?}", bytes)) diff --git a/relayer-cli/src/commands/query/packet/commitment.rs b/relayer-cli/src/commands/query/packet/commitment.rs index 7910c53030..47c941df79 100644 --- a/relayer-cli/src/commands/query/packet/commitment.rs +++ b/relayer-cli/src/commands/query/packet/commitment.rs @@ -1,9 +1,10 @@ use abscissa_core::clap::Parser; use abscissa_core::{Command, Runnable}; +use ibc_relayer::chain::requests::{IncludeProof, QueryPacketCommitmentRequest}; use serde::Serialize; use subtle_encoding::{Encoding, Hex}; -use ibc::core::ics04_channel::packet::{PacketMsgType, Sequence}; +use ibc::core::ics04_channel::packet::Sequence; use ibc::core::ics24_host::identifier::{ChainId, ChannelId, PortId}; use ibc::Height; use ibc_relayer::chain::handle::ChainHandle; @@ -45,15 +46,16 @@ impl QueryPacketCommitmentCmd { let chain = spawn_chain_runtime(&config, &self.chain_id)?; - let bytes = chain - .build_packet_proofs( - PacketMsgType::Recv, - &self.port_id, - &self.channel_id, - self.sequence, - Height::new(chain.id().version(), self.height.unwrap_or(0_u64)), + let (bytes, _) = chain + .query_packet_commitment( + QueryPacketCommitmentRequest { + port_id: self.port_id.clone(), + channel_id: self.channel_id, + sequence: self.sequence, + height: Height::new(chain.id().version(), self.height.unwrap_or(0_u64)), + }, + IncludeProof::No, ) - .map(|(bytes, _)| bytes) .map_err(Error::relayer)?; if bytes.is_empty() { diff --git a/relayer/src/link/relay_path.rs b/relayer/src/link/relay_path.rs index 870a8d9516..b2021bba7e 100644 --- a/relayer/src/link/relay_path.rs +++ b/relayer/src/link/relay_path.rs @@ -14,6 +14,7 @@ use crate::chain::requests::IncludeProof; use crate::chain::requests::QueryChannelRequest; use crate::chain::requests::QueryHostConsensusStateRequest; use crate::chain::requests::QueryNextSequenceReceiveRequest; +use crate::chain::requests::QueryPacketCommitmentRequest; use crate::chain::requests::QueryUnreceivedAcksRequest; use crate::chain::requests::QueryUnreceivedPacketsRequest; use crate::chain::tracking::TrackedMsgs; @@ -782,12 +783,14 @@ impl RelayPath { fn send_packet_commitment_cleared_on_src(&self, packet: &Packet) -> Result { let (bytes, _) = self .src_chain() - .build_packet_proofs( - PacketMsgType::Recv, - self.src_port_id(), - self.src_channel_id(), - packet.sequence, - Height::zero(), + .query_packet_commitment( + QueryPacketCommitmentRequest { + port_id: self.src_port_id().clone(), + channel_id: *self.src_channel_id(), + sequence: packet.sequence, + height: Height::zero(), + }, + IncludeProof::No, ) .map_err(LinkError::relayer)?; From 5ecb37a809e44da7744b6c50dbecd3b8eb394832 Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Fri, 27 May 2022 14:27:30 -0400 Subject: [PATCH 10/19] build_packet_proofs now only returns proofs --- relayer/src/chain.rs | 6 +++--- relayer/src/chain/handle.rs | 4 ++-- relayer/src/chain/handle/base.rs | 2 +- relayer/src/chain/handle/cache.rs | 2 +- relayer/src/chain/handle/counting.rs | 2 +- relayer/src/chain/runtime.rs | 2 +- relayer/src/link/relay_path.rs | 8 ++++---- tools/test-framework/src/relayer/chain.rs | 2 +- 8 files changed, 14 insertions(+), 14 deletions(-) diff --git a/relayer/src/chain.rs b/relayer/src/chain.rs index 013b3183ad..89bff59803 100644 --- a/relayer/src/chain.rs +++ b/relayer/src/chain.rs @@ -472,7 +472,7 @@ pub trait ChainEndpoint: Sized { channel_id: ChannelId, sequence: Sequence, height: ICSHeight, - ) -> Result<(Vec, Proofs), Error> { + ) -> Result { let channel_proof = if packet_type == PacketMsgType::TimeoutOnClose { let (_, maybe_channel_proof) = self.query_channel( QueryChannelRequest { @@ -488,7 +488,7 @@ pub trait ChainEndpoint: Sized { None }; - let (bytes, packet_proof) = + let (_, packet_proof) = self.proven_packet(packet_type, port_id, channel_id, sequence, height)?; let proofs = Proofs::new( @@ -500,6 +500,6 @@ pub trait ChainEndpoint: Sized { ) .map_err(Error::malformed_proof)?; - Ok((bytes, proofs)) + Ok(proofs) } } diff --git a/relayer/src/chain/handle.rs b/relayer/src/chain/handle.rs index e8d7b51d1d..2e8312f620 100644 --- a/relayer/src/chain/handle.rs +++ b/relayer/src/chain/handle.rs @@ -295,7 +295,7 @@ pub enum ChainRequest { channel_id: ChannelId, sequence: Sequence, height: Height, - reply_to: ReplyTo<(Vec, Proofs)>, + reply_to: ReplyTo, }, QueryPacketCommitment { @@ -538,7 +538,7 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { channel_id: &ChannelId, sequence: Sequence, height: Height, - ) -> Result<(Vec, Proofs), Error>; + ) -> Result; fn query_packet_commitment( &self, diff --git a/relayer/src/chain/handle/base.rs b/relayer/src/chain/handle/base.rs index 7b14e95aae..6a790fc665 100644 --- a/relayer/src/chain/handle/base.rs +++ b/relayer/src/chain/handle/base.rs @@ -389,7 +389,7 @@ impl ChainHandle for BaseChainHandle { channel_id: &ChannelId, sequence: Sequence, height: Height, - ) -> Result<(Vec, Proofs), Error> { + ) -> Result { self.send(|reply_to| ChainRequest::BuildPacketProofs { packet_type, port_id: port_id.clone(), diff --git a/relayer/src/chain/handle/cache.rs b/relayer/src/chain/handle/cache.rs index 0b01e3cd33..31dc0d0956 100644 --- a/relayer/src/chain/handle/cache.rs +++ b/relayer/src/chain/handle/cache.rs @@ -414,7 +414,7 @@ impl ChainHandle for CachingChainHandle { channel_id: &ChannelId, sequence: Sequence, height: Height, - ) -> Result<(Vec, Proofs), Error> { + ) -> Result { self.inner() .build_packet_proofs(packet_type, port_id, channel_id, sequence, height) } diff --git a/relayer/src/chain/handle/counting.rs b/relayer/src/chain/handle/counting.rs index 54dde6f5f6..eee6f1324b 100644 --- a/relayer/src/chain/handle/counting.rs +++ b/relayer/src/chain/handle/counting.rs @@ -390,7 +390,7 @@ impl ChainHandle for CountingChainHandle { channel_id: &ChannelId, sequence: Sequence, height: Height, - ) -> Result<(Vec, Proofs), Error> { + ) -> Result { self.inc_metric("build_packet_proofs"); self.inner() .build_packet_proofs(packet_type, port_id, channel_id, sequence, height) diff --git a/relayer/src/chain/runtime.rs b/relayer/src/chain/runtime.rs index d113574750..06eef04ba2 100644 --- a/relayer/src/chain/runtime.rs +++ b/relayer/src/chain/runtime.rs @@ -784,7 +784,7 @@ where channel_id: ChannelId, sequence: Sequence, height: Height, - reply_to: ReplyTo<(Vec, Proofs)>, + reply_to: ReplyTo, ) -> Result<(), Error> { let result = self.chain diff --git a/relayer/src/link/relay_path.rs b/relayer/src/link/relay_path.rs index b2021bba7e..c92a0cb693 100644 --- a/relayer/src/link/relay_path.rs +++ b/relayer/src/link/relay_path.rs @@ -1124,7 +1124,7 @@ impl RelayPath { } fn build_recv_packet(&self, packet: &Packet, height: Height) -> Result, LinkError> { - let (_, proofs) = self + let proofs = self .src_chain() .build_packet_proofs( PacketMsgType::Recv, @@ -1152,7 +1152,7 @@ impl RelayPath { ) -> Result, LinkError> { let packet = event.packet.clone(); - let (_, proofs) = self + let proofs = self .src_chain() .build_packet_proofs( PacketMsgType::Ack, @@ -1205,7 +1205,7 @@ impl RelayPath { (PacketMsgType::TimeoutUnordered, packet.sequence) }; - let (_, proofs) = self + let proofs = self .dst_chain() .build_packet_proofs( packet_type, @@ -1237,7 +1237,7 @@ impl RelayPath { packet: &Packet, height: Height, ) -> Result, LinkError> { - let (_, proofs) = self + let proofs = self .dst_chain() .build_packet_proofs( PacketMsgType::TimeoutOnClose, diff --git a/tools/test-framework/src/relayer/chain.rs b/tools/test-framework/src/relayer/chain.rs index 3201258543..becc0400a5 100644 --- a/tools/test-framework/src/relayer/chain.rs +++ b/tools/test-framework/src/relayer/chain.rs @@ -330,7 +330,7 @@ where channel_id: &ChannelId, sequence: Sequence, height: Height, - ) -> Result<(Vec, Proofs), Error> { + ) -> Result { self.value() .build_packet_proofs(packet_type, port_id, channel_id, sequence, height) } From e205d0097945f50839d85ebde917eebdeea8c5f9 Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Fri, 27 May 2022 14:42:41 -0400 Subject: [PATCH 11/19] build_packet_proofs no longer uses proven_packet --- relayer/src/chain.rs | 96 +++++++++++++++++++++++++++++++++++++------- 1 file changed, 81 insertions(+), 15 deletions(-) diff --git a/relayer/src/chain.rs b/relayer/src/chain.rs index 89bff59803..5f0345c462 100644 --- a/relayer/src/chain.rs +++ b/relayer/src/chain.rs @@ -473,23 +473,89 @@ pub trait ChainEndpoint: Sized { sequence: Sequence, height: ICSHeight, ) -> Result { - let channel_proof = if packet_type == PacketMsgType::TimeoutOnClose { - let (_, maybe_channel_proof) = self.query_channel( - QueryChannelRequest { - port_id: port_id.clone(), - channel_id, - height, - }, - IncludeProof::Yes, - )?; - let channel_proof = maybe_channel_proof.expect(QUERY_PROOF_EXPECT_MSG); - Some(CommitmentProofBytes::try_from(channel_proof).map_err(Error::malformed_proof)?) - } else { - None + let (maybe_packet_proof, channel_proof) = match packet_type { + PacketMsgType::Recv => { + let (_, maybe_packet_proof) = self.query_packet_commitment( + QueryPacketCommitmentRequest { + port_id, + channel_id, + sequence, + height, + }, + IncludeProof::Yes, + )?; + + (maybe_packet_proof, None) + } + PacketMsgType::Ack => { + let (_, maybe_packet_proof) = self.query_packet_acknowledgement( + QueryPacketAcknowledgementRequest { + port_id, + channel_id, + sequence, + height, + }, + IncludeProof::Yes, + )?; + + (maybe_packet_proof, None) + } + PacketMsgType::TimeoutUnordered => { + let (_, maybe_packet_proof) = self.query_packet_receipt( + QueryPacketReceiptRequest { + port_id, + channel_id, + sequence, + height, + }, + IncludeProof::Yes, + )?; + + (maybe_packet_proof, None) + } + PacketMsgType::TimeoutOrdered => { + let (_, maybe_packet_proof) = self.query_next_sequence_receive( + QueryNextSequenceReceiveRequest { + port_id, + channel_id, + height, + }, + IncludeProof::Yes, + )?; + + (maybe_packet_proof, None) + } + PacketMsgType::TimeoutOnClose => { + let channel_proof = { + let (_, maybe_channel_proof) = self.query_channel( + QueryChannelRequest { + port_id: port_id.clone(), + channel_id, + height, + }, + IncludeProof::Yes, + )?; + let channel_merkle_proof = maybe_channel_proof.expect(QUERY_PROOF_EXPECT_MSG); + Some( + CommitmentProofBytes::try_from(channel_merkle_proof) + .map_err(Error::malformed_proof)?, + ) + }; + let (_, maybe_packet_proof) = self.query_packet_receipt( + QueryPacketReceiptRequest { + port_id, + channel_id, + sequence, + height, + }, + IncludeProof::Yes, + )?; + + (maybe_packet_proof, channel_proof) + } }; - let (_, packet_proof) = - self.proven_packet(packet_type, port_id, channel_id, sequence, height)?; + let packet_proof = maybe_packet_proof.expect(QUERY_PROOF_EXPECT_MSG); let proofs = Proofs::new( CommitmentProofBytes::try_from(packet_proof).map_err(Error::malformed_proof)?, From d1b5d8876f21f41b578e30d0d0dc0436418a2e04 Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Fri, 27 May 2022 14:45:50 -0400 Subject: [PATCH 12/19] proven_packet removed --- relayer/src/chain.rs | 9 ------- relayer/src/chain/cosmos.rs | 47 ++----------------------------------- relayer/src/chain/mock.rs | 15 ++---------- 3 files changed, 4 insertions(+), 67 deletions(-) diff --git a/relayer/src/chain.rs b/relayer/src/chain.rs index 5f0345c462..7aa4a2253c 100644 --- a/relayer/src/chain.rs +++ b/relayer/src/chain.rs @@ -315,15 +315,6 @@ pub trait ChainEndpoint: Sized { height: ICSHeight, ) -> Result<(AnyConsensusState, MerkleProof), Error>; - fn proven_packet( - &self, - packet_type: PacketMsgType, - port_id: PortId, - channel_id: ChannelId, - sequence: Sequence, - height: ICSHeight, - ) -> Result<(Vec, MerkleProof), Error>; - fn build_client_state( &self, height: ICSHeight, diff --git a/relayer/src/chain/cosmos.rs b/relayer/src/chain/cosmos.rs index ed14571e07..3f86c874a7 100644 --- a/relayer/src/chain/cosmos.rs +++ b/relayer/src/chain/cosmos.rs @@ -35,9 +35,9 @@ use ibc::core::ics04_channel::channel::{ ChannelEnd, IdentifiedChannelEnd, QueryPacketEventDataRequest, }; use ibc::core::ics04_channel::events as ChannelEvents; -use ibc::core::ics04_channel::packet::{Packet, PacketMsgType, Sequence}; +use ibc::core::ics04_channel::packet::{Packet, Sequence}; use ibc::core::ics23_commitment::commitment::CommitmentPrefix; -use ibc::core::ics24_host::identifier::{ChainId, ChannelId, ClientId, ConnectionId, PortId}; +use ibc::core::ics24_host::identifier::{ChainId, ClientId, ConnectionId}; use ibc::core::ics24_host::path::{ AcksPath, ChannelEndsPath, ClientConsensusStatePath, ClientStatePath, CommitmentsPath, ConnectionsPath, ReceiptsPath, SeqRecvsPath, @@ -1540,49 +1540,6 @@ impl ChainEndpoint for CosmosSdkChain { Ok((consensus_state, proof)) } - fn proven_packet( - &self, - packet_type: PacketMsgType, - port_id: PortId, - channel_id: ChannelId, - sequence: Sequence, - height: ICSHeight, - ) -> Result<(Vec, MerkleProof), Error> { - let data: Path = match packet_type { - PacketMsgType::Recv => CommitmentsPath { - port_id, - channel_id, - sequence, - } - .into(), - PacketMsgType::Ack => AcksPath { - port_id, - channel_id, - sequence, - } - .into(), - PacketMsgType::TimeoutUnordered => ReceiptsPath { - port_id, - channel_id, - sequence, - } - .into(), - PacketMsgType::TimeoutOrdered => SeqRecvsPath(port_id, channel_id).into(), - PacketMsgType::TimeoutOnClose => ReceiptsPath { - port_id, - channel_id, - sequence, - } - .into(), - }; - - let res = self.query(data, height, true)?; - - let commitment_proof_bytes = res.proof.ok_or_else(Error::empty_response_proof)?; - - Ok((res.value, commitment_proof_bytes)) - } - fn build_client_state( &self, height: ICSHeight, diff --git a/relayer/src/chain/mock.rs b/relayer/src/chain/mock.rs index 121a818562..af79662cb5 100644 --- a/relayer/src/chain/mock.rs +++ b/relayer/src/chain/mock.rs @@ -17,9 +17,9 @@ use ibc::core::ics02_client::client_state::{AnyClientState, IdentifiedAnyClientS use ibc::core::ics03_connection::connection::{ConnectionEnd, IdentifiedConnectionEnd}; use ibc::core::ics04_channel::channel::{ChannelEnd, IdentifiedChannelEnd}; use ibc::core::ics04_channel::context::ChannelReader; -use ibc::core::ics04_channel::packet::{PacketMsgType, Sequence}; +use ibc::core::ics04_channel::packet::Sequence; use ibc::core::ics23_commitment::{commitment::CommitmentPrefix, specs::ProofSpecs}; -use ibc::core::ics24_host::identifier::{ChainId, ChannelId, ClientId, ConnectionId, PortId}; +use ibc::core::ics24_host::identifier::{ChainId, ClientId, ConnectionId}; use ibc::events::IbcEvent; use ibc::mock::context::MockContext; use ibc::mock::host::HostType; @@ -348,17 +348,6 @@ impl ChainEndpoint for MockChain { unimplemented!() } - fn proven_packet( - &self, - _packet_type: PacketMsgType, - _port_id: PortId, - _channel_id: ChannelId, - _sequence: Sequence, - _height: Height, - ) -> Result<(Vec, MerkleProof), Error> { - unimplemented!() - } - fn build_client_state( &self, height: Height, From c2f968926a61ca5c09491403f8784c7bf9f2dc0e Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Tue, 31 May 2022 14:30:33 -0400 Subject: [PATCH 13/19] query_consensus_state --- relayer-cli/src/commands/query/client.rs | 15 ++++-- relayer/src/chain.rs | 13 ++--- relayer/src/chain/cosmos.rs | 58 ++++++++++++++++++++--- relayer/src/chain/handle.rs | 14 +++--- relayer/src/chain/handle/base.rs | 9 +++- relayer/src/chain/handle/cache.rs | 5 +- relayer/src/chain/handle/counting.rs | 5 +- relayer/src/chain/mock.rs | 19 +++++--- relayer/src/chain/runtime.rs | 11 +++-- relayer/src/foreign_client.rs | 17 ++++--- tools/test-framework/src/relayer/chain.rs | 5 +- 11 files changed, 121 insertions(+), 50 deletions(-) diff --git a/relayer-cli/src/commands/query/client.rs b/relayer-cli/src/commands/query/client.rs index 8d0eb3256a..7b849bb5cb 100644 --- a/relayer-cli/src/commands/query/client.rs +++ b/relayer-cli/src/commands/query/client.rs @@ -136,11 +136,16 @@ impl Runnable for QueryClientConsensusCmd { let height = ibc::Height::new(chain.id().version(), self.height.unwrap_or(0_u64)); let consensus_height = ibc::Height::new(counterparty_chain.version(), cs_height); - let res = chain.query_consensus_state(QueryConsensusStateRequest { - client_id: self.client_id.clone(), - consensus_height, - query_height: height, - }); + let res = chain + .query_consensus_state( + QueryConsensusStateRequest { + client_id: self.client_id.clone(), + consensus_height, + query_height: height, + }, + IncludeProof::No, + ) + .map(|(consensus_state, _)| consensus_state); match res { Ok(cs) => Output::success(cs).exit(), diff --git a/relayer/src/chain.rs b/relayer/src/chain.rs index 7aa4a2253c..376d9bc859 100644 --- a/relayer/src/chain.rs +++ b/relayer/src/chain.rs @@ -180,17 +180,18 @@ pub trait ChainEndpoint: Sized { include_proof: IncludeProof, ) -> Result<(AnyClientState, Option), Error>; - fn query_consensus_states( - &self, - request: QueryConsensusStatesRequest, - ) -> Result, Error>; - /// Performs a query to retrieve the consensus state (for a specific height `consensus_height`) /// that an on-chain client stores. fn query_consensus_state( &self, request: QueryConsensusStateRequest, - ) -> Result; + include_proof: IncludeProof, + ) -> Result<(AnyConsensusState, Option), Error>; + + fn query_consensus_states( + &self, + request: QueryConsensusStatesRequest, + ) -> Result, Error>; fn query_upgraded_client_state( &self, diff --git a/relayer/src/chain/cosmos.rs b/relayer/src/chain/cosmos.rs index 3f86c874a7..c4a2529436 100644 --- a/relayer/src/chain/cosmos.rs +++ b/relayer/src/chain/cosmos.rs @@ -846,17 +846,61 @@ impl ChainEndpoint for CosmosSdkChain { fn query_consensus_state( &self, request: QueryConsensusStateRequest, - ) -> Result { + include_proof: IncludeProof, + ) -> Result<(AnyConsensusState, Option), Error> { crate::time!("query_consensus_state"); crate::telemetry!(query, self.id(), "query_consensus_state"); - let (consensus_state, _proof) = self.proven_client_consensus( - &request.client_id, - request.consensus_height, - request.query_height, - )?; + match include_proof { + IncludeProof::Yes => { + let res = self.query( + ClientConsensusStatePath { + client_id: request.client_id.clone(), + epoch: request.consensus_height.revision_number, + height: request.consensus_height.revision_height, + }, + request.query_height, + true, + )?; + + let consensus_state = + AnyConsensusState::decode_vec(&res.value).map_err(Error::decode)?; + + if !matches!(consensus_state, AnyConsensusState::Tendermint(_)) { + return Err(Error::consensus_state_type_mismatch( + ClientType::Tendermint, + consensus_state.client_type(), + )); + } + + let proof = res.proof.ok_or_else(Error::empty_response_proof)?; - Ok(consensus_state) + Ok((consensus_state, Some(proof))) + } + IncludeProof::No => { + let res = self.query( + ClientConsensusStatePath { + client_id: request.client_id.clone(), + epoch: request.consensus_height.revision_number, + height: request.consensus_height.revision_height, + }, + request.query_height, + false, + )?; + + let consensus_state = + AnyConsensusState::decode_vec(&res.value).map_err(Error::decode)?; + + if !matches!(consensus_state, AnyConsensusState::Tendermint(_)) { + return Err(Error::consensus_state_type_mismatch( + ClientType::Tendermint, + consensus_state.client_type(), + )); + } + + Ok((consensus_state, None)) + } + } } fn query_client_connections( diff --git a/relayer/src/chain/handle.rs b/relayer/src/chain/handle.rs index 2e8312f620..7b2d2c4896 100644 --- a/relayer/src/chain/handle.rs +++ b/relayer/src/chain/handle.rs @@ -209,16 +209,17 @@ pub enum ChainRequest { reply_to: ReplyTo>, }, + QueryConsensusState { + request: QueryConsensusStateRequest, + include_proof: IncludeProof, + reply_to: ReplyTo<(AnyConsensusState, Option)>, + }, + QueryConsensusStates { request: QueryConsensusStatesRequest, reply_to: ReplyTo>, }, - QueryConsensusState { - request: QueryConsensusStateRequest, - reply_to: ReplyTo, - }, - QueryUpgradedClientState { request: QueryUpgradedClientStateRequest, reply_to: ReplyTo<(AnyClientState, MerkleProof)>, @@ -427,7 +428,8 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { fn query_consensus_state( &self, request: QueryConsensusStateRequest, - ) -> Result; + include_proof: IncludeProof, + ) -> Result<(AnyConsensusState, Option), Error>; fn query_upgraded_client_state( &self, diff --git a/relayer/src/chain/handle/base.rs b/relayer/src/chain/handle/base.rs index 6a790fc665..dac27fa335 100644 --- a/relayer/src/chain/handle/base.rs +++ b/relayer/src/chain/handle/base.rs @@ -194,8 +194,13 @@ impl ChainHandle for BaseChainHandle { fn query_consensus_state( &self, request: QueryConsensusStateRequest, - ) -> Result { - self.send(|reply_to| ChainRequest::QueryConsensusState { request, reply_to }) + include_proof: IncludeProof, + ) -> Result<(AnyConsensusState, Option), Error> { + self.send(|reply_to| ChainRequest::QueryConsensusState { + request, + include_proof, + reply_to, + }) } fn query_upgraded_client_state( diff --git a/relayer/src/chain/handle/cache.rs b/relayer/src/chain/handle/cache.rs index 31dc0d0956..5555f568c8 100644 --- a/relayer/src/chain/handle/cache.rs +++ b/relayer/src/chain/handle/cache.rs @@ -209,8 +209,9 @@ impl ChainHandle for CachingChainHandle { fn query_consensus_state( &self, request: QueryConsensusStateRequest, - ) -> Result { - self.inner().query_consensus_state(request) + include_proof: IncludeProof, + ) -> Result<(AnyConsensusState, Option), Error> { + self.inner().query_consensus_state(request, include_proof) } fn query_upgraded_client_state( diff --git a/relayer/src/chain/handle/counting.rs b/relayer/src/chain/handle/counting.rs index eee6f1324b..cb0f7bb645 100644 --- a/relayer/src/chain/handle/counting.rs +++ b/relayer/src/chain/handle/counting.rs @@ -212,9 +212,10 @@ impl ChainHandle for CountingChainHandle { fn query_consensus_state( &self, request: QueryConsensusStateRequest, - ) -> Result { + include_proof: IncludeProof, + ) -> Result<(AnyConsensusState, Option), Error> { self.inc_metric("query_consensus_state"); - self.inner().query_consensus_state(request) + self.inner().query_consensus_state(request, include_proof) } fn query_upgraded_client_state( diff --git a/relayer/src/chain/mock.rs b/relayer/src/chain/mock.rs index af79662cb5..156dbbd0f7 100644 --- a/relayer/src/chain/mock.rs +++ b/relayer/src/chain/mock.rs @@ -426,13 +426,20 @@ impl ChainEndpoint for MockChain { fn query_consensus_state( &self, request: QueryConsensusStateRequest, - ) -> Result { + include_proof: IncludeProof, + ) -> Result<(AnyConsensusState, Option), Error> { + // IncludeProof::Yes not implemented + assert!(matches!(include_proof, IncludeProof::No)); + let consensus_states = self.context.consensus_states(&request.client_id); - Ok(consensus_states - .into_iter() - .find(|s| s.height == request.consensus_height) - .unwrap() - .consensus_state) + Ok(( + consensus_states + .into_iter() + .find(|s| s.height == request.consensus_height) + .unwrap() + .consensus_state, + None, + )) } fn query_upgraded_consensus_state( diff --git a/relayer/src/chain/runtime.rs b/relayer/src/chain/runtime.rs index 06eef04ba2..f6d5f2a4fa 100644 --- a/relayer/src/chain/runtime.rs +++ b/relayer/src/chain/runtime.rs @@ -327,8 +327,8 @@ where self.query_consensus_states(request, reply_to)? }, - Ok(ChainRequest::QueryConsensusState { request, reply_to }) => { - self.query_consensus_state(request, reply_to)? + Ok(ChainRequest::QueryConsensusState { request, include_proof, reply_to }) => { + self.query_consensus_state(request, include_proof, reply_to)? }, Ok(ChainRequest::QueryUpgradedClientState { request, reply_to }) => { @@ -662,11 +662,12 @@ where fn query_consensus_state( &self, request: QueryConsensusStateRequest, - reply_to: ReplyTo, + include_proof: IncludeProof, + reply_to: ReplyTo<(AnyConsensusState, Option)>, ) -> Result<(), Error> { - let consensus_state = self.chain.query_consensus_state(request); + let res = self.chain.query_consensus_state(request, include_proof); - reply_to.send(consensus_state).map_err(Error::send) + reply_to.send(res).map_err(Error::send) } fn query_upgraded_consensus_state( diff --git a/relayer/src/foreign_client.rs b/relayer/src/foreign_client.rs index a19efbd3e4..ecb39ad700 100644 --- a/relayer/src/foreign_client.rs +++ b/relayer/src/foreign_client.rs @@ -1202,13 +1202,16 @@ impl ForeignClient Result { - let res = self + let (consensus_state, _) = self .dst_chain - .query_consensus_state(QueryConsensusStateRequest { - client_id: self.id.clone(), - consensus_height: height, - query_height: Height::zero(), - }) + .query_consensus_state( + QueryConsensusStateRequest { + client_id: self.id.clone(), + consensus_height: height, + query_height: Height::zero(), + }, + IncludeProof::No, + ) .map_err(|e| { ForeignClientError::client_consensus_query( self.id.clone(), @@ -1218,7 +1221,7 @@ impl ForeignClient Result { - self.value().query_consensus_state(request) + include_proof: IncludeProof, + ) -> Result<(AnyConsensusState, Option), Error> { + self.value().query_consensus_state(request, include_proof) } fn query_upgraded_client_state( From 8f0eba91eaced80403b9a42694c8705ed26608ca Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Tue, 31 May 2022 14:38:33 -0400 Subject: [PATCH 14/19] remove proven_client_consensus --- relayer/src/chain.rs | 23 ++++++++-------- relayer/src/chain/cosmos.rs | 32 ----------------------- relayer/src/chain/handle.rs | 14 ---------- relayer/src/chain/handle/base.rs | 14 ---------- relayer/src/chain/handle/cache.rs | 10 ------- relayer/src/chain/handle/counting.rs | 11 -------- relayer/src/chain/mock.rs | 11 +------- relayer/src/chain/runtime.rs | 19 -------------- tools/test-framework/src/relayer/chain.rs | 10 ------- 9 files changed, 13 insertions(+), 131 deletions(-) diff --git a/relayer/src/chain.rs b/relayer/src/chain.rs index 376d9bc859..507900132d 100644 --- a/relayer/src/chain.rs +++ b/relayer/src/chain.rs @@ -308,14 +308,6 @@ pub trait ChainEndpoint: Sized { request: QueryHostConsensusStateRequest, ) -> Result; - // Provable queries - fn proven_client_consensus( - &self, - client_id: &ClientId, - consensus_height: ICSHeight, - height: ICSHeight, - ) -> Result<(AnyConsensusState, MerkleProof), Error>; - fn build_client_state( &self, height: ICSHeight, @@ -401,9 +393,18 @@ pub trait ChainEndpoint: Sized { .map_err(Error::malformed_proof)?, ); - let consensus_state_proof = self - .proven_client_consensus(client_id, client_state_value.latest_height(), height)? - .1; + let consensus_state_proof = { + let (_, maybe_consensus_state_proof) = self.query_consensus_state( + QueryConsensusStateRequest { + client_id: client_id.clone(), + consensus_height: client_state_value.latest_height(), + query_height: height, + }, + IncludeProof::Yes, + )?; + + maybe_consensus_state_proof.expect(QUERY_PROOF_EXPECT_MSG) + }; consensus_proof = Option::from( ConsensusProof::new( diff --git a/relayer/src/chain/cosmos.rs b/relayer/src/chain/cosmos.rs index c4a2529436..1e51ec57e8 100644 --- a/relayer/src/chain/cosmos.rs +++ b/relayer/src/chain/cosmos.rs @@ -1552,38 +1552,6 @@ impl ChainEndpoint for CosmosSdkChain { Ok(response.block.header.into()) } - fn proven_client_consensus( - &self, - client_id: &ClientId, - consensus_height: ICSHeight, - height: ICSHeight, - ) -> Result<(AnyConsensusState, MerkleProof), Error> { - crate::time!("proven_client_consensus"); - - let res = self.query( - ClientConsensusStatePath { - client_id: client_id.clone(), - epoch: consensus_height.revision_number, - height: consensus_height.revision_height, - }, - height, - true, - )?; - - let consensus_state = AnyConsensusState::decode_vec(&res.value).map_err(Error::decode)?; - - if !matches!(consensus_state, AnyConsensusState::Tendermint(_)) { - return Err(Error::consensus_state_type_mismatch( - ClientType::Tendermint, - consensus_state.client_type(), - )); - } - - let proof = res.proof.ok_or_else(Error::empty_response_proof)?; - - Ok((consensus_state, proof)) - } - fn build_client_state( &self, height: ICSHeight, diff --git a/relayer/src/chain/handle.rs b/relayer/src/chain/handle.rs index 7b2d2c4896..96f916aff0 100644 --- a/relayer/src/chain/handle.rs +++ b/relayer/src/chain/handle.rs @@ -276,13 +276,6 @@ pub enum ChainRequest { reply_to: ReplyTo<(Sequence, Option)>, }, - ProvenClientConsensus { - client_id: ClientId, - consensus_height: Height, - height: Height, - reply_to: ReplyTo<(AnyConsensusState, MerkleProof)>, - }, - BuildChannelProofs { port_id: PortId, channel_id: ChannelId, @@ -483,13 +476,6 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { request: QueryChannelClientStateRequest, ) -> Result, Error>; - fn proven_client_consensus( - &self, - client_id: &ClientId, - consensus_height: Height, - height: Height, - ) -> Result<(AnyConsensusState, MerkleProof), Error>; - fn build_header( &self, trusted_height: Height, diff --git a/relayer/src/chain/handle/base.rs b/relayer/src/chain/handle/base.rs index dac27fa335..5fa482e403 100644 --- a/relayer/src/chain/handle/base.rs +++ b/relayer/src/chain/handle/base.rs @@ -289,20 +289,6 @@ impl ChainHandle for BaseChainHandle { self.send(|reply_to| ChainRequest::QueryChannelClientState { request, reply_to }) } - fn proven_client_consensus( - &self, - client_id: &ClientId, - consensus_height: Height, - height: Height, - ) -> Result<(AnyConsensusState, MerkleProof), Error> { - self.send(|reply_to| ChainRequest::ProvenClientConsensus { - client_id: client_id.clone(), - consensus_height, - height, - reply_to, - }) - } - fn build_header( &self, trusted_height: Height, diff --git a/relayer/src/chain/handle/cache.rs b/relayer/src/chain/handle/cache.rs index 5555f568c8..dc3fe89654 100644 --- a/relayer/src/chain/handle/cache.rs +++ b/relayer/src/chain/handle/cache.rs @@ -335,16 +335,6 @@ impl ChainHandle for CachingChainHandle { self.inner().query_channel_client_state(request) } - fn proven_client_consensus( - &self, - client_id: &ClientId, - consensus_height: Height, - height: Height, - ) -> Result<(AnyConsensusState, MerkleProof), Error> { - self.inner() - .proven_client_consensus(client_id, consensus_height, height) - } - fn build_header( &self, trusted_height: Height, diff --git a/relayer/src/chain/handle/counting.rs b/relayer/src/chain/handle/counting.rs index cb0f7bb645..b8ae50806e 100644 --- a/relayer/src/chain/handle/counting.rs +++ b/relayer/src/chain/handle/counting.rs @@ -304,17 +304,6 @@ impl ChainHandle for CountingChainHandle { self.inner().query_channel_client_state(request) } - fn proven_client_consensus( - &self, - client_id: &ClientId, - consensus_height: Height, - height: Height, - ) -> Result<(AnyConsensusState, MerkleProof), Error> { - self.inc_metric("proven_client_consensus"); - self.inner() - .proven_client_consensus(client_id, consensus_height, height) - } - fn build_header( &self, trusted_height: Height, diff --git a/relayer/src/chain/mock.rs b/relayer/src/chain/mock.rs index 156dbbd0f7..a2159746de 100644 --- a/relayer/src/chain/mock.rs +++ b/relayer/src/chain/mock.rs @@ -19,7 +19,7 @@ use ibc::core::ics04_channel::channel::{ChannelEnd, IdentifiedChannelEnd}; use ibc::core::ics04_channel::context::ChannelReader; use ibc::core::ics04_channel::packet::Sequence; use ibc::core::ics23_commitment::{commitment::CommitmentPrefix, specs::ProofSpecs}; -use ibc::core::ics24_host::identifier::{ChainId, ClientId, ConnectionId}; +use ibc::core::ics24_host::identifier::{ChainId, ConnectionId}; use ibc::events::IbcEvent; use ibc::mock::context::MockContext; use ibc::mock::host::HostType; @@ -339,15 +339,6 @@ impl ChainEndpoint for MockChain { unimplemented!() } - fn proven_client_consensus( - &self, - _client_id: &ClientId, - _consensus_height: Height, - _height: Height, - ) -> Result<(AnyConsensusState, MerkleProof), Error> { - unimplemented!() - } - fn build_client_state( &self, height: Height, diff --git a/relayer/src/chain/runtime.rs b/relayer/src/chain/runtime.rs index f6d5f2a4fa..a6136ad0c0 100644 --- a/relayer/src/chain/runtime.rs +++ b/relayer/src/chain/runtime.rs @@ -371,10 +371,6 @@ where self.query_channel_client_state(request, reply_to)? }, - Ok(ChainRequest::ProvenClientConsensus { client_id, consensus_height, height, reply_to }) => { - self.proven_client_consensus(client_id, consensus_height, height, reply_to)? - }, - Ok(ChainRequest::BuildPacketProofs { packet_type, port_id, channel_id, sequence, height, reply_to }) => { self.build_packet_proofs(packet_type, port_id, channel_id, sequence, height, reply_to)? }, @@ -749,21 +745,6 @@ where reply_to.send(result).map_err(Error::send) } - fn proven_client_consensus( - &self, - client_id: ClientId, - consensus_height: Height, - height: Height, - reply_to: ReplyTo<(AnyConsensusState, MerkleProof)>, - ) -> Result<(), Error> { - let result = self - .chain - .proven_client_consensus(&client_id, consensus_height, height) - .map(|(cs, mp)| (cs.wrap_any(), mp)); - - reply_to.send(result).map_err(Error::send) - } - fn build_channel_proofs( &self, port_id: PortId, diff --git a/tools/test-framework/src/relayer/chain.rs b/tools/test-framework/src/relayer/chain.rs index dab4e540bb..62e48160be 100644 --- a/tools/test-framework/src/relayer/chain.rs +++ b/tools/test-framework/src/relayer/chain.rs @@ -251,16 +251,6 @@ where self.value().query_channel_client_state(request) } - fn proven_client_consensus( - &self, - client_id: &ClientId, - consensus_height: Height, - height: Height, - ) -> Result<(AnyConsensusState, MerkleProof), Error> { - self.value() - .proven_client_consensus(client_id, consensus_height, height) - } - fn build_header( &self, trusted_height: Height, From 150c43df1559d13931e57b774061afcedbdaf1ce Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Tue, 31 May 2022 15:12:55 -0400 Subject: [PATCH 15/19] cleanup --- relayer/src/chain/cosmos.rs | 216 ++++++++++++++---------------------- 1 file changed, 83 insertions(+), 133 deletions(-) diff --git a/relayer/src/chain/cosmos.rs b/relayer/src/chain/cosmos.rs index 1e51ec57e8..a2270f9e70 100644 --- a/relayer/src/chain/cosmos.rs +++ b/relayer/src/chain/cosmos.rs @@ -743,28 +743,19 @@ impl ChainEndpoint for CosmosSdkChain { crate::time!("query_client_state"); crate::telemetry!(query, self.id(), "query_client_state"); + let res = self.query( + ClientStatePath(request.client_id.clone()), + request.height, + matches!(include_proof, IncludeProof::Yes), + )?; + let client_state = AnyClientState::decode_vec(&res.value).map_err(Error::decode)?; + match include_proof { IncludeProof::Yes => { - let res = self.query( - ClientStatePath(request.client_id.clone()), - request.height, - true, - )?; - - let client_state = AnyClientState::decode_vec(&res.value).map_err(Error::decode)?; - - Ok(( - client_state, - Some(res.proof.ok_or_else(Error::empty_response_proof)?), - )) - } - IncludeProof::No => { - let client_state = self - .query(ClientStatePath(request.client_id), request.height, false) - .and_then(|v| AnyClientState::decode_vec(&v.value).map_err(Error::decode))?; - - Ok((client_state, None)) + let proof = res.proof.ok_or_else(Error::empty_response_proof)?; + Ok((client_state, Some(proof))) } + IncludeProof::No => Ok((client_state, None)), } } @@ -851,55 +842,31 @@ impl ChainEndpoint for CosmosSdkChain { crate::time!("query_consensus_state"); crate::telemetry!(query, self.id(), "query_consensus_state"); - match include_proof { - IncludeProof::Yes => { - let res = self.query( - ClientConsensusStatePath { - client_id: request.client_id.clone(), - epoch: request.consensus_height.revision_number, - height: request.consensus_height.revision_height, - }, - request.query_height, - true, - )?; + let res = self.query( + ClientConsensusStatePath { + client_id: request.client_id.clone(), + epoch: request.consensus_height.revision_number, + height: request.consensus_height.revision_height, + }, + request.query_height, + matches!(include_proof, IncludeProof::Yes), + )?; - let consensus_state = - AnyConsensusState::decode_vec(&res.value).map_err(Error::decode)?; + let consensus_state = AnyConsensusState::decode_vec(&res.value).map_err(Error::decode)?; - if !matches!(consensus_state, AnyConsensusState::Tendermint(_)) { - return Err(Error::consensus_state_type_mismatch( - ClientType::Tendermint, - consensus_state.client_type(), - )); - } + if !matches!(consensus_state, AnyConsensusState::Tendermint(_)) { + return Err(Error::consensus_state_type_mismatch( + ClientType::Tendermint, + consensus_state.client_type(), + )); + } + match include_proof { + IncludeProof::Yes => { let proof = res.proof.ok_or_else(Error::empty_response_proof)?; - Ok((consensus_state, Some(proof))) } - IncludeProof::No => { - let res = self.query( - ClientConsensusStatePath { - client_id: request.client_id.clone(), - epoch: request.consensus_height.revision_number, - height: request.consensus_height.revision_height, - }, - request.query_height, - false, - )?; - - let consensus_state = - AnyConsensusState::decode_vec(&res.value).map_err(Error::decode)?; - - if !matches!(consensus_state, AnyConsensusState::Tendermint(_)) { - return Err(Error::consensus_state_type_mismatch( - ClientType::Tendermint, - consensus_state.client_type(), - )); - } - - Ok((consensus_state, None)) - } + IncludeProof::No => Ok((consensus_state, None)), } } @@ -1123,31 +1090,20 @@ impl ChainEndpoint for CosmosSdkChain { crate::time!("query_channel"); crate::telemetry!(query, self.id(), "query_channel"); - match include_proof { - IncludeProof::Yes => { - let res = self.query( - ChannelEndsPath(request.port_id, request.channel_id), - request.height, - true, - )?; - - let channel_end = ChannelEnd::decode_vec(&res.value).map_err(Error::decode)?; + let res = self.query( + ChannelEndsPath(request.port_id, request.channel_id), + request.height, + matches!(include_proof, IncludeProof::Yes), + )?; - Ok(( - channel_end, - Some(res.proof.ok_or_else(Error::empty_response_proof)?), - )) - } - IncludeProof::No => { - let res = self.query( - ChannelEndsPath(request.port_id, request.channel_id), - request.height, - false, - )?; - let channel_end = ChannelEnd::decode_vec(&res.value).map_err(Error::decode)?; + let channel_end = ChannelEnd::decode_vec(&res.value).map_err(Error::decode)?; - Ok((channel_end, None)) + match include_proof { + IncludeProof::Yes => { + let proof = res.proof.ok_or_else(Error::empty_response_proof)?; + Ok((channel_end, Some(proof))) } + IncludeProof::No => Ok((channel_end, None)), } } @@ -1185,26 +1141,23 @@ impl ChainEndpoint for CosmosSdkChain { request: QueryPacketCommitmentRequest, include_proof: IncludeProof, ) -> Result<(Vec, Option), Error> { - let data: Path = CommitmentsPath { - port_id: request.port_id, - channel_id: request.channel_id, - sequence: request.sequence, - } - .into(); + let res = self.query( + CommitmentsPath { + port_id: request.port_id, + channel_id: request.channel_id, + sequence: request.sequence, + }, + request.height, + matches!(include_proof, IncludeProof::Yes), + )?; match include_proof { IncludeProof::Yes => { - let res = self.query(data, request.height, true)?; - - let commitment_proof_bytes = res.proof.ok_or_else(Error::empty_response_proof)?; - - Ok((res.value, Some(commitment_proof_bytes))) - } - IncludeProof::No => { - let res = self.query(data, request.height, false)?; + let proof = res.proof.ok_or_else(Error::empty_response_proof)?; - Ok((res.value, None)) + Ok((res.value, Some(proof))) } + IncludeProof::No => Ok((res.value, None)), } } @@ -1251,26 +1204,23 @@ impl ChainEndpoint for CosmosSdkChain { request: QueryPacketReceiptRequest, include_proof: IncludeProof, ) -> Result<(Vec, Option), Error> { - let data: Path = ReceiptsPath { - port_id: request.port_id, - channel_id: request.channel_id, - sequence: request.sequence, - } - .into(); + let res = self.query( + ReceiptsPath { + port_id: request.port_id, + channel_id: request.channel_id, + sequence: request.sequence, + }, + request.height, + matches!(include_proof, IncludeProof::Yes), + )?; match include_proof { IncludeProof::Yes => { - let res = self.query(data, request.height, true)?; - - let commitment_proof_bytes = res.proof.ok_or_else(Error::empty_response_proof)?; - - Ok((res.value, Some(commitment_proof_bytes))) - } - IncludeProof::No => { - let res = self.query(data, request.height, false)?; + let proof = res.proof.ok_or_else(Error::empty_response_proof)?; - Ok((res.value, None)) + Ok((res.value, Some(proof))) } + IncludeProof::No => Ok((res.value, None)), } } @@ -1310,26 +1260,23 @@ impl ChainEndpoint for CosmosSdkChain { request: QueryPacketAcknowledgementRequest, include_proof: IncludeProof, ) -> Result<(Vec, Option), Error> { - let data: Path = AcksPath { - port_id: request.port_id, - channel_id: request.channel_id, - sequence: request.sequence, - } - .into(); + let res = self.query( + AcksPath { + port_id: request.port_id, + channel_id: request.channel_id, + sequence: request.sequence, + }, + request.height, + matches!(include_proof, IncludeProof::Yes), + )?; match include_proof { IncludeProof::Yes => { - let res = self.query(data, request.height, true)?; - - let commitment_proof_bytes = res.proof.ok_or_else(Error::empty_response_proof)?; - - Ok((res.value, Some(commitment_proof_bytes))) - } - IncludeProof::No => { - let res = self.query(data, request.height, false)?; + let proof = res.proof.ok_or_else(Error::empty_response_proof)?; - Ok((res.value, None)) + Ok((res.value, Some(proof))) } + IncludeProof::No => Ok((res.value, None)), } } @@ -1411,9 +1358,12 @@ impl ChainEndpoint for CosmosSdkChain { match include_proof { IncludeProof::Yes => { - let data: Path = SeqRecvsPath(request.port_id, request.channel_id).into(); + let res = self.query( + SeqRecvsPath(request.port_id, request.channel_id), + request.height, + true, + )?; - let res = self.query(data, request.height, true)?; // Note: We expect the return to be a u64 encoded in big-endian. Refer to ibc-go: // https://github.com/cosmos/ibc-go/blob/25767f6bdb5bab2c2a116b41d92d753c93e18121/modules/core/04-channel/client/utils/utils.go#L191 if res.value.len() != 8 { @@ -1421,9 +1371,9 @@ impl ChainEndpoint for CosmosSdkChain { } let seq: Sequence = Bytes::from(res.value).get_u64().into(); - let commitment_proof_bytes = res.proof.ok_or_else(Error::empty_response_proof)?; + let proof = res.proof.ok_or_else(Error::empty_response_proof)?; - Ok((seq, Some(commitment_proof_bytes))) + Ok((seq, Some(proof))) } IncludeProof::No => { let mut client = self From 7bb9aeb85898b09a714213b3e89f4760d8704845 Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Tue, 31 May 2022 16:33:22 -0400 Subject: [PATCH 16/19] docstrings --- relayer/src/chain.rs | 58 ++++++++++++++++----- relayer/src/chain/counterparty.rs | 2 +- relayer/src/chain/handle.rs | 62 ++++++++++++++++++++--- relayer/src/chain/handle/base.rs | 2 +- relayer/src/chain/handle/cache.rs | 4 +- relayer/src/chain/handle/counting.rs | 4 +- relayer/src/link/relay_path.rs | 2 +- tools/test-framework/src/relayer/chain.rs | 4 +- 8 files changed, 111 insertions(+), 27 deletions(-) diff --git a/relayer/src/chain.rs b/relayer/src/chain.rs index 507900132d..fa103ab05d 100644 --- a/relayer/src/chain.rs +++ b/relayer/src/chain.rs @@ -174,20 +174,24 @@ pub trait ChainEndpoint: Sized { request: QueryClientStatesRequest, ) -> Result, Error>; + /// Performs a query to retrieve the state of the specified light client. A + /// proof can optionally be returned along with the result. fn query_client_state( &self, request: QueryClientStateRequest, include_proof: IncludeProof, ) -> Result<(AnyClientState, Option), Error>; - /// Performs a query to retrieve the consensus state (for a specific height `consensus_height`) - /// that an on-chain client stores. + /// Performs a query to retrieve the consensus state for a specified height + /// `consensus_height` that the specified light client stores. fn query_consensus_state( &self, request: QueryConsensusStateRequest, include_proof: IncludeProof, ) -> Result<(AnyConsensusState, Option), Error>; + /// Performs a query to retrieve all the consensus states that the specified + /// light client stores. fn query_consensus_states( &self, request: QueryConsensusStatesRequest, @@ -215,81 +219,111 @@ pub trait ChainEndpoint: Sized { request: QueryClientConnectionsRequest, ) -> Result, Error>; + /// Performs a query to retrieve the connection associated with a given + /// connection identifier. A proof can optionally be returned along with the + /// result. fn query_connection( &self, request: QueryConnectionRequest, include_proof: IncludeProof, ) -> Result<(ConnectionEnd, Option), Error>; - /// Performs a query to retrieve the identifiers of all channels associated with a connection. + /// Performs a query to retrieve all channels associated with a connection. fn query_connection_channels( &self, request: QueryConnectionChannelsRequest, ) -> Result, Error>; - /// Performs a query to retrieve the identifiers of all channels. + /// Performs a query to retrieve all the channels of a chain. fn query_channels( &self, request: QueryChannelsRequest, ) -> Result, Error>; + /// Performs a query to retrieve the channel associated with a given channel + /// identifier. A proof can optionally be returned along with the result. fn query_channel( &self, request: QueryChannelRequest, include_proof: IncludeProof, ) -> Result<(ChannelEnd, Option), Error>; + /// Performs a query to retrieve the client state for the channel associated + /// with a given channel identifier. fn query_channel_client_state( &self, request: QueryChannelClientStateRequest, ) -> Result, Error>; + /// Performs a query to retrieve a stored packet commitment hash, stored on + /// the chain at path `path::CommitmentsPath`. A proof can optionally be + /// returned along with the result. fn query_packet_commitment( &self, request: QueryPacketCommitmentRequest, include_proof: IncludeProof, ) -> Result<(Vec, Option), Error>; - /// Queries all the packet commitments hashes associated with a channel. - /// Returns the corresponding packet sequence numbers. + /// Performs a query to retrieve all the packet commitments hashes + /// associated with a channel. Returns the corresponding packet sequence + /// numbers and the height at which they were retrieved. fn query_packet_commitments( &self, request: QueryPacketCommitmentsRequest, ) -> Result<(Vec, ICSHeight), Error>; + /// Performs a query to retrieve a given packet receipt, stored on the chain at path + /// `path::CommitmentsPath`. A proof can optionally be returned along with the result. fn query_packet_receipt( &self, request: QueryPacketReceiptRequest, include_proof: IncludeProof, ) -> Result<(Vec, Option), Error>; - /// Queries all the unreceived IBC packets associated with a channel and packet commit sequences. - /// Returns the corresponding packet sequence numbers. + /// Performs a query about which IBC packets in the specified list has not + /// been received. Returns the sequence numbers of the packets that were not + /// received. + /// + /// For example, given a request with the sequence numbers `[5,6,7,8]`, a + /// response of `[7,8]` would indicate that packets 5 & 6 were received, + /// while packets 7, 8 were not. fn query_unreceived_packets( &self, request: QueryUnreceivedPacketsRequest, ) -> Result, Error>; + /// Performs a query to retrieve a stored packet acknowledgement hash, + /// stored on the chain at path `path::AcksPath`. A proof can optionally be + /// returned along with the result. fn query_packet_acknowledgement( &self, request: QueryPacketAcknowledgementRequest, include_proof: IncludeProof, ) -> Result<(Vec, Option), Error>; - /// Queries all the packet acknowledgements associated with a channel. - /// Returns the corresponding packet sequence numbers. + /// Performs a query to retrieve all the packet acknowledgements associated + /// with a channel. Returns the corresponding packet sequence numbers and + /// the height at which they were retrieved. fn query_packet_acknowledgements( &self, request: QueryPacketAcknowledgementsRequest, ) -> Result<(Vec, ICSHeight), Error>; - /// Queries all the unreceived packet acknowledgements associated with a - /// Returns the corresponding packet sequence numbers. + /// Performs a query about which IBC packets in the specified list has not + /// been acknowledged. Returns the sequence numbers of the packets that were not + /// acknowledged. + /// + /// For example, given a request with the sequence numbers `[5,6,7,8]`, a + /// response of `[7,8]` would indicate that packets 5 & 6 were acknowledged, + /// while packets 7, 8 were not. fn query_unreceived_acknowledgements( &self, request: QueryUnreceivedAcksRequest, ) -> Result, Error>; + /// Performs a query to retrieve `nextSequenceRecv` stored at path + /// `path::SeqRecvsPath` as defined in ICS-4. A proof can optionally be + /// returned along with the result. fn query_next_sequence_receive( &self, request: QueryNextSequenceReceiveRequest, diff --git a/relayer/src/chain/counterparty.rs b/relayer/src/chain/counterparty.rs index f8a91832ba..acc75b26fd 100644 --- a/relayer/src/chain/counterparty.rs +++ b/relayer/src/chain/counterparty.rs @@ -432,7 +432,7 @@ pub fn unreceived_acknowledgements_sequences( } chain - .query_unreceived_acknowledgement(QueryUnreceivedAcksRequest { + .query_unreceived_acknowledgements(QueryUnreceivedAcksRequest { port_id: port_id.clone(), channel_id: *channel_id, packet_ack_sequences: acks_on_counterparty, diff --git a/relayer/src/chain/handle.rs b/relayer/src/chain/handle.rs index 96f916aff0..3ef1c8fd45 100644 --- a/relayer/src/chain/handle.rs +++ b/relayer/src/chain/handle.rs @@ -391,39 +391,48 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { /// Query the balance of the current account for the denom used to pay tx fees. fn query_balance(&self) -> Result; + /// Query the latest height and timestamp the application is at fn query_application_status(&self) -> Result; fn query_latest_height(&self) -> Result { Ok(self.query_application_status()?.height) } + /// Performs a query to retrieve the state of all clients that a chain hosts. fn query_clients( &self, request: QueryClientStatesRequest, ) -> Result, Error>; + /// Performs a query to retrieve the state of the specified light client. A + /// proof can optionally be returned along with the result. fn query_client_state( &self, request: QueryClientStateRequest, include_proof: IncludeProof, ) -> Result<(AnyClientState, Option), Error>; + /// Performs a query to retrieve the identifiers of all connections. fn query_client_connections( &self, request: QueryClientConnectionsRequest, ) -> Result, Error>; - fn query_consensus_states( - &self, - request: QueryConsensusStatesRequest, - ) -> Result, Error>; - + /// Performs a query to retrieve the consensus state for a specified height + /// `consensus_height` that the specified light client stores. fn query_consensus_state( &self, request: QueryConsensusStateRequest, include_proof: IncludeProof, ) -> Result<(AnyConsensusState, Option), Error>; + /// Performs a query to retrieve all the consensus states that the specified + /// light client stores. + fn query_consensus_states( + &self, + request: QueryConsensusStatesRequest, + ) -> Result, Error>; + fn query_upgraded_client_state( &self, request: QueryUpgradedClientStateRequest, @@ -438,39 +447,52 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { fn query_compatible_versions(&self) -> Result, Error>; + /// Performs a query to retrieve the connection associated with a given + /// connection identifier. A proof can optionally be returned along with the + /// result. fn query_connection( &self, request: QueryConnectionRequest, include_proof: IncludeProof, ) -> Result<(ConnectionEnd, Option), Error>; + /// Performs a query to retrieve the identifiers of all connections. fn query_connections( &self, request: QueryConnectionsRequest, ) -> Result, Error>; + /// Performs a query to retrieve all channels associated with a connection. fn query_connection_channels( &self, request: QueryConnectionChannelsRequest, ) -> Result, Error>; + /// Performs a query to retrieve `nextSequenceRecv` stored at path + /// `path::SeqRecvsPath` as defined in ICS-4. A proof can optionally be + /// returned along with the result. fn query_next_sequence_receive( &self, request: QueryNextSequenceReceiveRequest, include_proof: IncludeProof, ) -> Result<(Sequence, Option), Error>; + /// Performs a query to retrieve all the channels of a chain. fn query_channels( &self, request: QueryChannelsRequest, ) -> Result, Error>; + /// Performs a query to retrieve the channel associated with a given channel + /// identifier. A proof can optionally be returned along with the result. fn query_channel( &self, request: QueryChannelRequest, include_proof: IncludeProof, ) -> Result<(ChannelEnd, Option), Error>; + /// Performs a query to retrieve the client state for the channel associated + /// with a given channel identifier. fn query_channel_client_state( &self, request: QueryChannelClientStateRequest, @@ -528,40 +550,68 @@ pub trait ChainHandle: Clone + Send + Sync + Serialize + Debug + 'static { height: Height, ) -> Result; + /// Performs a query to retrieve a stored packet commitment hash, stored on + /// the chain at path `path::CommitmentsPath`. A proof can optionally be + /// returned along with the result. fn query_packet_commitment( &self, request: QueryPacketCommitmentRequest, include_proof: IncludeProof, ) -> Result<(Vec, Option), Error>; + /// Performs a query to retrieve all the packet commitments hashes + /// associated with a channel. Returns the corresponding packet sequence + /// numbers and the height at which they were retrieved. fn query_packet_commitments( &self, request: QueryPacketCommitmentsRequest, ) -> Result<(Vec, Height), Error>; + /// Performs a query to retrieve a given packet receipt, stored on the chain at path + /// `path::CommitmentsPath`. A proof can optionally be returned along with the result. fn query_packet_receipt( &self, request: QueryPacketReceiptRequest, include_proof: IncludeProof, ) -> Result<(Vec, Option), Error>; + /// Performs a query about which IBC packets in the specified list has not + /// been received. Returns the sequence numbers of the packets that were not + /// received. + /// + /// For example, given a request with the sequence numbers `[5,6,7,8]`, a + /// response of `[7,8]` would indicate that packets 5 & 6 were received, + /// while packets 7, 8 were not. fn query_unreceived_packets( &self, request: QueryUnreceivedPacketsRequest, ) -> Result, Error>; + /// Performs a query to retrieve a stored packet acknowledgement hash, + /// stored on the chain at path `path::AcksPath`. A proof can optionally be + /// returned along with the result. fn query_packet_acknowledgement( &self, request: QueryPacketAcknowledgementRequest, include_proof: IncludeProof, ) -> Result<(Vec, Option), Error>; + /// Performs a query to retrieve all the packet acknowledgements associated + /// with a channel. Returns the corresponding packet sequence numbers and + /// the height at which they were retrieved. fn query_packet_acknowledgements( &self, request: QueryPacketAcknowledgementsRequest, ) -> Result<(Vec, Height), Error>; - fn query_unreceived_acknowledgement( + /// Performs a query about which IBC packets in the specified list has not + /// been acknowledged. Returns the sequence numbers of the packets that were not + /// acknowledged. + /// + /// For example, given a request with the sequence numbers `[5,6,7,8]`, a + /// response of `[7,8]` would indicate that packets 5 & 6 were acknowledged, + /// while packets 7, 8 were not. + fn query_unreceived_acknowledgements( &self, request: QueryUnreceivedAcksRequest, ) -> Result, Error>; diff --git a/relayer/src/chain/handle/base.rs b/relayer/src/chain/handle/base.rs index 5fa482e403..21ff4d444d 100644 --- a/relayer/src/chain/handle/base.rs +++ b/relayer/src/chain/handle/base.rs @@ -448,7 +448,7 @@ impl ChainHandle for BaseChainHandle { self.send(|reply_to| ChainRequest::QueryPacketAcknowledgements { request, reply_to }) } - fn query_unreceived_acknowledgement( + fn query_unreceived_acknowledgements( &self, request: QueryUnreceivedAcksRequest, ) -> Result, Error> { diff --git a/relayer/src/chain/handle/cache.rs b/relayer/src/chain/handle/cache.rs index dc3fe89654..306bb6c0b2 100644 --- a/relayer/src/chain/handle/cache.rs +++ b/relayer/src/chain/handle/cache.rs @@ -456,11 +456,11 @@ impl ChainHandle for CachingChainHandle { self.inner().query_packet_acknowledgements(request) } - fn query_unreceived_acknowledgement( + fn query_unreceived_acknowledgements( &self, request: QueryUnreceivedAcksRequest, ) -> Result, Error> { - self.inner().query_unreceived_acknowledgement(request) + self.inner().query_unreceived_acknowledgements(request) } fn query_txs(&self, request: QueryTxRequest) -> Result, Error> { diff --git a/relayer/src/chain/handle/counting.rs b/relayer/src/chain/handle/counting.rs index b8ae50806e..09d8ea1d0c 100644 --- a/relayer/src/chain/handle/counting.rs +++ b/relayer/src/chain/handle/counting.rs @@ -438,12 +438,12 @@ impl ChainHandle for CountingChainHandle { self.inner().query_packet_acknowledgements(request) } - fn query_unreceived_acknowledgement( + fn query_unreceived_acknowledgements( &self, request: QueryUnreceivedAcksRequest, ) -> Result, Error> { self.inc_metric("query_unreceived_acknowledgement"); - self.inner().query_unreceived_acknowledgement(request) + self.inner().query_unreceived_acknowledgements(request) } fn query_txs(&self, request: QueryTxRequest) -> Result, Error> { diff --git a/relayer/src/link/relay_path.rs b/relayer/src/link/relay_path.rs index c92a0cb693..0884db4642 100644 --- a/relayer/src/link/relay_path.rs +++ b/relayer/src/link/relay_path.rs @@ -809,7 +809,7 @@ impl RelayPath { fn recv_packet_acknowledged_on_src(&self, packet: &Packet) -> Result { let unreceived_ack = self .dst_chain() - .query_unreceived_acknowledgement(QueryUnreceivedAcksRequest { + .query_unreceived_acknowledgements(QueryUnreceivedAcksRequest { port_id: self.dst_port_id().clone(), channel_id: *self.dst_channel_id(), packet_ack_sequences: vec![packet.sequence], diff --git a/tools/test-framework/src/relayer/chain.rs b/tools/test-framework/src/relayer/chain.rs index 62e48160be..4245b8c465 100644 --- a/tools/test-framework/src/relayer/chain.rs +++ b/tools/test-framework/src/relayer/chain.rs @@ -372,11 +372,11 @@ where self.value().query_packet_acknowledgements(request) } - fn query_unreceived_acknowledgement( + fn query_unreceived_acknowledgements( &self, request: QueryUnreceivedAcksRequest, ) -> Result, Error> { - self.value().query_unreceived_acknowledgement(request) + self.value().query_unreceived_acknowledgements(request) } fn query_txs(&self, request: QueryTxRequest) -> Result, Error> { From 92450232abf64c1b991a3c2d95ffa2891eff5037 Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Tue, 31 May 2022 16:37:24 -0400 Subject: [PATCH 17/19] changelog --- .../improvements/relayer/2223-consolidate-chain-query-proven.md | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 .changelog/unreleased/improvements/relayer/2223-consolidate-chain-query-proven.md diff --git a/.changelog/unreleased/improvements/relayer/2223-consolidate-chain-query-proven.md b/.changelog/unreleased/improvements/relayer/2223-consolidate-chain-query-proven.md new file mode 100644 index 0000000000..df7817429a --- /dev/null +++ b/.changelog/unreleased/improvements/relayer/2223-consolidate-chain-query-proven.md @@ -0,0 +1,2 @@ +- Consolidate ChainEndpoint::proven_* methods with their corresponding query_*() + form ([#2223](https://github.com/informalsystems/ibc-rs/issues/2223)) \ No newline at end of file From 399e5f24062f453386b60420bde187b5f11e3727 Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Wed, 1 Jun 2022 12:01:44 -0400 Subject: [PATCH 18/19] fix compilation errors --- relayer-cli/src/commands/query/channel_client.rs | 2 +- tools/integration-test/src/mbt/utils.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/relayer-cli/src/commands/query/channel_client.rs b/relayer-cli/src/commands/query/channel_client.rs index c803e6ccb5..fef376e3a7 100644 --- a/relayer-cli/src/commands/query/channel_client.rs +++ b/relayer-cli/src/commands/query/channel_client.rs @@ -35,7 +35,7 @@ impl Runnable for QueryChannelClientCmd { match chain.query_channel_client_state(QueryChannelClientStateRequest { port_id: self.port_id.clone(), - channel_id: self.channel_id.clone(), + channel_id: self.channel_id, }) { Ok(cs) => Output::success(cs).exit(), Err(e) => Output::error(format!("{}", e)).exit(), diff --git a/tools/integration-test/src/mbt/utils.rs b/tools/integration-test/src/mbt/utils.rs index 97af0c01cc..1245f3d6b2 100644 --- a/tools/integration-test/src/mbt/utils.rs +++ b/tools/integration-test/src/mbt/utils.rs @@ -115,7 +115,7 @@ pub fn get_unacknowledged_packets_at_src( From 54c8127586d33156b302d979a68984046999031a Mon Sep 17 00:00:00 2001 From: Philippe Laferriere Date: Mon, 6 Jun 2022 12:51:48 -0400 Subject: [PATCH 19/19] mock consensus_state query --- relayer/src/chain/mock.rs | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/relayer/src/chain/mock.rs b/relayer/src/chain/mock.rs index a7fa857f1b..a98461ef46 100644 --- a/relayer/src/chain/mock.rs +++ b/relayer/src/chain/mock.rs @@ -422,14 +422,12 @@ impl ChainEndpoint for MockChain { assert!(matches!(include_proof, IncludeProof::No)); let consensus_states = self.context.consensus_states(&request.client_id); - Ok(( - consensus_states - .into_iter() - .find(|s| s.height == request.consensus_height) - .unwrap() - .consensus_state, - None, - )) + let consensus_state = consensus_states + .into_iter() + .find(|s| s.height == request.consensus_height) + .ok_or_else(|| Error::query("Invalid consensus height".into()))? + .consensus_state; + Ok((consensus_state, None)) } fn query_upgraded_consensus_state(