Persist InteractiveTxSigningSession to resume signing across restarts

We fully persist `InteractiveTxSigningSession` as it provides the full
context of the constructed transaction which is still needed for signing.

Author: dunxen

lightning/src/ln/channel.rs

@@ -10640,6 +10640,7 @@ impl<SP: Deref> Writeable for FundedChannel<SP> where SP::Target: SignerProvider
 			(49, self.context.local_initiated_shutdown, option), // Added in 0.0.122
 			(51, is_manual_broadcast, option), // Added in 0.0.124
 			(53, funding_tx_broadcast_safe_event_emitted, option), // Added in 0.0.124
+			(54, self.interactive_tx_signing_session, option) // Added in 0.2, even as we don't want downgrades during a signing session
 		});
 
 		Ok(())
@@ -10931,6 +10932,8 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, &'c Channel
 		let mut next_holder_commitment_point_opt: Option<PublicKey> = None;
 		let mut is_manual_broadcast = None;
 
+		let mut interactive_tx_signing_session: Option<InteractiveTxSigningSession> = None;
+
 		read_tlv_fields!(reader, {
 			(0, announcement_sigs, option),
 			(1, minimum_depth, option),
@@ -10966,6 +10969,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, &'c Channel
 			(49, local_initiated_shutdown, option),
 			(51, is_manual_broadcast, option),
 			(53, funding_tx_broadcast_safe_event_emitted, option),
+			(54, interactive_tx_signing_session, option),
 		});
 
 		let holder_signer = signer_provider.derive_channel_signer(channel_keys_id);
@@ -11220,7 +11224,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, &'c Channel
 
 				is_holder_quiescence_initiator: None,
 			},
-			interactive_tx_signing_session: None,
+			interactive_tx_signing_session,
 			is_v2_established,
 			holder_commitment_point,
 			#[cfg(splicing)]

lightning/src/ln/interactivetxs.rs

@@ -8,12 +8,13 @@
 // licenses.
 
 use crate::io_extras::sink;
-use crate::prelude::*;
+use crate::{io, prelude::*};
 
 use bitcoin::absolute::LockTime as AbsoluteLockTime;
 use bitcoin::amount::Amount;
 use bitcoin::consensus::Encodable;
 use bitcoin::constants::WITNESS_SCALE_FACTOR;
+use bitcoin::hashes::Hash;
 use bitcoin::policy::MAX_STANDARD_TX_WEIGHT;
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::transaction::Version;
@@ -26,11 +27,13 @@ use crate::ln::msgs;
 use crate::ln::msgs::{MessageSendEvent, SerialId, TxSignatures};
 use crate::ln::types::ChannelId;
 use crate::sign::{EntropySource, P2TR_KEY_PATH_WITNESS_WEIGHT, P2WPKH_WITNESS_WEIGHT};
-use crate::util::ser::TransactionU16LenLimited;
+use crate::util::ser::{Readable, TransactionU16LenLimited, Writeable, Writer};
 
 use core::fmt::Display;
 use core::ops::Deref;
 
+use super::msgs::DecodeError;
+
 /// The number of received `tx_add_input` messages during a negotiation at which point the
 /// negotiation MUST be failed.
 const MAX_RECEIVED_TX_ADD_INPUT_COUNT: u16 = 4096;
@@ -168,6 +171,61 @@ pub(crate) struct ConstructedTransaction {
 	holder_sends_tx_signatures_first: bool,
 }
 
