From d101aaf84b4e02b958342e3bd47d82c954c4be3e Mon Sep 17 00:00:00 2001
From: Mikhail Zabaluev <mikhail@informal.systems>
Date: Mon, 13 Dec 2021 18:19:10 +0200
Subject: [PATCH] modules: Replaced uses of chrono with time-rs

---
 .../msgs/transfer.rs                          |   2 +-
 .../ics07_tendermint/consensus_state.rs       |  11 +-
 .../src/clients/ics07_tendermint/header.rs    |   2 +-
 .../src/core/ics02_client/client_consensus.rs |   7 +-
 modules/src/core/ics04_channel/events.rs      |   4 +-
 .../core/ics04_channel/handler/send_packet.rs |   2 +-
 modules/src/core/ics04_channel/packet.rs      |   2 +-
 modules/src/mock/client_state.rs              |   4 +-
 modules/src/mock/header.rs                    |   2 +-
 modules/src/mock/host.rs                      |   7 +-
 modules/src/timestamp.rs                      | 168 +++++++-----------
 11 files changed, 87 insertions(+), 124 deletions(-)

diff --git a/modules/src/applications/ics20_fungible_token_transfer/msgs/transfer.rs b/modules/src/applications/ics20_fungible_token_transfer/msgs/transfer.rs
index 2522376f95..88be8fb54b 100644
--- a/modules/src/applications/ics20_fungible_token_transfer/msgs/transfer.rs
+++ b/modules/src/applications/ics20_fungible_token_transfer/msgs/transfer.rs
@@ -92,7 +92,7 @@ impl From<MsgTransfer> for RawMsgTransfer {
             sender: domain_msg.sender.to_string(),
             receiver: domain_msg.receiver.to_string(),
             timeout_height: Some(domain_msg.timeout_height.into()),
-            timeout_timestamp: domain_msg.timeout_timestamp.as_nanoseconds(),
+            timeout_timestamp: domain_msg.timeout_timestamp.nanoseconds(),
         }
     }
 }
diff --git a/modules/src/clients/ics07_tendermint/consensus_state.rs b/modules/src/clients/ics07_tendermint/consensus_state.rs
index 3f0f173672..141df337a6 100644
--- a/modules/src/clients/ics07_tendermint/consensus_state.rs
+++ b/modules/src/clients/ics07_tendermint/consensus_state.rs
@@ -4,6 +4,7 @@ use core::convert::Infallible;
 
 use serde::Serialize;
 use tendermint::{hash::Algorithm, time::Time, Hash};
+use tendermint_proto::google::protobuf as tpb;
 use tendermint_proto::Protobuf;
 
 use ibc_proto::ibc::lightclients::tendermint::v1::ConsensusState as RawConsensusState;
