Removed kernel sum from header. Fixes #1568

chain/src/chain.rs

@@ -637,13 +637,6 @@ impl Chain {
 			// Full validation, including rangeproofs and kernel signature verification.
 			let (utxo_sum, kernel_sum) = extension.validate(false, status)?;
 
-			// Now that we have block_sums the total_kernel_sum on the block_header is redundant.
-			if header.total_kernel_sum != kernel_sum {
-				return Err(
-					ErrorKind::Other(format!("total_kernel_sum in header does not match")).into(),
-				);
-			}
-
 			// Save the block_sums (utxo_sum, kernel_sum) to the db for use later.
 			extension.batch.save_block_sums(
 				&header.hash(),

chain/src/pipe.rs

@@ -454,11 +454,8 @@ fn validate_header(header: &BlockHeader, ctx: &mut BlockContext) -> Result<(), E
 fn validate_block(block: &Block, ctx: &mut BlockContext) -> Result<(), Error> {
 	let prev = ctx.batch.get_block_header(&block.header.previous)?;
 	block
-		.validate(
-			&prev.total_kernel_offset,
-			&prev.total_kernel_sum,
-			ctx.verifier_cache.clone(),
-		).map_err(|e| ErrorKind::InvalidBlockProof(e))?;
+		.validate(&prev.total_kernel_offset, ctx.verifier_cache.clone())
+		.map_err(|e| ErrorKind::InvalidBlockProof(e))?;
 	Ok(())
 }
 
@@ -480,16 +477,6 @@ fn verify_block_sums(b: &Block, ext: &mut txhashset::Extension) -> Result<(), Er
 	// Retrieve the block_sums for the previous block.
 	let block_sums = ext.batch.get_block_sums(&b.header.previous)?;
 
-	{
-		// Now that we have block_sums the total_kernel_sum on the block_header is redundant.
-		let prev = ext.batch.get_block_header(&b.header.previous)?;
-		if prev.total_kernel_sum != block_sums.kernel_sum {
-			return Err(
-				ErrorKind::Other(format!("total_kernel_sum in header does not match")).into(),
-			);
-		}
-	}
-
 	// Overage is based purely on the new block.
 	// Previous block_sums have taken all previous overage into account.
 	let overage = b.header.overage();

core/src/core/block.rs

@@ -35,7 +35,7 @@ use global;
 use keychain::{self, BlindingFactor};
 use pow::{Difficulty, Proof, ProofOfWork};
 use ser::{self, Readable, Reader, Writeable, Writer};
-use util::{secp, secp_static, static_secp_instance, LOGGER};
+use util::{secp, static_secp_instance, LOGGER};
 
 /// Errors thrown by Block validation
 #[derive(Debug, Clone, Eq, PartialEq, Fail)]
@@ -130,9 +130,6 @@ pub struct BlockHeader {
 	/// We can derive the kernel offset sum for *this* block from
 	/// the total kernel offset of the previous block header.
 	pub total_kernel_offset: BlindingFactor,
-	/// Total accumulated sum of kernel commitments since genesis block.
-	/// Should always equal the UTXO commitment sum minus supply.
-	pub total_kernel_sum: Commitment,
 	/// Total size of the output MMR after applying this block
 	pub output_mmr_size: u64,
 	/// Total size of the kernel MMR after applying this block
@@ -152,7 +149,6 @@ fn fixed_size_of_serialized_header(version: u16) -> usize {
 	size += mem::size_of::<Hash>(); // range_proof_root
 	size += mem::size_of::<Hash>(); // kernel_root
 	size += mem::size_of::<BlindingFactor>(); // total_kernel_offset
-	size += mem::size_of::<Commitment>(); // total_kernel_sum
 	size += mem::size_of::<u64>(); // output_mmr_size
 	size += mem::size_of::<u64>(); // kernel_mmr_size
 	size += mem::size_of::<Difficulty>(); // total_difficulty
@@ -188,7 +184,6 @@ impl Default for BlockHeader {
 			range_proof_root: ZERO_HASH,
 			kernel_root: ZERO_HASH,
 			total_kernel_offset: BlindingFactor::zero(),
-			total_kernel_sum: Commitment::from_vec(vec![0; 33]),
 			output_mmr_size: 0,
 			kernel_mmr_size: 0,
 			pow: ProofOfWork::default(),
@@ -221,7 +216,6 @@ impl Readable for BlockHeader {
 		let range_proof_root = Hash::read(reader)?;
 		let kernel_root = Hash::read(reader)?;
 		let total_kernel_offset = BlindingFactor::read(reader)?;
-		let total_kernel_sum = Commitment::read(reader)?;
 		let (output_mmr_size, kernel_mmr_size) = ser_multiread!(reader, read_u64, read_u64);
 		let mut pow = ProofOfWork::read(version, reader)?;
 		if version == 1 {
@@ -243,7 +237,6 @@ impl Readable for BlockHeader {
 			range_proof_root,
 			kernel_root,
 			total_kernel_offset,
-			total_kernel_sum,
 			output_mmr_size,
 			kernel_mmr_size,
 			pow,
@@ -271,7 +264,6 @@ impl BlockHeader {
 			[write_fixed_bytes, &self.range_proof_root],
 			[write_fixed_bytes, &self.kernel_root],
 			[write_fixed_bytes, &self.total_kernel_offset],
-			[write_fixed_bytes, &self.total_kernel_sum],
 			[write_u64, self.output_mmr_size],
 			[write_u64, self.kernel_mmr_size]
 		);
@@ -506,16 +498,6 @@ impl Block {
 		let total_kernel_offset =
 			committed::sum_kernel_offsets(vec![agg_tx.offset, prev.total_kernel_offset], vec![])?;
 
-		let total_kernel_sum = {
-			let zero_commit = secp_static::commit_to_zero_value();
-			let secp = static_secp_instance();
-			let secp = secp.lock().unwrap();
-			let mut excesses = map_vec!(agg_tx.kernels(), |x| x.excess());
-			excesses.push(prev.total_kernel_sum);
-			excesses.retain(|x| *x != zero_commit);
-			secp.commit_sum(excesses, vec![])?
-		};
-
 		let now = Utc::now().timestamp();
 		let timestamp = DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(now, 0), Utc);
 
@@ -535,7 +517,6 @@ impl Block {
 				timestamp,
 				previous: prev.hash(),
 				total_kernel_offset,
-				total_kernel_sum,
 				pow: ProofOfWork {
 					total_difficulty: difficulty + prev.pow.total_difficulty,
 					..Default::default()
@@ -630,7 +611,6 @@ impl Block {
 	pub fn validate(
 		&self,
 		prev_kernel_offset: &BlindingFactor,
-		prev_kernel_sum: &Commitment,
 		verifier: Arc<RwLock<VerifierCache>>,
 	) -> Result<(Commitment), Error> {
 		self.body.validate(true, verifier)?;
@@ -654,12 +634,6 @@ impl Block {
 		let (_utxo_sum, kernel_sum) =
 			self.verify_kernel_sums(self.header.overage(), block_kernel_offset)?;
 
-		// check the block header's total kernel sum
-		let total_sum = committed::sum_commits(vec![kernel_sum, prev_kernel_sum.clone()], vec![])?;
-		if total_sum != self.header.total_kernel_sum {
-			return Err(Error::InvalidTotalKernelSum);
-		}
-
 		Ok(kernel_sum)
 	}
 

servers/src/common/adapters.rs

@@ -163,11 +163,8 @@ impl p2p::ChainAdapter for NetToChainAdapter {
 
 			if let Ok(prev) = self.chain().get_block_header(&cb.header.previous) {
 				if block
-					.validate(
-						&prev.total_kernel_offset,
-						&prev.total_kernel_sum,
-						self.verifier_cache.clone(),
-					).is_ok()
+					.validate(&prev.total_kernel_offset, self.verifier_cache.clone())
+					.is_ok()
 				{
 					debug!(LOGGER, "adapter: successfully hydrated block from tx pool!");
 					self.process_block(block, addr)

servers/src/mining/mine_block.rs

@@ -129,11 +129,7 @@ fn build_block(
 	let mut b = core::Block::with_reward(&head, txs, output, kernel, difficulty.clone())?;
 
 	// making sure we're not spending time mining a useless block
-	b.validate(
-		&head.total_kernel_offset,
-		&head.total_kernel_sum,
-		verifier_cache,
-	)?;
+	b.validate(&head.total_kernel_offset, verifier_cache)?;
 
 	b.header.pow.nonce = thread_rng().gen();
 	b.header.timestamp = DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(now_sec, 0), Utc);;