Fix to always keep the current timestamp in Context

enclave-modules/ecall-handler/src/light_client/aggregate_messages.rs

@@ -13,8 +13,6 @@ pub fn aggregate_messages<R: LightClientResolver, S: KVStore, K: Signer>(
     ctx: &mut Context<R, S, K>,
     input: AggregateMessagesInput,
 ) -> Result<LightClientResponse, Error> {
-    ctx.set_timestamp(input.current_timestamp);
-
     if input.messages.len() < 2 {
         return Err(Error::invalid_argument(
             "messages and signatures must have at least 2 elements".into(),

enclave-modules/ecall-handler/src/light_client/init_client.rs

@@ -13,8 +13,6 @@ pub fn init_client<R: LightClientResolver, S: KVStore, K: Signer>(
     ctx: &mut Context<R, S, K>,
     input: InitClientInput,
 ) -> Result<LightClientResponse, Error> {
-    ctx.set_timestamp(input.current_timestamp);
-
     let lc = match ctx.get_light_client(&input.any_client_state.type_url) {
         Some(lc) => lc,
         None => {

enclave-modules/ecall-handler/src/light_client/router.rs

@@ -21,8 +21,12 @@ pub fn dispatch<E: Env>(
             let sealed_ek = cctx
                 .sealed_ek
                 .ok_or(Error::sealed_enclave_key_not_found())?;
-            let mut ctx =
-                Context::new(env.get_lc_registry(), env.new_store(cctx.tx_id), &sealed_ek);
+            let mut ctx = Context::new(
+                env.get_lc_registry(),
+                env.new_store(cctx.tx_id),
+                &sealed_ek,
+                cctx.current_timestamp,
+            );
             match cmd {
                 InitClient(input) => init_client(&mut ctx, input)?,
                 UpdateClient(input) => update_client(&mut ctx, input)?,
@@ -33,8 +37,12 @@ pub fn dispatch<E: Env>(
         }
         LightClientCommand::Query(cmd) => {
             use LightClientQueryCommand::*;
-            let mut ctx =
-                Context::new(env.get_lc_registry(), env.new_store(cctx.tx_id), &NopSigner);
+            let mut ctx = Context::new(
+                env.get_lc_registry(),
+                env.new_store(cctx.tx_id),
+                &NopSigner,
+                cctx.current_timestamp,
+            );
             match cmd {
                 QueryClient(input) => query_client(&mut ctx, input)?,
             }

enclave-modules/ecall-handler/src/light_client/update_client.rs

@@ -12,8 +12,6 @@ pub fn update_client<R: LightClientResolver, S: KVStore, K: Signer>(
     ctx: &mut Context<R, S, K>,
     input: UpdateClientInput,
 ) -> Result<LightClientResponse, Error> {
-    ctx.set_timestamp(input.current_timestamp);
-
     let lc = get_light_client_by_client_id(ctx, &input.client_id)?;
     let ek = ctx.get_enclave_key();
     match lc.update_client(ctx, input.client_id.clone(), input.any_header)? {

modules/context/src/context.rs

@@ -11,23 +11,19 @@ pub struct Context<'k, R: LightClientResolver, S: KVStore, K: Signer> {
     lc_registry: R,
     store: S,
     ek: &'k K,
-    current_timestamp: Option<Time>,
+    current_timestamp: Time,
 }
 
 impl<'k, R: LightClientResolver, S: KVStore, K: Signer> Context<'k, R, S, K> {
-    pub fn new(lc_registry: R, store: S, ek: &'k K) -> Self {
+    pub fn new(lc_registry: R, store: S, ek: &'k K, current_timestamp: Time) -> Self {
         Self {
             lc_registry,
             store,
             ek,
-            current_timestamp: None,
+            current_timestamp,
         }
     }
 
-    pub fn set_timestamp(&mut self, timestamp: Time) {
-        self.current_timestamp = Some(timestamp)
-    }
-
     pub fn get_enclave_key(&self) -> &'k dyn Signer {
         self.ek
     }
@@ -49,7 +45,7 @@ impl<'k, R: LightClientResolver, S: KVStore, K: Signer> KVStore for Context<'k,
 
 impl<'k, R: LightClientResolver, S: KVStore, K: Signer> HostContext for Context<'k, R, S, K> {
     fn host_timestamp(&self) -> Time {
-        self.current_timestamp.unwrap()
+        self.current_timestamp
     }
 }
 

modules/ecall-commands/src/light_client.rs

@@ -1,7 +1,7 @@
 use crate::{prelude::*, EnclaveKeySelector};
 use commitments::CommitmentProof;
 use crypto::Address;
-use lcp_types::{Any, ClientId, Height, Time};
+use lcp_types::{Any, ClientId, Height};
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -44,7 +44,6 @@ pub struct InitClientInput {
     pub client_id: String,
     pub any_client_state: Any,
     pub any_consensus_state: Any,
-    pub current_timestamp: Time,
     pub signer: Address,
 }
 
@@ -53,7 +52,6 @@ pub struct UpdateClientInput {
     pub client_id: ClientId,
     pub any_header: Any,
     pub include_state: bool,
-    pub current_timestamp: Time,
     pub signer: Address,
 }
 
@@ -62,7 +60,6 @@ pub struct AggregateMessagesInput {
     pub signer: Address,
     pub messages: Vec<Vec<u8>>,
     pub signatures: Vec<Vec<u8>>,
-    pub current_timestamp: Time,
 }
 
 #[derive(Serialize, Deserialize, Debug)]

modules/ecall-commands/src/msgs.rs

@@ -9,7 +9,7 @@ use lcp_types::proto::lcp::service::elc::v1::{
     MsgVerifyNonMembership, MsgVerifyNonMembershipResponse,
     QueryClientRequest as MsgQueryClientRequest, QueryClientResponse as MsgQueryClientResponse,
 };
-use lcp_types::{ClientId, Time};
+use lcp_types::ClientId;
 
 impl TryFrom<MsgCreateClient> for InitClientInput {
     type Error = Error;
@@ -26,7 +26,6 @@ impl TryFrom<MsgCreateClient> for InitClientInput {
             client_id: msg.client_id,
             any_client_state,
             any_consensus_state,
-            current_timestamp: Time::now(),
             signer: Address::try_from(msg.signer.as_slice())?,
         })
     }
@@ -44,7 +43,6 @@ impl TryFrom<MsgUpdateClient> for UpdateClientInput {
             client_id,
             any_header,
             include_state: msg.include_state,
-            current_timestamp: Time::now(),
             signer: Address::try_from(msg.signer.as_slice())?,
         })
     }
@@ -58,7 +56,6 @@ impl TryFrom<MsgAggregateMessages> for AggregateMessagesInput {
             signer,
             messages: msg.messages,
             signatures: msg.signatures,
-            current_timestamp: Time::now(),
         })
     }
 }

modules/lcp-client/src/client_def.rs

@@ -656,9 +656,7 @@ mod tests {
                 timestamp: Time::unix_epoch(),
             };
 
-            let mut ctx = Context::new(registry.clone(), ibc_store.clone(), &ek);
-            ctx.set_timestamp(Time::now());
-
+            let mut ctx = Context::new(registry.clone(), ibc_store.clone(), &ek, Time::now());
             let client_id = ClientId::from_str(&format!("{}-0", LCPClient.client_type())).unwrap();
 
             let res = LCPClient.initialise(
@@ -673,8 +671,7 @@ mod tests {
 
         // 2. register enclave key to the LCP client
         {
-            let mut ctx = Context::new(registry.clone(), ibc_store.clone(), &ek);
-            ctx.set_timestamp(Time::now());
+            let mut ctx = Context::new(registry.clone(), ibc_store.clone(), &ek, Time::now());
             let report = generate_dummy_signed_avr(&ek.get_pubkey());
             let operator_signature = op_key
                 .sign(compute_eip712_register_enclave_key(report.avr.as_str()).as_slice())
@@ -692,8 +689,7 @@ mod tests {
             let header = MockHeader::new(ICS02Height::new(0, 1).unwrap());
             let client_state = mock_lc::ClientState::from(MockClientState::new(header));
             let consensus_state = mock_lc::ConsensusState::from(MockConsensusState::new(header));
-            let mut ctx = Context::new(registry.clone(), lcp_store.clone(), &ek);
-            ctx.set_timestamp(Time::now());
+            let mut ctx = Context::new(registry.clone(), lcp_store.clone(), &ek, Time::now());
 
             let res = MockLightClient.create_client(
                 &ctx,
@@ -721,8 +717,7 @@ mod tests {
         let proof1 = {
             let header = MockHeader::new(ICS02Height::new(0, 2).unwrap());
 
-            let mut ctx = Context::new(registry.clone(), lcp_store.clone(), &ek);
-            ctx.set_timestamp(Time::now());
+            let mut ctx = Context::new(registry.clone(), lcp_store.clone(), &ek, Time::now());
             let res = MockLightClient.update_client(
                 &ctx,
                 upstream_client_id.clone(),
@@ -758,18 +753,20 @@ mod tests {
                 proxy_message: proof1.message().unwrap(),
                 signatures: vec![proof1.signature],
             });
-            let mut ctx = Context::new(registry.clone(), ibc_store.clone(), &ek);
-            ctx.set_timestamp((Time::now() + Duration::from_secs(60)).unwrap());
+            let mut ctx = Context::new(
+                registry.clone(),
+                ibc_store.clone(),
+                &ek,
+                (Time::now() + Duration::from_secs(60)).unwrap(),
+            );
 
             let res = LCPClient.update_client(&mut ctx, lcp_client_id.clone(), header);
             assert!(res.is_ok(), "res={:?}", res);
         }
 
         // 6. on the upstream side, updates the Light Client state with a misbehaviour
         let misbehaviour_proof = {
-            let mut ctx = Context::new(registry.clone(), lcp_store, &ek);
-            ctx.set_timestamp(Time::now());
-
+            let ctx = Context::new(registry.clone(), lcp_store, &ek, Time::now());
             let mock_misbehaviour = MockMisbehaviour {
                 client_id: upstream_client_id.clone().into(),
                 header1: MockHeader::new(ICS02Height::new(0, 3).unwrap()),
@@ -797,9 +794,12 @@ mod tests {
                 proxy_message: misbehaviour_proof.message().unwrap(),
                 signatures: vec![misbehaviour_proof.signature],
             });
-            let mut ctx = Context::new(registry, ibc_store, &ek);
-            ctx.set_timestamp((Time::now() + Duration::from_secs(60)).unwrap());
-
+            let mut ctx = Context::new(
+                registry,
+                ibc_store,
+                &ek,
+                (Time::now() + Duration::from_secs(60)).unwrap(),
+            );
             let res = LCPClient.update_client(&mut ctx, lcp_client_id, header);
             assert!(res.is_ok(), "res={:?}", res);
         }

tests/integration/src/config.rs

@@ -57,7 +57,7 @@ fn make_tm_config(cfg: TestChainConfig) -> ChainConfig {
         max_msg_num: Default::default(),
         max_tx_size: Default::default(),
         max_block_time: Default::default(),
-        clock_drift: Duration::from_secs(5),
+        clock_drift: Duration::from_secs(30),
         trusting_period: Some(Duration::from_secs(14 * 24 * 3600)),
         trust_threshold: Default::default(),
         gas_price: config::GasPrice::new(0.001, "stake".to_string()),

tests/integration/src/lib.rs

@@ -35,10 +35,10 @@ mod tests {
     };
     use keymanager::EnclaveKeyManager;
     use lcp_proto::protobuf::Protobuf;
-    use lcp_types::{ClientId, Height, Time};
+    use lcp_types::{ClientId, Height};
     use log::*;
+    use std::str::FromStr;
     use std::sync::{Arc, RwLock};
-    use std::{ops::Add, str::FromStr, time::Duration};
     use store::{host::HostStore, memory::MemStore};
     use tempfile::TempDir;
     use tokio::runtime::Runtime as TokioRuntime;
@@ -239,7 +239,6 @@ mod tests {
                 client_id: client_id.clone(),
                 any_client_state: client_state,
                 any_consensus_state: consensus_state,
-                current_timestamp: Time::now(),
                 signer,
             })?;
             assert!(!res.proof.is_proven());
@@ -254,7 +253,6 @@ mod tests {
             let res = enclave.update_client(UpdateClientInput {
                 client_id: client_id.clone(),
                 any_header: target_header,
-                current_timestamp: Time::now(),
                 include_state: true,
                 signer,
             })?;
@@ -298,7 +296,6 @@ mod tests {
                 let res = enclave.update_client(UpdateClientInput {
                     client_id: client_id.clone(),
                     any_header: target_header,
-                    current_timestamp: Time::now().add(Duration::from_secs(10))?, // for gaiad's clock drift
                     include_state: false,
                     signer,
                 })?;
@@ -316,7 +313,6 @@ mod tests {
                 messages,
                 signatures,
                 signer,
-                current_timestamp: Time::now().add(Duration::from_secs(10))?,
             })?;
             let msg: UpdateStateProxyMessage = res.0.message().unwrap().try_into()?;
             assert!(msg.prev_height == Some(Height::from(last_height)));