diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs
index d30502835e6..4ecdae810f4 100644
--- a/lightning/src/ln/channel.rs
+++ b/lightning/src/ln/channel.rs
@@ -30,7 +30,7 @@ use crate::ln::types::ChannelId;
 use crate::types::payment::{PaymentPreimage, PaymentHash};
 use crate::types::features::{ChannelTypeFeatures, InitFeatures};
 use crate::ln::interactivetxs::{
-	calculate_change_output_value, get_output_weight, AbortReason, HandleTxCompleteValue, HandleTxCompleteResult, InteractiveTxConstructor,
+	calculate_change_output_value, get_output_weight, AbortReason, HandleTxCompleteResult, InteractiveTxConstructor,
 	InteractiveTxConstructorArgs, InteractiveTxMessageSend, InteractiveTxSigningSession, InteractiveTxMessageSendResult,
 	OutputOwned, SharedOwnedOutput, TX_COMMON_FIELDS_WEIGHT,
 };
@@ -480,6 +480,9 @@ mod state_flags {
 	pub const LOCAL_STFU_SENT: u32 = 1 << 15;
 	pub const REMOTE_STFU_SENT: u32 = 1 << 16;
 	pub const QUIESCENT: u32 = 1 << 17;
+	pub const INTERACTIVE_SIGNING: u32 = 1 << 18;
+	pub const OUR_TX_SIGNATURES_READY: u32 = 1 << 19;
+	pub const THEIR_TX_SIGNATURES_SENT: u32 = 1 << 20;
 }
 
 define_state_flags!(
@@ -512,6 +515,21 @@ define_state_flags!(
 	]
 );
 