+impl Writeable for ConstructedTransaction {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+		let lock_time = self.lock_time.to_consensus_u32();
+		write_tlv_fields!(writer, {
+			(1, self.holder_is_initiator, required),
+			(3, self.inputs, required),
+			(5, self.outputs, required),
+			(7, self.local_inputs_value_satoshis, required),
+			(9, self.local_outputs_value_satoshis, required),
+			(11, self.remote_inputs_value_satoshis, required),
+			(13, self.remote_outputs_value_satoshis, required),
+			(15, lock_time, required),
+			(17, self.holder_sends_tx_signatures_first, required),
+		});
+		Ok(())
+	}
+}
+
+impl Readable for ConstructedTransaction {
+	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+		let mut holder_is_initiator = false;
+		let mut inputs: Vec<InteractiveTxInput> = vec![];
+		let mut outputs: Vec<InteractiveTxOutput> = vec![];
+		let mut local_inputs_value_satoshis: u64 = 0;
+		let mut local_outputs_value_satoshis: u64 = 0;
+		let mut remote_inputs_value_satoshis: u64 = 0;
+		let mut remote_outputs_value_satoshis: u64 = 0;
+		let mut lock_time: u32 = 0;
+		let mut holder_sends_tx_signatures_first = false;
+		read_tlv_fields!(reader, {
+			(1, holder_is_initiator, required),
+			(3, inputs, required),
+			(5, outputs, required),
+			(7, local_inputs_value_satoshis, required),
+			(9, local_outputs_value_satoshis, required),
+			(11, remote_inputs_value_satoshis, required),
+			(13, remote_outputs_value_satoshis, required),
+			(15, lock_time, required),
+			(17, holder_sends_tx_signatures_first, required),
+		});
+		let lock_time = AbsoluteLockTime::from_consensus(lock_time);
+		Ok(ConstructedTransaction {
+			holder_is_initiator,
+			inputs,
+			outputs,
+			local_inputs_value_satoshis,
+			local_outputs_value_satoshis,
+			remote_inputs_value_satoshis,
+			remote_outputs_value_satoshis,
+			lock_time,
+			holder_sends_tx_signatures_first,
+		})
+	}
+}
+
 impl ConstructedTransaction {
 	fn new(context: NegotiationContext) -> Self {
 		let local_inputs_value_satoshis = context
@@ -418,6 +476,13 @@ impl InteractiveTxSigningSession {
 	}
 }
 
+impl_writeable_tlv_based!(InteractiveTxSigningSession, {
+	(1, unsigned_tx, required),
+	(3, holder_sends_tx_signatures_first, required),
+	(5, has_received_commitment_signed, required),
+	(7, holder_tx_signatures, required),
+});
+
 #[derive(Debug)]
 struct NegotiationContext {
 	holder_node_id: PublicKey,
@@ -1141,6 +1206,11 @@ enum AddingRole {
 	Remote,
 }
 
+impl_writeable_tlv_based_enum!(AddingRole,
+	(1, Local) => {},
+	(3, Remote) => {},
+);
+
 /// Represents an input -- local or remote (both have the same fields)
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct LocalOrRemoteInput {
@@ -1149,19 +1219,68 @@ pub struct LocalOrRemoteInput {
 	prev_output: TxOut,
 }
 
+impl Writeable for LocalOrRemoteInput {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+		write_tlv_fields!(writer, {
+			(1, self.serial_id, required),
+			(3, self.input.sequence.0, required),
+			(5, self.input.previous_output, required),
+			(7, self.input.script_sig, required),
+			(9, self.input.witness, required),
+			(11, self.prev_output, required),
+		});
+		Ok(())
+	}
+}
+
+impl Readable for LocalOrRemoteInput {
+	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+		let mut serial_id: u64 = 0;
+		let mut sequence: u32 = 0;
+		let mut previous_output = OutPoint::new(Txid::from_byte_array([0; 32]), 0);
+		let mut script_sig = ScriptBuf::default();
+		let mut witness = Witness::new();
+		let mut prev_output =
+			TxOut { value: Amount::default(), script_pubkey: ScriptBuf::default() };
+		read_tlv_fields!(reader, {
+			(1, serial_id, required),
+			(3, sequence, required),
+			(5, previous_output, required),
+			(7, script_sig, required),
+			(9, witness, required),
+			(11, prev_output, required),
+		});
+		Ok(LocalOrRemoteInput {
+			serial_id,
+			input: TxIn { previous_output, script_sig, sequence: Sequence(sequence), witness },
+			prev_output,
+		})
+	}
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) enum InteractiveTxInput {
 	Local(LocalOrRemoteInput),
 	Remote(LocalOrRemoteInput),
 	// TODO(splicing) SharedInput should be added
 }
 
+impl_writeable_tlv_based_enum!(InteractiveTxInput,
+	{1, Local} => (),
+	{3, Remote} => (),
+);
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct SharedOwnedOutput {
 	tx_out: TxOut,
 	local_owned: u64,
 }
 
+impl_writeable_tlv_based!(SharedOwnedOutput, {
+	(1, tx_out, required),
+	(3, local_owned, required),
+});
+
 impl SharedOwnedOutput {
 	fn new(tx_out: TxOut, local_owned: u64) -> SharedOwnedOutput {
 		debug_assert!(
@@ -1191,6 +1310,12 @@ pub enum OutputOwned {
 	Shared(SharedOwnedOutput),
 }
 
+impl_writeable_tlv_based_enum!(OutputOwned,
+	{1, Single} => (),
+	{3, SharedControlFullyOwned} => (),
+	{5, Shared} => (),
+);
+
 impl OutputOwned {
 	fn tx_out(&self) -> &TxOut {
 		match self {
@@ -1250,6 +1375,12 @@ pub(crate) struct InteractiveTxOutput {
 	output: OutputOwned,
 }
 
+impl_writeable_tlv_based!(InteractiveTxOutput, {
+	(1, serial_id, required),
+	(3, added_by, required),
+	(5, output, required),
+});
+
 impl InteractiveTxOutput {
 	pub fn tx_out(&self) -> &TxOut {
 		self.output.tx_out()

lightning/src/util/ser.rs

@@ -15,6 +15,7 @@
 
 use crate::io::{self, BufRead, Read, Write};
 use crate::io_extras::{copy, sink};
+use crate::ln::interactivetxs::{InteractiveTxInput, InteractiveTxOutput};
 use crate::prelude::*;
 use crate::sync::{Mutex, RwLock};
 use core::cmp;
@@ -43,9 +44,9 @@ use bitcoin::{consensus, Witness};
 use dnssec_prover::rr::Name;
 
 use crate::chain::ClaimId;
-use crate::ln::msgs::DecodeError;
 #[cfg(taproot)]
 use crate::ln::msgs::PartialSignatureWithNonce;
+use crate::ln::msgs::{DecodeError, SerialId};
 use crate::types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
 use core::time::Duration;
 
@@ -1074,6 +1075,9 @@ impl_for_vec!(crate::ln::channelmanager::MonitorUpdateCompletionAction);
 impl_for_vec!(crate::ln::channelmanager::PaymentClaimDetails);
 impl_for_vec!(crate::ln::msgs::SocketAddress);
 impl_for_vec!((A, B), A, B);
+impl_for_vec!(SerialId);
+impl_for_vec!(InteractiveTxInput);
+impl_for_vec!(InteractiveTxOutput);
 impl_writeable_for_vec!(&crate::routing::router::BlindedTail);
 impl_readable_for_vec!(crate::routing::router::BlindedTail);
 impl_for_vec!(crate::routing::router::TrampolineHop);