refactor

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

Author: Naohiro Yoshida

light-client/src/header/eth_header.rs

@@ -288,7 +288,7 @@ impl ETHHeader {
         if self.extra_data.len() <= EXTRA_VANITY + EXTRA_SEAL {
             return Err(Error::UnexpectedVoteLength(self.extra_data.len()));
         }
-        let attestation_bytes = if self.number % BLOCKS_PER_EPOCH != 0 {
+        let attestation_bytes = if !self.is_epoch() {
             &self.extra_data[EXTRA_VANITY..self.extra_data.len() - EXTRA_SEAL]
         } else {
             let num = self.extra_data[EXTRA_VANITY] as usize;
@@ -307,7 +307,26 @@ impl ETHHeader {
     }
 
     pub fn is_epoch(&self) -> bool {
-        self.number % BLOCKS_PER_EPOCH == 0
+        is_epoch(self.number)
+    }
+
+    pub fn current_epoch_block_number(&self) -> BlockNumber {
+        current_epoch_block_number(self.number)
+    }
+
+    pub fn previous_epoch_block_number(&self) -> BlockNumber {
+        let current_epoch = self.current_epoch_block_number();
+        previous_epoch_block_number_from(current_epoch)
+    }
+
+    pub fn next_epoch_block_number(&self) -> BlockNumber {
+        let current_epoch = self.current_epoch_block_number();
+        next_epoch_block_number_from(current_epoch)
+    }
+
+    pub fn next_next_epoch_block_number(&self) -> BlockNumber {
+        let next_epoch = self.next_epoch_block_number();
+        next_epoch_block_number_from(next_epoch)
     }
 
     pub fn verify_fork_rule(&self, fork_specs: &[ForkSpec]) -> Result<(), Error> {
@@ -332,6 +351,22 @@ impl ETHHeader {
     }
 }
 
+fn is_epoch(number: BlockNumber) -> bool {
+    number % BLOCKS_PER_EPOCH == 0
+}
+
+pub fn current_epoch_block_number(number: BlockNumber) -> BlockNumber {
+    number - (number % BLOCKS_PER_EPOCH)
+}
+
+fn previous_epoch_block_number_from(base_epoch_block_number: BlockNumber) -> BlockNumber {
+    base_epoch_block_number - BLOCKS_PER_EPOCH
+}
+
+fn next_epoch_block_number_from(base_epoch_block_number: BlockNumber) -> BlockNumber {
+    base_epoch_block_number + BLOCKS_PER_EPOCH
+}
+
 pub fn get_validator_bytes_and_turn_length(extra_data: &[u8]) -> Result<(Validators, u8), Error> {
     if extra_data.len() <= EXTRA_VANITY + EXTRA_SEAL {
         return Err(Error::UnexpectedExtraDataLength(extra_data.len()));
@@ -428,7 +463,7 @@ impl TryFrom<RawETHHeader> for ETHHeader {
         }
         let hash: Hash = keccak_256(value.header.as_slice());
 
-        let epoch = if number % BLOCKS_PER_EPOCH == 0 {
+        let epoch = if is_epoch(number) {
             let (validators, turn_length) = get_validator_bytes_and_turn_length(&extra_data)?;
             Some(Epoch::new(validators.into(), turn_length))
         } else {

light-client/src/header/eth_headers.rs

@@ -9,7 +9,6 @@ use crate::header::epoch::{EitherEpoch, Epoch, TrustedEpoch};
 use crate::misc::{BlockNumber, ChainId, Validators};
 
 use super::eth_header::ETHHeader;
-use super::BLOCKS_PER_EPOCH;
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct ETHHeaders {
@@ -34,10 +33,18 @@ impl ETHHeaders {
         previous_epoch: &TrustedEpoch,
     ) -> Result<(), Error> {
         // Ensure the header after the next or next checkpoint must not exist.
-        let epoch = self.target.number / BLOCKS_PER_EPOCH;
-        let checkpoint = epoch * BLOCKS_PER_EPOCH + previous_epoch.checkpoint();
-        let next_checkpoint = (epoch + 1) * BLOCKS_PER_EPOCH + current_epoch.checkpoint();
-        let n_val = self.verify_header_size(epoch, checkpoint, next_checkpoint, current_epoch)?;
+        let current_epoch_block_number = self.target.current_epoch_block_number();
+        let checkpoint = current_epoch_block_number + previous_epoch.checkpoint();
+
+        let next_epoch_block_number = self.target.next_epoch_block_number();
+        let next_checkpoint = next_epoch_block_number + current_epoch.checkpoint();
+
+        let n_val = self.verify_header_size(
+            self.target.next_next_epoch_block_number(),
+            checkpoint,
+            next_checkpoint,
+            current_epoch,
+        )?;
 
         // Ensure all the headers are successfully chained.
         self.verify_cascading_fields()?;
@@ -140,7 +147,7 @@ impl ETHHeaders {
     /// checkpoint range and ensures that they meet the size requirements for the current and next epochs.
     fn verify_header_size(
         &self,
-        epoch: u64,
+        next_next_epoch_block_number: BlockNumber,
         checkpoint: u64,
         next_checkpoint: u64,
         current_epoch: &EitherEpoch,
@@ -176,7 +183,7 @@ impl ETHHeaders {
                     return Ok(None);
                 }
 
-                let next_next_checkpoint = (epoch + 2) * BLOCKS_PER_EPOCH + next_epoch.checkpoint();
+                let next_next_checkpoint = next_next_epoch_block_number + next_epoch.checkpoint();
 
                 // Ensure headers are before the next_next_checkpoint
                 if hs.iter().any(|h| h.number >= next_next_checkpoint) {

light-client/src/header/mod.rs

@@ -7,7 +7,7 @@ use parlia_ibc_proto::ibc::lightclients::parlia::v1::Header as RawHeader;
 use crate::consensus_state::ConsensusState;
 use crate::fork_spec::ForkSpec;
 use crate::header::epoch::{EitherEpoch, Epoch, TrustedEpoch, UntrustedEpoch};
-use crate::header::eth_header::{validate_turn_length, ETHHeader};
+use crate::header::eth_header::{current_epoch_block_number, validate_turn_length, ETHHeader};
 
 use crate::header::eth_headers::ETHHeaders;
 use crate::misc::{new_height, new_timestamp, ChainId, Hash};
@@ -106,11 +106,11 @@ fn verify_epoch<'a>(
     current_epoch: &'a Epoch,
 ) -> Result<(EitherEpoch<'a>, TrustedEpoch<'a>), Error> {
     let is_epoch = target.is_epoch();
-    let header_epoch = height.revision_height() / BLOCKS_PER_EPOCH;
-    let trusted_epoch = trusted_height.revision_height() / BLOCKS_PER_EPOCH;
+    let trusted_epoch = current_epoch_block_number(trusted_height.revision_height());
 
     if is_epoch {
-        if header_epoch != trusted_epoch + 1 {
+        let header_previous_epoch = target.previous_epoch_block_number();
+        if header_previous_epoch != trusted_epoch {
             return Err(Error::UnexpectedTrustedHeight(
                 trusted_height.revision_height(),
                 height.revision_height(),
@@ -144,6 +144,7 @@ fn verify_epoch<'a>(
             TrustedEpoch::new(previous_epoch),
         ))
     } else {
+        let header_epoch = target.current_epoch_block_number();
         if header_epoch != trusted_epoch {
             return Err(Error::UnexpectedTrustedHeight(
                 trusted_height.revision_height(),