Rename views to author_view and finalized_view

author_view: view when the block was created. finalized_view: view when the block was finalized.

Author: majecty

core/src/consensus/tendermint/types.rs

@@ -224,13 +224,17 @@ impl<'a> TendermintSealView<'a> {
  }
  }
 
- pub fn previous_block_view(&self) -> Result<u64, DecoderError> {
+ /// The parent block is finalized at this view.
+ /// Signatures in the seal field is signed for this view.
+ pub fn parent_block_finalized_view(&self) -> Result<u64, DecoderError> {
  let view_rlp =
  self.seal.get(0).expect("block went through verify_block_basic; block has .seal_fields() fields; qed");
  UntrustedRlp::new(view_rlp.as_slice()).as_val()
  }
 
- pub fn consensus_view(&self) -> Result<u64, DecoderError> {
+ /// Block is created at auth_view.
+ /// Block verifier use other_view to verify the author
+ pub fn author_view(&self) -> Result<u64, DecoderError> {
  let view_rlp =
  self.seal.get(1).expect("block went through verify_block_basic; block has .seal_fields() fields; qed");
  UntrustedRlp::new(view_rlp.as_slice()).as_val()

core/src/consensus/tendermint/worker.rs

@@ -928,9 +928,9 @@ impl Worker {
 
  let height = proposal.number() as Height;
  let seal_view = TendermintSealView::new(proposal.seal());
- let prev_block_view = seal_view.previous_block_view().expect("The proposal is verified");
+ let parent_block_finalized_view = seal_view.parent_block_finalized_view().expect("The proposal is verified");
  let on = VoteOn {
- step: VoteStep::new(height - 1, prev_block_view, Step::Precommit),
+ step: VoteStep::new(height - 1, parent_block_finalized_view, Step::Precommit),
  block_hash: Some(*proposal.parent_hash()),
  };
  for (index, signature) in seal_view.signatures().expect("The proposal is verified") {
@@ -990,7 +990,7 @@ impl Worker {
  };
  } else if current_height < height {
  let finalized_view_of_previous_height =
- TendermintSealView::new(proposal.seal()).previous_block_view().unwrap();
+ TendermintSealView::new(proposal.seal()).parent_block_finalized_view().unwrap();
 
  self.jump_to_height(height, finalized_view_of_previous_height);
 
@@ -1095,16 +1095,15 @@ impl Worker {
  fn proposal_generated(&mut self, sealed_block: &SealedBlock) {
  let proposal_height = sealed_block.header().number();
  let proposal_seal = sealed_block.header().seal();
- let proposal_view = TendermintSealView::new(proposal_seal)
- .consensus_view()
- .expect("Generated proposal should have a valid seal");
+ let proposal_author_view =
+ TendermintSealView::new(proposal_seal).author_view().expect("Generated proposal should have a valid seal");
  assert!(proposal_height <= self.height, "A proposal cannot be generated on the future height");
- if proposal_height < self.height || (proposal_height == self.height && proposal_view != self.view) {
+ if proposal_height < self.height || (proposal_height == self.height && proposal_author_view != self.view) {
  ctrace!(
  ENGINE,
  "Proposal is generated on the height {} and view {}. Current height is {} and view is {}",
  proposal_height,
- proposal_view,
+ proposal_author_view,
  self.height,
  self.view,
  );
@@ -1131,7 +1130,7 @@ impl Worker {
  );
  return
  }
- debug_assert_eq!(Ok(self.view), TendermintSealView::new(header.seal()).consensus_view());
+ debug_assert_eq!(Ok(self.view), TendermintSealView::new(header.seal()).author_view());
 
  self.vote_on_header_for_proposal(&header).expect("I'm a proposer");
 
@@ -1152,8 +1151,8 @@ impl Worker {
  }
 
  let height = header.number();
- let view = TendermintSealView::new(header.seal()).consensus_view().unwrap();
- let score = calculate_score(height, view);
+ let author_view = TendermintSealView::new(header.seal()).author_view().unwrap();
+ let score = calculate_score(height, author_view);
 
  if *header.score() != score {
  return Err(BlockError::InvalidScore(Mismatch {
@@ -1168,13 +1167,13 @@ impl Worker {
 
  fn verify_block_external(&self, header: &Header) -> Result<(), Error> {
  let height = header.number() as usize;
- let view = TendermintSealView::new(header.seal()).consensus_view()?;
- ctrace!(ENGINE, "Verify external at {}-{}, {:?}", height, view, header);
+ let author_view = TendermintSealView::new(header.seal()).author_view()?;
+ ctrace!(ENGINE, "Verify external at {}-{}, {:?}", height, author_view, header);
  let proposer = header.author();
  if !self.is_authority(header.parent_hash(), proposer) {
  return Err(EngineError::BlockNotAuthorized(*proposer).into())
  }
- self.check_view_proposer(header.parent_hash(), header.number(), view, &proposer)?;
+ self.check_view_proposer(header.parent_hash(), header.number(), author_view, &proposer)?;
  let seal_view = TendermintSealView::new(header.seal());
  let bitset_count = seal_view.bitset()?.count();
  let precommits_count = seal_view.precommits().item_count()?;
@@ -1197,9 +1196,9 @@ impl Worker {
  return Err(BlockError::InvalidSeal.into())
  }
 
- let previous_block_view = TendermintSealView::new(header.seal()).previous_block_view()?;
+ let parent_block_finalized_view = TendermintSealView::new(header.seal()).parent_block_finalized_view()?;
  let precommit_vote_on = VoteOn {
- step: VoteStep::new(header.number() - 1, previous_block_view, Step::Precommit),
+ step: VoteStep::new(header.number() - 1, parent_block_finalized_view, Step::Precommit),
  block_hash: Some(*header.parent_hash()),
  };
 
@@ -1642,7 +1641,7 @@ impl Worker {
  if self.height < header.number() {
  cinfo!(ENGINE, "Received a commit: {:?}.", header.number());
  let finalized_view_of_previous_height = TendermintSealView::new(full_header.seal())
- .previous_block_view()
+ .parent_block_finalized_view()
  .expect("Imported block already checked");
  self.jump_to_height(header.number(), finalized_view_of_previous_height);
  }
@@ -1791,15 +1790,14 @@ impl Worker {
  // The proposer re-proposed its locked proposal.
  // If we already imported the proposal, we should set `proposal` here.
  if c.block(&BlockId::Hash(header_view.hash())).is_some() {
- let generated_view = TendermintSealView::new(header_view.seal())
- .consensus_view()
- .expect("Imported block is verified");
+ let author_view =
+ TendermintSealView::new(header_view.seal()).author_view().expect("Imported block is verified");
  cdebug!(
  ENGINE,
  "Received a proposal({}) by a locked proposer. current view: {}, original proposal's view: {}",
  header_view.hash(),
  proposed_view,
- generated_view
+ author_view
  );
  self.proposal = Proposal::new_imported(header_view.hash());
  } else {
@@ -1975,13 +1973,14 @@ impl Worker {
  let block = self.client().block(&height.into()).expect("Parent block should exist");
  let block_hash = block.hash();
  let seal = block.seal();
- let view = TendermintSealView::new(&seal).consensus_view().expect("Block is already verified and imported");
+ let author_view =
+ TendermintSealView::new(&seal).author_view().expect("Block is already verified and imported");
 
  let votes = self
  .votes
  .get_all_votes_in_round(&VoteStep {
  height,
- view,
+ view: author_view,
  step: Step::Precommit,
  })
  .into_iter()
@@ -1994,9 +1993,10 @@ impl Worker {
  let child_block = self.client().block(&(height + 1).into()).expect("Parent block should exist");
  let child_block_header_seal = child_block.header().seal();
  let child_block_seal_view = TendermintSealView::new(&child_block_header_seal);
- let view = child_block_seal_view.previous_block_view().expect("Verified block");
+ let parent_block_finalized_view =
+ child_block_seal_view.parent_block_finalized_view().expect("Verified block");
  let on = VoteOn {
- step: VoteStep::new(height, view, Step::Precommit),
+ step: VoteStep::new(height, parent_block_finalized_view, Step::Precommit),
  block_hash: Some(block.hash()),
  };
  let mut votes = Vec::new();