From 1defac61f784ead13f26c5759cf47fd544ae29f0 Mon Sep 17 00:00:00 2001
From: Jun Kimura <jun.kimura@datachain.jp>
Date: Sun, 20 Oct 2024 13:54:44 +0900
Subject: [PATCH] remove tendermint crate from `lcp-types`

Signed-off-by: Jun Kimura <jun.kimura@datachain.jp>
---
 Cargo.lock                          |   2 +-
 enclave/Cargo.lock                  |   2 +-
 modules/mock-lc/src/client.rs       |   7 +-
 modules/mock-lc/src/errors.rs       |   6 +-
 modules/tendermint-lc/src/client.rs |  32 ++++-
 modules/tendermint-lc/src/errors.rs |   9 +-
 modules/types/Cargo.toml            |   5 +-
 modules/types/src/errors.rs         |  10 +-
 modules/types/src/time.rs           | 179 +++++++++++++++++++++-------
 9 files changed, 190 insertions(+), 62 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c321f8d1..7af4387e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2729,7 +2729,7 @@ dependencies = [
  "serde_json",
  "serde_with",
  "sgx_types",
- "tendermint 0.29.0",
+ "time",
 ]
 
 [[package]]
diff --git a/enclave/Cargo.lock b/enclave/Cargo.lock
index 2616bebb..bd0d9834 100644
--- a/enclave/Cargo.lock
+++ b/enclave/Cargo.lock
@@ -867,7 +867,7 @@ dependencies = [
  "serde_json",
  "serde_with",
  "sgx_types",
- "tendermint",
+ "time",
 ]
 
 [[package]]
