imp(core-host-types): add new storage paths

ibc-core/ics24-host/types/src/path.rs

@@ -22,8 +22,13 @@
 /// The Path enum abstracts out the different sub-paths.
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, From, Display)]
 pub enum Path {
+    NextClientSequence(NextClientSequencePath),
+    NextConnectionSequence(NextConnectionSequencePath),
+    NextChannelSequence(NextChannelSequencePath),
     ClientState(ClientStatePath),
     ClientConsensusState(ClientConsensusStatePath),
+    ClientUpdateTime(ClientUpdateTimePath),
+    ClientUpdateHeight(ClientUpdateHeightPath),
     ClientConnection(ClientConnectionPath),
     Connection(ConnectionPath),
     Ports(PortPath),
@@ -37,6 +42,57 @@
     UpgradeClient(UpgradeClientPath),
 }
 
+#[cfg_attr(
+    feature = "parity-scale-codec",
+    derive(
+        parity_scale_codec::Encode,
+        parity_scale_codec::Decode,
+        scale_info::TypeInfo
+    )
+)]
+#[cfg_attr(
+    feature = "borsh",
+    derive(borsh::BorshSerialize, borsh::BorshDeserialize)
+)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Display)]
+#[display(fmt = "nextClientSequence")]
+pub struct NextClientSequencePath;
+
+#[cfg_attr(
+    feature = "parity-scale-codec",
+    derive(
+        parity_scale_codec::Encode,
+        parity_scale_codec::Decode,
+        scale_info::TypeInfo
+    )
+)]
+#[cfg_attr(
+    feature = "borsh",
+    derive(borsh::BorshSerialize, borsh::BorshDeserialize)
+)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Display)]
+#[display(fmt = "nextConnectionSequence")]
+pub struct NextConnectionSequencePath;
+
+#[cfg_attr(
+    feature = "parity-scale-codec",
+    derive(
+        parity_scale_codec::Encode,
+        parity_scale_codec::Decode,
+        scale_info::TypeInfo
+    )
+)]
+#[cfg_attr(
+    feature = "borsh",
+    derive(borsh::BorshSerialize, borsh::BorshDeserialize)
+)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Display)]
+#[display(fmt = "nextChannelSequence")]
+pub struct NextChannelSequencePath;
+
 #[cfg_attr(
     feature = "parity-scale-codec",
     derive(
@@ -95,6 +151,72 @@
     }
 }
 
+#[cfg_attr(
+    feature = "parity-scale-codec",
+    derive(
+        parity_scale_codec::Encode,
+        parity_scale_codec::Decode,
+        scale_info::TypeInfo
+    )
+)]
+#[cfg_attr(
+    feature = "borsh",
+    derive(borsh::BorshSerialize, borsh::BorshDeserialize)
+)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Display)]
+#[display(
+    fmt = "clients/{client_id}/consensusStates/{revision_number}-{revision_height}/processedTime"
+)]
+pub struct ClientUpdateTimePath {
+    pub client_id: ClientId,
+    pub revision_number: u64,
+    pub revision_height: u64,
+}
+
+impl ClientUpdateTimePath {
+    pub fn new(client_id: ClientId, revision_number: u64, revision_height: u64) -> Self {
+        Self {
+            client_id,
+            revision_number,
+            revision_height,
+        }
+    }
+}
+
+#[cfg_attr(
+    feature = "parity-scale-codec",
+    derive(
+        parity_scale_codec::Encode,
+        parity_scale_codec::Decode,
+        scale_info::TypeInfo
+    )
+)]
+#[cfg_attr(
+    feature = "borsh",
+    derive(borsh::BorshSerialize, borsh::BorshDeserialize)
+)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Display)]
+#[display(
+    fmt = "clients/{client_id}/consensusStates/{revision_number}-{revision_height}/processedHeight"
+)]
+pub struct ClientUpdateHeightPath {
+    pub client_id: ClientId,
+    pub revision_number: u64,
+    pub revision_height: u64,
+}
+
+impl ClientUpdateHeightPath {
+    pub fn new(client_id: ClientId, revision_number: u64, revision_height: u64) -> Self {
+        Self {
+            client_id,
+            revision_number,
+            revision_height,
+        }
+    }
+}
+
 #[cfg_attr(
     feature = "parity-scale-codec",
     derive(
@@ -414,7 +536,8 @@
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let components: Vec<&str> = s.split('/').collect();
 
-        parse_client_paths(&components)
+        parse_next_sequence(&components)
+            .or_else(|| parse_client_paths(&components))
             .or_else(|| parse_connections(&components))
             .or_else(|| parse_ports(&components))
             .or_else(|| parse_channel_ends(&components))
@@ -429,6 +552,19 @@
     }
 }
 
