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

Diff for: lightning/src/ln/channel.rs

@@ -5039,6 +5039,13 @@ pub(super) struct FundedChannel<SP: Deref> where SP::Target: SignerProvider {
 	pub funding: FundingScope,
 	pending_funding: Vec<FundingScope>,
 	pub context: ChannelContext<SP>,
+	/// The signing session for the current interactive tx construction, if any.
+	///
+	/// This is populated when the interactive tx construction phase completes
+	/// (i.e., upon receiving a consecutive `tx_complete`) and the channel enters
+	/// the signing phase (`FundingNegotiated` state with the `INTERACTIVE_SIGNING` flag set).
+	///
+	/// This field is cleared once our counterparty sends a `channel_ready`.
 	pub interactive_tx_signing_session: Option<InteractiveTxSigningSession>,
 	holder_commitment_point: HolderCommitmentPoint,
 	/// Info about an in-progress, pending splice (if any), on the pre-splice channel
@@ -10949,6 +10956,7 @@ impl<SP: Deref> Writeable for FundedChannel<SP> where SP::Target: SignerProvider
 			(54, self.pending_funding, optional_vec), // Added in 0.2
 			(55, removed_htlc_failure_attribution_data, optional_vec), // Added in 0.2
 			(57, holding_cell_failure_attribution_data, optional_vec), // Added in 0.2
+			(58, self.interactive_tx_signing_session, option) // Added in 0.2
 		});
 
 		Ok(())
@@ -11248,6 +11256,8 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, &'c Channel
 
 		let mut pending_funding = Some(Vec::new());
 
+		let mut interactive_tx_signing_session: Option<InteractiveTxSigningSession> = None;
+
 		read_tlv_fields!(reader, {
 			(0, announcement_sigs, option),
 			(1, minimum_depth, option),
@@ -11286,6 +11296,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, &'c Channel
 			(54, pending_funding, optional_vec), // Added in 0.2
 			(55, removed_htlc_failure_attribution_data, optional_vec),
 			(57, holding_cell_failure_attribution_data, optional_vec),
+			(58, interactive_tx_signing_session, option), // Added in 0.2
 		});
 
 		let holder_signer = signer_provider.derive_channel_signer(channel_keys_id);
@@ -11568,7 +11579,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,
 			holder_commitment_point,
 			#[cfg(splicing)]
 			pending_splice: None,

Diff for: lightning/src/ln/interactivetxs.rs

@@ -189,6 +189,18 @@ pub(crate) struct ConstructedTransaction {
 	holder_sends_tx_signatures_first: bool,
 }
 
+impl_writeable_tlv_based!(ConstructedTransaction, {
+	(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),
+});
+
 impl ConstructedTransaction {
 	fn new(context: NegotiationContext) -> Self {
 		let local_inputs_value_satoshis = context
@@ -439,6 +451,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,
@@ -1162,6 +1181,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 {
@@ -1170,19 +1194,35 @@ pub struct LocalOrRemoteInput {
 	prev_output: TxOut,
 }
 
+impl_writeable_tlv_based!(LocalOrRemoteInput, {
+	(1, serial_id, required),
+	(3, input, required),
+	(5, prev_output, required),
+});
+
 #[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(super) struct SharedOwnedOutput {
 	tx_out: TxOut,
 	local_owned: u64,
 }
 
+impl_writeable_tlv_based!(SharedOwnedOutput, {
+	(1, tx_out, required),
+	(3, local_owned, required),
+});
+
 impl SharedOwnedOutput {
 	pub fn new(tx_out: TxOut, local_owned: u64) -> SharedOwnedOutput {
 		debug_assert!(
@@ -1210,6 +1250,11 @@ pub(super) enum OutputOwned {
 	Shared(SharedOwnedOutput),
 }
 
+impl_writeable_tlv_based_enum!(OutputOwned,
+	{1, Single} => (),
+	{3, Shared} => (),
+);
+
 impl OutputOwned {
 	pub fn tx_out(&self) -> &TxOut {
 		match self {
@@ -1264,6 +1309,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()

Diff for: 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::ln::onion_utils::{HMAC_COUNT, HMAC_LEN, HOLD_TIME_LEN, MAX_HOPS};
 use crate::prelude::*;
 use crate::sync::{Mutex, RwLock};
@@ -24,6 +25,7 @@ use core::ops::Deref;
 
 use alloc::collections::BTreeMap;
 
+use bitcoin::absolute::LockTime as AbsoluteLockTime;
 use bitcoin::amount::Amount;
 use bitcoin::consensus::Encodable;
 use bitcoin::constants::ChainHash;
@@ -39,14 +41,14 @@ use bitcoin::secp256k1::ecdsa;
 use bitcoin::secp256k1::schnorr;
 use bitcoin::secp256k1::{PublicKey, SecretKey};
 use bitcoin::transaction::{OutPoint, Transaction, TxOut};
-use bitcoin::{consensus, Witness};
+use bitcoin::{consensus, TxIn, 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;
 
@@ -1079,6 +1081,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);
@@ -1350,6 +1355,19 @@ impl<T: LengthReadable> Readable for Option<T> {
 	}
 }
 
+impl Writeable for AbsoluteLockTime {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		self.to_consensus_u32().write(w)
+	}
+}
+
+impl Readable for AbsoluteLockTime {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		let lock_time: u32 = Readable::read(r)?;
+		Ok(AbsoluteLockTime::from_consensus(lock_time))
+	}
+}
+
 impl Writeable for Amount {
 	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
 		self.to_sat().write(w)
@@ -1451,6 +1469,7 @@ macro_rules! impl_consensus_ser {
 	};
 }
 impl_consensus_ser!(Transaction);
+impl_consensus_ser!(TxIn);
 impl_consensus_ser!(TxOut);
 impl_consensus_ser!(Witness);