BELC5

Signed-off-by: Naohiro Yoshida <[email protected]>

.github/workflows/ci.yaml

@@ -41,3 +41,8 @@ jobs:
         with:
           command: test
           args: --release --features=std --manifest-path light-client/Cargo.toml
+      - uses: actions-rs/cargo@v1
+        name: unit-test-dev-test
+        with:
+          command: dev-test
+          args: MINIMUM_TIMESTAMP_SUPPORTED=1731495592 --features=dev --manifest-path light-client/Cargo.toml --lib test::dev_test

light-client/build.rs

@@ -5,10 +5,13 @@ fn main() {
         let mut file = std::fs::File::create("src/header/constant.rs").unwrap();
         let blocks_per_epoch =
             std::env::var("BSC_BLOCKS_PER_EPOCH").unwrap_or_else(|_| "200".to_string());
+        let minimum_time_stamp_supported =
+            std::env::var("MINIMUM_TIMESTAMP_SUPPORTED").unwrap_or_else(|_| "0".to_string());
         writeln!(
             file,
-            "pub const BLOCKS_PER_EPOCH: u64 = {};",
-            blocks_per_epoch
+            "pub const BLOCKS_PER_EPOCH: u64 = {};\npub const MINIMUM_TIMESTAMP_SUPPORTED: u64 = {};",
+            blocks_per_epoch,
+            minimum_time_stamp_supported
         )
         .unwrap();
     }

light-client/src/client.rs

@@ -19,7 +19,7 @@ use crate::commitment::{
 };
 use crate::consensus_state::ConsensusState;
 use crate::errors::{ClientError, Error};
-
+use crate::header::constant::MINIMUM_TIMESTAMP_SUPPORTED;
 use crate::header::Header;
 use crate::message::ClientMessage;
 use crate::misbehaviour::Misbehaviour;
