Channel upgradability

Cargo.toml

@@ -15,8 +15,8 @@ members = [
     "tools/query-events",
 ]
 
-# [patch.crates-io]
-# ibc-proto                        = { git = "https://github.com/cosmos/ibc-proto-rs.git",       branch = "main" }
+[patch.crates-io]
+ibc-proto                        = { git = "https://github.com/cosmos/ibc-proto-rs.git",       branch = "romac/channel-upgrade-only" }
 # tendermint                       = { git = "https://github.com/informalsystems/tendermint-rs", branch = "main" }
 # tendermint-rpc                   = { git = "https://github.com/informalsystems/tendermint-rs", branch = "main" }
 # tendermint-proto                 = { git = "https://github.com/informalsystems/tendermint-rs", branch = "main" }

crates/relayer-cli/src/commands/tx/channel.rs

@@ -16,6 +16,19 @@ use crate::conclude::Output;
 use crate::error::Error;
 use crate::prelude::*;
 
+/// Macro that generates the `Runnable::run` implementation for a
+/// `tx channel` subcommand.
+///
+/// The macro takes the following arguments:
+/// - `$dbg_string`: a string literal that will be used to identify the subcommand
+///  in debug logs
+/// - `$func`: the method that will be called to build and send the `Channel` message
+/// - `$self`: the type that `Runnable` is being implemented for
+/// - `$chan`: a closure that specifies how to build the `Channel` object
+///
+/// The macro spawns a `ChainHandlePair`, fetches the destination connection,
+/// creates a `Channel` object via the closure, and then calls the `$func` method
+/// with the `Channel` object.
 macro_rules! tx_chan_cmd {
     ($dbg_string:literal, $func:ident, $self:expr, $chan:expr) => {
         let config = app_config();
@@ -110,56 +123,33 @@ pub struct TxChanOpenInitCmd {
 
 impl Runnable for TxChanOpenInitCmd {
     fn run(&self) {
-        let config = app_config();
-
-        let chains = match ChainHandlePair::spawn(&config, &self.src_chain_id, &self.dst_chain_id) {
-            Ok(chains) => chains,
-            Err(e) => Output::error(e).exit(),
-        };
-
-        // Retrieve the connection
-        let dst_connection = match chains.dst.query_connection(
-            QueryConnectionRequest {
-                connection_id: self.dst_conn_id.clone(),
-                height: QueryHeight::Latest,
-            },
-            IncludeProof::No,
-        ) {
-            Ok((connection, _)) => connection,
-            Err(e) => Output::error(e).exit(),
-        };
-
-        let channel = Channel {
-            connection_delay: Default::default(),
-            ordering: self.order,
-            a_side: ChannelSide::new(
-                chains.src,
-                ClientId::default(),
-                ConnectionId::default(),
-                self.src_port_id.clone(),
-                None,
-                None,
-            ),
-            b_side: ChannelSide::new(
-                chains.dst,
-                dst_connection.client_id().clone(),
-                self.dst_conn_id.clone(),
-                self.dst_port_id.clone(),
-                None,
-                None,
-            ),
-        };
-
-        info!("message ChanOpenInit: {}", channel);
-
-        let res: Result<IbcEvent, Error> = channel
-            .build_chan_open_init_and_send()
-            .map_err(Error::channel);
-
-        match res {
-            Ok(receipt) => Output::success(receipt).exit(),
-            Err(e) => Output::error(e).exit(),
-        }
+        tx_chan_cmd!(
+            "ChanOpenInit",
+            build_chan_open_init_and_send,
+            self,
+            |chains: ChainHandlePair, dst_connection: ConnectionEnd| {
+                Channel {
+                    connection_delay: Default::default(),
+                    ordering: self.order,
+                    a_side: ChannelSide::new(
+                        chains.src,
+                        ClientId::default(),
+                        ConnectionId::default(),
+                        self.src_port_id.clone(),
+                        None,
+                        None,
+                    ),
+                    b_side: ChannelSide::new(
+                        chains.dst,
+                        dst_connection.client_id().clone(),
+                        self.dst_conn_id.clone(),
+                        self.dst_port_id.clone(),
+                        None,
+                        None,
+                    ),
+                }
+            }
+        );
     }
 }
 
@@ -666,6 +656,194 @@ impl Runnable for TxChanCloseConfirmCmd {
     }
 }
 
+// FIXME: Since the channel already exists, we don't need both the src and dst chain,
+// only the src/dst chain and src/dst channel.
+//
+// TODO: Add arguments for version, ordering, connection hops and timeouts.
+
+/// Build and send a `ChanUpgradeInit` message to a destination
+/// chain that the source chain has an already-existing channel open
+/// with, signaling the intent by the source chain to perform
+/// the channel upgrade handshake.
+#[derive(Clone, Command, Debug, Parser, PartialEq, Eq)]
+pub struct TxChanUpgradeInitCmd {
+    #[clap(
+        long = "dst-chain",
+        required = true,
+        value_name = "DST_CHAIN_ID",
+        help_heading = "REQUIRED",
+        help = "Identifier of the destination chain"
+    )]
+    dst_chain_id: ChainId,
+
+    #[clap(
+        long = "src-chain",
+        required = true,
+        value_name = "SRC_CHAIN_ID",
+        help_heading = "REQUIRED",
+        help = "Identifier of the source chain"
+    )]
+    src_chain_id: ChainId,
+
+    #[clap(
+        long = "dst-connection",
+        visible_alias = "dst-conn",
+        required = true,
+        value_name = "DST_CONNECTION_ID",
+        help_heading = "REQUIRED",
+        help = "Identifier of the destination connection"
+    )]
+    dst_conn_id: ConnectionId,
+
+    #[clap(
+        long = "dst-port",
+        required = true,
+        value_name = "DST_PORT_ID",
+        help_heading = "REQUIRED",
+        help = "Identifier of the destination port"
+    )]
+    dst_port_id: PortId,
+
+    #[clap(
+        long = "src-port",
+        required = true,
+        value_name = "SRC_PORT_ID",
+        help_heading = "REQUIRED",
+        help = "Identifier of the source port"
+    )]
+    src_port_id: PortId,
+
+    #[clap(
+        long = "dst-channel",
+        visible_alias = "dst-chan",
+        required = true,
+        value_name = "DST_CHANNEL_ID",
+        help_heading = "REQUIRED",
+        help = "Identifier of the destination channel (required)"
+    )]
+    dst_chan_id: ChannelId,
+
+    #[clap(
+        long = "src-channel",
+        visible_alias = "src-chan",
+        required = true,
+        value_name = "SRC_CHANNEL_ID",
+        help_heading = "REQUIRED",
+        help = "Identifier of the source channel (required)"
+    )]
+    src_chan_id: ChannelId,
+}
+
+impl Runnable for TxChanUpgradeInitCmd {
+    fn run(&self) {
+        // TODO: Take version, connections hops, ordering and timeouts and hops from the arguments
+        // and pass them to build_chan_upgrade_init_and_send
+
+        // tx_chan_cmd!(
+        //     "ChanUpgradeInit",
+        //     build_chan_upgrade_init_and_send,
+        //     self,
+        //     |chains: ChainHandlePair, dst_connection: ConnectionEnd| {
+        //         Channel {
+        //             connection_delay: Default::default(),
+        //             ordering: Order::default(),
+        //             a_side: ChannelSide::new(
+        //                 chains.src,
+        //                 ClientId::default(),
+        //                 ConnectionId::default(),
+        //                 self.src_port_id.clone(),
+        //                 Some(self.src_chan_id.clone()),
+        //                 None,
+        //             ),
+        //             b_side: ChannelSide::new(
+        //                 chains.dst,
+        //                 dst_connection.client_id().clone(),
+        //                 self.dst_conn_id.clone(),
+        //                 self.dst_port_id.clone(),
+        //                 Some(self.dst_chan_id.clone()),
+        //                 None,
+        //             ),
+        //         }
+        //     }
+        // );
+    }
+}
+
+/// Build and send a `ChanUpgradeTry` message in response to
+/// a `ChanUpgradeInnit` message, signaling the chain's intent to
+/// cooperate with the source chain on upgrading the specified channel
+///  and initiating the upgrade handshake.
+#[derive(Clone, Command, Debug, Parser, PartialEq, Eq)]
+pub struct TxChanUpgradeTryCmd {
+    #[clap(
+        long = "dst-chain",
+        required = true,
+        value_name = "DST_CHAIN_ID",
+        help_heading = "REQUIRED",
+        help = "Identifier of the destination chain"
+    )]
+    dst_chain_id: ChainId,
+
+    #[clap(
+        long = "src-chain",
+        required = true,
+        value_name = "SRC_CHAIN_ID",
+        help_heading = "REQUIRED",
+        help = "Identifier of the source chain"
+    )]
+    src_chain_id: ChainId,
+
+    #[clap(
+        long = "dst-connection",
+        visible_alias = "dst-conn",
+        required = true,
+        value_name = "DST_CONNECTION_ID",
+        help_heading = "REQUIRED",
+        help = "Identifier of the destination connection"
+    )]
+    dst_conn_id: ConnectionId,
+
+    #[clap(
+        long = "dst-port",
+        required = true,
+        value_name = "DST_PORT_ID",
+        help_heading = "REQUIRED",
+        help = "Identifier of the destination port"
+    )]
+    dst_port_id: PortId,
+
+    #[clap(
+        long = "src-port",
+        required = true,
+        value_name = "SRC_PORT_ID",
+        help_heading = "REQUIRED",
+        help = "Identifier of the source port"
+    )]
+    src_port_id: PortId,
+
+    #[clap(
+        long = "src-channel",
+        visible_alias = "src-chan",
+        required = true,
+        value_name = "SRC_CHANNEL_ID",
+        help_heading = "REQUIRED",
+        help = "Identifier of the source channel (required)"
+    )]
+    src_chan_id: ChannelId,
+
+    #[clap(
+        long = "dst-channel",
+        visible_alias = "dst-chan",
+        value_name = "DST_CHANNEL_ID",
+        help = "Identifier of the destination channel (optional)"
+    )]
+    dst_chan_id: Option<ChannelId>,
+}
+
+impl Runnable for TxChanUpgradeTryCmd {
+    fn run(&self) {}
+}
+
 #[cfg(test)]
 mod tests {
     use super::{

crates/relayer-types/src/core/ics04_channel/channel.rs

@@ -323,6 +323,8 @@ impl From<Counterparty> for RawCounterparty {
     }
 }
 
+pub type Ordering = Order;
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize, Default)]
 pub enum Order {
     None = 0,
@@ -371,13 +373,22 @@ impl FromStr for Order {
     }
 }
 
