Rename amount variables in InputMaterial

As per BIP143, value of the output spent is part of the transaction
digest algorithm, providing a wrong value will generate a falsely
hash and fail signature verification. Clarity about amount spent
is that's why important.

Author: Antoine Riard

lightning/src/ln/channelmonitor.rs

@@ -455,27 +455,27 @@ pub(crate) enum InputMaterial {
 		pubkey: Option<PublicKey>,
 		key: SecretKey,
 		is_htlc: bool,
-		amount: u64,
+		revoked_amount: u64,
 	},
 	RemoteHTLC {
 		script: Script,
 		key: SecretKey,
 		preimage: Option<PaymentPreimage>,
-		amount: u64,
+		remote_amount: u64,
 		locktime: u32,
 	},
 	LocalHTLC {
 		script: Script,
 		sigs: (Signature, Signature),
 		preimage: Option<PaymentPreimage>,
-		amount: u64,
+		local_amount: u64,
 	}
 }
 
 impl Writeable for InputMaterial  {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 		match self {
-			&InputMaterial::Revoked { ref script, ref pubkey, ref key, ref is_htlc, ref amount} => {
+			&InputMaterial::Revoked { ref script, ref pubkey, ref key, ref is_htlc, ref revoked_amount} => {
 				writer.write_all(&[0; 1])?;
 				script.write(writer)?;
 				pubkey.write(writer)?;
@@ -485,23 +485,23 @@ impl Writeable for InputMaterial  {
 				} else {
 					writer.write_all(&[1; 1])?;
 				}
-				writer.write_all(&byte_utils::be64_to_array(*amount))?;
+				writer.write_all(&byte_utils::be64_to_array(*revoked_amount))?;
 			},
-			&InputMaterial::RemoteHTLC { ref script, ref key, ref preimage, ref amount, ref locktime } => {
+			&InputMaterial::RemoteHTLC { ref script, ref key, ref preimage, ref remote_amount, ref locktime } => {
 				writer.write_all(&[1; 1])?;
 				script.write(writer)?;
 				key.write(writer)?;
 				preimage.write(writer)?;
-				writer.write_all(&byte_utils::be64_to_array(*amount))?;
+				writer.write_all(&byte_utils::be64_to_array(*remote_amount))?;
 				writer.write_all(&byte_utils::be32_to_array(*locktime))?;
 			},
-			&InputMaterial::LocalHTLC { ref script, ref sigs, ref preimage, ref amount } => {
+			&InputMaterial::LocalHTLC { ref script, ref sigs, ref preimage, ref local_amount } => {
 				writer.write_all(&[2; 1])?;
 				script.write(writer)?;
 				sigs.0.write(writer)?;
 				sigs.1.write(writer)?;
 				preimage.write(writer)?;
-				writer.write_all(&byte_utils::be64_to_array(*amount))?;
+				writer.write_all(&byte_utils::be64_to_array(*local_amount))?;
 			}
 		}
 		Ok(())
@@ -520,26 +520,26 @@ impl<R: ::std::io::Read> Readable<R> for InputMaterial {
 					1 => false,
 					_ => return Err(DecodeError::InvalidValue),
 				};
-				let amount = Readable::read(reader)?;
+				let revoked_amount = Readable::read(reader)?;
 				InputMaterial::Revoked {
 					script,
 					pubkey,
 					key,
 					is_htlc,
-					amount
+					revoked_amount
 				}
 			},
 			1 => {
 				let script = Readable::read(reader)?;
 				let key = Readable::read(reader)?;
 				let preimage = Readable::read(reader)?;
-				let amount = Readable::read(reader)?;
+				let remote_amount = Readable::read(reader)?;
 				let locktime = Readable::read(reader)?;
 				InputMaterial::RemoteHTLC {
 					script,
 					key,
 					preimage,
-					amount,
+					remote_amount,
 					locktime
 				}
 			},
@@ -548,12 +548,12 @@ impl<R: ::std::io::Read> Readable<R> for InputMaterial {
 				let their_sig = Readable::read(reader)?;
 				let our_sig = Readable::read(reader)?;
 				let preimage = Readable::read(reader)?;
-				let amount = Readable::read(reader)?;
+				let local_amount = Readable::read(reader)?;
 				InputMaterial::LocalHTLC {
 					script,
 					sigs: (their_sig, our_sig),
 					preimage,
-					amount
+					local_amount
 				}
 			}
 			_ => return Err(DecodeError::InvalidValue),
@@ -1463,7 +1463,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 			// First, process non-htlc outputs (to_local & to_remote)
 			for (idx, outp) in tx.output.iter().enumerate() {
 				if outp.script_pubkey == revokeable_p2wsh {
-					let witness_data = InputMaterial::Revoked { script: revokeable_redeemscript.clone(), pubkey: Some(revocation_pubkey), key: revocation_key, is_htlc: false, amount: outp.value };
+					let witness_data = InputMaterial::Revoked { script: revokeable_redeemscript.clone(), pubkey: Some(revocation_pubkey), key: revocation_key, is_htlc: false, revoked_amount: outp.value };
 					outpoints.push(ClaimRequest { absolute_timelock: height + self.our_to_self_delay as u32, aggregable: true, outpoint: BitcoinOutPoint { txid: commitment_txid, vout: idx as u32 }, witness_data});
 				} else if Some(&outp.script_pubkey) == local_payment_p2wpkh.as_ref() {
 					spendable_descriptor = Some(SpendableOutputDescriptor::DynamicOutputP2WPKH {
@@ -1484,7 +1484,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 								tx.output[transaction_output_index as usize].script_pubkey != expected_script.to_v0_p2wsh() {
 							return (claimable_outpoints, (commitment_txid, watch_outputs), spendable_descriptor); // Corrupted per_commitment_data, fuck this user
 						}
-						let witness_data = InputMaterial::Revoked { script: expected_script, pubkey: Some(revocation_pubkey), key: revocation_key, is_htlc: true, amount: tx.output[transaction_output_index as usize].value };
+						let witness_data = InputMaterial::Revoked { script: expected_script, pubkey: Some(revocation_pubkey), key: revocation_key, is_htlc: true, revoked_amount: tx.output[transaction_output_index as usize].value };
 						outpoints.push(ClaimRequest { absolute_timelock: htlc.cltv_expiry, aggregable: true, outpoint: BitcoinOutPoint { txid: commitment_txid, vout: transaction_output_index }, witness_data });
 					}
 				}
@@ -1648,7 +1648,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 							let preimage = if htlc.offered { if let Some(p) = self.payment_preimages.get(&htlc.payment_hash) { Some(*p) } else { None } } else { None };
 							let aggregable = if !htlc.offered { false } else { true };
 							if preimage.is_some() || !htlc.offered {
-								let witness_data = InputMaterial::RemoteHTLC { script: expected_script, key: htlc_privkey, preimage, amount: htlc.amount_msat / 1000, locktime: htlc.cltv_expiry };
+								let witness_data = InputMaterial::RemoteHTLC { script: expected_script, key: htlc_privkey, preimage, remote_amount: htlc.amount_msat / 1000, locktime: htlc.cltv_expiry };
 								outpoints.push(ClaimRequest { absolute_timelock: htlc.cltv_expiry, aggregable, outpoint: BitcoinOutPoint { txid: commitment_txid, vout: transaction_output_index }, witness_data });
 							}
 						}
@@ -1704,7 +1704,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 		let htlc_txid = tx.txid(); //TODO: This is gonna be a performance bottleneck for watchtowers!
 
 		log_trace!(self, "Remote HTLC broadcast {}:{}", htlc_txid, 0);
-		let witness_data = InputMaterial::Revoked { script: redeemscript, pubkey: Some(revocation_pubkey), key: revocation_key, is_htlc: false, amount: tx.output[0].value };
+		let witness_data = InputMaterial::Revoked { script: redeemscript, pubkey: Some(revocation_pubkey), key: revocation_key, is_htlc: false, revoked_amount: tx.output[0].value };
 		let outpoints = vec!(ClaimRequest { absolute_timelock: height + self.our_to_self_delay as u32, aggregable: true, outpoint: BitcoinOutPoint { txid: htlc_txid, vout: 0}, witness_data });
 		let mut claimable_outpoints = HashMap::with_capacity(1);
 		claimable_outpoints.insert(htlc_txid, outpoints);
@@ -1754,7 +1754,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 
 							add_dynamic_output!(htlc_timeout_tx, 0);
 							let mut per_input_material = HashMap::with_capacity(1);
-							per_input_material.insert(htlc_timeout_tx.input[0].previous_output, InputMaterial::LocalHTLC { script: htlc_script, sigs: (*their_sig, our_sig), preimage: None, amount: htlc.amount_msat / 1000});
+							per_input_material.insert(htlc_timeout_tx.input[0].previous_output, InputMaterial::LocalHTLC { script: htlc_script, sigs: (*their_sig, our_sig), preimage: None, local_amount: htlc.amount_msat / 1000});
 							//TODO: with option_simplified_commitment track outpoint too
 							log_trace!(self, "Outpoint {}:{} is being being claimed", htlc_timeout_tx.input[0].previous_output.vout, htlc_timeout_tx.input[0].previous_output.txid);
 							res.push(htlc_timeout_tx);
@@ -1770,7 +1770,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 
 								add_dynamic_output!(htlc_success_tx, 0);
 								let mut per_input_material = HashMap::with_capacity(1);
-								per_input_material.insert(htlc_success_tx.input[0].previous_output, InputMaterial::LocalHTLC { script: htlc_script, sigs: (*their_sig, our_sig), preimage: Some(*payment_preimage), amount: htlc.amount_msat / 1000});
+								per_input_material.insert(htlc_success_tx.input[0].previous_output, InputMaterial::LocalHTLC { script: htlc_script, sigs: (*their_sig, our_sig), preimage: Some(*payment_preimage), local_amount: htlc.amount_msat / 1000});
 								//TODO: with option_simplified_commitment track outpoint too
 								log_trace!(self, "Outpoint {}:{} is being being claimed", htlc_success_tx.input[0].previous_output.vout, htlc_success_tx.input[0].previous_output.txid);
 								res.push(htlc_success_tx);

lightning/src/ln/onchaintx.rs

@@ -389,16 +389,16 @@ impl OnchainTxHandler {
 
 		let new_timer = Self::get_height_timer(height, cached_claim_datas.soonest_timelock);
 		let mut inputs_witnesses_weight = 0;
-		let mut amt = 0;
+		let mut total_amount = 0;
 		for per_outp_material in cached_claim_datas.per_input_material.values() {
 			match per_outp_material {
-				&InputMaterial::Revoked { ref script, ref is_htlc, ref amount, .. } => {
+				&InputMaterial::Revoked { ref script, ref is_htlc, ref revoked_amount, .. } => {
 					inputs_witnesses_weight += Self::get_witnesses_weight(if !is_htlc { &[InputDescriptors::RevokedOutput] } else if HTLCType::scriptlen_to_htlctype(script.len()) == Some(HTLCType::OfferedHTLC) { &[InputDescriptors::RevokedOfferedHTLC] } else if HTLCType::scriptlen_to_htlctype(script.len()) == Some(HTLCType::AcceptedHTLC) { &[InputDescriptors::RevokedReceivedHTLC] } else { &[] });
-					amt += *amount;
+					total_amount += *revoked_amount;
 				},
-				&InputMaterial::RemoteHTLC { ref preimage, ref amount, .. } => {
+				&InputMaterial::RemoteHTLC { ref preimage, ref remote_amount, .. } => {
 					inputs_witnesses_weight += Self::get_witnesses_weight(if preimage.is_some() { &[InputDescriptors::OfferedHTLC] } else { &[InputDescriptors::ReceivedHTLC] });
-					amt += *amount;
+					total_amount += *remote_amount;
 				},
 				&InputMaterial::LocalHTLC { .. } => { return None; }
 			}
@@ -408,27 +408,27 @@ impl OnchainTxHandler {
 		let mut new_feerate;
 		// If old feerate is 0, first iteration of this claim, use normal fee calculation
 		if cached_claim_datas.feerate_previous != 0 {
-			if let Some((new_fee, feerate)) = RBF_bump!(amt, cached_claim_datas.feerate_previous, fee_estimator, predicted_weight as u64) {
+			if let Some((new_fee, feerate)) = RBF_bump!(total_amount, cached_claim_datas.feerate_previous, fee_estimator, predicted_weight as u64) {
 				// If new computed fee is superior at the whole claimable amount burn all in fees
-				if new_fee > amt {
+				if new_fee > total_amount {
 					bumped_tx.output[0].value = 0;
 				} else {
-					bumped_tx.output[0].value = amt - new_fee;
+					bumped_tx.output[0].value = total_amount - new_fee;
 				}
 				new_feerate = feerate;
 			} else { return None; }
 		} else {
-			if subtract_high_prio_fee!(self, fee_estimator, amt, predicted_weight, new_feerate) {
-				bumped_tx.output[0].value = amt;
+			if subtract_high_prio_fee!(self, fee_estimator, total_amount, predicted_weight, new_feerate) {
+				bumped_tx.output[0].value = total_amount;
 			} else { return None; }
 		}
 		assert!(new_feerate != 0);
 
 		for (i, (outp, per_outp_material)) in cached_claim_datas.per_input_material.iter().enumerate() {
 			match per_outp_material {
-				&InputMaterial::Revoked { ref script, ref pubkey, ref key, ref is_htlc, ref amount } => {
+				&InputMaterial::Revoked { ref script, ref pubkey, ref key, ref is_htlc, ref revoked_amount } => {
 					let sighash_parts = bip143::SighashComponents::new(&bumped_tx);
-					let sighash = hash_to_message!(&sighash_parts.sighash_all(&bumped_tx.input[i], &script, *amount)[..]);
+					let sighash = hash_to_message!(&sighash_parts.sighash_all(&bumped_tx.input[i], &script, *revoked_amount)[..]);
 					let sig = self.secp_ctx.sign(&sighash, &key);
 					bumped_tx.input[i].witness.push(sig.serialize_der().to_vec());
 					bumped_tx.input[i].witness[0].push(SigHashType::All as u8);
@@ -440,10 +440,10 @@ impl OnchainTxHandler {
 					bumped_tx.input[i].witness.push(script.clone().into_bytes());
 					log_trace!(self, "Going to broadcast Penalty Transaction {} claiming revoked {} output {} from {} with new feerate {}...", bumped_tx.txid(), if !is_htlc { "to_local" } else if HTLCType::scriptlen_to_htlctype(script.len()) == Some(HTLCType::OfferedHTLC) { "offered" } else if HTLCType::scriptlen_to_htlctype(script.len()) == Some(HTLCType::AcceptedHTLC) { "received" } else { "" }, outp.vout, outp.txid, new_feerate);
 				},
-				&InputMaterial::RemoteHTLC { ref script, ref key, ref preimage, ref amount, ref locktime } => {
+				&InputMaterial::RemoteHTLC { ref script, ref key, ref preimage, ref remote_amount, ref locktime } => {
 					if !preimage.is_some() { bumped_tx.lock_time = *locktime }; // Right now we don't aggregate time-locked transaction, if we do we should set lock_time before to avoid breaking hash computation
 					let sighash_parts = bip143::SighashComponents::new(&bumped_tx);
-					let sighash = hash_to_message!(&sighash_parts.sighash_all(&bumped_tx.input[i], &script, *amount)[..]);
+					let sighash = hash_to_message!(&sighash_parts.sighash_all(&bumped_tx.input[i], &script, *remote_amount)[..]);
 					let sig = self.secp_ctx.sign(&sighash, &key);
 					bumped_tx.input[i].witness.push(sig.serialize_der().to_vec());
 					bumped_tx.input[i].witness[0].push(SigHashType::All as u8);