Channel upgrade worker handshake

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

@@ -410,7 +410,7 @@
     /// During some steps of channel upgrades, the state is still in Open. The
     /// `UpgradeState` is used to differentiate these states during the upgrade
     /// handshake.
     /// https://github.com/cosmos/ibc/blob/main/spec/core/ics-004-channel-and-packet-semantics/UPGRADES.md#upgrade-handshake
     Open(UpgradeState),
     /// A channel has been closed and can no longer be used to send or receive
     /// packets.
@@ -474,6 +474,7 @@
 
     /// Returns whether or not the channel with this state
     /// has progressed less or the same than the argument.
+    /// This only takes into account the open channel handshake.
     ///
     /// # Example
     /// ```rust,ignore
@@ -490,30 +491,22 @@
             Init => !matches!(other, Uninitialized),
             TryOpen => !matches!(other, Uninitialized | Init),
             Open(UpgradeState::NotUpgrading) => !matches!(other, Uninitialized | Init | TryOpen),
-            Open(UpgradeState::Upgrading) => !matches!(
-                other,
-                Uninitialized | Init | TryOpen | Open(UpgradeState::NotUpgrading)
-            ),
+            _ => false,
+        }
+    }
 
-            Flushing => !matches!(
-                other,
-                Uninitialized
-                    | Init
-                    | TryOpen
-                    | Open(UpgradeState::NotUpgrading)
-                    | Open(UpgradeState::Upgrading)
-            ),
-            Flushcomplete => !matches!(
+    /// Returns whether or not the channel with this state is
+    /// being upgraded.
+    pub fn is_upgrading(self, other: Self) -> bool {
+        use State::*;
+
+        match self {
+            Open(UpgradeState::NotUpgrading) => matches!(
                 other,
-                Uninitialized
-                    | Init
-                    | TryOpen
-                    | Open(UpgradeState::NotUpgrading)
-                    | Open(UpgradeState::Upgrading)
-                    | Flushing
+                Open(UpgradeState::Upgrading) | Flushing | Flushcomplete
             ),
-
-            Closed => false,
+            Open(UpgradeState::Upgrading) | Flushing | Flushcomplete => true,
+            _ => false,
         }
     }
 }
@@ -690,4 +683,119 @@
             }
         }
     }