+fn parse_next_sequence(components: &[&str]) -> Option<Path> {
+    if components.len() != 1 {
+        return None;
+    }
+
+    match *components.first()? {
+        "nextClientSequence" => Some(NextClientSequencePath.into()),
+        "nextConnectionSequence" => Some(NextConnectionSequencePath.into()),
+        "nextChannelSequence" => Some(NextChannelSequencePath.into()),
+        _ => None,
+    }
+}
+
 fn parse_client_paths(components: &[&str]) -> Option<Path> {
     let first = match components.first() {
         Some(f) => *f,
@@ -450,17 +586,13 @@
             "connections" => Some(ClientConnectionPath(client_id).into()),
             _ => None,
         }
-    } else if components.len() == 4 {
-        if "consensusStates" != components[2] {
-            return None;
+    } else if components.len() == 4 || components.len() == 5 {
+        match components[2] {
+            "consensusStates" => {}
+            _ => return None,
         }
 
-        let epoch_height = match components.last() {
-            Some(eh) => *eh,
-            None => return None,
-        };
-
-        let epoch_height: Vec<&str> = epoch_height.split('-').collect();
+        let epoch_height: Vec<&str> = components[3].split('-').collect();
 
         if epoch_height.len() != 2 {
             return None;
@@ -479,14 +611,36 @@
             Err(_) => return None,
         };
 
-        Some(
-            ClientConsensusStatePath {
-                client_id,
-                revision_number,
-                revision_height,
-            }
-            .into(),
-        )
+        match components.len() {
+            4 => Some(
+                ClientConsensusStatePath {
+                    client_id,
+                    revision_number,
+                    revision_height,
+                }
+                .into(),
+            ),
+            5 => match components[4] {
+                "processedTime" => Some(
+                    ClientUpdateTimePath {
+                        client_id,
+                        revision_number,
+                        revision_height,
+                    }
+                    .into(),
+                ),
+                "processedHeight" => Some(
+                    ClientUpdateHeightPath {
+                        client_id,
+                        revision_number,
+                        revision_height,
+                    }
+                    .into(),
+                ),
+                _ => None,
+            },
+            _ => None,
+        }
     } else {
         None
     }
@@ -840,6 +994,28 @@
 
     use super::*;
 
+    #[test]
+    fn test_parse_next_sequence_fn() {
+        let path = "nextClientSequence";
+
+        assert!(matches!(
+            Path::from_str(path),
+            Ok(Path::NextClientSequence(NextClientSequencePath))
+        ));
+
+        let path = "nextConnectionSequence";
+        assert!(matches!(
+            Path::from_str(path),
+            Ok(Path::NextConnectionSequence(NextConnectionSequencePath))
+        ));
+
+        let path = "nextChannelSequence";
+        assert!(matches!(
+            Path::from_str(path),
+            Ok(Path::NextChannelSequence(NextChannelSequencePath))
+        ));
+    }
+
     #[test]
     fn invalid_path_doesnt_parse() {
         let invalid_path = Path::from_str("clients/clientType");
@@ -870,6 +1046,33 @@
         );
     }
 
+    #[test]
+    fn test_parse_client_update_paths_fn() {
+        let path = "clients/07-tendermint-0/consensusStates/15-31/processedTime";
+        let components: Vec<&str> = path.split('/').collect();
+
+        assert_eq!(
+            parse_client_paths(&components),
+            Some(Path::ClientUpdateTime(ClientUpdateTimePath {
+                client_id: ClientId::default(),
+                revision_number: 15,
+                revision_height: 31,
+            }))
+        );
+
+        let path = "clients/07-tendermint-0/consensusStates/15-31/processedHeight";
+        let components: Vec<&str> = path.split('/').collect();
+
+        assert_eq!(
+            parse_client_paths(&components),
+            Some(Path::ClientUpdateHeight(ClientUpdateHeightPath {
+                client_id: ClientId::default(),
+                revision_number: 15,
+                revision_height: 31,
+            }))
+        );
+    }
+
     #[test]
     fn client_state_path_parses() {
         let path = "clients/07-tendermint-0/clientState";
@@ -882,6 +1085,31 @@
         );
     }
 
+    #[test]
+    fn test_parse_client_update_paths_parses() {
+        let path = "clients/07-tendermint-0/consensusStates/15-31/processedTime";
+
+        assert_eq!(
+            Path::from_str(path).ok(),
+            Some(Path::ClientUpdateTime(ClientUpdateTimePath {
+                client_id: ClientId::default(),
+                revision_number: 15,
+                revision_height: 31,
+            }))
+        );
+
+        let path = "clients/07-tendermint-0/consensusStates/15-31/processedHeight";
+
+        assert_eq!(
+            Path::from_str(path).ok(),
+            Some(Path::ClientUpdateHeight(ClientUpdateHeightPath {
+                client_id: ClientId::default(),
+                revision_number: 15,
+                revision_height: 31,
+            }))
+        );
+    }
+
     #[test]
     fn client_consensus_state_path_parses() {
         let path = "clients/07-tendermint-0/consensusStates/15-31";