fix SharedOwnedInput has no prev_output

Author: optout21

lightning/src/ln/interactivetxs.rs

@@ -272,7 +272,7 @@ impl ConstructedTransaction {
 
 	pub fn weight(&self) -> Weight {
 		let inputs_weight = self.inputs.iter().fold(Weight::from_wu(0), |weight, input| {
-			weight.checked_add(estimate_input_weight(input.prev_output())).unwrap_or(Weight::MAX)
+			weight.checked_add(input.estimate_input_weight()).unwrap_or(Weight::MAX)
 		});
 		let outputs_weight = self.outputs.iter().fold(Weight::from_wu(0), |weight, output| {
 			weight.checked_add(get_output_weight(output.script_pubkey())).unwrap_or(Weight::MAX)
@@ -578,7 +578,7 @@ impl NegotiationContext {
 				.iter()
 				.filter(|(serial_id, _)| self.is_serial_id_valid_for_counterparty(serial_id))
 				.fold(0u64, |weight, (_, input)| {
-					weight.saturating_add(estimate_input_weight(input.prev_output()).to_wu())
+					weight.saturating_add(input.estimate_input_weight().to_wu())
 				}),
 		)
 	}
@@ -595,9 +595,7 @@ impl NegotiationContext {
 	}
 
 	fn local_inputs_value(&self) -> u64 {
-		self.inputs
-			.iter()
-			.fold(0u64, |acc, (_, input)| acc.saturating_add(input.prev_output().value.to_sat()))
+		self.inputs.iter().fold(0u64, |acc, (_, input)| acc.saturating_add(input.value()))
 	}
 
 	fn received_tx_add_input(&mut self, msg: &msgs::TxAddInput) -> Result<(), AbortReason> {
@@ -649,12 +647,9 @@ impl NegotiationContext {
 						sequence: Sequence(msg.sequence),
 						..Default::default()
 					};
-					let prev_output = TxOut {
-						value: Amount::from_sat(shared_funding_input.1),
-						script_pubkey: txin.script_sig.to_p2wsh(),
-					};
 					let local_owned_sats = shared_funding_input.2;
-					let shared_input = SharedOwnedInput::new(txin, prev_output, local_owned_sats);
+					let shared_input =
+						SharedOwnedInput::new(txin, shared_funding_input.1, local_owned_sats);
 					(InputOwned::Shared(shared_input), previous_output)
 				}
 			} else {
@@ -850,14 +845,7 @@ impl NegotiationContext {
 			if let Some(shared_funding_input) = &self.shared_funding_input {
 				let value = shared_funding_input.1;
 				let local_owned = shared_funding_input.2;
-				let prev_output = TxOut {
-					value: Amount::from_sat(value),
-					script_pubkey: txin.script_sig.to_p2wsh(),
-				};
-				(
-					prev_outpoint,
-					InputOwned::Shared(SharedOwnedInput::new(txin, prev_output, local_owned)),
-				)
+				(prev_outpoint, InputOwned::Shared(SharedOwnedInput::new(txin, value, local_owned)))
 			} else {
 				return Err(AbortReason::UnexpectedFundingInput);
 			}
@@ -1289,29 +1277,29 @@ impl_writeable_tlv_based!(SingleOwnedInput, {
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct SharedOwnedInput {
 	input: TxIn,
-	prev_output: TxOut,
+	value: u64,
 	local_owned: u64,
 }
 
 impl_writeable_tlv_based!(SharedOwnedInput, {
 	(1, input, required),
-	(3, prev_output, required),
+	(3, value, required),
 	(5, local_owned, required),
 });
 
 impl SharedOwnedInput {
-	pub fn new(input: TxIn, prev_output: TxOut, local_owned: u64) -> Self {
+	pub fn new(input: TxIn, value: u64, local_owned: u64) -> Self {
 		debug_assert!(
-			local_owned <= prev_output.value.to_sat(),
+			local_owned <= value,
 			"SharedOwnedInput: Inconsistent local_owned value {}, larger than prev out value {}",
 			local_owned,
-			prev_output.value.to_sat(),
+			value,
 		);
-		Self { input, prev_output, local_owned }
+		Self { input, value, local_owned }
 	}
 
 	fn remote_owned(&self) -> u64 {
-		self.prev_output.value.to_sat().saturating_sub(self.local_owned)
+		self.value.saturating_sub(self.local_owned)
 	}
 }
 
@@ -1354,10 +1342,10 @@ impl InputOwned {
 		}
 	}
 
-	pub fn prev_output(&self) -> &TxOut {
+	pub fn value(&self) -> u64 {
 		match self {
-			InputOwned::Single(single) => &single.prev_output,
-			InputOwned::Shared(shared) => &shared.prev_output,
+			InputOwned::Single(single) => single.prev_output.value.to_sat(),
+			InputOwned::Shared(shared) => shared.value,
 		}
 	}
 
@@ -1387,6 +1375,13 @@ impl InputOwned {
 			InputOwned::Shared(shared) => shared.remote_owned(),
 		}
 	}
+
+	fn estimate_input_weight(&self) -> Weight {
+		match self {
+			InputOwned::Single(single) => estimate_input_weight(&single.prev_output),
+			InputOwned::Shared(_shared) => Weight::from_wu(P2WSH_INPUT_WEIGHT_LOWER_BOUND),
+		}
+	}
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -1548,12 +1543,8 @@ impl InteractiveTxInput {
 		self.input.into_tx_in()
 	}
 
-	pub fn prev_output(&self) -> &TxOut {
-		self.input.prev_output()
-	}
-
 	pub fn value(&self) -> u64 {
-		self.prev_output().value.to_sat()
+		self.input.value()
 	}
 
 	pub fn local_value(&self) -> u64 {
@@ -1563,6 +1554,10 @@ impl InteractiveTxInput {
 	pub fn remote_value(&self) -> u64 {
 		self.input.remote_value(self.added_by)
 	}
+
+	pub fn estimate_input_weight(&self) -> Weight {
+		self.input.estimate_input_weight()
+	}
 }
 
 pub(super) struct InteractiveTxConstructor {
@@ -1770,11 +1765,7 @@ impl InteractiveTxConstructor {
 					sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
 					..Default::default()
 				};
-				let prev_out = TxOut {
-					value: Amount::from_sat(value),
-					script_pubkey: txin.script_sig.to_p2wsh(),
-				};
-				let input = SharedOwnedInput::new(txin, prev_out, local_owned);
+				let input = SharedOwnedInput::new(txin, value, local_owned);
 				inputs_to_contribute.push((serial_id, InputOwned::Shared(input)));
 			}
 		}