@@ -57,9 +58,12 @@ impl TryFrom<RawConsensusState> for ConsensusState {
     type Error = Error;
 
     fn try_from(raw: RawConsensusState) -> Result<Self, Self::Error> {
-        let proto_timestamp = raw
+        let prost_types::Timestamp { seconds, nanos } = raw
             .timestamp
             .ok_or_else(|| Error::invalid_raw_consensus_state("missing timestamp".into()))?;
+        // FIXME: shunts like this are necessary due to
+        // https://github.com/informalsystems/tendermint-rs/issues/1053
+        let proto_timestamp = tpb::Timestamp { seconds, nanos };
         let timestamp = proto_timestamp
             .try_into()
             .map_err(|e| Error::invalid_raw_consensus_state(format!("invalid timestamp: {}", e)))?;
@@ -81,7 +85,10 @@ impl TryFrom<RawConsensusState> for ConsensusState {
 
 impl From<ConsensusState> for RawConsensusState {
     fn from(value: ConsensusState) -> Self {
-        let timestamp: prost_types::Timestamp = value.timestamp.into();
+        // FIXME: shunts like this are necessary due to
+        // https://github.com/informalsystems/tendermint-rs/issues/1053
+        let tpb::Timestamp { seconds, nanos } = value.timestamp.into();
+        let timestamp = prost_types::Timestamp { seconds, nanos };
 
         RawConsensusState {
             timestamp: Some(timestamp),
diff --git a/modules/src/clients/ics07_tendermint/header.rs b/modules/src/clients/ics07_tendermint/header.rs
index 03bc5c9090..8fe32105a5 100644
--- a/modules/src/clients/ics07_tendermint/header.rs
+++ b/modules/src/clients/ics07_tendermint/header.rs
@@ -77,7 +77,7 @@ impl crate::core::ics02_client::header::Header for Header {
     }
 
     fn timestamp(&self) -> Timestamp {
-        Timestamp::from_datetime(DateTime::from(self.signed_header.header.time))
+        self.signed_header.header.time.into()
     }
 
     fn wrap_any(self) -> AnyHeader {
diff --git a/modules/src/core/ics02_client/client_consensus.rs b/modules/src/core/ics02_client/client_consensus.rs
index 54c7192db6..de1e54fb80 100644
--- a/modules/src/core/ics02_client/client_consensus.rs
+++ b/modules/src/core/ics02_client/client_consensus.rs
@@ -3,8 +3,6 @@ use crate::prelude::*;
 use core::convert::Infallible;
 use core::marker::{Send, Sync};
 
-use chrono::{DateTime, Utc};
-
 use ibc_proto::ibc::core::client::v1::ConsensusStateWithHeight;
 use prost_types::Any;
 use serde::Serialize;
@@ -55,10 +53,7 @@ pub enum AnyConsensusState {
 impl AnyConsensusState {
     pub fn timestamp(&self) -> Timestamp {
         match self {
-            Self::Tendermint(cs_state) => {
-                let date: DateTime<Utc> = cs_state.timestamp.into();
-                Timestamp::from_datetime(date)
-            }
+            Self::Tendermint(cs_state) => cs_state.timestamp.into(),
 
             #[cfg(any(test, feature = "mocks"))]
             Self::Mock(mock_state) => mock_state.timestamp(),
diff --git a/modules/src/core/ics04_channel/events.rs b/modules/src/core/ics04_channel/events.rs
index 972794c8a8..11efb275b6 100644
--- a/modules/src/core/ics04_channel/events.rs
+++ b/modules/src/core/ics04_channel/events.rs
@@ -294,7 +294,7 @@ impl TryFrom<Packet> for Vec<Tag> {
             key: PKT_TIMEOUT_TIMESTAMP_ATTRIBUTE_KEY.parse().unwrap(),
             value: p
                 .timeout_timestamp
-                .as_nanoseconds()
+                .nanoseconds()
                 .to_string()
                 .parse()
                 .unwrap(),
@@ -960,7 +960,7 @@ mod tests {
             destination_channel: "b_test_channel".parse().unwrap(),
             data: "test_data".as_bytes().to_vec(),
             timeout_height: Height::new(1, 10),
-            timeout_timestamp: Timestamp::from_datetime(chrono::offset::Utc::now()),
+            timeout_timestamp: Timestamp::now(),
         };
         let mut abci_events = vec![];
         let send_packet = SendPacket {
diff --git a/modules/src/core/ics04_channel/handler/send_packet.rs b/modules/src/core/ics04_channel/handler/send_packet.rs
index dde7d60ede..1131fa6c8b 100644
--- a/modules/src/core/ics04_channel/handler/send_packet.rs
+++ b/modules/src/core/ics04_channel/handler/send_packet.rs
@@ -145,7 +145,7 @@ mod tests {
 
         let timestamp = Timestamp::now().add(Duration::from_secs(10));
         //CD:TODO remove unwrap
-        let mut packet: Packet = get_dummy_raw_packet(1, timestamp.unwrap().as_nanoseconds())
+        let mut packet: Packet = get_dummy_raw_packet(1, timestamp.unwrap().nanoseconds())
             .try_into()
             .unwrap();
         packet.sequence = 1.into();
diff --git a/modules/src/core/ics04_channel/packet.rs b/modules/src/core/ics04_channel/packet.rs
index 12ec013549..6b4cdd1093 100644
--- a/modules/src/core/ics04_channel/packet.rs
+++ b/modules/src/core/ics04_channel/packet.rs
@@ -238,7 +238,7 @@ impl From<Packet> for RawPacket {
             destination_channel: packet.destination_channel.to_string(),
             data: packet.data,
             timeout_height: Some(packet.timeout_height.into()),
-            timeout_timestamp: packet.timeout_timestamp.as_nanoseconds(),
+            timeout_timestamp: packet.timeout_timestamp.nanoseconds(),
         }
     }
 }
diff --git a/modules/src/mock/client_state.rs b/modules/src/mock/client_state.rs
index a218255942..d0779a0b77 100644
--- a/modules/src/mock/client_state.rs
+++ b/modules/src/mock/client_state.rs
@@ -85,7 +85,7 @@ impl From<MockClientState> for RawMockClientState {
         RawMockClientState {
             header: Some(ibc_proto::ibc::mock::Header {
                 height: Some(value.header.height().into()),
-                timestamp: value.header.timestamp.as_nanoseconds(),
+                timestamp: value.header.timestamp.nanoseconds(),
             }),
         }
     }
@@ -158,7 +158,7 @@ impl From<MockConsensusState> for RawMockConsensusState {
         RawMockConsensusState {
             header: Some(ibc_proto::ibc::mock::Header {
                 height: Some(value.header.height().into()),
-                timestamp: value.header.timestamp.as_nanoseconds(),
+                timestamp: value.header.timestamp.nanoseconds(),
             }),
         }
     }
diff --git a/modules/src/mock/header.rs b/modules/src/mock/header.rs
index 1678a62407..381975ae48 100644
--- a/modules/src/mock/header.rs
+++ b/modules/src/mock/header.rs
@@ -37,7 +37,7 @@ impl From<MockHeader> for RawMockHeader {
     fn from(value: MockHeader) -> Self {
         RawMockHeader {
             height: Some(value.height.into()),
-            timestamp: value.timestamp.as_nanoseconds(),
+            timestamp: value.timestamp.nanoseconds(),
         }
     }
 }
diff --git a/modules/src/mock/host.rs b/modules/src/mock/host.rs
index ec65ad7171..71cdd6d39b 100644
--- a/modules/src/mock/host.rs
+++ b/modules/src/mock/host.rs
@@ -3,6 +3,7 @@
 use tendermint::time::Time;
 use tendermint_testgen::light_block::TmLightBlock;
 use tendermint_testgen::{Generator, LightBlock as TestgenLightBlock};
+use time::OffsetDateTime;
 
 use crate::clients::ics07_tendermint::consensus_state::ConsensusState as TMConsensusState;
 use crate::clients::ics07_tendermint::header::Header as TMHeader;
@@ -63,10 +64,8 @@ impl HostBlock {
         // same timestamp as two block can be generated per second.
         let ten_millis = core::time::Duration::from_millis(1000);
         std::thread::sleep(ten_millis);
-        let time = Time(chrono::Utc::now())
-            .duration_since(Time::unix_epoch())
-            .unwrap()
-            .as_secs();
+        let time: Time = OffsetDateTime::now_utc().try_into().unwrap();
+        let time = time.duration_since(Time::unix_epoch()).unwrap().as_secs();
 
         TestgenLightBlock::new_default_with_time_and_chain_id(chain_id.to_string(), time, height)
             .generate()
diff --git a/modules/src/timestamp.rs b/modules/src/timestamp.rs
index 500ea37377..267e7bf824 100644
--- a/modules/src/timestamp.rs
+++ b/modules/src/timestamp.rs
@@ -1,28 +1,40 @@
 use crate::prelude::*;
 
 use core::fmt::Display;
+use core::hash::{Hash, Hasher};
 use core::num::ParseIntError;
 use core::ops::{Add, Sub};
 use core::str::FromStr;
 use core::time::Duration;
 
-use chrono::{offset::Utc, DateTime, TimeZone};
 use flex_error::{define_error, TraceError};
 use serde_derive::{Deserialize, Serialize};
 use tendermint::Time;
+use time::OffsetDateTime;
 
 pub const ZERO_DURATION: Duration = Duration::from_secs(0);
 
-/// A newtype wrapper over `Option<DateTime<Utc>>` to keep track of
+const NANOS_PER_SEC: u64 = 1_000_000_000;
+
+/// A newtype wrapper over `Option<Time>` to keep track of
 /// IBC packet timeout.
 ///
 /// We use an explicit `Option` type to distinguish this when converting between
 /// a `u64` value and a raw timestamp. In protocol buffer, the timestamp is
 /// represented as a `u64` Unix timestamp in nanoseconds, with 0 representing the absence
 /// of timestamp.
-#[derive(PartialEq, Eq, Copy, Clone, Debug, Default, Deserialize, Serialize, Hash)]
+#[derive(PartialEq, Eq, Copy, Clone, Debug, Default, Deserialize, Serialize)]
 pub struct Timestamp {
-    time: Option<DateTime<Utc>>,
+    time: Option<Time>,
+}
+
+// TODO: derive when tendermint::Time supports it:
+// https://github.com/informalsystems/tendermint-rs/pull/1054
+impl Hash for Timestamp {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        let odt: Option<OffsetDateTime> = self.time.map(Into::into);
+        odt.hash(state);
+    }
 }
 
 /// The expiry result when comparing two timestamps.
@@ -51,30 +63,19 @@ impl Timestamp {
         if nanoseconds == 0 {
             Ok(Timestamp { time: None })
         } else {
-            // The underlying library [`chrono::DateTime`] does not support
-            // conversion from `u64` nanoseconds value, only from `i64`
-            // (which can overflow when converting from the unsigned type).
-            // We go around this limitation by decomposing the `u64` nanos
-            // into seconds + nanos and constructing the timestamp from that.
-            let (s, ns) = util::break_in_secs_and_nanos(nanoseconds);
-
-            match Utc.timestamp_opt(s, ns) {
-                chrono::LocalResult::None => {
-                    Err(ParseTimestampError::invalid_timestamp_conversion(s, ns))
-                }
-                chrono::LocalResult::Single(ts) => Ok(Timestamp { time: Some(ts) }),
-                chrono::LocalResult::Ambiguous(_, _) => {
-                    Err(ParseTimestampError::ambiguous_timestamp_conversion(s, ns))
-                }
-            }
+            // As the `u64` representation can only represent times up to
+            // about year 2554, there is no risk of overflowing `Time`.
+            let seconds = (nanoseconds / NANOS_PER_SEC) as i64;
+            let subsec_nanos = (nanoseconds % NANOS_PER_SEC) as u32;
+            let ts = Time::from_unix_timestamp(seconds, subsec_nanos).unwrap();
+            Ok(Timestamp { time: Some(ts) })
         }
     }
 
     /// Returns a `Timestamp` representation of the current time.
     pub fn now() -> Timestamp {
-        Timestamp {
-            time: Some(Utc::now()),
-        }
+        let ts = OffsetDateTime::now_utc().try_into().unwrap();
+        Timestamp { time: Some(ts) }
     }
 
     /// Returns a `Timestamp` representation of a timestamp not being set.
@@ -88,42 +89,48 @@ impl Timestamp {
     /// than the current or if either of the `Timestamp`s is not set.
     pub fn duration_since(&self, other: &Timestamp) -> Option<Duration> {
         match (self.time, other.time) {
-            (Some(time1), Some(time2)) => time1.signed_duration_since(time2).to_std().ok(),
+            (Some(time1), Some(time2)) => time1.duration_since(time2).ok(),
             _ => None,
         }
     }
 
-    /// Convert a `Timestamp` from [`chrono::DateTime<Utc>`].
-    pub fn from_datetime(time: DateTime<Utc>) -> Timestamp {
-        Timestamp { time: Some(time) }
+    /// Convert a `Timestamp` to `u64` value in nanoseconds. If no timestamp
+    /// is set, the result is 0.
+    ///
+    #[deprecated(since = "0.9.1", note = "use `nanoseconds` instead")]
+    pub fn as_nanoseconds(&self) -> u64 {
+        (*self).nanoseconds()
     }
 
     /// Convert a `Timestamp` to `u64` value in nanoseconds. If no timestamp
     /// is set, the result is 0.
     /// ```
     /// use ibc::timestamp::Timestamp;
+    ///
     /// let max = u64::MAX;
     /// let tx = Timestamp::from_nanoseconds(max).unwrap();
-    /// let utx = tx.as_nanoseconds();
+    /// let utx = tx.nanoseconds();
     /// assert_eq!(utx, max);
     /// let min = u64::MIN;
     /// let ti = Timestamp::from_nanoseconds(min).unwrap();
-    /// let uti = ti.as_nanoseconds();
+    /// let uti = ti.nanoseconds();
     /// assert_eq!(uti, min);
+    /// let tz = Timestamp::default();
+    /// let utz = tz.nanoseconds();
+    /// assert_eq!(utz, 0);
     /// ```
-    pub fn as_nanoseconds(&self) -> u64 {
+    pub fn nanoseconds(self) -> u64 {
         self.time.map_or(0, |time| {
-            let s = time.timestamp();
+            let t: OffsetDateTime = time.into();
+            let s = t.unix_timestamp_nanos();
             assert!(s >= 0, "time {:?} has negative `.timestamp()`", time);
-            let s: u64 = s.try_into().unwrap();
-
-            util::assemble_in_nanos(s, time.timestamp_subsec_nanos())
+            s.try_into().unwrap()
         })
     }
 
-    /// Convert a `Timestamp` to an optional [`chrono::DateTime<Utc>`]
-    pub fn as_datetime(&self) -> Option<DateTime<Utc>> {
-        self.time
+    /// Convert a `Timestamp` to an optional [`OffsetDateTime`]
+    pub fn into_datetime(self) -> Option<OffsetDateTime> {
+        self.time.map(Into::into)
     }
 
     /// Checks whether the timestamp has expired when compared to the
@@ -170,15 +177,16 @@ define_error! {
     }
 }
 
+// XXX: is it sane that 0 + duration = None?
 impl Add<Duration> for Timestamp {
     type Output = Result<Timestamp, TimestampOverflowError>;
 
     fn add(self, duration: Duration) -> Result<Timestamp, TimestampOverflowError> {
-        match self.as_datetime() {
-            Some(datetime) => {
-                let duration2 = chrono::Duration::from_std(duration)
-                    .map_err(|_| TimestampOverflowError::timestamp_overflow())?;
-                Ok(Self::from_datetime(datetime + duration2))
+        match self.time {
+            Some(time) => {
+                let time =
+                    (time + duration).map_err(|_| TimestampOverflowError::timestamp_overflow())?;
+                Ok(Timestamp { time: Some(time) })
             }
             None => Ok(self),
         }
@@ -189,11 +197,11 @@ impl Sub<Duration> for Timestamp {
     type Output = Result<Timestamp, TimestampOverflowError>;
 
     fn sub(self, duration: Duration) -> Result<Timestamp, TimestampOverflowError> {
-        match self.as_datetime() {
-            Some(datetime) => {
-                let duration2 = chrono::Duration::from_std(duration)
-                    .map_err(|_| TimestampOverflowError::timestamp_overflow())?;
-                Ok(Self::from_datetime(datetime - duration2))
+        match self.time {
+            Some(time) => {
+                let time =
+                    (time - duration).map_err(|_| TimestampOverflowError::timestamp_overflow())?;
+                Ok(Timestamp { time: Some(time) })
             }
             None => Ok(self),
         }
@@ -206,20 +214,6 @@ define_error! {
         ParseInt
             [ TraceError<ParseIntError> ]
             | _ | { "error parsing u64 integer from string"},
-
-        InvalidTimestampConversion
-            {
-                secs: i64,
-                nanos: u32,
-            }
-            | _ | { "error converting into Timestamp from seconds + nanoseconds" },
-
-        AmbiguousTimestampConversion
-            {
-                secs: i64,
-                nanos: u32,
-            }
-            | _ | { "ambigous conversion into Timestamp from seconds + nanoseconds" },
     }
 }
 
@@ -241,40 +235,9 @@ impl From<Time> for Timestamp {
     }
 }
 
-pub mod util {
-
-    const NANOS_PER_SEC: u64 = 1_000_000_000;
-
-    /// Helper for the [`Timestamp::from_nanoseconds`] constructor.
-    ///
-    /// Converts `u64` nanoseconds into its constituent
-    /// seconds (represented as `i64`) plus the remaining
-    /// nanoseconds (represented as `u32`).
-    ///
-    /// Similar to [`chrono::timestamp_nanos`].
-    pub(super) fn break_in_secs_and_nanos(nanoseconds: u64) -> (i64, u32) {
-        let seconds = nanoseconds / NANOS_PER_SEC;
-
-        // Safe because u64::MAX divided by NANOS_PER_SEC fits into i64
-        let out_secs: i64 = seconds.try_into().unwrap();
-        let out_nanos = (nanoseconds % NANOS_PER_SEC) as u32;
-
-        (out_secs, out_nanos)
-    }
-
-    /// Helper method for achieving the reverse of
-    /// [`break_in_secs_and_nanos`].
-    ///
-    pub(super) fn assemble_in_nanos(s: u64, subsec_ns: u32) -> u64 {
-        let ns = s * NANOS_PER_SEC;
-
-        ns + subsec_ns as u64
-    }
-}
-
 #[cfg(test)]
 mod tests {
-    use chrono::Utc;
+    use time::OffsetDateTime;
 
     use core::time::Duration;
     use std::thread::sleep;
@@ -286,18 +249,17 @@ mod tests {
     fn test_timestamp_comparisons() {
         let nil_timestamp = Timestamp::from_nanoseconds(0).unwrap();
         assert_eq!(nil_timestamp.time, None);
-        assert_eq!(nil_timestamp.as_nanoseconds(), 0);
+        assert_eq!(nil_timestamp.nanoseconds(), 0);
 
         let timestamp1 = Timestamp::from_nanoseconds(1).unwrap();
-        assert_eq!(timestamp1.time.unwrap().timestamp(), 0);
-        assert_eq!(timestamp1.time.unwrap().timestamp_millis(), 0);
-        assert_eq!(timestamp1.time.unwrap().timestamp_nanos(), 1);
-        assert_eq!(timestamp1.as_nanoseconds(), 1);
+        let dt: OffsetDateTime = timestamp1.time.unwrap().into();
+        assert_eq!(dt.unix_timestamp_nanos(), 1);
+        assert_eq!(timestamp1.nanoseconds(), 1);
 
         let timestamp2 = Timestamp::from_nanoseconds(1_000_000_000).unwrap();
-        assert_eq!(timestamp2.time.unwrap().timestamp(), 1);
-        assert_eq!(timestamp2.time.unwrap().timestamp_millis(), 1_000);
-        assert_eq!(timestamp2.as_nanoseconds(), 1_000_000_000);
+        let dt: OffsetDateTime = timestamp2.time.unwrap().into();
+        assert_eq!(dt.unix_timestamp_nanos(), 1_000_000_000);
+        assert_eq!(timestamp2.nanoseconds(), 1_000_000_000);
 
         assert!(Timestamp::from_nanoseconds(u64::MAX).is_ok());
         assert!(Timestamp::from_nanoseconds(i64::MAX.try_into().unwrap()).is_ok());
@@ -339,9 +301,9 @@ mod tests {
     fn subtract_compare() {
         let sleep_duration = Duration::from_micros(100);
 
-        let start = Timestamp::from_datetime(Utc::now());
+        let start = Timestamp::now();
         sleep(sleep_duration);
-        let end = Timestamp::from_datetime(Utc::now());
+        let end = Timestamp::now();
 
         let res = end.duration_since(&start);
         assert!(res.is_some());