check strict

Signed-off-by: Naohiro Yoshida <naohiro.yoshida@datachain.jp>

Author: Naohiro Yoshida

light-client/src/client.rs

@@ -836,7 +836,7 @@ mod test {
             consensus_state: mock_consensus_state,
         };
         let err = client.update_client(&ctx, client_id, any).unwrap_err();
-        assert_err(err, "MissingForkHeightIntBoundaryCalculation");
+        assert_err(err, "MissingForkHeightInBoundaryCalculation");
     }
 
     #[rstest]

light-client/src/client_state.rs

@@ -129,7 +129,7 @@ impl ClientState {
         }
 
         // Ensure satisfying fork specs
-        header.verify_fork_rule(&self.fork_specs)?;
+        header.assign_fork_spec(&self.fork_specs)?;
 
         // Ensure header is valid
         header.verify(&self.chain_id, cs)

light-client/src/errors.rs

@@ -109,6 +109,8 @@ pub enum Error {
     MissingForkSpec(BlockNumber, u64),
     MissingForkSpecByHeight(BlockNumber),
     UnexpectedHeaderItemCount(BlockNumber, usize, u64),
+    MissingEpochInfo(BlockNumber),
+    UnexpectedEpochInfo(BlockNumber, BlockNumber),
 
     // Vote attestation
     UnexpectedTooManyHeadersToFinalize(BlockNumber, usize),
@@ -132,9 +134,18 @@ pub enum Error {
     UnexpectedForkSpecTimestampOrder(u64, u64),
     UnexpectedForkSpecHeightOrder(u64, u64),
     MissingForkHeightIntPreviousEpochCalculation(u64, ForkSpec),
-    MissingForkHeightIntBoundaryCalculation(ForkSpec),
-    NotVerifiableHeader(BlockNumber),
+    MissingForkHeightInBoundaryCalculation(ForkSpec),
+    MissingBoundaryEpochs(BlockNumber),
     MissingPreviousForkSpec(ForkSpec),
+    UnexpectedCurrentEpochInCalculatingNextEpoch(BlockNumber, BlockNumber, BlockNumber),
+    UnexpectedMissingForkSpecInCurrentEpochCalculation(BlockNumber, alloc::boxed::Box<Error>),
+    UnexpectedMissingForkSpecInPreviousEpochCalculation(BlockNumber, alloc::boxed::Box<Error>),
+    UnexpectedPreviousEpochInCalculatingNextEpoch(
+        BlockNumber,
+        BlockNumber,
+        BlockNumber,
+        BlockNumber,
+    ),
 
     // Misbehaviour
     MissingHeader1,
@@ -457,15 +468,49 @@ impl core::fmt::Display for Error {
                     e1, e2
                 )
             }
-            Error::MissingForkHeightIntBoundaryCalculation(e1) => {
-                write!(f, "MissingForkHeightIntBoundaryCalculation : {:?}", e1)
+            Error::MissingForkHeightInBoundaryCalculation(e1) => {
+                write!(f, "MissingForkHeightInBoundaryCalculation : {:?}", e1)
             }
-            Error::NotVerifiableHeader(e1) => {
-                write!(f, "NotVerifiableHeader : {}", e1)
+            Error::MissingBoundaryEpochs(e1) => {
+                write!(f, "MissingBoundaryEpochs : {}", e1)
             }
             Error::MissingPreviousForkSpec(e1) => {
                 write!(f, "MissingPreviousForkSpec : {:?}", e1)
             }
+            Error::UnexpectedCurrentEpochInCalculatingNextEpoch(e1, e2, e3) => {
+                write!(
+                    f,
+                    "UnexpectedCurrentEpochInCalculatingNextEpoch : {} {} {}",
+                    e1, e2, e3
+                )
+            }
+            Error::UnexpectedMissingForkSpecInCurrentEpochCalculation(e1, e2) => {
+                write!(
+                    f,
+                    "UnexpectedMissingForkSpecInCurrentEpochCalculation : {} {:?} ",
+                    e1, e2
+                )
+            }
+            Error::UnexpectedMissingForkSpecInPreviousEpochCalculation(e1, e2) => {
+                write!(
+                    f,
+                    "UnexpectedMissingForkSpecInPreviousEpochCalculation : {} {:?} ",
+                    e1, e2
+                )
+            }
+            Error::UnexpectedPreviousEpochInCalculatingNextEpoch(e1, e2, e3, e4) => {
+                write!(
+                    f,
+                    "UnexpectedPreviousEpochInCalculatingNextEpoch : {} {} {} {} ",
+                    e1, e2, e3, e4
+                )
+            }
+            Error::MissingEpochInfo(e1) => {
+                write!(f, "MissingEpochInfo : {} ", e1)
+            }
+            Error::UnexpectedEpochInfo(e1, e2) => {
+                write!(f, "UnexpectedEpochInfo : {} {}", e1, e2)
+            }
         }
     }
 }

light-client/src/fork_spec.rs

@@ -75,7 +75,7 @@ impl ForkSpec {
                 intermediates,
             });
         }