+define_state_flags!(
+	"Flags that only apply to [`ChannelState::FundingNegotiated`].",
+	FUNDED_STATE, FundingNegotiatedFlags, [
+		("Indicates we have an active interactive signing session for an interactive transaction",
+			INTERACTIVE_SIGNING, state_flags::INTERACTIVE_SIGNING,
+			is_interactive_signing, set_interactive_signing, clear_interactive_signing),
+		("Indicates they sent us a `tx_signatures` message.",
+			THEIR_TX_SIGNATURES_SENT, state_flags::THEIR_TX_SIGNATURES_SENT,
+			is_their_tx_signatures_sent, set_their_tx_signatures_sent, clear_their_tx_signatures_sent),
+		("Indicates we are ready to send them a `tx_signatures` message and it has been queued to send.",
+			OUR_TX_SIGNATURES_READY, state_flags::OUR_TX_SIGNATURES_READY,
+			is_our_tx_signatures_ready, set_our_tx_signatures_ready, clear_our_tx_signatures_ready)
+	]
+);
+
 define_state_flags!(
 	"Flags that only apply to [`ChannelState::AwaitingChannelReady`].",
 	FUNDED_STATE, AwaitingChannelReadyFlags, [
@@ -570,7 +588,11 @@ enum ChannelState {
 	/// We have sent `funding_created` and are awaiting a `funding_signed` to advance to
 	/// `AwaitingChannelReady`. Note that this is nonsense for an inbound channel as we immediately generate
 	/// `funding_signed` upon receipt of `funding_created`, so simply skip this state.
-	FundingNegotiated,
+	///
+	/// For inbound and outbound interactively funded channels (dual-funding/splicing), this flag indicates
+	/// that interactive transaction construction has been completed and we are now interactively signing
+	/// the funding/splice transaction.
+	FundingNegotiated(FundingNegotiatedFlags),
 	/// We've received/sent `funding_created` and `funding_signed` and are thus now waiting on the
 	/// funding transaction to confirm.
 	AwaitingChannelReady(AwaitingChannelReadyFlags),
@@ -613,7 +635,7 @@ macro_rules! impl_state_flag {
 		}
 	};
 	($get: ident, $set: ident, $clear: ident, FUNDED_STATES) => {
-		impl_state_flag!($get, $set, $clear, [AwaitingChannelReady, ChannelReady]);
+		impl_state_flag!($get, $set, $clear, [FundingNegotiated, AwaitingChannelReady, ChannelReady]);
 	};
 	($get: ident, $set: ident, $clear: ident, $state: ident) => {
 		impl_state_flag!($get, $set, $clear, [$state]);
@@ -623,10 +645,12 @@ macro_rules! impl_state_flag {
 impl ChannelState {
 	fn from_u32(state: u32) -> Result<Self, ()> {
 		match state {
-			state_flags::FUNDING_NEGOTIATED => Ok(ChannelState::FundingNegotiated),
 			state_flags::SHUTDOWN_COMPLETE => Ok(ChannelState::ShutdownComplete),
 			val => {
-				if val & state_flags::AWAITING_CHANNEL_READY == state_flags::AWAITING_CHANNEL_READY {
+				if val & state_flags::FUNDING_NEGOTIATED == state_flags::FUNDING_NEGOTIATED {
+					FundingNegotiatedFlags::from_u32(val & !state_flags::FUNDING_NEGOTIATED)
+						.map(|flags| ChannelState::FundingNegotiated(flags))
+				} else if val & state_flags::AWAITING_CHANNEL_READY == state_flags::AWAITING_CHANNEL_READY {
 					AwaitingChannelReadyFlags::from_u32(val & !state_flags::AWAITING_CHANNEL_READY)
 						.map(|flags| ChannelState::AwaitingChannelReady(flags))
 				} else if val & state_flags::CHANNEL_READY == state_flags::CHANNEL_READY {
@@ -644,7 +668,7 @@ impl ChannelState {
 	fn to_u32(self) -> u32 {
 		match self {
 			ChannelState::NegotiatingFunding(flags) => flags.0,
-			ChannelState::FundingNegotiated => state_flags::FUNDING_NEGOTIATED,
+			ChannelState::FundingNegotiated(flags) => state_flags::FUNDING_NEGOTIATED | flags.0,
 			ChannelState::AwaitingChannelReady(flags) => state_flags::AWAITING_CHANNEL_READY | flags.0,
 			ChannelState::ChannelReady(flags) => state_flags::CHANNEL_READY | flags.0,
 			ChannelState::ShutdownComplete => state_flags::SHUTDOWN_COMPLETE,
@@ -652,7 +676,11 @@ impl ChannelState {
 	}
 
 	fn is_pre_funded_state(&self) -> bool {
-		matches!(self, ChannelState::NegotiatingFunding(_)|ChannelState::FundingNegotiated)
+		match self {
+			ChannelState::NegotiatingFunding(_) => true,
+			ChannelState::FundingNegotiated(flags) => !flags.is_their_tx_signatures_sent() && !flags.is_our_tx_signatures_ready(),
+			_ => false,
+		}
 	}
 
 	fn is_both_sides_shutdown(&self) -> bool {
@@ -686,6 +714,9 @@ impl ChannelState {
 	impl_state_flag!(is_monitor_update_in_progress, set_monitor_update_in_progress, clear_monitor_update_in_progress, FUNDED_STATES);
 	impl_state_flag!(is_local_shutdown_sent, set_local_shutdown_sent, clear_local_shutdown_sent, FUNDED_STATES);
 	impl_state_flag!(is_remote_shutdown_sent, set_remote_shutdown_sent, clear_remote_shutdown_sent, FUNDED_STATES);
+	impl_state_flag!(is_interactive_signing, set_interactive_signing, clear_interactive_signing, FundingNegotiated);
+	impl_state_flag!(is_our_tx_signatures_ready, set_our_tx_signatures_ready, clear_our_tx_signatures_ready, FundingNegotiated);
+	impl_state_flag!(is_their_tx_signatures_sent, set_their_tx_signatures_sent, clear_their_tx_signatures_sent, FundingNegotiated);
 	impl_state_flag!(is_our_channel_ready, set_our_channel_ready, clear_our_channel_ready, AwaitingChannelReady);
 	impl_state_flag!(is_their_channel_ready, set_their_channel_ready, clear_their_channel_ready, AwaitingChannelReady);
 	impl_state_flag!(is_waiting_for_batch, set_waiting_for_batch, clear_waiting_for_batch, AwaitingChannelReady);
@@ -973,6 +1004,8 @@ pub(super) struct ReestablishResponses {
 	pub order: RAACommitmentOrder,
 	pub announcement_sigs: Option<msgs::AnnouncementSignatures>,
 	pub shutdown_msg: Option<msgs::Shutdown>,
+	pub tx_signatures: Option<msgs::TxSignatures>,
+	pub tx_abort: Option<msgs::TxAbort>,
 }
 
 /// The first message we send to our peer after connection
@@ -2011,22 +2044,6 @@ pub(super) struct ChannelContext<SP: Deref> where SP::Target: SignerProvider {
 	/// store it here and only release it to the `ChannelManager` once it asks for it.
 	blocked_monitor_updates: Vec<PendingChannelMonitorUpdate>,
 
-	// The `next_funding_txid` field allows peers to finalize the signing steps of an interactive
-	// transaction construction, or safely abort that transaction if it was not signed by one of the
-	// peers, who has thus already removed it from its state.
-	//
-	// If we've sent `commtiment_signed` for an interactively constructed transaction
-	// during a signing session, but have not received `tx_signatures` we MUST set `next_funding_txid`
-	// to the txid of that interactive transaction, else we MUST NOT set it.
-	//
-	// See the spec for further details on this:
-	//   * `channel_reestablish`-sending node: https://github.com/lightning/bolts/blob/247e83d/02-peer-protocol.md?plain=1#L2466-L2470
-	//   * `channel_reestablish`-receiving node: https://github.com/lightning/bolts/blob/247e83d/02-peer-protocol.md?plain=1#L2520-L2531
-	//
-	// TODO(dual_funding): Persist this when we actually contribute funding inputs. For now we always
-	// send an empty witnesses array in `tx_signatures` as a V2 channel acceptor
-	next_funding_txid: Option<Txid>,
-
 	/// Only set when a counterparty `stfu` has been processed to track which node is allowed to
 	/// propose "something fundamental" upon becoming quiescent.
 	is_holder_quiescence_initiator: Option<bool>,
@@ -2114,14 +2131,17 @@ trait InitialRemoteCommitmentReceiver<SP: Deref> where SP::Target: SignerProvide
 
 		// Now that we're past error-generating stuff, update our local state:
 
+		let is_v2_established = self.is_v2_established();
 		let context = self.context_mut();
 		context.channel_id = channel_id;
 
 		assert!(!context.channel_state.is_monitor_update_in_progress()); // We have not had any monitor(s) yet to fail update!
-		if context.is_batch_funding() {
-			context.channel_state = ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::WAITING_FOR_BATCH);
-		} else {
-			context.channel_state = ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new());
+		if !is_v2_established {
+			if context.is_batch_funding() {
+				context.channel_state = ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::WAITING_FOR_BATCH);
+			} else {
+				context.channel_state = ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new());
+			}
 		}
 		if holder_commitment_point.advance(&context.holder_signer, &context.secp_ctx, logger).is_err() {
 			// We only fail to advance our commitment point/number if we're currently
@@ -2153,6 +2173,19 @@ trait InitialRemoteCommitmentReceiver<SP: Deref> where SP::Target: SignerProvide
 
 		Ok((channel_monitor, counterparty_initial_commitment_tx))
 	}
+
+	fn is_v2_established(&self) -> bool {
+		let channel_parameters = &self.funding().channel_transaction_parameters;
+		// This will return false if `counterparty_parameters` is `None`. This is possible if we sent `open_channel2`,
+		// but did not yet receive an `accept_channel2`.
+		if let Some(ref counterparty_parameters) = channel_parameters.counterparty_parameters {
+			self.context().channel_id().is_v2_channel_id(
+				&channel_parameters.holder_pubkeys.revocation_basepoint,
+				&counterparty_parameters.pubkeys.revocation_basepoint)
+		} else {
+			false
+		}
+	}
 }
 
 impl<SP: Deref> InitialRemoteCommitmentReceiver<SP> for OutboundV1Channel<SP> where SP::Target: SignerProvider {
@@ -2374,10 +2407,6 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 			}
 		};
 
-		if let HandleTxCompleteValue::SendTxComplete(_, ref signing_session) = tx_complete {
-			self.context.next_funding_txid = Some(signing_session.unsigned_tx.compute_txid());
-		};
-
 		HandleTxCompleteResult(Ok(tx_complete))
 	}
 
@@ -2392,7 +2421,7 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 
 		let mut output_index = None;
 		let expected_spk = self.funding.get_funding_redeemscript().to_p2wsh();
-		for (idx, outp) in signing_session.unsigned_tx.outputs().enumerate() {
+		for (idx, outp) in signing_session.unsigned_tx().outputs().enumerate() {
 			if outp.script_pubkey() == &expected_spk && outp.value() == self.funding.get_value_satoshis() {
 				if output_index.is_some() {
 					return Err(ChannelError::Close(
@@ -2405,7 +2434,7 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 			}
 		}
 		let outpoint = if let Some(output_index) = output_index {
-			OutPoint { txid: signing_session.unsigned_tx.compute_txid(), index: output_index }
+			OutPoint { txid: signing_session.unsigned_tx().compute_txid(), index: output_index }
 		} else {
 			return Err(ChannelError::Close(
 				(
@@ -2418,10 +2447,7 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 		self.context.assert_no_commitment_advancement(transaction_number, "initial commitment_signed");
 		let commitment_signed = self.context.get_initial_commitment_signed(&self.funding, logger);
 		let commitment_signed = match commitment_signed {
-			Ok(commitment_signed) => {
-				self.funding.funding_transaction = Some(signing_session.unsigned_tx.build_unsigned_tx());
-				commitment_signed
-			},
+			Ok(commitment_signed) => commitment_signed,
 			Err(err) => {
 				self.funding.channel_transaction_parameters.funding_outpoint = None;
 				return Err(ChannelError::Close((err.to_string(), ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(false) })));
@@ -2466,7 +2492,9 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 			)));
 		};
 
-		self.context.channel_state = ChannelState::FundingNegotiated;
+		let mut channel_state = ChannelState::FundingNegotiated(FundingNegotiatedFlags::new());
+		channel_state.set_interactive_signing();
+		self.context.channel_state = channel_state;
 
 		// Clear the interactive transaction constructor
 		self.interactive_tx_constructor.take();
@@ -2813,8 +2841,6 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 
 			is_manual_broadcast: false,
 
-			next_funding_txid: None,
-
 			is_holder_quiescence_initiator: None,
 		};
 
@@ -3046,7 +3072,6 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 			blocked_monitor_updates: Vec::new(),
 			local_initiated_shutdown: None,
 			is_manual_broadcast: false,
-			next_funding_txid: None,
 
 			is_holder_quiescence_initiator: None,
 		};
@@ -3552,7 +3577,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 
 	fn unset_funding_info(&mut self, funding: &mut FundingScope) {
 		debug_assert!(
-			matches!(self.channel_state, ChannelState::FundingNegotiated)
+			matches!(self.channel_state, ChannelState::FundingNegotiated(flags) if !flags.is_their_tx_signatures_sent() && !flags.is_our_tx_signatures_ready())
 				|| matches!(self.channel_state, ChannelState::AwaitingChannelReady(_))
 		);
 		funding.channel_transaction_parameters.funding_outpoint = None;
@@ -4503,7 +4528,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 
 	fn if_unbroadcasted_funding<F, O>(&self, f: F) -> Option<O> where F: Fn() -> Option<O> {
 		match self.channel_state {
-			ChannelState::FundingNegotiated => f(),
+			ChannelState::FundingNegotiated(_) => f(),
 			ChannelState::AwaitingChannelReady(flags) =>
 				if flags.is_set(AwaitingChannelReadyFlags::WAITING_FOR_BATCH) ||
 					flags.is_set(FundedStateFlags::MONITOR_UPDATE_IN_PROGRESS.into())
@@ -4944,6 +4969,13 @@ pub(super) struct DualFundingChannelContext {
 pub(super) struct FundedChannel<SP: Deref> where SP::Target: SignerProvider {
 	pub funding: 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,
 	/// Indicates whether this funded channel had been established with V2 channel
@@ -5515,6 +5547,8 @@ impl<SP: Deref> FundedChannel<SP> where
 
 		self.context.counterparty_prev_commitment_point = self.context.counterparty_cur_commitment_point;
 		self.context.counterparty_cur_commitment_point = Some(msg.next_per_commitment_point);
+		// Clear any interactive signing session.
+		self.interactive_tx_signing_session = None;
 
 		log_info!(logger, "Received channel_ready from peer for channel {}", &self.context.channel_id());
 
@@ -5719,7 +5753,7 @@ impl<SP: Deref> FundedChannel<SP> where
 	) -> Result<ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>, ChannelError>
 	where L::Target: Logger
 	{
-		if !matches!(self.context.channel_state, ChannelState::FundingNegotiated) {
+		if !matches!(self.context.channel_state, ChannelState::FundingNegotiated(_)) {
 			return Err(ChannelError::Close(
 				(
 					"Received initial commitment_signed before funding transaction constructed!".to_owned(),
@@ -5736,7 +5770,6 @@ impl<SP: Deref> FundedChannel<SP> where
 		log_info!(logger, "Received initial commitment_signed from peer for channel {}", &self.context.channel_id());
 
 		let need_channel_ready = self.check_get_channel_ready(0, logger).is_some();
-		self.context.channel_state = ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new());
 		self.monitor_updating_paused(false, false, need_channel_ready, Vec::new(), Vec::new(), Vec::new());
 
 		if let Some(tx_signatures) = self.interactive_tx_signing_session.as_mut().and_then(
@@ -6323,15 +6356,15 @@ impl<SP: Deref> FundedChannel<SP> where
 		}
 	}
 
-	pub fn tx_signatures<L: Deref>(&mut self, msg: &msgs::TxSignatures, logger: &L) -> Result<Option<msgs::TxSignatures>, ChannelError>
+	pub fn tx_signatures<L: Deref>(&mut self, msg: &msgs::TxSignatures, logger: &L) -> Result<(Option<Transaction>, Option<msgs::TxSignatures>), ChannelError>
 		where L::Target: Logger
 	{
-		if !matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(_)) {
+		if !matches!(self.context.channel_state, ChannelState::FundingNegotiated(flags) if flags.is_interactive_signing()) {
 			return Err(ChannelError::close("Received tx_signatures in strange state!".to_owned()));
 		}
 
 		if let Some(ref mut signing_session) = self.interactive_tx_signing_session {
-			if msg.tx_hash != signing_session.unsigned_tx.compute_txid() {
+			if msg.tx_hash != signing_session.unsigned_tx().compute_txid() {
 				return Err(ChannelError::Close(
 					(
 						"The txid for the transaction does not match".to_string(),
@@ -6363,22 +6396,29 @@ impl<SP: Deref> FundedChannel<SP> where
 			let (holder_tx_signatures_opt, funding_tx_opt) = signing_session.received_tx_signatures(msg.clone())
 				.map_err(|_| ChannelError::Warn("Witness count did not match contributed input count".to_string()))?;
 
+			// Set `THEIR_TX_SIGNATURES_SENT` flag after all potential errors.
+			self.context.channel_state.set_their_tx_signatures_sent();
 
 			if funding_tx_opt.is_some() {
-				// We have a finalized funding transaction, so we can set the funding transaction and reset the
-				// signing session fields.
-				self.funding.funding_transaction = funding_tx_opt;
-				self.context.next_funding_txid = None;
-				self.interactive_tx_signing_session = None;
+				// We have a finalized funding transaction, so we can set the funding transaction.
+				self.funding.funding_transaction = funding_tx_opt.clone();
 			}
 
+			// Note that `holder_tx_signatures_opt` will be `None` if we sent `tx_signatures` first, so this
+			// case checks if there is a monitor persist in progress when we need to respond with our `tx_signatures`
+			// and sets it as pending.
 			if holder_tx_signatures_opt.is_some() && self.is_awaiting_initial_mon_persist() {
 				log_debug!(logger, "Not sending tx_signatures: a monitor update is in progress. Setting monitor_pending_tx_signatures.");
 				self.context.monitor_pending_tx_signatures = holder_tx_signatures_opt;
-				return Ok(None);
+				return Ok((None, None));
+			}
+
+			if holder_tx_signatures_opt.is_some() {
+				self.context.channel_state.set_our_tx_signatures_ready();
 			}
 
-			Ok(holder_tx_signatures_opt)
+			self.context.channel_state = ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new());
+			Ok((funding_tx_opt, holder_tx_signatures_opt))
 		} else {
 			Err(ChannelError::Close((
 				"Unexpected tx_signatures. No funding transaction awaiting signatures".to_string(),
@@ -6640,6 +6680,9 @@ impl<SP: Deref> FundedChannel<SP> where
 		// MonitorUpdateInProgress (and we assume the user will never directly broadcast the funding
 		// transaction and waits for us to do it).
 		let tx_signatures = self.context.monitor_pending_tx_signatures.take();
+		if tx_signatures.is_some() {
+			self.context.channel_state.set_our_tx_signatures_ready();
+		}
 
 		if self.context.channel_state.is_peer_disconnected() {
 			self.context.monitor_pending_revoke_and_ack = false;
@@ -6981,7 +7024,10 @@ impl<SP: Deref> FundedChannel<SP> where
 		}
 
 		if msg.next_local_commitment_number >= INITIAL_COMMITMENT_NUMBER || msg.next_remote_commitment_number >= INITIAL_COMMITMENT_NUMBER ||
-			msg.next_local_commitment_number == 0 {
+			(msg.next_local_commitment_number == 0 && msg.next_funding_txid.is_none()) {
+			// Note: This also covers the following case in the V2 channel establishment specification:
+			//   if `next_funding_txid` is not set, and `next_commitment_number` is zero:
+			//     MUST immediately fail the channel and broadcast any relevant latest commitment transaction.
 			return Err(ChannelError::close("Peer sent an invalid channel_reestablish to force close in a non-standard way".to_owned()));
 		}
 
@@ -7045,6 +7091,8 @@ impl<SP: Deref> FundedChannel<SP> where
 					raa: None, commitment_update: None,
 					order: RAACommitmentOrder::CommitmentFirst,
 					shutdown_msg, announcement_sigs,
+					tx_signatures: None,
+					tx_abort: None,
 				});
 			}
 
@@ -7054,6 +7102,8 @@ impl<SP: Deref> FundedChannel<SP> where
 				raa: None, commitment_update: None,
 				order: RAACommitmentOrder::CommitmentFirst,
 				shutdown_msg, announcement_sigs,
+				tx_signatures: None,
+				tx_abort: None,
 			});
 		}
 
@@ -7096,11 +7146,88 @@ impl<SP: Deref> FundedChannel<SP> where
 				log_debug!(logger, "Reconnected channel {} with no loss", &self.context.channel_id());
 			}
 
+			// if next_funding_txid is set:
+			let (commitment_update, tx_signatures, tx_abort) = if let Some(next_funding_txid) = msg.next_funding_txid {
+				// if it also sets `next_funding_txid` in its own `channel_reestablish`, but the values don't match:
+				if let Some(our_next_funding_txid) = self.maybe_get_next_funding_txid().filter(|txid| txid != &next_funding_txid) {
+					//   MUST send an `error` and fail the channel.
+					return Err(ChannelError::Close((format!(
+						"Our next_funding_txid ({}) does not match your next_funding_txid ({})",
+						our_next_funding_txid, next_funding_txid,
+					), ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) })));
+				}
+				if let Some(session) = &self.interactive_tx_signing_session {
+					// if next_funding_txid matches the latest interactive funding transaction or the current channel funding transaction:
+					let our_next_funding_txid = session.unsigned_tx().compute_txid();
+					let our_current_funding_txid_opt = self.funding.funding_transaction.as_ref().map(|tx| tx.compute_txid());
+					if our_current_funding_txid_opt.map(|txid| txid == next_funding_txid).unwrap_or(false) || our_next_funding_txid == next_funding_txid {
+						let has_received_commitment_signed = session.has_received_commitment_signed();
+						let holder_sends_tx_signatures_first = session.holder_sends_tx_signatures_first();
+						let holder_tx_signatures = session.holder_tx_signatures().clone();
+						debug_assert_eq!(session.unsigned_tx().compute_txid(), self.maybe_get_next_funding_txid().unwrap());
+						// if next_commitment_number is equal to the commitment number of the commitment_signed message it
+						// sent for this funding transaction or the current channel funding transaction:
+						let commitment_update = if msg.next_local_commitment_number == next_counterparty_commitment_number {
+							//   MUST retransmit its commitment_signed for that funding transaction.
+							self.get_last_commitment_update_for_send(logger).ok()
+						} else { None };
+						// TODO(dual_funding): For async signing support we need to hold back `tx_signatures` until the `commitment_signed` is ready.
+						let tx_signatures = if (
+							// if it has not received tx_signatures for that funding transaction AND
+							// if it has already received commitment_signed AND it should sign first, as specified in the tx_signatures requirements:
+							//   MUST send its tx_signatures for that funding transaction.
+							!self.context.channel_state.is_their_tx_signatures_sent() && has_received_commitment_signed && holder_sends_tx_signatures_first
+							// else if it has already received tx_signatures for that funding transaction:
+							//   MUST send its tx_signatures for that funding transaction.
+						) || self.context.channel_state.is_their_tx_signatures_sent() {
+							if self.context.channel_state.is_monitor_update_in_progress() {
+								// The `monitor_pending_tx_signatures` field should have already been set in `commitment_signed_initial_v2`
+								// if we were up first for signing and had a monitor update in progress, but check again just in case.
+								debug_assert!(self.context.monitor_pending_tx_signatures.is_some(), "monitor_pending_tx_signatures should already be set");
+								log_debug!(logger, "Not sending tx_signatures: a monitor update is in progress. Setting monitor_pending_tx_signatures.");
+								if self.context.monitor_pending_tx_signatures.is_none() {
+									self.context.monitor_pending_tx_signatures = holder_tx_signatures;
+								}
+								None
+							} else {
+								// If `holder_tx_signatures` is `None` here, the `tx_signatures` message will be sent
+								// when the holder provides their witnesses as this will queue a `tx_signatures` if the
+								// holder must send one.
+								holder_tx_signatures
+							}
+						} else {
+							None
+						};
+						if !has_received_commitment_signed {
+							self.context.expecting_peer_commitment_signed = true;
+						}
+						(commitment_update, tx_signatures, None)
+					} else {
+						// The `next_funding_txid` does not match the latest interactive funding transaction so we
+						// MUST send tx_abort to let the remote  know that they can forget this funding transaction.
+						(None, None, Some(msgs::TxAbort {
+							channel_id: self.context.channel_id(),
+							data: format!(
+								"next_funding_txid {} does match our latest interactive funding txid {}{}",
+								next_funding_txid, our_next_funding_txid,
+								if let Some(txid) = our_current_funding_txid_opt { format!(" or our current funding txid {}", txid) } else { "".into() }
+							).into_bytes() }))
+					}
+				} else {
+					return Err(ChannelError::close("Counterparty set `next_funding_txid` at incorrect state".into()));
+				}
+			} else {
+				// Don't send anything related to interactive signing if `next_funding_txid` is not set.
+				(None, None, None)
+			};
+
 			Ok(ReestablishResponses {
 				channel_ready, shutdown_msg, announcement_sigs,
 				raa: required_revoke,
-				commitment_update: None,
+				commitment_update,
 				order: self.context.resend_order.clone(),
+				tx_signatures,
+				tx_abort,
 			})
 		} else if msg.next_local_commitment_number == next_counterparty_commitment_number - 1 {
 			if required_revoke.is_some() || self.context.signer_pending_revoke_and_ack {
@@ -7115,6 +7242,8 @@ impl<SP: Deref> FundedChannel<SP> where
 					channel_ready, shutdown_msg, announcement_sigs,
 					commitment_update: None, raa: None,
 					order: self.context.resend_order.clone(),
+					tx_signatures: None,
+					tx_abort: None,
 				})
 			} else {
 				let commitment_update = if self.context.resend_order == RAACommitmentOrder::RevokeAndACKFirst
@@ -7137,6 +7266,8 @@ impl<SP: Deref> FundedChannel<SP> where
 					channel_ready, shutdown_msg, announcement_sigs,
 					raa, commitment_update,
 					order: self.context.resend_order.clone(),
+					tx_signatures: None,
+					tx_abort: None,
 				})
 			}
 		} else if msg.next_local_commitment_number < next_counterparty_commitment_number {
@@ -8424,6 +8555,25 @@ impl<SP: Deref> FundedChannel<SP> where
 		}
 	}
 
+	fn maybe_get_next_funding_txid(&self) -> Option<Txid> {
+		// If we've sent `commtiment_signed` for an interactively constructed transaction
+		// during a signing session, but have not received `tx_signatures` we MUST set `next_funding_txid`
+		// to the txid of that interactive transaction, else we MUST NOT set it.
+		if self.context.channel_state.is_interactive_signing() {
+			// Since we have a signing_session, this implies we've sent an initial `commitment_signed`...
+			if !self.context.channel_state.is_their_tx_signatures_sent() {
+				// ...but we didn't receive a `tx_signatures` from the counterparty yet.
+				Some(self.funding_outpoint().txid)
+			} else {
+				// ...and we received a `tx_signatures` from the counterparty.
+				None
+			}
+		} else {
+			// We don't have an active signing session.
+			None
+		}
+	}
+
 	/// May panic if called on a channel that wasn't immediately-previously
 	/// self.remove_uncommitted_htlcs_and_mark_paused()'d
 	fn get_channel_reestablish<L: Deref>(&mut self, logger: &L) -> msgs::ChannelReestablish where L::Target: Logger {
@@ -8473,7 +8623,7 @@ impl<SP: Deref> FundedChannel<SP> where
 			next_remote_commitment_number: INITIAL_COMMITMENT_NUMBER - self.context.cur_counterparty_commitment_transaction_number - 1,
 			your_last_per_commitment_secret: remote_last_secret,
 			my_current_per_commitment_point: dummy_pubkey,
-			next_funding_txid: self.context.next_funding_txid,
+			next_funding_txid: self.maybe_get_next_funding_txid(),
 		}
 	}
 
@@ -9393,7 +9543,7 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
 
 		// Now that we're past error-generating stuff, update our local state:
 
-		self.context.channel_state = ChannelState::FundingNegotiated;
+		self.context.channel_state = ChannelState::FundingNegotiated(FundingNegotiatedFlags::new());
 		self.context.channel_id = ChannelId::v1_from_funding_outpoint(funding_txo);
 
 		// If the funding transaction is a coinbase transaction, we need to set the minimum depth to 100.
@@ -9510,7 +9660,7 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
 		if !self.funding.is_outbound() {
 			return Err((self, ChannelError::close("Received funding_signed for an inbound channel?".to_owned())));
 		}
-		if !matches!(self.context.channel_state, ChannelState::FundingNegotiated) {
+		if !matches!(self.context.channel_state, ChannelState::FundingNegotiated(_)) {
 			return Err((self, ChannelError::close("Received funding_signed in strange state!".to_owned())));
 		}
 		let mut holder_commitment_point = match self.unfunded_context.holder_commitment_point {
@@ -10605,6 +10755,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(())
@@ -10896,6 +11047,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),
@@ -10931,6 +11084,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);
@@ -11182,17 +11336,9 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, &'c Channel
 				blocked_monitor_updates: blocked_monitor_updates.unwrap(),
 				is_manual_broadcast: is_manual_broadcast.unwrap_or(false),
 
-				// TODO(dual_funding): Instead of getting this from persisted value, figure it out based on the
-				// funding transaction and other channel state.
-				//
-				// If we've sent `commtiment_signed` for an interactively constructed transaction
-				// during a signing session, but have not received `tx_signatures` we MUST set `next_funding_txid`
-				// to the txid of that interactive transaction, else we MUST NOT set it.
-				next_funding_txid: None,
-
 				is_holder_quiescence_initiator: None,
 			},
-			interactive_tx_signing_session: None,
+			interactive_tx_signing_session,
 			is_v2_established,
 			holder_commitment_point,
 			#[cfg(splicing)]
@@ -11249,11 +11395,12 @@ mod tests {
 	#[test]
 	fn test_channel_state_order() {
 		use crate::ln::channel::NegotiatingFundingFlags;
+		use crate::ln::channel::FundingNegotiatedFlags;
 		use crate::ln::channel::AwaitingChannelReadyFlags;
 		use crate::ln::channel::ChannelReadyFlags;
 
-		assert!(ChannelState::NegotiatingFunding(NegotiatingFundingFlags::new()) < ChannelState::FundingNegotiated);
-		assert!(ChannelState::FundingNegotiated < ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new()));
+		assert!(ChannelState::NegotiatingFunding(NegotiatingFundingFlags::new()) < ChannelState::FundingNegotiated(FundingNegotiatedFlags::new()));
+		assert!(ChannelState::FundingNegotiated(FundingNegotiatedFlags::new()) < ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new()));
 		assert!(ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new()) < ChannelState::ChannelReady(ChannelReadyFlags::new()));
 		assert!(ChannelState::ChannelReady(ChannelReadyFlags::new()) < ChannelState::ShutdownComplete);
 	}
diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
index 2e8c60d672a..4408aa0eeaa 100644
--- a/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@ -3229,7 +3229,7 @@ macro_rules! handle_monitor_update_completion {
 			&mut $peer_state.pending_msg_events, $chan, updates.raa,
 			updates.commitment_update, updates.order, updates.accepted_htlcs, updates.pending_update_adds,
 			updates.funding_broadcastable, updates.channel_ready,
-			updates.announcement_sigs, updates.tx_signatures);
+			updates.announcement_sigs, updates.tx_signatures, None);
 		if let Some(upd) = channel_update {
 			$peer_state.pending_msg_events.push(upd);
 		}
@@ -7640,10 +7640,10 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 		pending_forwards: Vec<(PendingHTLCInfo, u64)>, pending_update_adds: Vec<msgs::UpdateAddHTLC>,
 		funding_broadcastable: Option<Transaction>,
 		channel_ready: Option<msgs::ChannelReady>, announcement_sigs: Option<msgs::AnnouncementSignatures>,
-		tx_signatures: Option<msgs::TxSignatures>
+		tx_signatures: Option<msgs::TxSignatures>, tx_abort: Option<msgs::TxAbort>,
 	) -> (Option<(u64, Option<PublicKey>, OutPoint, ChannelId, u128, Vec<(PendingHTLCInfo, u64)>)>, Option<(u64, Vec<msgs::UpdateAddHTLC>)>) {
 		let logger = WithChannelContext::from(&self.logger, &channel.context, None);
-		log_trace!(logger, "Handling channel resumption for channel {} with {} RAA, {} commitment update, {} pending forwards, {} pending update_add_htlcs, {}broadcasting funding, {} channel ready, {} announcement, {} tx_signatures",
+		log_trace!(logger, "Handling channel resumption for channel {} with {} RAA, {} commitment update, {} pending forwards, {} pending update_add_htlcs, {}broadcasting funding, {} channel ready, {} announcement, {} tx_signatures, {} tx_abort",
 			&channel.context.channel_id(),
 			if raa.is_some() { "an" } else { "no" },
 			if commitment_update.is_some() { "a" } else { "no" },
@@ -7652,6 +7652,7 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 			if channel_ready.is_some() { "sending" } else { "without" },
 			if announcement_sigs.is_some() { "sending" } else { "without" },
 			if tx_signatures.is_some() { "sending" } else { "without" },
+			if tx_abort.is_some() { "sending" } else { "without" },
 		);
 
 		let counterparty_node_id = channel.context.get_counterparty_node_id();
@@ -7685,6 +7686,12 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 				msg,
 			});
 		}
+		if let Some(msg) = tx_abort {
+			pending_msg_events.push(MessageSendEvent::SendTxAbort {
+				node_id: counterparty_node_id,
+				msg,
+			});
+		}
 
 		macro_rules! handle_cs { () => {
 			if let Some(update) = commitment_update {
@@ -8556,14 +8563,14 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 				match chan_entry.get_mut().as_funded_mut() {
 					Some(chan) => {
 						let logger = WithChannelContext::from(&self.logger, &chan.context, None);
-						let tx_signatures_opt = try_channel_entry!(self, peer_state, chan.tx_signatures(msg, &&logger), chan_entry);
+						let (funding_tx_opt, tx_signatures_opt) = try_channel_entry!(self, peer_state, chan.tx_signatures(msg, &&logger), chan_entry);
 						if let Some(tx_signatures) = tx_signatures_opt {
 							peer_state.pending_msg_events.push(MessageSendEvent::SendTxSignatures {
 								node_id: *counterparty_node_id,
 								msg: tx_signatures,
 							});
 						}
-						if let Some(ref funding_tx) = chan.context.unbroadcasted_funding(&chan.funding) {
+						if let Some(ref funding_tx) = funding_tx_opt {
 							self.tx_broadcaster.broadcast_transactions(&[funding_tx]);
 							{
 								let mut pending_events = self.pending_events.lock().unwrap();
@@ -9432,7 +9439,8 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 						let need_lnd_workaround = chan.context.workaround_lnd_bug_4006.take();
 						let (htlc_forwards, decode_update_add_htlcs) = self.handle_channel_resumption(
 							&mut peer_state.pending_msg_events, chan, responses.raa, responses.commitment_update, responses.order,
-							Vec::new(), Vec::new(), None, responses.channel_ready, responses.announcement_sigs, None);
+							Vec::new(), Vec::new(), None, responses.channel_ready, responses.announcement_sigs,
+							responses.tx_signatures, responses.tx_abort);
 						debug_assert!(htlc_forwards.is_none());
 						debug_assert!(decode_update_add_htlcs.is_none());
 						if let Some(upd) = channel_update {
@@ -11936,6 +11944,12 @@ where
 	}
 
 	fn handle_open_channel_v2(&self, counterparty_node_id: PublicKey, msg: &msgs::OpenChannelV2) {
+		if !self.node_features().supports_dual_fund() {
+			let _: Result<(), _> = handle_error!(self, Err(MsgHandleErrInternal::send_err_msg_no_close(
+				"Dual-funded channels not supported".to_owned(),
+				msg.common_fields.temporary_channel_id.clone())), counterparty_node_id);
+			return;
+		}
 		// Note that we never need to persist the updated ChannelManager for an inbound
 		// open_channel message - pre-funded channels are never written so there should be no
 		// change to the contents.
@@ -12846,7 +12860,9 @@ pub fn provided_init_features(config: &UserConfig) -> InitFeatures {
 	if config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx {
 		features.set_anchors_zero_fee_htlc_tx_optional();
 	}
-	features.set_dual_fund_optional();
+	if config.enable_dual_funded_channels {
+		features.set_dual_fund_optional();
+	}
 	// Only signal quiescence support in tests for now, as we don't yet support any
 	// quiescent-dependent protocols (e.g., splicing).
 	#[cfg(any(test, fuzzing))]
diff --git a/lightning/src/ln/dual_funding_tests.rs b/lightning/src/ln/dual_funding_tests.rs
index 07d23763c99..58e1ee8a273 100644
--- a/lightning/src/ln/dual_funding_tests.rs
+++ b/lightning/src/ln/dual_funding_tests.rs
@@ -39,7 +39,9 @@ struct V2ChannelEstablishmentTestSession {
 fn do_test_v2_channel_establishment(session: V2ChannelEstablishmentTestSession) {
 	let chanmon_cfgs = create_chanmon_cfgs(2);
 	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
-	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
+	let mut node_1_user_config = test_default_channel_config();
+	node_1_user_config.enable_dual_funded_channels = true;
+	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(node_1_user_config)]);
 	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 	let logger_a = test_utils::TestLogger::with_id("node a".to_owned());
 
@@ -206,13 +208,6 @@ fn do_test_v2_channel_establishment(session: V2ChannelEstablishmentTestSession)
 	assert!(events.is_empty());
 	nodes[1].chain_monitor.complete_sole_pending_chan_update(&channel_id);
 
-	let events = nodes[1].node.get_and_clear_pending_events();
-	assert_eq!(events.len(), 1);
-	match events[0] {
-		Event::ChannelPending { channel_id: chan_id, .. } => assert_eq!(chan_id, channel_id),
-		_ => panic!("Unexpected event"),
-	};
-
 	let tx_signatures_msg = get_event_msg!(
 		nodes[1],
 		MessageSendEvent::SendTxSignatures,
@@ -234,6 +229,13 @@ fn do_test_v2_channel_establishment(session: V2ChannelEstablishmentTestSession)
 		},
 	);
 
+	let events = nodes[1].node.get_and_clear_pending_events();
+	assert_eq!(events.len(), 1);
+	match events[0] {
+		Event::ChannelPending { channel_id: chan_id, .. } => assert_eq!(chan_id, channel_id),
+		_ => panic!("Unexpected event"),
+	};
+
 	// For an inbound channel V2 channel the transaction should be broadcast once receiving a
 	// tx_signature and applying local tx_signatures:
 	let broadcasted_txs = nodes[1].tx_broadcaster.txn_broadcast();
diff --git a/lightning/src/ln/interactivetxs.rs b/lightning/src/ln/interactivetxs.rs
index 28dbd3d1245..ee991a0ae8c 100644
--- a/lightning/src/ln/interactivetxs.rs
+++ b/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
@@ -309,25 +321,32 @@ impl ConstructedTransaction {
 /// https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#sharing-funding-signatures-tx_signatures
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct InteractiveTxSigningSession {
-	pub unsigned_tx: ConstructedTransaction,
+	unsigned_tx: ConstructedTransaction,
 	holder_sends_tx_signatures_first: bool,
-	received_commitment_signed: bool,
+	has_received_commitment_signed: bool,
 	holder_tx_signatures: Option<TxSignatures>,
-	counterparty_sent_tx_signatures: bool,
 }
 
 impl InteractiveTxSigningSession {
-	pub fn received_commitment_signed(&mut self) -> Option<TxSignatures> {
-		self.received_commitment_signed = true;
-		if self.holder_sends_tx_signatures_first {
-			self.holder_tx_signatures.clone()
-		} else {
-			None
-		}
+	pub fn unsigned_tx(&self) -> &ConstructedTransaction {
+		&self.unsigned_tx
+	}
+
+	pub fn holder_sends_tx_signatures_first(&self) -> bool {
+		self.holder_sends_tx_signatures_first
+	}
+
+	pub fn has_received_commitment_signed(&self) -> bool {
+		self.has_received_commitment_signed
+	}
+
+	pub fn holder_tx_signatures(&self) -> &Option<TxSignatures> {
+		&self.holder_tx_signatures
 	}
 
-	pub fn get_tx_signatures(&self) -> Option<TxSignatures> {
-		if self.received_commitment_signed {
+	pub fn received_commitment_signed(&mut self) -> Option<TxSignatures> {
+		self.has_received_commitment_signed = true;
+		if self.holder_sends_tx_signatures_first {
 			self.holder_tx_signatures.clone()
 		} else {
 			None
@@ -352,7 +371,6 @@ impl InteractiveTxSigningSession {
 			return Err(());
 		}
 		self.unsigned_tx.add_remote_witnesses(tx_signatures.witnesses.clone());
-		self.counterparty_sent_tx_signatures = true;
 
 		let holder_tx_signatures = if !self.holder_sends_tx_signatures_first {
 			self.holder_tx_signatures.clone()
@@ -433,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,
@@ -1008,9 +1033,8 @@ macro_rules! define_state_transitions {
 				let signing_session = InteractiveTxSigningSession {
 					holder_sends_tx_signatures_first: tx.holder_sends_tx_signatures_first,
 					unsigned_tx: tx,
-					received_commitment_signed: false,
+					has_received_commitment_signed: false,
 					holder_tx_signatures: None,
-					counterparty_sent_tx_signatures: false,
 				};
 				Ok(NegotiationComplete(signing_session))
 			}
@@ -1157,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 {
@@ -1165,6 +1194,12 @@ 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),
@@ -1172,12 +1207,22 @@ pub(crate) enum InteractiveTxInput {
 	// 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!(
@@ -1205,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 {
@@ -1259,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 --git a/lightning/src/ln/msgs.rs b/lightning/src/ln/msgs.rs
index 41c7ceb014a..9f300e688a0 100644
--- a/lightning/src/ln/msgs.rs
+++ b/lightning/src/ln/msgs.rs
@@ -853,6 +853,18 @@ pub struct ChannelReestablish {
 	/// The sender's per-commitment point for their current commitment transaction
 	pub my_current_per_commitment_point: PublicKey,
 	/// The next funding transaction ID
+	///
+	/// Allows peers to finalize the signing steps of an interactive transaction construction, or
+	/// safely abort that transaction if it was not signed by one of the peers, who has thus already
+	/// removed it from its state.
+	///
+	/// If we've sent `commtiment_signed` for an interactively constructed transaction
+	/// during a signing session, but have not received `tx_signatures` we MUST set `next_funding_txid`
+	/// to the txid of that interactive transaction, else we MUST NOT set it.
+	///
+	/// See the spec for further details on this:
+	///   * `channel_reestablish`-sending node: https:///github.com/lightning/bolts/blob/247e83d/02-peer-protocol.md?plain=1#L2466-L2470
+	///   * `channel_reestablish`-receiving node: https:///github.com/lightning/bolts/blob/247e83d/02-peer-protocol.md?plain=1#L2520-L2531
 	pub next_funding_txid: Option<Txid>,
 }
 
diff --git a/lightning/src/util/config.rs b/lightning/src/util/config.rs
index 152a6a62eb6..7fcebcf1e73 100644
--- a/lightning/src/util/config.rs
+++ b/lightning/src/util/config.rs
@@ -875,6 +875,10 @@ pub struct UserConfig {
 	/// [`ChannelManager::send_payment_for_bolt12_invoice`]: crate::ln::channelmanager::ChannelManager::send_payment_for_bolt12_invoice
 	/// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
 	pub manually_handle_bolt12_invoices: bool,
+	/// If this is set to `true`, dual-funded channels will be enabled.
+	///
+	/// Default value: `false`
+	pub enable_dual_funded_channels: bool,
 }
 
 impl Default for UserConfig {
@@ -888,6 +892,7 @@ impl Default for UserConfig {
 			manually_accept_inbound_channels: false,
 			accept_intercept_htlcs: false,
 			manually_handle_bolt12_invoices: false,
+			enable_dual_funded_channels: false,
 		}
 	}
 }
@@ -907,6 +912,7 @@ impl Readable for UserConfig {
 			manually_accept_inbound_channels: Readable::read(reader)?,
 			accept_intercept_htlcs: Readable::read(reader)?,
 			manually_handle_bolt12_invoices: Readable::read(reader)?,
+			enable_dual_funded_channels: Readable::read(reader)?,
 		})
 	}
 }
diff --git a/lightning/src/util/ser.rs b/lightning/src/util/ser.rs
index 8a706a8cbdf..bd55ebdbfb3 100644
--- a/lightning/src/util/ser.rs
+++ b/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;
@@ -23,6 +24,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;
@@ -38,14 +40,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;
 
@@ -1074,6 +1076,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);
@@ -1345,6 +1350,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)
@@ -1446,6 +1464,7 @@ macro_rules! impl_consensus_ser {
 	};
 }
 impl_consensus_ser!(Transaction);
+impl_consensus_ser!(TxIn);
 impl_consensus_ser!(TxOut);
 impl_consensus_ser!(Witness);