+
+    #[test]
+    fn less_or_equal_progress_uninitialized() {
+        use crate::core::ics04_channel::channel::State;
+        use crate::core::ics04_channel::channel::UpgradeState;
+
+        let higher_or_equal_states = vec![
+            State::Uninitialized,
+            State::Init,
+            State::TryOpen,
+            State::Open(UpgradeState::NotUpgrading),
+            State::Open(UpgradeState::Upgrading),
+            State::Closed,
+            State::Flushing,
+            State::Flushcomplete,
+        ];
+        for state in higher_or_equal_states {
+            assert!(State::Uninitialized.less_or_equal_progress(state))
+        }
+    }
+
+    #[test]
+    fn less_or_equal_progress_init() {
+        use crate::core::ics04_channel::channel::State;
+        use crate::core::ics04_channel::channel::UpgradeState;
+
+        let lower_states = vec![State::Uninitialized];
+        let higher_or_equal_states = vec![
+            State::Init,
+            State::TryOpen,
+            State::Open(UpgradeState::NotUpgrading),
+            State::Open(UpgradeState::Upgrading),
+            State::Closed,
+            State::Flushing,
+            State::Flushcomplete,
+        ];
+        for state in lower_states {
+            assert!(!State::Init.less_or_equal_progress(state));
+        }
+        for state in higher_or_equal_states {
+            assert!(State::Init.less_or_equal_progress(state))
+        }
+    }
+
+    #[test]
+    fn less_or_equal_progress_tryopen() {
+        use crate::core::ics04_channel::channel::State;
+        use crate::core::ics04_channel::channel::UpgradeState;
+
+        let lower_states = vec![State::Uninitialized, State::Init];
+        let higher_or_equal_states = vec![
+            State::TryOpen,
+            State::Open(UpgradeState::NotUpgrading),
+            State::Open(UpgradeState::Upgrading),
+            State::Closed,
+            State::Flushing,
+            State::Flushcomplete,
+        ];
+        for state in lower_states {
+            assert!(!State::TryOpen.less_or_equal_progress(state));
+        }
+        for state in higher_or_equal_states {
+            assert!(State::TryOpen.less_or_equal_progress(state))
+        }
+    }
+
+    #[test]
+    fn less_or_equal_progress_open_not_upgrading() {
+        use crate::core::ics04_channel::channel::State;
+        use crate::core::ics04_channel::channel::UpgradeState;
+
+        let lower_states = vec![State::Uninitialized, State::Init, State::TryOpen];
+        let higher_or_equal_states = vec![
+            State::Open(UpgradeState::NotUpgrading),
+            State::Open(UpgradeState::Upgrading),
+            State::Closed,
+            State::Flushing,
+            State::Flushcomplete,
+        ];
+        for state in lower_states {
+            assert!(!State::Open(UpgradeState::NotUpgrading).less_or_equal_progress(state));
+        }
+        for state in higher_or_equal_states {
+            assert!(State::Open(UpgradeState::NotUpgrading).less_or_equal_progress(state))
+        }
+    }
+
+    #[test]
+    fn less_or_equal_progress_upgrading_states() {
+        use crate::core::ics04_channel::channel::State;
+        use crate::core::ics04_channel::channel::UpgradeState;
+
+        let states = [
+            State::Uninitialized,
+            State::Init,
+            State::TryOpen,
+            State::Open(UpgradeState::NotUpgrading),
+            State::Open(UpgradeState::Upgrading),
+            State::Closed,
+            State::Flushing,
+            State::Flushcomplete,
+        ];
+
+        let upgrading_states = vec![
+            State::Open(UpgradeState::Upgrading),
+            State::Closed,
+            State::Flushing,
+            State::Flushcomplete,
+        ];
+        for upgrade_state in upgrading_states {
+            for state in states.iter() {
+                assert!(!upgrade_state.less_or_equal_progress(*state));
+            }
+        }
+    }
 }

crates/relayer/src/channel.rs

@@ -793,7 +793,7 @@ impl<ChainA: ChainHandle, ChainB: ChainHandle> Channel<ChainA, ChainB> {
             (State::Flushcomplete, State::Flushing) => {
                 Some(self.build_chan_upgrade_confirm_and_send()?)
             }
-            (State::Open(UpgradeState::Upgrading), State::Flushcomplete) => {
+            (State::Open(_), State::Flushcomplete) => {
                 Some(self.build_chan_upgrade_open_and_send()?)
             }
 

crates/relayer/src/supervisor/spawn.rs

@@ -315,14 +315,16 @@ impl<'a, Chain: ChainHandle> SpawnContext<'a, Chain> {
             let open_handshake = chan_state_dst.less_or_equal_progress(ChannelState::TryOpen)
                 && chan_state_dst.less_or_equal_progress(chan_state_src);
 
+            let upgrade_handshake = chan_state_dst.is_upgrading(chan_state_src);
+
             // Determine if close handshake is required, i.e. if channel state on source is `Closed`,
             // and on destination channel state is not `Closed, and there are no pending packets.
             // If there are pending packets on destination then we let the packet worker clear the
             // packets and we do not finish the channel handshake.
             let close_handshake =
                 chan_state_src.is_closed() && !chan_state_dst.is_closed() && !has_packets();
 
-            if open_handshake || close_handshake {
+            if open_handshake || upgrade_handshake || close_handshake {
                 // create worker for channel handshake that will advance the counterparty state
                 let channel_object = Object::Channel(Channel {
                     dst_chain_id: counterparty_chain.id(),

tools/integration-test/src/tests/channel_upgrade/mod.rs

@@ -1,3 +1,3 @@
 pub mod ics29;
-pub mod manual_channel_upgrade;
 pub mod upgrade_handshake;
+pub mod upgrade_handshake_steps;