-        Err(Error::MissingForkHeightIntBoundaryCalculation(self.clone()))
+        Err(Error::MissingForkHeightInBoundaryCalculation(self.clone()))
     }
 }
 
@@ -526,7 +526,7 @@ mod test {
             .boundary_epochs(&fork_spec_after_pascal())
             .unwrap_err()
         {
-            Error::MissingForkHeightIntBoundaryCalculation(e1) => {
+            Error::MissingForkHeightInBoundaryCalculation(e1) => {
                 assert_eq!(current, e1);
             }
             _ => unreachable!("unexpected error"),

light-client/src/header/eth_header.rs

@@ -316,15 +316,15 @@ impl ETHHeader {
         Ok(self
             .boundary_epochs
             .as_ref()
-            .ok_or(Error::NotVerifiableHeader(self.number))?
+            .ok_or(Error::MissingBoundaryEpochs(self.number))?
             .current_epoch_block_number(self.number))
     }
 
     pub fn previous_epoch_block_number(&self) -> Result<BlockNumber, Error> {
         let boundary = self
             .boundary_epochs
             .as_ref()
-            .ok_or(Error::NotVerifiableHeader(self.number))?;
+            .ok_or(Error::MissingBoundaryEpochs(self.number))?;
         let current_epoch_block_number = boundary.current_epoch_block_number(self.number);
         Ok(boundary.previous_epoch_block_number(current_epoch_block_number))
     }
@@ -351,7 +351,7 @@ impl ETHHeader {
                 Ok(())
             }
             HeightOrTimestamp::Time(_) => {
-                Err(Error::MissingForkHeightIntBoundaryCalculation(fs.clone()))
+                Err(Error::MissingForkHeightInBoundaryCalculation(fs.clone()))
             }
         }
     }

light-client/src/header/eth_headers.rs

@@ -35,7 +35,8 @@ impl ETHHeaders {
         let current_epoch_block_number = self.target.current_epoch_block_number()?;
         let checkpoint = current_epoch_block_number + previous_epoch.checkpoint();
 
-        let (n_val, next_checkpoint) = self.verify_header_size(checkpoint, current_epoch)?;
+        let (n_val, next_checkpoint) =
+            self.verify_header_size(checkpoint, current_epoch, current_epoch_block_number)?;
 
         // Ensure all the headers are successfully chained.
         self.verify_cascading_fields()?;
@@ -139,29 +140,73 @@ impl ETHHeaders {
     /// checkpoint range and ensures that they meet the size requirements for the current and next epochs.
     fn verify_header_size(
         &self,
-        checkpoint: u64,
+        current_checkpoint: u64,
         current_epoch: &EitherEpoch,
+        current_epoch_block_number: BlockNumber,
     ) -> Result<(Option<Epoch>, Option<BlockNumber>), Error> {
-        let after_checkpoint: Vec<&ETHHeader> =
-            self.all.iter().filter(|h| h.number >= checkpoint).collect();
-
-        let find_next_epoch = |hs: &Vec<&ETHHeader>, height_to_checkpoint: u64| {
-            for h in hs.iter() {
-                if let Ok(next_epoch) = get_validator_bytes_and_turn_length(&h.extra_data) {
-                    let next_epoch = Epoch::new(next_epoch.0.into(), next_epoch.1);
-                    let next_checkpoint = h.number + height_to_checkpoint;
-                    return (Some(next_epoch), Some(next_checkpoint));
+        let after_checkpoint: Vec<&ETHHeader> = self
+            .all
+            .iter()
+            .filter(|h| h.number >= current_checkpoint)
+            .collect();
+
+        let find_next_epoch =
+            |hs: &Vec<&ETHHeader>,
+             height_to_checkpoint: u64,
+             expected_prev_epoch_number: BlockNumber| {
+                for h in hs.iter() {
+                    let self_current_epoch_number =
+                        h.current_epoch_block_number().map_err(|e| {
+                            Error::UnexpectedMissingForkSpecInCurrentEpochCalculation(
+                                h.number,
+                                alloc::boxed::Box::new(e),
+                            )
+                        })?;
+                    if self_current_epoch_number == h.number {
+                        return if let Some(next_epoch) = &h.epoch {
+                            let self_previous_epoch_number =
+                                h.previous_epoch_block_number().map_err(|e| {
+                                    Error::UnexpectedMissingForkSpecInPreviousEpochCalculation(
+                                        h.number,
+                                        alloc::boxed::Box::new(e),
+                                    )
+                                })?;
+                            if self_previous_epoch_number != expected_prev_epoch_number {
+                                return Err(Error::UnexpectedPreviousEpochInCalculatingNextEpoch(
+                                    h.number,
+                                    self_previous_epoch_number,
+                                    expected_prev_epoch_number,
+                                    current_epoch_block_number,
+                                ));
+                            }
+                            let next_checkpoint = h.number + height_to_checkpoint;
+                            Ok((
+                                Some(next_epoch.clone()),
+                                Some(next_checkpoint),
+                                Some(self_current_epoch_number),
+                            ))
+                        } else {
+                            Err(Error::MissingEpochInfo(h.number))
+                        };
+                    } else if h.is_epoch() {
+                        return Err(Error::UnexpectedEpochInfo(
+                            h.number,
+                            self_current_epoch_number,
+                        ));
+                    }
                 }
-            }
-            (None, None)
-        };
+                Ok((None, None, None))
+            };
 
         match current_epoch {
             // ex) t=200 then  200 <= h < 411 (at least 1 honest c_val(200)' can be in p_val)
             Untrusted(_) => {
                 // Ensure headers are before the next_checkpoint
-                let (next_epoch, next_checkpoint) =
-                    find_next_epoch(&after_checkpoint, current_epoch.checkpoint());
+                let (next_epoch, next_checkpoint, _) = find_next_epoch(
+                    &after_checkpoint,
+                    current_epoch.checkpoint(),
+                    current_epoch_block_number,
+                )?;
                 if let Some(next_checkpoint) = next_checkpoint {
                     if after_checkpoint.iter().any(|h| h.number >= next_checkpoint) {
                         return Err(Error::UnexpectedNextCheckpointHeader(
@@ -175,28 +220,31 @@ impl ETHHeaders {
             // ex) t=201 then 201 <= h < 611 (at least 1 honest n_val(400) can be in c_val(200))
             Trusted(_) => {
                 // Get next_epoch if epoch after checkpoint ex) 400
-                let (next_epoch, next_checkpoint) =
-                    find_next_epoch(&after_checkpoint, current_epoch.checkpoint());
+                let (next_epoch, next_checkpoint, next_epoch_block_number) = find_next_epoch(
+                    &after_checkpoint,
+                    current_epoch.checkpoint(),
+                    current_epoch_block_number,
+                )?;
                 let next_checkpoint = match next_checkpoint {
                     None => return Ok((next_epoch, next_checkpoint)),
                     Some(v) => v,
                 };
 
                 // Finish if no headers over next checkpoint were found
-                let after_next_checkpoint: Vec<&ETHHeader> = self
-                    .all
-                    .iter()
+                let after_next_checkpoint: Vec<&ETHHeader> = after_checkpoint
+                    .into_iter()
                     .filter(|h| h.number >= next_checkpoint)
                     .collect();
                 if after_next_checkpoint.is_empty() {
                     return Ok((next_epoch, Some(next_checkpoint)));
                 }
 
                 // Ensure headers are before the next_next_checkpoint
-                let (_, next_next_checkpoint) = find_next_epoch(
+                let (_, next_next_checkpoint, _) = find_next_epoch(
                     &after_next_checkpoint,
                     next_epoch.clone().unwrap().checkpoint(),
-                );
+                    next_epoch_block_number.unwrap(),
+                )?;
                 if let Some(next_next_checkpoint) = next_next_checkpoint {
                     if after_next_checkpoint
                         .iter()

light-client/src/header/mod.rs

@@ -5,7 +5,7 @@ use parlia_ibc_proto::google::protobuf::Any as IBCAny;
 use parlia_ibc_proto::ibc::lightclients::parlia::v1::Header as RawHeader;
 
 use crate::consensus_state::ConsensusState;
-use crate::fork_spec::{find_target_fork_spec, get_boundary_epochs, ForkSpec};
+use crate::fork_spec::{find_target_fork_spec, get_boundary_epochs, ForkSpec, HeightOrTimestamp};
 use crate::header::epoch::{EitherEpoch, Epoch, TrustedEpoch, UntrustedEpoch};
 use crate::header::eth_header::{validate_turn_length, ETHHeader};
 
@@ -71,13 +71,37 @@ impl Header {
         &self.headers.target.hash
     }
 
-    pub fn verify_fork_rule(&mut self, fork_specs: &[ForkSpec]) -> Result<(), Error> {
+    pub fn assign_fork_spec(&mut self, fork_specs: &[ForkSpec]) -> Result<(), Error> {
+        let mut fork_specs = fork_specs.to_vec();
         for header in &mut self.headers.all {
-            header.verify_fork_rule(fork_specs)?;
+            header.verify_fork_rule(&fork_specs)?;
+        }
+        // Ensure HF height is required for target without seeking next headers
+        self.headers.target.set_boundary_epochs(&fork_specs)?;
+
+        // Try to set HF height
+        if !fork_specs.is_empty() {
+            let last_index = fork_specs.len() - 1;
+            let last = &mut fork_specs[last_index];
+            match last.height_or_timestamp {
+                HeightOrTimestamp::Time(time) => {
+                    for header in &mut self.headers.all {
+                        if header.milli_timestamp() >= time {
+                            last.height_or_timestamp = HeightOrTimestamp::Height(header.number);
+                            break;
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        // Set boundary epoch to verify header size.
+        for header in &mut self.headers.all {
+            header.set_boundary_epochs(&fork_specs)?
         }
-        self.headers.target.set_boundary_epochs(fork_specs)?;
 
-        self.fork_specs = fork_specs.to_vec();
+        self.fork_specs = fork_specs;
         Ok(())
     }