Rename parameter to two_thirds_majority_transition.

ethcore/src/engines/authority_round/finality.rs

@@ -36,19 +36,19 @@ pub struct RollingFinality {
 	sign_count: HashMap<Address, usize>,
 	last_pushed: Option<H256>,
 	/// First block for which a 2/3 quorum (instead of 1/2) is required.
-	quorum_2_3_transition: BlockNumber,
+	two_thirds_majority_transition: BlockNumber,
 }
 
 impl RollingFinality {
 	/// Create a blank finality checker under the given validator set.
-	pub fn blank(signers: Vec<Address>, quorum_2_3_transition: BlockNumber) -> Self {
+	pub fn blank(signers: Vec<Address>, two_thirds_majority_transition: BlockNumber) -> Self {
 		trace!(target: "finality", "Instantiating blank RollingFinality with {} signers: {:?}", signers.len(), signers);
 		RollingFinality {
 			headers: VecDeque::new(),
 			signers: SimpleList::new(signers),
 			sign_count: HashMap::new(),
 			last_pushed: None,
-			quorum_2_3_transition,
+			two_thirds_majority_transition,
 		}
 	}
 
@@ -133,15 +133,15 @@ impl RollingFinality {
 	}
 
 	/// Returns the first block for which a 2/3 quorum (instead of 1/2) is required.
-	pub fn quorum_2_3_transition(&self) -> BlockNumber {
-		self.quorum_2_3_transition
+	pub fn two_thirds_majority_transition(&self) -> BlockNumber {
+		self.two_thirds_majority_transition
 	}
 
 	/// Returns whether the first entry in `self.headers` is finalized.
 	fn is_finalized(&self) -> bool {
 		match self.headers.front() {
 			None => false,
-			Some((_, number, _)) if *number < self.quorum_2_3_transition => {
+			Some((_, number, _)) if *number < self.two_thirds_majority_transition => {
 				self.sign_count.len() * 2 > self.signers.len()
 			}
 			Some((_, _, _)) => {

ethcore/src/engines/authority_round/mod.rs

@@ -90,7 +90,7 @@ pub struct AuthorityRoundParams {
 	/// Empty step messages transition block.
 	pub empty_steps_transition: u64,
 	/// First block for which a 2/3 quorum (instead of 1/2) is required.
-	pub quorum_2_3_transition: BlockNumber,
+	pub two_thirds_majority_transition: BlockNumber,
 	/// Number of accepted empty steps.
 	pub maximum_empty_steps: usize,
 	/// Transition block to strict empty steps validation.
@@ -124,7 +124,7 @@ impl From<ethjson::spec::AuthorityRoundParams> for AuthorityRoundParams {
 			maximum_uncle_count: p.maximum_uncle_count.map_or(0, Into::into),
 			empty_steps_transition: p.empty_steps_transition.map_or(u64::max_value(), |n| ::std::cmp::max(n.into(), 1)),
 			maximum_empty_steps: p.maximum_empty_steps.map_or(0, Into::into),
-			quorum_2_3_transition: p.quorum_2_3_transition.map_or_else(BlockNumber::max_value, Into::into),
+			two_thirds_majority_transition: p.two_thirds_majority_transition.map_or_else(BlockNumber::max_value, Into::into),
 			strict_empty_steps_transition: p.strict_empty_steps_transition.map_or(0, Into::into),
 		}
 	}
@@ -220,11 +220,11 @@ struct EpochManager {
 }
 
 impl EpochManager {
-	fn blank(quorum_2_3_transition: BlockNumber) -> Self {
+	fn blank(two_thirds_majority_transition: BlockNumber) -> Self {
 		EpochManager {
 			epoch_transition_hash: H256::zero(),
 			epoch_transition_number: 0,
-			finality_checker: RollingFinality::blank(Vec::new(), quorum_2_3_transition),
+			finality_checker: RollingFinality::blank(Vec::new(), two_thirds_majority_transition),
 			force: true,
 		}
 	}
@@ -288,8 +288,8 @@ impl EpochManager {
 				})
 				.expect("proof produced by this engine; therefore it is valid; qed");
 
-			let quorum_2_3_transition = self.finality_checker.quorum_2_3_transition();
-			self.finality_checker = RollingFinality::blank(epoch_set, quorum_2_3_transition);
+			let two_thirds_majority_transition = self.finality_checker.two_thirds_majority_transition();
+			self.finality_checker = RollingFinality::blank(epoch_set, two_thirds_majority_transition);
 		}
 
 		self.epoch_transition_hash = last_transition.block_hash;
@@ -452,7 +452,7 @@ pub struct AuthorityRound {
 	maximum_uncle_count: usize,
 	empty_steps_transition: u64,
 	strict_empty_steps_transition: u64,
-	quorum_2_3_transition: BlockNumber,
+	two_thirds_majority_transition: BlockNumber,
 	maximum_empty_steps: usize,
 	machine: Machine,
 }
@@ -463,7 +463,7 @@ struct EpochVerifier {
 	subchain_validators: SimpleList,
 	empty_steps_transition: u64,
 	/// First block for which a 2/3 quorum (instead of 1/2) is required.
-	quorum_2_3_transition: BlockNumber,
+	two_thirds_majority_transition: BlockNumber,
 }
 
 impl super::EpochVerifier for EpochVerifier {
@@ -477,7 +477,7 @@ impl super::EpochVerifier for EpochVerifier {
 
 	fn check_finality_proof(&self, proof: &[u8]) -> Option<Vec<H256>> {
 		let signers = self.subchain_validators.clone().into_inner();
-		let mut finality_checker = RollingFinality::blank(signers, self.quorum_2_3_transition);
+		let mut finality_checker = RollingFinality::blank(signers, self.two_thirds_majority_transition);
 		let mut finalized = Vec::new();
 
 		let headers: Vec<Header> = Rlp::new(proof).as_list().ok()?;
@@ -713,7 +713,7 @@ impl AuthorityRound {
 				validate_score_transition: our_params.validate_score_transition,
 				validate_step_transition: our_params.validate_step_transition,
 				empty_steps: Default::default(),
-				epoch_manager: Mutex::new(EpochManager::blank(our_params.quorum_2_3_transition)),
+				epoch_manager: Mutex::new(EpochManager::blank(our_params.two_thirds_majority_transition)),
 				immediate_transitions: our_params.immediate_transitions,
 				block_reward: our_params.block_reward,
 				block_reward_contract_transition: our_params.block_reward_contract_transition,
@@ -722,7 +722,7 @@ impl AuthorityRound {
 				maximum_uncle_count: our_params.maximum_uncle_count,
 				empty_steps_transition: our_params.empty_steps_transition,
 				maximum_empty_steps: our_params.maximum_empty_steps,
-				quorum_2_3_transition: our_params.quorum_2_3_transition,
+				two_thirds_majority_transition: our_params.two_thirds_majority_transition,
 				strict_empty_steps_transition: our_params.strict_empty_steps_transition,
 				machine,
 			});
@@ -1263,8 +1263,8 @@ impl Engine for AuthorityRound {
 	) -> Result<(), Error> {
 		let mut beneficiaries = Vec::new();
 
-		if block.header.number() == self.quorum_2_3_transition {
-			info!(target: "engine", "Block {}: Transitioning to 2/3 quorum.", self.quorum_2_3_transition);
+		if block.header.number() == self.two_thirds_majority_transition {
+			info!(target: "engine", "Block {}: Transitioning to 2/3 quorum.", self.two_thirds_majority_transition);
 		}
 
 		if block.header.number() >= self.empty_steps_transition {
@@ -1579,7 +1579,7 @@ impl Engine for AuthorityRound {
 					step: self.step.clone(),
 					subchain_validators: list,
 					empty_steps_transition: self.empty_steps_transition,
-					quorum_2_3_transition: self.quorum_2_3_transition,
+					two_thirds_majority_transition: self.two_thirds_majority_transition,
 				});
 
 				match finalize {
@@ -1679,7 +1679,7 @@ mod tests {
 			block_reward_contract_transition: 0,
 			block_reward_contract: Default::default(),
 			strict_empty_steps_transition: 0,
-			quorum_2_3_transition: 0,
+			two_thirds_majority_transition: 0,
 		};
 
 		// mutate aura params

json/src/spec/authority_round.rs

@@ -59,7 +59,7 @@ pub struct AuthorityRoundParams {
 	/// Strict validation of empty steps transition block.
 	pub strict_empty_steps_transition: Option<Uint>,
 	/// First block for which a 2/3 quorum (instead of 1/2) is required.
-	pub quorum_2_3_transition: Option<Uint>,
+	pub two_thirds_majority_transition: Option<Uint>,
 }
 
 /// Authority engine deserialization.