+/// The possible state variants that a channel can exhibit.
+///
+/// These are encoded with integer discriminants so that there is
+/// an easy way to compare channel states against one another. More
+/// explicitly, this is an attempt to capture the lifecycle of a
+/// channel, beginning from the `Uninitialized` state, through the
+/// `Open` state, before finally being `Closed`.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum State {
     Uninitialized = 0,
     Init = 1,
     TryOpen = 2,
     Open = 3,
-    Closed = 4,
+    InitUpgrade = 4,
+    TryUpgrade = 5,
+    Closed = 6,
 }
 
 impl State {
@@ -389,6 +400,8 @@ impl State {
             Self::TryOpen => "TRYOPEN",
             Self::Open => "OPEN",
             Self::Closed => "CLOSED",
+            Self::InitUpgrade => "INITUPGRADE",
+            Self::TryUpgrade => "TRYUPGRADE",
         }
     }
 
@@ -399,7 +412,9 @@ impl State {
             1 => Ok(Self::Init),
             2 => Ok(Self::TryOpen),
             3 => Ok(Self::Open),
-            4 => Ok(Self::Closed),
+            4 => Ok(Self::InitUpgrade),
+            5 => Ok(Self::TryUpgrade),
+            6 => Ok(Self::Closed),
             _ => Err(Error::unknown_state(s)),
         }
     }