@@ -165,6 +165,10 @@ impl InnerLightClient {
         let height = client_state.latest_height;
         let timestamp = consensus_state.timestamp;
 
+        if timestamp.as_unix_timestamp_secs() < MINIMUM_TIMESTAMP_SUPPORTED {
+            return Err(Error::UnsupportedTimestamp(timestamp));
+        }
+
         Ok(CreateClientResult {
             height,
             message: UpdateStateProxyMessage {
@@ -1119,4 +1123,35 @@ mod test {
     fn assert_err(err: light_client::Error, contains: &str) {
         assert!(format!("{:?}", err).contains(contains), "{}", err);
     }
+
+    #[cfg(feature = "dev")]
+    mod dev_test {
+        use crate::client::test::MockClientReader;
+        use crate::client::ParliaLightClient;
+        use hex_literal::hex;
+        use light_client::{types::Any, LightClient};
+        use std::collections::BTreeMap;
+
+        #[test]
+        fn test_supported_timestamp() {
+            let client_state = hex!("0a272f6962632e6c69676874636c69656e74732e7061726c69612e76312e436c69656e745374617465124d08381214151f3951fa218cac426edfe078fa9e5c6dcea5001a2000000000000000000000000000000000000000000000000000000000000000002205109b9ea90f2a040880a305320410c0843d").to_vec();
+            let consensus_state = hex!("0a2a2f6962632e6c69676874636c69656e74732e7061726c69612e76312e436f6e73656e7375735374617465126c0a2056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b42110de82d5a8061a209c59cf0b5717cb6e2bd8620b7f3481605c8abcd45636bdf45c86db06338f0c5e22207a1dede35f5c835fecdc768324928cd0d9d9161e8529e1ba1e60451f3a9d088a").to_vec();
+            let client = ParliaLightClient::default();
+            let mock_consensus_state = BTreeMap::new();
+            let ctx = MockClientReader {
+                client_state: None,
+                consensus_state: mock_consensus_state,
+            };
+            let any_client_state: Any = client_state.try_into().unwrap();
+            let any_consensus_state: Any = consensus_state.try_into().unwrap();
+            let err = client
+                .create_client(&ctx, any_client_state.clone(), any_consensus_state.clone())
+                .unwrap_err();
+            assert!(
+                format!("{:?}", err).contains("UnsupportedTimestamp"),
+                "{}",
+                err
+            );
+        }
+    }
 }

light-client/src/client_state.rs

@@ -11,6 +11,7 @@ use parlia_ibc_proto::ibc::lightclients::parlia::v1::ClientState as RawClientSta
 use crate::commitment::resolve_account;
 use crate::consensus_state::ConsensusState;
 use crate::errors::Error;
+use crate::header::constant::MINIMUM_TIMESTAMP_SUPPORTED;
 use crate::header::Header;
 use crate::misbehaviour::Misbehaviour;
 use crate::misc::{new_height, Address, ChainId, Hash};
@@ -97,12 +98,18 @@ impl ClientState {
     }
 
     fn check_header(&self, now: Time, cs: &ConsensusState, header: &Header) -> Result<(), Error> {
+        // Ensure header has supported timestamp
+        let ts = header.timestamp()?;
+        if ts.as_unix_timestamp_secs() < MINIMUM_TIMESTAMP_SUPPORTED {
+            return Err(Error::UnsupportedTimestamp(ts));
+        }
+
         // Ensure last consensus state is within the trusting period
         validate_within_trusting_period(
             now,
             self.trusting_period,
             self.max_clock_drift,
-            header.timestamp()?,
+            ts,
             cs.timestamp,
         )?;
 
@@ -673,4 +680,41 @@ mod test {
             panic!("expected error");
         }
     }
+    #[cfg(feature = "dev")]
+    mod dev_test {
+        use crate::client_state::ClientState;
+        use crate::consensus_state::ConsensusState;
+        use crate::errors::Error;
+        use crate::fixture::localnet;
+        use crate::header::eth_header::ETHHeader;
+        use crate::header::eth_headers::ETHHeaders;
+        use crate::header::Header;
+        use crate::misc::new_timestamp;
+        use parlia_ibc_proto::ibc::core::client::v1::Height;
+
+        #[test]
+        fn test_supported_timestamp() {
+            let header = Header::new(
+                vec![1],
+                ETHHeaders {
+                    target: localnet().previous_epoch_header(),
+                    all: vec![],
+                },
+                Height::default(),
+                localnet().previous_epoch_header().epoch.unwrap(),
+                localnet().epoch_header().epoch.unwrap(),
+            );
+            let cs = ClientState::default();
+            let cons_state = ConsensusState::default();
+            let err = cs
+                .check_header(new_timestamp(0).unwrap(), &cons_state, &header)
+                .unwrap_err();
+            match err {
+                Error::UnsupportedTimestamp(e1) => {
+                    assert_eq!(e1, header.timestamp().unwrap());
+                }
+                err => unreachable!("{:?}", err),
+            }
+        }
+    }
 }

light-client/src/errors.rs

@@ -50,6 +50,7 @@ pub enum Error {
     UnexpectedValidatorsHashSize(Vec<u8>),
 
     // Header error
+    UnsupportedTimestamp(Time),
     MissingPreviousValidators(BlockNumber),
     MissingCurrentValidators(BlockNumber),
     OutOfTrustingPeriod(Time, Time),
@@ -372,6 +373,9 @@ impl core::fmt::Display for Error {
                     e1, e2, e3, e4
                 )
             }
+            Error::UnsupportedTimestamp(e1) => {
+                write!(f, "UnsupportedTimestamp : {:?}", e1)
+            }
         }
     }
 }

light-client/src/header/constant.rs

@@ -1 +1,2 @@
 pub const BLOCKS_PER_EPOCH: u64 = 200;
+pub const MINIMUM_TIMESTAMP_SUPPORTED: u64 = 0;