diff --git a/modules/mock-lc/src/client.rs b/modules/mock-lc/src/client.rs
index 5404944f..37f85a7d 100644
--- a/modules/mock-lc/src/client.rs
+++ b/modules/mock-lc/src/client.rs
@@ -50,7 +50,10 @@ impl LightClient for MockLightClient {
         let client_state: ClientState = any_client_state.clone().try_into()?;
         let consensus_state: ConsensusState = any_consensus_state.try_into()?;
         let height = client_state.latest_height().into();
-        let timestamp: Time = consensus_state.timestamp().into();
+        let timestamp: Time = consensus_state
+            .timestamp()
+            .try_into()
+            .map_err(Error::time)?;
         Ok(CreateClientResult {
             height,
             message: UpdateStateProxyMessage {
@@ -128,7 +131,7 @@ impl MockLightClient {
         }
 
         let height = header.height().into();
-        let header_timestamp = header.timestamp().into();
+        let header_timestamp = header.timestamp().try_into().map_err(Error::time)?;
 
         let latest_height = client_state.latest_height();
 
diff --git a/modules/mock-lc/src/errors.rs b/modules/mock-lc/src/errors.rs
index a486a351..414ef771 100644
--- a/modules/mock-lc/src/errors.rs
+++ b/modules/mock-lc/src/errors.rs
@@ -30,7 +30,11 @@ define_error! {
 
         Commitment
         [light_client::commitments::Error]
-        |_| { "Commitment error" }
+        |_| { "Commitment error" },
+
+        Time
+        [light_client::types::TimeError]
+        |_| { "Time error" },
     }
 }
 
diff --git a/modules/tendermint-lc/src/client.rs b/modules/tendermint-lc/src/client.rs
index c3ad65d7..585c3d80 100644
--- a/modules/tendermint-lc/src/client.rs
+++ b/modules/tendermint-lc/src/client.rs
@@ -70,7 +70,13 @@ impl LightClient for TendermintLightClient {
 
         let canonical_client_state = canonicalize_state(&client_state);
         let height = client_state.latest_height().into();
-        let timestamp: Time = consensus_state.timestamp.into();
+        let timestamp = Time::try_from(
+            consensus_state
+                .timestamp()
+                .into_datetime()
+                .ok_or_else(Error::invalid_timestamp)?,
+        )
+        .map_err(Error::time)?;
         let state_id = gen_state_id(canonical_client_state, consensus_state)?;
 
         Ok(CreateClientResult {
@@ -241,7 +247,7 @@ impl TendermintLightClient {
         }
 
         let height = header.height().into();
-        let header_timestamp: Time = header.timestamp().into();
+        let header_timestamp: Time = header.timestamp().try_into().map_err(Error::time)?;
 
         let trusted_consensus_state: ConsensusState = ctx
             .consensus_state(&client_id, &header.trusted_height.into())
@@ -282,7 +288,10 @@ impl TendermintLightClient {
                 .clone(),
         );
 
-        let trusted_state_timestamp: Time = trusted_consensus_state.timestamp().into();
+        let trusted_state_timestamp: Time = trusted_consensus_state
+            .timestamp()
+            .try_into()
+            .map_err(Error::time)?;
         let lc_opts = client_state.as_light_client_options().unwrap();
 
         let prev_state_id =
@@ -365,13 +374,21 @@ impl TendermintLightClient {
                 context: TrustingPeriodContext::new(
                     lc_opts.trusting_period,
                     lc_opts.clock_drift,
-                    misbehaviour.header1().timestamp().into(),
+                    misbehaviour
+                        .header1()
+                        .timestamp()
+                        .try_into()
+                        .map_err(Error::time)?,
                     trusted_consensus_state_timestamps[0],
                 )
                 .aggregate(TrustingPeriodContext::new(
                     lc_opts.trusting_period,
                     lc_opts.clock_drift,
-                    misbehaviour.header2().timestamp().into(),
+                    misbehaviour
+                        .header2()
+                        .timestamp()
+                        .try_into()
+                        .map_err(Error::time)?,
                     trusted_consensus_state_timestamps[1],
                 ))
                 .map_err(|e| {
@@ -405,7 +422,10 @@ impl TendermintLightClient {
                     })
                 })?
                 .try_into()?;
-            let timestamp = consensus_state.timestamp().into();
+            let timestamp = consensus_state
+                .timestamp()
+                .try_into()
+                .map_err(Error::time)?;
             let prev_state_id = gen_state_id(canonicalize_state(client_state), consensus_state)?;
             prev_states.push(PrevState {
                 height,
diff --git a/modules/tendermint-lc/src/errors.rs b/modules/tendermint-lc/src/errors.rs
index 1f4d4848..6f14115c 100644
--- a/modules/tendermint-lc/src/errors.rs
+++ b/modules/tendermint-lc/src/errors.rs
@@ -30,7 +30,14 @@ define_error! {
 
         Commitment
         [light_client::commitments::Error]
-        |_| { "Commitment error" }
+        |_| { "Commitment error" },
+
+        InvalidTimestamp
+        |_| { "Invalid timestamp" },
+
+        Time
+        [light_client::types::TimeError]
+        |_| { "Time error" },
     }
 }
 
diff --git a/modules/types/Cargo.toml b/modules/types/Cargo.toml
index dfdc2201..86f03382 100644
--- a/modules/types/Cargo.toml
+++ b/modules/types/Cargo.toml
@@ -8,12 +8,12 @@ sgx_types = { rev = "v1.1.6", git = "https://github.com/apache/incubator-teaclav
 prost = { version = "0.11", default-features = false }
 ibc = { version = "0.29.0", default-features = false, features = ["serde"], optional = true }
 lcp-proto = { path = "../../proto", default-features = false }
-tendermint = { version = "0.29", default-features = false }
 serde = { version = "1.0.184", default-features = false, features = ["alloc", "derive"] }
 serde_with = { version = "2.0.1", default-features = false, features = ["alloc", "macros"] }
 serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
 flex-error = { version = "0.4.4", default-features = false }
 hex = { version = "0.4", default-features = false, features = ["alloc"] }
+time = { version = "0.3", default-features = false, features = ["macros", "parsing"] }
 
 [dev-dependencies]
 proptest = "1.2.0"
@@ -22,7 +22,8 @@ ibc = { version = "0.29.0", default-features = false, features = ["serde"] }
 [features]
 default = ["std"]
 std = [
-    "flex-error/std"
+    "flex-error/std",
+    "time/std",
 ]
 ibc = [
     "dep:ibc"
diff --git a/modules/types/src/errors.rs b/modules/types/src/errors.rs
index 74cba744..a0157e98 100644
--- a/modules/types/src/errors.rs
+++ b/modules/types/src/errors.rs
@@ -97,11 +97,15 @@ impl From<lcp_proto::protobuf::Error> for TypeError {
 define_error! {
     #[derive(Debug, Clone, PartialEq, Eq)]
     TimeError {
-        Tendermint
-            [tendermint::Error]
+        InvalidDate
             |_| {
-                "tendermint error"
+                "invalid date"
             },
+        DurationOutOfRange
+            |_| { format_args!("duration value out of range") },
+        ComponentRange
+            [TraceError<time::error::ComponentRange>]
+            |e| { format_args!("{}", e) },
         TryFromIntError
             [TraceError<core::num::TryFromIntError>]
             |_| {"TryFromIntError"}
diff --git a/modules/types/src/time.rs b/modules/types/src/time.rs
index fc3cb5bb..ed2b76cb 100644
--- a/modules/types/src/time.rs
+++ b/modules/types/src/time.rs
@@ -1,67 +1,114 @@
 use crate::errors::TimeError;
 use crate::prelude::*;
 use core::fmt::Display;
-use core::ops::Deref;
 use core::ops::{Add, Sub};
 use core::time::Duration;
+use lcp_proto::google::protobuf::Timestamp;
+use lcp_proto::protobuf::Protobuf;
 use serde::{Deserialize, Serialize};
-use tendermint::Time as TmTime;
+use time::macros::{datetime, offset};
+use time::{OffsetDateTime, PrimitiveDateTime};
 
-// NOTE: This value is limited by "tendermint/time" crate
-// i.e. 9999-12-31T23:59:59.999999999Z
+/// The maximum Unix timestamp in nanoseconds that can be represented in `Time`.
+/// i.e., 9999-12-31T23:59:59.999999999Z
 pub const MAX_UNIX_TIMESTAMP_NANOS: u128 = 253_402_300_799_999_999_999;
 
+/// A newtype wrapper over `PrimitiveDateTime` which serves as the foundational
+/// basis for capturing timestamps. It is used directly to keep track of host
+/// timestamps.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)]
-#[serde(transparent)]
-pub struct Time(TmTime);
+#[serde(try_from = "Timestamp", into = "Timestamp")]
+pub struct Time(PrimitiveDateTime);
+
+impl Protobuf<Timestamp> for Time {}
+
+impl TryFrom<Timestamp> for Time {
+    type Error = TimeError;
+
+    fn try_from(value: Timestamp) -> Result<Self, TimeError> {
+        let nanos = value.nanos.try_into()?;
+        Self::from_unix_timestamp(value.seconds, nanos)
+    }
+}
+
+impl From<Time> for Timestamp {
+    fn from(value: Time) -> Self {
+        let t = value.0.assume_utc();
+        let seconds = t.unix_timestamp();
+        // Safe to convert to i32 because .nanosecond()
+        // is guaranteed to return a value in 0..1_000_000_000 range.
+        let nanos = t.nanosecond() as i32;
+        Timestamp { seconds, nanos }
+    }
+}
 
 impl Time {
+    /// Returns the current time as a `Time`.
     #[cfg(feature = "std")]
     pub fn now() -> Self {
-        use std::time::{SystemTime, UNIX_EPOCH};
-        let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
-        Time(TmTime::from_unix_timestamp(now.as_secs() as i64, now.subsec_nanos()).unwrap())
+        OffsetDateTime::now_utc()
+            .try_into()
+            .expect("now is in the range of 0..=9999 years")
     }
 
+    /// Returns the Unix epoch as a `Time`.
     pub fn unix_epoch() -> Self {
-        Time(TmTime::unix_epoch())
+        Self(datetime!(1970-01-01 00:00:00))
+    }
+
+    /// Constructs a `Time` from a Unix timestamp in nanoseconds.
+    pub fn from_unix_timestamp_nanos(nanoseconds: u128) -> Result<Self, TimeError> {
+        if nanoseconds > MAX_UNIX_TIMESTAMP_NANOS {
+            return Err(TimeError::invalid_date());
+        }
+        // Safe to convert to i128 because nanoseconds is guaranteed to be in range 0..=MAX_UNIX_TIMESTAMP_NANOS.
+        let odt = OffsetDateTime::from_unix_timestamp_nanos(nanoseconds as i128)
+            .map_err(TimeError::component_range)?;
+        Self::from_utc(odt)
     }
 
+    /// Constructs a `Time` from a Unix timestamp in seconds and nanoseconds.
     pub fn from_unix_timestamp(secs: i64, nanos: u32) -> Result<Self, TimeError> {
-        let ut = TmTime::from_unix_timestamp(secs, nanos).map_err(TimeError::tendermint)?;
-        Ok(Time(ut))
+        if secs < 0 {
+            return Err(TimeError::invalid_date());
+        }
+        if nanos > 999_999_999 {
+            return Err(TimeError::invalid_date());
+        }
+        let total_nanos = secs as u128 * 1_000_000_000 + nanos as u128;
+        Self::from_unix_timestamp_nanos(total_nanos)
+    }
+
+    /// Internal helper to produce a `Timestamp` value validated with regard to
+    /// the date range allowed in protobuf timestamps. The source
+    /// `OffsetDateTime` value must have the zero UTC offset.
+    fn from_utc(t: OffsetDateTime) -> Result<Self, TimeError> {
+        debug_assert_eq!(t.offset(), offset!(UTC));
+        match t.year() {
+            1970..=9999 => Ok(Self(PrimitiveDateTime::new(t.date(), t.time()))),
+            _ => Err(TimeError::invalid_date()),
+        }
     }
 
-    pub fn from_unix_timestamp_nanos(timestamp: u128) -> Result<Self, TimeError> {
-        let d = nanos_to_duration(timestamp)?;
-        Self::from_unix_timestamp(d.as_secs().try_into()?, d.subsec_nanos())
+    /// Computes the duration difference of another `Timestamp` from the current
+    /// one. Returns the difference in time as an [`core::time::Duration`].
+    pub fn duration_since(&self, other: &Self) -> Option<Duration> {
+        let duration = self.0.assume_utc() - other.0.assume_utc();
+        duration.try_into().ok()
     }
 
+    /// Returns the `Timestamp` as a Unix timestamp in seconds.
     pub fn as_unix_timestamp_secs(&self) -> u64 {
-        self.0
-            .duration_since(TmTime::unix_epoch())
-            .unwrap()
-            .as_secs()
+        self.0.assume_utc().unix_timestamp().try_into().unwrap()
     }
 
+    /// Return a Unix timestamp in nanoseconds.
     pub fn as_unix_timestamp_nanos(&self) -> u128 {
         self.0
-            .duration_since(TmTime::unix_epoch())
+            .assume_utc()
+            .unix_timestamp_nanos()
+            .try_into()
             .unwrap()
-            .as_nanos()
-    }
-}
-
-pub fn nanos_to_duration(nanos: u128) -> Result<Duration, TimeError> {
-    let secs = (nanos / 1_000_000_000).try_into()?;
-    let nanos = (nanos % 1_000_000_000) as u32;
-    Ok(Duration::new(secs, nanos))
-}
-
-impl Deref for Time {
-    type Target = TmTime;
-    fn deref(&self) -> &Self::Target {
-        &self.0
     }
 }
 
@@ -71,9 +118,11 @@ impl Display for Time {
     }
 }
 
-impl From<TmTime> for Time {
-    fn from(value: TmTime) -> Self {
-        Self(value)
+impl TryFrom<OffsetDateTime> for Time {
+    type Error = TimeError;
+
+    fn try_from(t: OffsetDateTime) -> Result<Time, TimeError> {
+        Self::from_utc(t.to_offset(offset!(UTC)))
     }
 }
 
@@ -81,7 +130,14 @@ impl Add<Duration> for Time {
     type Output = Result<Self, TimeError>;
 
     fn add(self, rhs: Duration) -> Self::Output {
-        Ok(Self((*self + rhs).map_err(TimeError::tendermint)?))
+        let duration = rhs
+            .try_into()
+            .map_err(|_| TimeError::duration_out_of_range())?;
+        let t = self
+            .0
+            .checked_add(duration)
+            .ok_or_else(TimeError::duration_out_of_range)?;
+        Self::from_utc(t.assume_utc())
     }
 }
 
@@ -89,24 +145,47 @@ impl Sub<Duration> for Time {
     type Output = Result<Self, TimeError>;
 
     fn sub(self, rhs: Duration) -> Self::Output {
-        Ok(Self((*self - rhs).map_err(TimeError::tendermint)?))
+        let duration = rhs
+            .try_into()
+            .map_err(|_| TimeError::duration_out_of_range())?;
+        let t = self
+            .0
+            .checked_sub(duration)
+            .ok_or_else(TimeError::duration_out_of_range)?;
+        Self::from_utc(t.assume_utc())
     }
 }
 
 #[cfg(feature = "ibc")]
 impl From<Time> for ibc::timestamp::Timestamp {
     fn from(value: Time) -> Self {
-        value.0.into()
+        // Safe to convert to u64 because as_unix_timestamp_nanos() returns a value in 0..=MAX_UNIX_TIMESTAMP_NANOS.
+        ibc::timestamp::Timestamp::from_nanoseconds(
+            value.as_unix_timestamp_nanos().try_into().unwrap(),
+        )
+        .unwrap()
     }
 }
 
 #[cfg(feature = "ibc")]
-impl From<ibc::timestamp::Timestamp> for Time {
-    fn from(value: ibc::timestamp::Timestamp) -> Self {
-        Self(value.into_tm_time().unwrap())
+impl TryFrom<ibc::timestamp::Timestamp> for Time {
+    type Error = TimeError;
+
+    fn try_from(value: ibc::timestamp::Timestamp) -> Result<Self, Self::Error> {
+        match value.into_datetime() {
+            Some(datetime) => Ok(datetime.try_into()?),
+            None => Err(TimeError::invalid_date()),
+        }
     }
 }
 
+/// Converts a duration in nanoseconds to a `core::time::Duration`.
+pub fn nanos_to_duration(nanos: u128) -> Result<Duration, TimeError> {
+    let secs = (nanos / 1_000_000_000).try_into()?;
+    let nanos = (nanos % 1_000_000_000) as u32;
+    Ok(Duration::new(secs, nanos))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -117,7 +196,9 @@ mod tests {
         fn test_time_from_unix_timestamp_nanos(timestamp in ..=MAX_UNIX_TIMESTAMP_NANOS) {
             let time = Time::from_unix_timestamp_nanos(timestamp);
             assert!(time.is_ok());
-            assert_eq!(time.unwrap().as_unix_timestamp_nanos(), timestamp);
+            let time = time.unwrap();
+            assert_eq!(time.as_unix_timestamp_nanos(), timestamp);
+            assert_eq!(time.as_unix_timestamp_secs(), (timestamp / 1_000_000_000) as u64);
         }
 
         #[test]
@@ -128,11 +209,19 @@ mod tests {
     }
 
     #[test]
-    fn test_max_time() {
+    fn test_time_range() {
         assert!(Time::from_unix_timestamp_nanos(MAX_UNIX_TIMESTAMP_NANOS).is_ok());
         assert!(Time::from_unix_timestamp_nanos(MAX_UNIX_TIMESTAMP_NANOS + 1).is_err());
         let max_time = Time::from_unix_timestamp_nanos(MAX_UNIX_TIMESTAMP_NANOS).unwrap();
         assert_eq!(max_time.as_unix_timestamp_nanos(), MAX_UNIX_TIMESTAMP_NANOS);
         assert!((max_time + Duration::new(0, 1)).is_err());
+
+        assert!(Time::from_unix_timestamp(0, 999_999_999).is_ok());
+        assert!(Time::from_unix_timestamp(i64::MAX, 0).is_err());
+        assert!(Time::from_unix_timestamp(0, 1_000_000_000).is_err());
+
+        assert!(Time::from_unix_timestamp(0, 0).is_ok());
+        assert!(Time::from_unix_timestamp(-1, 0).is_err());
+        assert!(Time::from_unix_timestamp(i64::MIN, 0).is_err());
     }
 }