Channel splicing support

bindings/ldk_node.udl

@@ -150,6 +150,10 @@ interface Node {
 	[Throws=NodeError]
 	UserChannelId open_announced_channel(PublicKey node_id, SocketAddress address, u64 channel_amount_sats, u64? push_to_counterparty_msat, ChannelConfig? channel_config);
 	[Throws=NodeError]
+	void splice_in([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, u64 splice_amount_sats);
+	[Throws=NodeError]
+	void splice_out([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, [ByRef]Address address, u64 splice_amount_sats);
+	[Throws=NodeError]
 	void close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id);
 	[Throws=NodeError]
 	void force_close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, string? reason);
@@ -290,6 +294,7 @@ enum NodeError {
 	"ProbeSendingFailed",
 	"ChannelCreationFailed",
 	"ChannelClosingFailed",
+	"ChannelSplicingFailed",
 	"ChannelConfigUpdateFailed",
 	"PersistenceFailed",
 	"FeerateEstimationUpdateFailed",
@@ -393,8 +398,10 @@ interface Event {
 	PaymentForwarded(ChannelId prev_channel_id, ChannelId next_channel_id, UserChannelId?
 	prev_user_channel_id, UserChannelId? next_user_channel_id, PublicKey? prev_node_id, PublicKey? next_node_id, u64? total_fee_earned_msat, u64? skimmed_fee_msat, boolean claim_from_onchain_tx, u64? outbound_amount_forwarded_msat);
 	ChannelPending(ChannelId channel_id, UserChannelId user_channel_id, ChannelId former_temporary_channel_id, PublicKey counterparty_node_id, OutPoint funding_txo);
-	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id);
+	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, OutPoint? funding_txo);
 	ChannelClosed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, ClosureReason? reason);
+	SplicePending(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint new_funding_txo);
+	SpliceFailed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint? abandoned_funding_txo);
 };
 
 enum PaymentFailureReason {

src/builder.rs

@@ -1795,6 +1795,7 @@ fn build_with_store_internal(
  wallet,
  chain_source,
  tx_broadcaster,
+ fee_estimator,
  event_queue,
  channel_manager,
  chain_monitor,

src/config.rs

@@ -325,6 +325,7 @@ pub(crate) fn default_user_config(config: &Config) -> UserConfig {
 	user_config.manually_accept_inbound_channels = true;
 	user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx =
  config.anchor_channels_config.is_some();
+	user_config.reject_inbound_splices = false;
 
 	if may_announce_channel(config).is_err() {
  user_config.accept_forwards_to_priv_channels = false;

src/error.rs

@@ -43,6 +43,8 @@ pub enum Error {
 	ChannelCreationFailed,
 	/// A channel could not be closed.
 	ChannelClosingFailed,
+	/// A channel could not be spliced.
+	ChannelSplicingFailed,
 	/// A channel configuration could not be updated.
 	ChannelConfigUpdateFailed,
 	/// Persistence failed.
@@ -145,6 +147,7 @@ impl fmt::Display for Error {
  Self::ProbeSendingFailed => write!(f, "Failed to send the given payment probe."),
  Self::ChannelCreationFailed => write!(f, "Failed to create channel."),
  Self::ChannelClosingFailed => write!(f, "Failed to close channel."),
+ Self::ChannelSplicingFailed => write!(f, "Failed to splice channel."),
  Self::ChannelConfigUpdateFailed => write!(f, "Failed to update channel config."),
  Self::PersistenceFailed => write!(f, "Failed to persist data."),
  Self::FeerateEstimationUpdateFailed => {

src/event.rs

@@ -199,6 +199,10 @@ pub enum Event {
  funding_txo: OutPoint,
 	},
 	/// A channel is ready to be used.
+	///
+	/// This event is emitted when:
+	/// - A new channel has been established and is ready for use
+	/// - An existing channel has been spliced and is ready with the new funding output
 	ChannelReady {
  /// The `channel_id` of the channel.
  channel_id: ChannelId,
@@ -208,6 +212,14 @@ pub enum Event {
  ///
  /// This will be `None` for events serialized by LDK Node v0.1.0 and prior.
  counterparty_node_id: Option<PublicKey>,
+ /// The outpoint of the channel's funding transaction.
+ ///
+ /// This represents the channel's current funding output, which may change when the
+ /// channel is spliced. For spliced channels, this will contain the new funding output
+ /// from the confirmed splice transaction.
+ ///
+ /// This will be `None` for events serialized by LDK Node v0.6.0 and prior.
+ funding_txo: Option<OutPoint>,
 	},
 	/// A channel has been closed.
 	ChannelClosed {
@@ -222,6 +234,28 @@ pub enum Event {
  /// This will be `None` for events serialized by LDK Node v0.2.1 and prior.
  reason: Option<ClosureReason>,
 	},
+	/// A channel splice is pending confirmation on-chain.
+	SplicePending {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction.
+ new_funding_txo: OutPoint,
+	},
+	/// A channel splice has failed.
+	SpliceFailed {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction, if one was created.
+ abandoned_funding_txo: Option<OutPoint>,
+	},
 }
 
 impl_writeable_tlv_based_enum!(Event,
@@ -246,6 +280,7 @@ impl_writeable_tlv_based_enum!(Event,
  (0, channel_id, required),
  (1, counterparty_node_id, option),
  (2, user_channel_id, required),
+ (3, funding_txo, option),
 	},
 	(4, ChannelPending) => {
  (0, channel_id, required),
@@ -278,7 +313,19 @@ impl_writeable_tlv_based_enum!(Event,
  (10, skimmed_fee_msat, option),
  (12, claim_from_onchain_tx, required),
  (14, outbound_amount_forwarded_msat, option),
-	}
+	},
+	(8, SplicePending) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, new_funding_txo, required),
+	},
+	(9, SpliceFailed) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, abandoned_funding_txo, option),
+	},
 );
 
 pub struct EventQueue<L: Deref>
@@ -1397,14 +1444,28 @@ where
  }
  },
  LdkEvent::ChannelReady {
- channel_id, user_channel_id, counterparty_node_id, ..
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ funding_txo,
+ ..
  } => {
- log_info!(
- self.logger,
- "Channel {} with counterparty {} ready to be used.",
- channel_id,
- counterparty_node_id,
- );
+ if let Some(funding_txo) = funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
 
  if let Some(liquidity_source) = self.liquidity_source.as_ref() {
  liquidity_source
@@ -1416,6 +1477,7 @@ where
  channel_id,
  user_channel_id: UserChannelId(user_channel_id),
  counterparty_node_id: Some(counterparty_node_id),
+ funding_txo,
  };
  match self.event_queue.add_event(event).await {
  Ok(_) => {},
@@ -1614,20 +1676,116 @@ where
  }
  }
  },
- LdkEvent::FundingTransactionReadyForSigning { .. } => {
- debug_assert!(false, "We currently don't support interactive-tx, so this event should never be emitted.");
+ // TODO(splicing): Revisit error handling once splicing API is settled in LDK 0.3
+ LdkEvent::FundingTransactionReadyForSigning {
+ channel_id,
+ counterparty_node_id,
+ unsigned_transaction,
+ ..
+ } => match self.wallet.sign_owned_inputs(unsigned_transaction) {
+ Ok(partially_signed_tx) => {
+ match self.channel_manager.funding_transaction_signed(
+ &channel_id,
+ &counterparty_node_id,
+ partially_signed_tx,
+ ) {
+ Ok(()) => {
+ log_info!(
+ self.logger,
+ "Signed funding transaction for channel {} with counterparty {}",
+ channel_id,
+ counterparty_node_id
+ );
+ },
+ Err(e) => {
+ // TODO(splicing): Abort splice once supported in LDK 0.3
+ debug_assert!(false, "Failed signing funding transaction: {:?}", e);
+ log_error!(self.logger, "Failed signing funding transaction: {:?}", e);
+ },
+ }
+ },
+ Err(()) => log_error!(self.logger, "Failed signing funding transaction"),
  },
- LdkEvent::SplicePending { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
+ LdkEvent::SplicePending {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ new_funding_txo,
+ ..
+ } => {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} pending splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ new_funding_txo,
  );
+
+ let event = Event::SplicePending {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ new_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
- LdkEvent::SpliceFailed { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
- );
+ LdkEvent::SpliceFailed {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ abandoned_funding_txo,
+ contributed_outputs,
+ ..
+ } => {
+ if let Some(funding_txo) = abandoned_funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
+
+ let tx = bitcoin::Transaction {
+ version: bitcoin::transaction::Version::TWO,
+ lock_time: bitcoin::absolute::LockTime::ZERO,
+ input: vec![],
+ output: contributed_outputs,
+ };
+ if let Err(e) = self.wallet.cancel_tx(&tx) {
+ log_error!(self.logger, "Failed reclaiming unused addresses: {}", e);
+ return Err(ReplayEvent());
+ }
+
+ let event = Event::SpliceFailed {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ abandoned_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
  }
  Ok(())
@@ -1655,6 +1813,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
  event_queue.add_event(expected_event.clone()).await.unwrap();
 
@@ -1692,6 +1851,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
 
  // Check `next_event_async` won't return if the queue is empty and always rather timeout.

bindings/ldk_node.udl

@@ -150,6 +150,10 @@ interface Node {
 	[Throws=NodeError]
 	UserChannelId open_announced_channel(PublicKey node_id, SocketAddress address, u64 channel_amount_sats, u64? push_to_counterparty_msat, ChannelConfig? channel_config);
 	[Throws=NodeError]
+	void splice_in([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, u64 splice_amount_sats);
+	[Throws=NodeError]
+	void splice_out([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, [ByRef]Address address, u64 splice_amount_sats);
+	[Throws=NodeError]
 	void close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id);
 	[Throws=NodeError]
 	void force_close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, string? reason);
@@ -290,6 +294,7 @@ enum NodeError {
 	"ProbeSendingFailed",
 	"ChannelCreationFailed",
 	"ChannelClosingFailed",
+	"ChannelSplicingFailed",
 	"ChannelConfigUpdateFailed",
 	"PersistenceFailed",
 	"FeerateEstimationUpdateFailed",
@@ -393,8 +398,10 @@ interface Event {
 	PaymentForwarded(ChannelId prev_channel_id, ChannelId next_channel_id, UserChannelId?
 	prev_user_channel_id, UserChannelId? next_user_channel_id, PublicKey? prev_node_id, PublicKey? next_node_id, u64? total_fee_earned_msat, u64? skimmed_fee_msat, boolean claim_from_onchain_tx, u64? outbound_amount_forwarded_msat);
 	ChannelPending(ChannelId channel_id, UserChannelId user_channel_id, ChannelId former_temporary_channel_id, PublicKey counterparty_node_id, OutPoint funding_txo);
-	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id);
+	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, OutPoint? funding_txo);
 	ChannelClosed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, ClosureReason? reason);
+	SplicePending(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint new_funding_txo);
+	SpliceFailed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint? abandoned_funding_txo);
 };
 
 enum PaymentFailureReason {

src/builder.rs

@@ -1795,6 +1795,7 @@ fn build_with_store_internal(
  wallet,
  chain_source,
  tx_broadcaster,
+ fee_estimator,
  event_queue,
  channel_manager,
  chain_monitor,

src/config.rs

@@ -325,6 +325,7 @@ pub(crate) fn default_user_config(config: &Config) -> UserConfig {
 	user_config.manually_accept_inbound_channels = true;
 	user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx =
  config.anchor_channels_config.is_some();
+	user_config.reject_inbound_splices = false;
 
 	if may_announce_channel(config).is_err() {
  user_config.accept_forwards_to_priv_channels = false;

src/error.rs

@@ -43,6 +43,8 @@ pub enum Error {
 	ChannelCreationFailed,
 	/// A channel could not be closed.
 	ChannelClosingFailed,
+	/// A channel could not be spliced.
+	ChannelSplicingFailed,
 	/// A channel configuration could not be updated.
 	ChannelConfigUpdateFailed,
 	/// Persistence failed.
@@ -145,6 +147,7 @@ impl fmt::Display for Error {
  Self::ProbeSendingFailed => write!(f, "Failed to send the given payment probe."),
  Self::ChannelCreationFailed => write!(f, "Failed to create channel."),
  Self::ChannelClosingFailed => write!(f, "Failed to close channel."),
+ Self::ChannelSplicingFailed => write!(f, "Failed to splice channel."),
  Self::ChannelConfigUpdateFailed => write!(f, "Failed to update channel config."),
  Self::PersistenceFailed => write!(f, "Failed to persist data."),
  Self::FeerateEstimationUpdateFailed => {

src/event.rs

@@ -199,6 +199,10 @@ pub enum Event {
  funding_txo: OutPoint,
 	},
 	/// A channel is ready to be used.
+	///
+	/// This event is emitted when:
+	/// - A new channel has been established and is ready for use
+	/// - An existing channel has been spliced and is ready with the new funding output
 	ChannelReady {
  /// The `channel_id` of the channel.
  channel_id: ChannelId,
@@ -208,6 +212,14 @@ pub enum Event {
  ///
  /// This will be `None` for events serialized by LDK Node v0.1.0 and prior.
  counterparty_node_id: Option<PublicKey>,
+ /// The outpoint of the channel's funding transaction.
+ ///
+ /// This represents the channel's current funding output, which may change when the
+ /// channel is spliced. For spliced channels, this will contain the new funding output
+ /// from the confirmed splice transaction.
+ ///
+ /// This will be `None` for events serialized by LDK Node v0.6.0 and prior.
+ funding_txo: Option<OutPoint>,
 	},
 	/// A channel has been closed.
 	ChannelClosed {
@@ -222,6 +234,28 @@ pub enum Event {
  /// This will be `None` for events serialized by LDK Node v0.2.1 and prior.
  reason: Option<ClosureReason>,
 	},
+	/// A channel splice is pending confirmation on-chain.
+	SplicePending {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction.
+ new_funding_txo: OutPoint,
+	},
+	/// A channel splice has failed.
+	SpliceFailed {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction, if one was created.
+ abandoned_funding_txo: Option<OutPoint>,
+	},
 }
 
 impl_writeable_tlv_based_enum!(Event,
@@ -246,6 +280,7 @@ impl_writeable_tlv_based_enum!(Event,
  (0, channel_id, required),
  (1, counterparty_node_id, option),
  (2, user_channel_id, required),
+ (3, funding_txo, option),
 	},
 	(4, ChannelPending) => {
  (0, channel_id, required),
@@ -278,7 +313,19 @@ impl_writeable_tlv_based_enum!(Event,
  (10, skimmed_fee_msat, option),
  (12, claim_from_onchain_tx, required),
  (14, outbound_amount_forwarded_msat, option),
-	}
+	},
+	(8, SplicePending) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, new_funding_txo, required),
+	},
+	(9, SpliceFailed) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, abandoned_funding_txo, option),
+	},
 );
 
 pub struct EventQueue<L: Deref>
@@ -1397,14 +1444,28 @@ where
  }
  },
  LdkEvent::ChannelReady {
- channel_id, user_channel_id, counterparty_node_id, ..
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ funding_txo,
+ ..
  } => {
- log_info!(
- self.logger,
- "Channel {} with counterparty {} ready to be used.",
- channel_id,
- counterparty_node_id,
- );
+ if let Some(funding_txo) = funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
 
  if let Some(liquidity_source) = self.liquidity_source.as_ref() {
  liquidity_source
@@ -1416,6 +1477,7 @@ where
  channel_id,
  user_channel_id: UserChannelId(user_channel_id),
  counterparty_node_id: Some(counterparty_node_id),
+ funding_txo,
  };
  match self.event_queue.add_event(event).await {
  Ok(_) => {},
@@ -1614,20 +1676,116 @@ where
  }
  }
  },
- LdkEvent::FundingTransactionReadyForSigning { .. } => {
- debug_assert!(false, "We currently don't support interactive-tx, so this event should never be emitted.");
+ // TODO(splicing): Revisit error handling once splicing API is settled in LDK 0.3
+ LdkEvent::FundingTransactionReadyForSigning {
+ channel_id,
+ counterparty_node_id,
+ unsigned_transaction,
+ ..
+ } => match self.wallet.sign_owned_inputs(unsigned_transaction) {
+ Ok(partially_signed_tx) => {
+ match self.channel_manager.funding_transaction_signed(
+ &channel_id,
+ &counterparty_node_id,
+ partially_signed_tx,
+ ) {
+ Ok(()) => {
+ log_info!(
+ self.logger,
+ "Signed funding transaction for channel {} with counterparty {}",
+ channel_id,
+ counterparty_node_id
+ );
+ },
+ Err(e) => {
+ // TODO(splicing): Abort splice once supported in LDK 0.3
+ debug_assert!(false, "Failed signing funding transaction: {:?}", e);
+ log_error!(self.logger, "Failed signing funding transaction: {:?}", e);
+ },
+ }
+ },
+ Err(()) => log_error!(self.logger, "Failed signing funding transaction"),
  },
- LdkEvent::SplicePending { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
+ LdkEvent::SplicePending {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ new_funding_txo,
+ ..
+ } => {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} pending splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ new_funding_txo,
  );
+
+ let event = Event::SplicePending {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ new_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
- LdkEvent::SpliceFailed { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
- );
+ LdkEvent::SpliceFailed {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ abandoned_funding_txo,
+ contributed_outputs,
+ ..
+ } => {
+ if let Some(funding_txo) = abandoned_funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
+
+ let tx = bitcoin::Transaction {
+ version: bitcoin::transaction::Version::TWO,
+ lock_time: bitcoin::absolute::LockTime::ZERO,
+ input: vec![],
+ output: contributed_outputs,
+ };
+ if let Err(e) = self.wallet.cancel_tx(&tx) {
+ log_error!(self.logger, "Failed reclaiming unused addresses: {}", e);
+ return Err(ReplayEvent());
+ }
+
+ let event = Event::SpliceFailed {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ abandoned_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
  }
  Ok(())
@@ -1655,6 +1813,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
  event_queue.add_event(expected_event.clone()).await.unwrap();
 
@@ -1692,6 +1851,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
 
  // Check `next_event_async` won't return if the queue is empty and always rather timeout.

bindings/ldk_node.udl

@@ -150,6 +150,10 @@ interface Node {
 	[Throws=NodeError]
 	UserChannelId open_announced_channel(PublicKey node_id, SocketAddress address, u64 channel_amount_sats, u64? push_to_counterparty_msat, ChannelConfig? channel_config);
 	[Throws=NodeError]
+	void splice_in([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, u64 splice_amount_sats);
+	[Throws=NodeError]
+	void splice_out([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, [ByRef]Address address, u64 splice_amount_sats);
+	[Throws=NodeError]
 	void close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id);
 	[Throws=NodeError]
 	void force_close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, string? reason);
@@ -290,6 +294,7 @@ enum NodeError {
 	"ProbeSendingFailed",
 	"ChannelCreationFailed",
 	"ChannelClosingFailed",
+	"ChannelSplicingFailed",
 	"ChannelConfigUpdateFailed",
 	"PersistenceFailed",
 	"FeerateEstimationUpdateFailed",
@@ -393,8 +398,10 @@ interface Event {
 	PaymentForwarded(ChannelId prev_channel_id, ChannelId next_channel_id, UserChannelId?
 	prev_user_channel_id, UserChannelId? next_user_channel_id, PublicKey? prev_node_id, PublicKey? next_node_id, u64? total_fee_earned_msat, u64? skimmed_fee_msat, boolean claim_from_onchain_tx, u64? outbound_amount_forwarded_msat);
 	ChannelPending(ChannelId channel_id, UserChannelId user_channel_id, ChannelId former_temporary_channel_id, PublicKey counterparty_node_id, OutPoint funding_txo);
-	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id);
+	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, OutPoint? funding_txo);
 	ChannelClosed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, ClosureReason? reason);
+	SplicePending(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint new_funding_txo);
+	SpliceFailed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint? abandoned_funding_txo);
 };
 
 enum PaymentFailureReason {

src/builder.rs

@@ -1795,6 +1795,7 @@ fn build_with_store_internal(
  wallet,
  chain_source,
  tx_broadcaster,
+ fee_estimator,
  event_queue,
  channel_manager,
  chain_monitor,

src/config.rs

@@ -325,6 +325,7 @@ pub(crate) fn default_user_config(config: &Config) -> UserConfig {
 	user_config.manually_accept_inbound_channels = true;
 	user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx =
  config.anchor_channels_config.is_some();
+	user_config.reject_inbound_splices = false;
 
 	if may_announce_channel(config).is_err() {
  user_config.accept_forwards_to_priv_channels = false;

src/error.rs

@@ -43,6 +43,8 @@ pub enum Error {
 	ChannelCreationFailed,
 	/// A channel could not be closed.
 	ChannelClosingFailed,
+	/// A channel could not be spliced.
+	ChannelSplicingFailed,
 	/// A channel configuration could not be updated.
 	ChannelConfigUpdateFailed,
 	/// Persistence failed.
@@ -145,6 +147,7 @@ impl fmt::Display for Error {
  Self::ProbeSendingFailed => write!(f, "Failed to send the given payment probe."),
  Self::ChannelCreationFailed => write!(f, "Failed to create channel."),
  Self::ChannelClosingFailed => write!(f, "Failed to close channel."),
+ Self::ChannelSplicingFailed => write!(f, "Failed to splice channel."),
  Self::ChannelConfigUpdateFailed => write!(f, "Failed to update channel config."),
  Self::PersistenceFailed => write!(f, "Failed to persist data."),
  Self::FeerateEstimationUpdateFailed => {

src/event.rs

@@ -199,6 +199,10 @@ pub enum Event {
  funding_txo: OutPoint,
 	},
 	/// A channel is ready to be used.
+	///
+	/// This event is emitted when:
+	/// - A new channel has been established and is ready for use
+	/// - An existing channel has been spliced and is ready with the new funding output
 	ChannelReady {
  /// The `channel_id` of the channel.
  channel_id: ChannelId,
@@ -208,6 +212,14 @@ pub enum Event {
  ///
  /// This will be `None` for events serialized by LDK Node v0.1.0 and prior.
  counterparty_node_id: Option<PublicKey>,
+ /// The outpoint of the channel's funding transaction.
+ ///
+ /// This represents the channel's current funding output, which may change when the
+ /// channel is spliced. For spliced channels, this will contain the new funding output
+ /// from the confirmed splice transaction.
+ ///
+ /// This will be `None` for events serialized by LDK Node v0.6.0 and prior.
+ funding_txo: Option<OutPoint>,
 	},
 	/// A channel has been closed.
 	ChannelClosed {
@@ -222,6 +234,28 @@ pub enum Event {
  /// This will be `None` for events serialized by LDK Node v0.2.1 and prior.
  reason: Option<ClosureReason>,
 	},
+	/// A channel splice is pending confirmation on-chain.
+	SplicePending {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction.
+ new_funding_txo: OutPoint,
+	},
+	/// A channel splice has failed.
+	SpliceFailed {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction, if one was created.
+ abandoned_funding_txo: Option<OutPoint>,
+	},
 }
 
 impl_writeable_tlv_based_enum!(Event,
@@ -246,6 +280,7 @@ impl_writeable_tlv_based_enum!(Event,
  (0, channel_id, required),
  (1, counterparty_node_id, option),
  (2, user_channel_id, required),
+ (3, funding_txo, option),
 	},
 	(4, ChannelPending) => {
  (0, channel_id, required),
@@ -278,7 +313,19 @@ impl_writeable_tlv_based_enum!(Event,
  (10, skimmed_fee_msat, option),
  (12, claim_from_onchain_tx, required),
  (14, outbound_amount_forwarded_msat, option),
-	}
+	},
+	(8, SplicePending) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, new_funding_txo, required),
+	},
+	(9, SpliceFailed) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, abandoned_funding_txo, option),
+	},
 );
 
 pub struct EventQueue<L: Deref>
@@ -1397,14 +1444,28 @@ where
  }
  },
  LdkEvent::ChannelReady {
- channel_id, user_channel_id, counterparty_node_id, ..
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ funding_txo,
+ ..
  } => {
- log_info!(
- self.logger,
- "Channel {} with counterparty {} ready to be used.",
- channel_id,
- counterparty_node_id,
- );
+ if let Some(funding_txo) = funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
 
  if let Some(liquidity_source) = self.liquidity_source.as_ref() {
  liquidity_source
@@ -1416,6 +1477,7 @@ where
  channel_id,
  user_channel_id: UserChannelId(user_channel_id),
  counterparty_node_id: Some(counterparty_node_id),
+ funding_txo,
  };
  match self.event_queue.add_event(event).await {
  Ok(_) => {},
@@ -1614,20 +1676,116 @@ where
  }
  }
  },
- LdkEvent::FundingTransactionReadyForSigning { .. } => {
- debug_assert!(false, "We currently don't support interactive-tx, so this event should never be emitted.");
+ // TODO(splicing): Revisit error handling once splicing API is settled in LDK 0.3
+ LdkEvent::FundingTransactionReadyForSigning {
+ channel_id,
+ counterparty_node_id,
+ unsigned_transaction,
+ ..
+ } => match self.wallet.sign_owned_inputs(unsigned_transaction) {
+ Ok(partially_signed_tx) => {
+ match self.channel_manager.funding_transaction_signed(
+ &channel_id,
+ &counterparty_node_id,
+ partially_signed_tx,
+ ) {
+ Ok(()) => {
+ log_info!(
+ self.logger,
+ "Signed funding transaction for channel {} with counterparty {}",
+ channel_id,
+ counterparty_node_id
+ );
+ },
+ Err(e) => {
+ // TODO(splicing): Abort splice once supported in LDK 0.3
+ debug_assert!(false, "Failed signing funding transaction: {:?}", e);
+ log_error!(self.logger, "Failed signing funding transaction: {:?}", e);
+ },
+ }
+ },
+ Err(()) => log_error!(self.logger, "Failed signing funding transaction"),
  },
- LdkEvent::SplicePending { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
+ LdkEvent::SplicePending {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ new_funding_txo,
+ ..
+ } => {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} pending splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ new_funding_txo,
  );
+
+ let event = Event::SplicePending {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ new_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
- LdkEvent::SpliceFailed { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
- );
+ LdkEvent::SpliceFailed {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ abandoned_funding_txo,
+ contributed_outputs,
+ ..
+ } => {
+ if let Some(funding_txo) = abandoned_funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
+
+ let tx = bitcoin::Transaction {
+ version: bitcoin::transaction::Version::TWO,
+ lock_time: bitcoin::absolute::LockTime::ZERO,
+ input: vec![],
+ output: contributed_outputs,
+ };
+ if let Err(e) = self.wallet.cancel_tx(&tx) {
+ log_error!(self.logger, "Failed reclaiming unused addresses: {}", e);
+ return Err(ReplayEvent());
+ }
+
+ let event = Event::SpliceFailed {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ abandoned_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
  }
  Ok(())
@@ -1655,6 +1813,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
  event_queue.add_event(expected_event.clone()).await.unwrap();
 
@@ -1692,6 +1851,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
 
  // Check `next_event_async` won't return if the queue is empty and always rather timeout.

bindings/ldk_node.udl

@@ -150,6 +150,10 @@ interface Node {
 	[Throws=NodeError]
 	UserChannelId open_announced_channel(PublicKey node_id, SocketAddress address, u64 channel_amount_sats, u64? push_to_counterparty_msat, ChannelConfig? channel_config);
 	[Throws=NodeError]
+	void splice_in([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, u64 splice_amount_sats);
+	[Throws=NodeError]
+	void splice_out([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, [ByRef]Address address, u64 splice_amount_sats);
+	[Throws=NodeError]
 	void close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id);
 	[Throws=NodeError]
 	void force_close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, string? reason);
@@ -290,6 +294,7 @@ enum NodeError {
 	"ProbeSendingFailed",
 	"ChannelCreationFailed",
 	"ChannelClosingFailed",
+	"ChannelSplicingFailed",
 	"ChannelConfigUpdateFailed",
 	"PersistenceFailed",
 	"FeerateEstimationUpdateFailed",
@@ -393,8 +398,10 @@ interface Event {
 	PaymentForwarded(ChannelId prev_channel_id, ChannelId next_channel_id, UserChannelId?
 	prev_user_channel_id, UserChannelId? next_user_channel_id, PublicKey? prev_node_id, PublicKey? next_node_id, u64? total_fee_earned_msat, u64? skimmed_fee_msat, boolean claim_from_onchain_tx, u64? outbound_amount_forwarded_msat);
 	ChannelPending(ChannelId channel_id, UserChannelId user_channel_id, ChannelId former_temporary_channel_id, PublicKey counterparty_node_id, OutPoint funding_txo);
-	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id);
+	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, OutPoint? funding_txo);
 	ChannelClosed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, ClosureReason? reason);
+	SplicePending(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint new_funding_txo);
+	SpliceFailed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint? abandoned_funding_txo);
 };
 
 enum PaymentFailureReason {

src/builder.rs

@@ -1795,6 +1795,7 @@ fn build_with_store_internal(
  wallet,
  chain_source,
  tx_broadcaster,
+ fee_estimator,
  event_queue,
  channel_manager,
  chain_monitor,

src/config.rs

@@ -325,6 +325,7 @@ pub(crate) fn default_user_config(config: &Config) -> UserConfig {
 	user_config.manually_accept_inbound_channels = true;
 	user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx =
  config.anchor_channels_config.is_some();
+	user_config.reject_inbound_splices = false;
 
 	if may_announce_channel(config).is_err() {
  user_config.accept_forwards_to_priv_channels = false;

src/error.rs

@@ -43,6 +43,8 @@ pub enum Error {
 	ChannelCreationFailed,
 	/// A channel could not be closed.
 	ChannelClosingFailed,
+	/// A channel could not be spliced.
+	ChannelSplicingFailed,
 	/// A channel configuration could not be updated.
 	ChannelConfigUpdateFailed,
 	/// Persistence failed.
@@ -145,6 +147,7 @@ impl fmt::Display for Error {
  Self::ProbeSendingFailed => write!(f, "Failed to send the given payment probe."),
  Self::ChannelCreationFailed => write!(f, "Failed to create channel."),
  Self::ChannelClosingFailed => write!(f, "Failed to close channel."),
+ Self::ChannelSplicingFailed => write!(f, "Failed to splice channel."),
  Self::ChannelConfigUpdateFailed => write!(f, "Failed to update channel config."),
  Self::PersistenceFailed => write!(f, "Failed to persist data."),
  Self::FeerateEstimationUpdateFailed => {

src/event.rs

@@ -199,6 +199,10 @@ pub enum Event {
  funding_txo: OutPoint,
 	},
 	/// A channel is ready to be used.
+	///
+	/// This event is emitted when:
+	/// - A new channel has been established and is ready for use
+	/// - An existing channel has been spliced and is ready with the new funding output
 	ChannelReady {
  /// The `channel_id` of the channel.
  channel_id: ChannelId,
@@ -208,6 +212,14 @@ pub enum Event {
  ///
  /// This will be `None` for events serialized by LDK Node v0.1.0 and prior.
  counterparty_node_id: Option<PublicKey>,
+ /// The outpoint of the channel's funding transaction.
+ ///
+ /// This represents the channel's current funding output, which may change when the
+ /// channel is spliced. For spliced channels, this will contain the new funding output
+ /// from the confirmed splice transaction.
+ ///
+ /// This will be `None` for events serialized by LDK Node v0.6.0 and prior.
+ funding_txo: Option<OutPoint>,
 	},
 	/// A channel has been closed.
 	ChannelClosed {
@@ -222,6 +234,28 @@ pub enum Event {
  /// This will be `None` for events serialized by LDK Node v0.2.1 and prior.
  reason: Option<ClosureReason>,
 	},
+	/// A channel splice is pending confirmation on-chain.
+	SplicePending {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction.
+ new_funding_txo: OutPoint,
+	},
+	/// A channel splice has failed.
+	SpliceFailed {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction, if one was created.
+ abandoned_funding_txo: Option<OutPoint>,
+	},
 }
 
 impl_writeable_tlv_based_enum!(Event,
@@ -246,6 +280,7 @@ impl_writeable_tlv_based_enum!(Event,
  (0, channel_id, required),
  (1, counterparty_node_id, option),
  (2, user_channel_id, required),
+ (3, funding_txo, option),
 	},
 	(4, ChannelPending) => {
  (0, channel_id, required),
@@ -278,7 +313,19 @@ impl_writeable_tlv_based_enum!(Event,
  (10, skimmed_fee_msat, option),
  (12, claim_from_onchain_tx, required),
  (14, outbound_amount_forwarded_msat, option),
-	}
+	},
+	(8, SplicePending) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, new_funding_txo, required),
+	},
+	(9, SpliceFailed) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, abandoned_funding_txo, option),
+	},
 );
 
 pub struct EventQueue<L: Deref>
@@ -1397,14 +1444,28 @@ where
  }
  },
  LdkEvent::ChannelReady {
- channel_id, user_channel_id, counterparty_node_id, ..
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ funding_txo,
+ ..
  } => {
- log_info!(
- self.logger,
- "Channel {} with counterparty {} ready to be used.",
- channel_id,
- counterparty_node_id,
- );
+ if let Some(funding_txo) = funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
 
  if let Some(liquidity_source) = self.liquidity_source.as_ref() {
  liquidity_source
@@ -1416,6 +1477,7 @@ where
  channel_id,
  user_channel_id: UserChannelId(user_channel_id),
  counterparty_node_id: Some(counterparty_node_id),
+ funding_txo,
  };
  match self.event_queue.add_event(event).await {
  Ok(_) => {},
@@ -1614,20 +1676,116 @@ where
  }
  }
  },
- LdkEvent::FundingTransactionReadyForSigning { .. } => {
- debug_assert!(false, "We currently don't support interactive-tx, so this event should never be emitted.");
+ // TODO(splicing): Revisit error handling once splicing API is settled in LDK 0.3
+ LdkEvent::FundingTransactionReadyForSigning {
+ channel_id,
+ counterparty_node_id,
+ unsigned_transaction,
+ ..
+ } => match self.wallet.sign_owned_inputs(unsigned_transaction) {
+ Ok(partially_signed_tx) => {
+ match self.channel_manager.funding_transaction_signed(
+ &channel_id,
+ &counterparty_node_id,
+ partially_signed_tx,
+ ) {
+ Ok(()) => {
+ log_info!(
+ self.logger,
+ "Signed funding transaction for channel {} with counterparty {}",
+ channel_id,
+ counterparty_node_id
+ );
+ },
+ Err(e) => {
+ // TODO(splicing): Abort splice once supported in LDK 0.3
+ debug_assert!(false, "Failed signing funding transaction: {:?}", e);
+ log_error!(self.logger, "Failed signing funding transaction: {:?}", e);
+ },
+ }
+ },
+ Err(()) => log_error!(self.logger, "Failed signing funding transaction"),
  },
- LdkEvent::SplicePending { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
+ LdkEvent::SplicePending {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ new_funding_txo,
+ ..
+ } => {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} pending splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ new_funding_txo,
  );
+
+ let event = Event::SplicePending {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ new_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
- LdkEvent::SpliceFailed { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
- );
+ LdkEvent::SpliceFailed {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ abandoned_funding_txo,
+ contributed_outputs,
+ ..
+ } => {
+ if let Some(funding_txo) = abandoned_funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
+
+ let tx = bitcoin::Transaction {
+ version: bitcoin::transaction::Version::TWO,
+ lock_time: bitcoin::absolute::LockTime::ZERO,
+ input: vec![],
+ output: contributed_outputs,
+ };
+ if let Err(e) = self.wallet.cancel_tx(&tx) {
+ log_error!(self.logger, "Failed reclaiming unused addresses: {}", e);
+ return Err(ReplayEvent());
+ }
+
+ let event = Event::SpliceFailed {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ abandoned_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
  }
  Ok(())
@@ -1655,6 +1813,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
  event_queue.add_event(expected_event.clone()).await.unwrap();
 
@@ -1692,6 +1851,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
 
  // Check `next_event_async` won't return if the queue is empty and always rather timeout.

bindings/ldk_node.udl

@@ -150,6 +150,10 @@ interface Node {
 	[Throws=NodeError]
 	UserChannelId open_announced_channel(PublicKey node_id, SocketAddress address, u64 channel_amount_sats, u64? push_to_counterparty_msat, ChannelConfig? channel_config);
 	[Throws=NodeError]
+	void splice_in([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, u64 splice_amount_sats);
+	[Throws=NodeError]
+	void splice_out([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, [ByRef]Address address, u64 splice_amount_sats);
+	[Throws=NodeError]
 	void close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id);
 	[Throws=NodeError]
 	void force_close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, string? reason);
@@ -290,6 +294,7 @@ enum NodeError {
 	"ProbeSendingFailed",
 	"ChannelCreationFailed",
 	"ChannelClosingFailed",
+	"ChannelSplicingFailed",
 	"ChannelConfigUpdateFailed",
 	"PersistenceFailed",
 	"FeerateEstimationUpdateFailed",
@@ -393,8 +398,10 @@ interface Event {
 	PaymentForwarded(ChannelId prev_channel_id, ChannelId next_channel_id, UserChannelId?
 	prev_user_channel_id, UserChannelId? next_user_channel_id, PublicKey? prev_node_id, PublicKey? next_node_id, u64? total_fee_earned_msat, u64? skimmed_fee_msat, boolean claim_from_onchain_tx, u64? outbound_amount_forwarded_msat);
 	ChannelPending(ChannelId channel_id, UserChannelId user_channel_id, ChannelId former_temporary_channel_id, PublicKey counterparty_node_id, OutPoint funding_txo);
-	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id);
+	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, OutPoint? funding_txo);
 	ChannelClosed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, ClosureReason? reason);
+	SplicePending(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint new_funding_txo);
+	SpliceFailed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint? abandoned_funding_txo);
 };
 
 enum PaymentFailureReason {

src/builder.rs

@@ -1795,6 +1795,7 @@ fn build_with_store_internal(
  wallet,
  chain_source,
  tx_broadcaster,
+ fee_estimator,
  event_queue,
  channel_manager,
  chain_monitor,

src/config.rs

@@ -325,6 +325,7 @@ pub(crate) fn default_user_config(config: &Config) -> UserConfig {
 	user_config.manually_accept_inbound_channels = true;
 	user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx =
  config.anchor_channels_config.is_some();
+	user_config.reject_inbound_splices = false;
 
 	if may_announce_channel(config).is_err() {
  user_config.accept_forwards_to_priv_channels = false;

src/error.rs

@@ -43,6 +43,8 @@ pub enum Error {
 	ChannelCreationFailed,
 	/// A channel could not be closed.
 	ChannelClosingFailed,
+	/// A channel could not be spliced.
+	ChannelSplicingFailed,
 	/// A channel configuration could not be updated.
 	ChannelConfigUpdateFailed,
 	/// Persistence failed.
@@ -145,6 +147,7 @@ impl fmt::Display for Error {
  Self::ProbeSendingFailed => write!(f, "Failed to send the given payment probe."),
  Self::ChannelCreationFailed => write!(f, "Failed to create channel."),
  Self::ChannelClosingFailed => write!(f, "Failed to close channel."),
+ Self::ChannelSplicingFailed => write!(f, "Failed to splice channel."),
  Self::ChannelConfigUpdateFailed => write!(f, "Failed to update channel config."),
  Self::PersistenceFailed => write!(f, "Failed to persist data."),
  Self::FeerateEstimationUpdateFailed => {

src/event.rs

@@ -199,6 +199,10 @@ pub enum Event {
  funding_txo: OutPoint,
 	},
 	/// A channel is ready to be used.
+	///
+	/// This event is emitted when:
+	/// - A new channel has been established and is ready for use
+	/// - An existing channel has been spliced and is ready with the new funding output
 	ChannelReady {
  /// The `channel_id` of the channel.
  channel_id: ChannelId,
@@ -208,6 +212,14 @@ pub enum Event {
  ///
  /// This will be `None` for events serialized by LDK Node v0.1.0 and prior.
  counterparty_node_id: Option<PublicKey>,
+ /// The outpoint of the channel's funding transaction.
+ ///
+ /// This represents the channel's current funding output, which may change when the
+ /// channel is spliced. For spliced channels, this will contain the new funding output
+ /// from the confirmed splice transaction.
+ ///
+ /// This will be `None` for events serialized by LDK Node v0.6.0 and prior.
+ funding_txo: Option<OutPoint>,
 	},
 	/// A channel has been closed.
 	ChannelClosed {
@@ -222,6 +234,28 @@ pub enum Event {
  /// This will be `None` for events serialized by LDK Node v0.2.1 and prior.
  reason: Option<ClosureReason>,
 	},
+	/// A channel splice is pending confirmation on-chain.
+	SplicePending {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction.
+ new_funding_txo: OutPoint,
+	},
+	/// A channel splice has failed.
+	SpliceFailed {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction, if one was created.
+ abandoned_funding_txo: Option<OutPoint>,
+	},
 }
 
 impl_writeable_tlv_based_enum!(Event,
@@ -246,6 +280,7 @@ impl_writeable_tlv_based_enum!(Event,
  (0, channel_id, required),
  (1, counterparty_node_id, option),
  (2, user_channel_id, required),
+ (3, funding_txo, option),
 	},
 	(4, ChannelPending) => {
  (0, channel_id, required),
@@ -278,7 +313,19 @@ impl_writeable_tlv_based_enum!(Event,
  (10, skimmed_fee_msat, option),
  (12, claim_from_onchain_tx, required),
  (14, outbound_amount_forwarded_msat, option),
-	}
+	},
+	(8, SplicePending) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, new_funding_txo, required),
+	},
+	(9, SpliceFailed) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, abandoned_funding_txo, option),
+	},
 );
 
 pub struct EventQueue<L: Deref>
@@ -1397,14 +1444,28 @@ where
  }
  },
  LdkEvent::ChannelReady {
- channel_id, user_channel_id, counterparty_node_id, ..
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ funding_txo,
+ ..
  } => {
- log_info!(
- self.logger,
- "Channel {} with counterparty {} ready to be used.",
- channel_id,
- counterparty_node_id,
- );
+ if let Some(funding_txo) = funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
 
  if let Some(liquidity_source) = self.liquidity_source.as_ref() {
  liquidity_source
@@ -1416,6 +1477,7 @@ where
  channel_id,
  user_channel_id: UserChannelId(user_channel_id),
  counterparty_node_id: Some(counterparty_node_id),
+ funding_txo,
  };
  match self.event_queue.add_event(event).await {
  Ok(_) => {},
@@ -1614,20 +1676,116 @@ where
  }
  }
  },
- LdkEvent::FundingTransactionReadyForSigning { .. } => {
- debug_assert!(false, "We currently don't support interactive-tx, so this event should never be emitted.");
+ // TODO(splicing): Revisit error handling once splicing API is settled in LDK 0.3
+ LdkEvent::FundingTransactionReadyForSigning {
+ channel_id,
+ counterparty_node_id,
+ unsigned_transaction,
+ ..
+ } => match self.wallet.sign_owned_inputs(unsigned_transaction) {
+ Ok(partially_signed_tx) => {
+ match self.channel_manager.funding_transaction_signed(
+ &channel_id,
+ &counterparty_node_id,
+ partially_signed_tx,
+ ) {
+ Ok(()) => {
+ log_info!(
+ self.logger,
+ "Signed funding transaction for channel {} with counterparty {}",
+ channel_id,
+ counterparty_node_id
+ );
+ },
+ Err(e) => {
+ // TODO(splicing): Abort splice once supported in LDK 0.3
+ debug_assert!(false, "Failed signing funding transaction: {:?}", e);
+ log_error!(self.logger, "Failed signing funding transaction: {:?}", e);
+ },
+ }
+ },
+ Err(()) => log_error!(self.logger, "Failed signing funding transaction"),
  },
- LdkEvent::SplicePending { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
+ LdkEvent::SplicePending {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ new_funding_txo,
+ ..
+ } => {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} pending splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ new_funding_txo,
  );
+
+ let event = Event::SplicePending {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ new_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
- LdkEvent::SpliceFailed { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
- );
+ LdkEvent::SpliceFailed {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ abandoned_funding_txo,
+ contributed_outputs,
+ ..
+ } => {
+ if let Some(funding_txo) = abandoned_funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
+
+ let tx = bitcoin::Transaction {
+ version: bitcoin::transaction::Version::TWO,
+ lock_time: bitcoin::absolute::LockTime::ZERO,
+ input: vec![],
+ output: contributed_outputs,
+ };
+ if let Err(e) = self.wallet.cancel_tx(&tx) {
+ log_error!(self.logger, "Failed reclaiming unused addresses: {}", e);
+ return Err(ReplayEvent());
+ }
+
+ let event = Event::SpliceFailed {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ abandoned_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
  }
  Ok(())
@@ -1655,6 +1813,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
  event_queue.add_event(expected_event.clone()).await.unwrap();
 
@@ -1692,6 +1851,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
 
  // Check `next_event_async` won't return if the queue is empty and always rather timeout.

bindings/ldk_node.udl

@@ -150,6 +150,10 @@ interface Node {
 	[Throws=NodeError]
 	UserChannelId open_announced_channel(PublicKey node_id, SocketAddress address, u64 channel_amount_sats, u64? push_to_counterparty_msat, ChannelConfig? channel_config);
 	[Throws=NodeError]
+	void splice_in([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, u64 splice_amount_sats);
+	[Throws=NodeError]
+	void splice_out([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, [ByRef]Address address, u64 splice_amount_sats);
+	[Throws=NodeError]
 	void close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id);
 	[Throws=NodeError]
 	void force_close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, string? reason);
@@ -290,6 +294,7 @@ enum NodeError {
 	"ProbeSendingFailed",
 	"ChannelCreationFailed",
 	"ChannelClosingFailed",
+	"ChannelSplicingFailed",
 	"ChannelConfigUpdateFailed",
 	"PersistenceFailed",
 	"FeerateEstimationUpdateFailed",
@@ -393,8 +398,10 @@ interface Event {
 	PaymentForwarded(ChannelId prev_channel_id, ChannelId next_channel_id, UserChannelId?
 	prev_user_channel_id, UserChannelId? next_user_channel_id, PublicKey? prev_node_id, PublicKey? next_node_id, u64? total_fee_earned_msat, u64? skimmed_fee_msat, boolean claim_from_onchain_tx, u64? outbound_amount_forwarded_msat);
 	ChannelPending(ChannelId channel_id, UserChannelId user_channel_id, ChannelId former_temporary_channel_id, PublicKey counterparty_node_id, OutPoint funding_txo);
-	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id);
+	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, OutPoint? funding_txo);
 	ChannelClosed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, ClosureReason? reason);
+	SplicePending(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint new_funding_txo);
+	SpliceFailed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint? abandoned_funding_txo);
 };
 
 enum PaymentFailureReason {

src/builder.rs

@@ -1795,6 +1795,7 @@ fn build_with_store_internal(
  wallet,
  chain_source,
  tx_broadcaster,
+ fee_estimator,
  event_queue,
  channel_manager,
  chain_monitor,

src/config.rs

@@ -325,6 +325,7 @@ pub(crate) fn default_user_config(config: &Config) -> UserConfig {
 	user_config.manually_accept_inbound_channels = true;
 	user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx =
  config.anchor_channels_config.is_some();
+	user_config.reject_inbound_splices = false;
 
 	if may_announce_channel(config).is_err() {
  user_config.accept_forwards_to_priv_channels = false;

src/error.rs

@@ -43,6 +43,8 @@ pub enum Error {
 	ChannelCreationFailed,
 	/// A channel could not be closed.
 	ChannelClosingFailed,
+	/// A channel could not be spliced.
+	ChannelSplicingFailed,
 	/// A channel configuration could not be updated.
 	ChannelConfigUpdateFailed,
 	/// Persistence failed.
@@ -145,6 +147,7 @@ impl fmt::Display for Error {
  Self::ProbeSendingFailed => write!(f, "Failed to send the given payment probe."),
  Self::ChannelCreationFailed => write!(f, "Failed to create channel."),
  Self::ChannelClosingFailed => write!(f, "Failed to close channel."),
+ Self::ChannelSplicingFailed => write!(f, "Failed to splice channel."),
  Self::ChannelConfigUpdateFailed => write!(f, "Failed to update channel config."),
  Self::PersistenceFailed => write!(f, "Failed to persist data."),
  Self::FeerateEstimationUpdateFailed => {

src/event.rs

@@ -199,6 +199,10 @@ pub enum Event {
  funding_txo: OutPoint,
 	},
 	/// A channel is ready to be used.
+	///
+	/// This event is emitted when:
+	/// - A new channel has been established and is ready for use
+	/// - An existing channel has been spliced and is ready with the new funding output
 	ChannelReady {
  /// The `channel_id` of the channel.
  channel_id: ChannelId,
@@ -208,6 +212,14 @@ pub enum Event {
  ///
  /// This will be `None` for events serialized by LDK Node v0.1.0 and prior.
  counterparty_node_id: Option<PublicKey>,
+ /// The outpoint of the channel's funding transaction.
+ ///
+ /// This represents the channel's current funding output, which may change when the
+ /// channel is spliced. For spliced channels, this will contain the new funding output
+ /// from the confirmed splice transaction.
+ ///
+ /// This will be `None` for events serialized by LDK Node v0.6.0 and prior.
+ funding_txo: Option<OutPoint>,
 	},
 	/// A channel has been closed.
 	ChannelClosed {
@@ -222,6 +234,28 @@ pub enum Event {
  /// This will be `None` for events serialized by LDK Node v0.2.1 and prior.
  reason: Option<ClosureReason>,
 	},
+	/// A channel splice is pending confirmation on-chain.
+	SplicePending {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction.
+ new_funding_txo: OutPoint,
+	},
+	/// A channel splice has failed.
+	SpliceFailed {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction, if one was created.
+ abandoned_funding_txo: Option<OutPoint>,
+	},
 }
 
 impl_writeable_tlv_based_enum!(Event,
@@ -246,6 +280,7 @@ impl_writeable_tlv_based_enum!(Event,
  (0, channel_id, required),
  (1, counterparty_node_id, option),
  (2, user_channel_id, required),
+ (3, funding_txo, option),
 	},
 	(4, ChannelPending) => {
  (0, channel_id, required),
@@ -278,7 +313,19 @@ impl_writeable_tlv_based_enum!(Event,
  (10, skimmed_fee_msat, option),
  (12, claim_from_onchain_tx, required),
  (14, outbound_amount_forwarded_msat, option),
-	}
+	},
+	(8, SplicePending) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, new_funding_txo, required),
+	},
+	(9, SpliceFailed) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, abandoned_funding_txo, option),
+	},
 );
 
 pub struct EventQueue<L: Deref>
@@ -1397,14 +1444,28 @@ where
  }
  },
  LdkEvent::ChannelReady {
- channel_id, user_channel_id, counterparty_node_id, ..
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ funding_txo,
+ ..
  } => {
- log_info!(
- self.logger,
- "Channel {} with counterparty {} ready to be used.",
- channel_id,
- counterparty_node_id,
- );
+ if let Some(funding_txo) = funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
 
  if let Some(liquidity_source) = self.liquidity_source.as_ref() {
  liquidity_source
@@ -1416,6 +1477,7 @@ where
  channel_id,
  user_channel_id: UserChannelId(user_channel_id),
  counterparty_node_id: Some(counterparty_node_id),
+ funding_txo,
  };
  match self.event_queue.add_event(event).await {
  Ok(_) => {},
@@ -1614,20 +1676,116 @@ where
  }
  }
  },
- LdkEvent::FundingTransactionReadyForSigning { .. } => {
- debug_assert!(false, "We currently don't support interactive-tx, so this event should never be emitted.");
+ // TODO(splicing): Revisit error handling once splicing API is settled in LDK 0.3
+ LdkEvent::FundingTransactionReadyForSigning {
+ channel_id,
+ counterparty_node_id,
+ unsigned_transaction,
+ ..
+ } => match self.wallet.sign_owned_inputs(unsigned_transaction) {
+ Ok(partially_signed_tx) => {
+ match self.channel_manager.funding_transaction_signed(
+ &channel_id,
+ &counterparty_node_id,
+ partially_signed_tx,
+ ) {
+ Ok(()) => {
+ log_info!(
+ self.logger,
+ "Signed funding transaction for channel {} with counterparty {}",
+ channel_id,
+ counterparty_node_id
+ );
+ },
+ Err(e) => {
+ // TODO(splicing): Abort splice once supported in LDK 0.3
+ debug_assert!(false, "Failed signing funding transaction: {:?}", e);
+ log_error!(self.logger, "Failed signing funding transaction: {:?}", e);
+ },
+ }
+ },
+ Err(()) => log_error!(self.logger, "Failed signing funding transaction"),
  },
- LdkEvent::SplicePending { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
+ LdkEvent::SplicePending {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ new_funding_txo,
+ ..
+ } => {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} pending splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ new_funding_txo,
  );
+
+ let event = Event::SplicePending {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ new_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
- LdkEvent::SpliceFailed { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
- );
+ LdkEvent::SpliceFailed {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ abandoned_funding_txo,
+ contributed_outputs,
+ ..
+ } => {
+ if let Some(funding_txo) = abandoned_funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
+
+ let tx = bitcoin::Transaction {
+ version: bitcoin::transaction::Version::TWO,
+ lock_time: bitcoin::absolute::LockTime::ZERO,
+ input: vec![],
+ output: contributed_outputs,
+ };
+ if let Err(e) = self.wallet.cancel_tx(&tx) {
+ log_error!(self.logger, "Failed reclaiming unused addresses: {}", e);
+ return Err(ReplayEvent());
+ }
+
+ let event = Event::SpliceFailed {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ abandoned_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
  }
  Ok(())
@@ -1655,6 +1813,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
  event_queue.add_event(expected_event.clone()).await.unwrap();
 
@@ -1692,6 +1851,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
 
  // Check `next_event_async` won't return if the queue is empty and always rather timeout.

bindings/ldk_node.udl

@@ -150,6 +150,10 @@ interface Node {
 	[Throws=NodeError]
 	UserChannelId open_announced_channel(PublicKey node_id, SocketAddress address, u64 channel_amount_sats, u64? push_to_counterparty_msat, ChannelConfig? channel_config);
 	[Throws=NodeError]
+	void splice_in([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, u64 splice_amount_sats);
+	[Throws=NodeError]
+	void splice_out([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, [ByRef]Address address, u64 splice_amount_sats);
+	[Throws=NodeError]
 	void close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id);
 	[Throws=NodeError]
 	void force_close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, string? reason);
@@ -290,6 +294,7 @@ enum NodeError {
 	"ProbeSendingFailed",
 	"ChannelCreationFailed",
 	"ChannelClosingFailed",
+	"ChannelSplicingFailed",
 	"ChannelConfigUpdateFailed",
 	"PersistenceFailed",
 	"FeerateEstimationUpdateFailed",
@@ -393,8 +398,10 @@ interface Event {
 	PaymentForwarded(ChannelId prev_channel_id, ChannelId next_channel_id, UserChannelId?
 	prev_user_channel_id, UserChannelId? next_user_channel_id, PublicKey? prev_node_id, PublicKey? next_node_id, u64? total_fee_earned_msat, u64? skimmed_fee_msat, boolean claim_from_onchain_tx, u64? outbound_amount_forwarded_msat);
 	ChannelPending(ChannelId channel_id, UserChannelId user_channel_id, ChannelId former_temporary_channel_id, PublicKey counterparty_node_id, OutPoint funding_txo);
-	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id);
+	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, OutPoint? funding_txo);
 	ChannelClosed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, ClosureReason? reason);
+	SplicePending(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint new_funding_txo);
+	SpliceFailed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint? abandoned_funding_txo);
 };
 
 enum PaymentFailureReason {

src/builder.rs

@@ -1795,6 +1795,7 @@ fn build_with_store_internal(
  wallet,
  chain_source,
  tx_broadcaster,
+ fee_estimator,
  event_queue,
  channel_manager,
  chain_monitor,

src/config.rs

@@ -325,6 +325,7 @@ pub(crate) fn default_user_config(config: &Config) -> UserConfig {
 	user_config.manually_accept_inbound_channels = true;
 	user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx =
  config.anchor_channels_config.is_some();
+	user_config.reject_inbound_splices = false;
 
 	if may_announce_channel(config).is_err() {
  user_config.accept_forwards_to_priv_channels = false;

src/error.rs

@@ -43,6 +43,8 @@ pub enum Error {
 	ChannelCreationFailed,
 	/// A channel could not be closed.
 	ChannelClosingFailed,
+	/// A channel could not be spliced.
+	ChannelSplicingFailed,
 	/// A channel configuration could not be updated.
 	ChannelConfigUpdateFailed,
 	/// Persistence failed.
@@ -145,6 +147,7 @@ impl fmt::Display for Error {
  Self::ProbeSendingFailed => write!(f, "Failed to send the given payment probe."),
  Self::ChannelCreationFailed => write!(f, "Failed to create channel."),
  Self::ChannelClosingFailed => write!(f, "Failed to close channel."),
+ Self::ChannelSplicingFailed => write!(f, "Failed to splice channel."),
  Self::ChannelConfigUpdateFailed => write!(f, "Failed to update channel config."),
  Self::PersistenceFailed => write!(f, "Failed to persist data."),
  Self::FeerateEstimationUpdateFailed => {

src/event.rs

@@ -199,6 +199,10 @@ pub enum Event {
  funding_txo: OutPoint,
 	},
 	/// A channel is ready to be used.
+	///
+	/// This event is emitted when:
+	/// - A new channel has been established and is ready for use
+	/// - An existing channel has been spliced and is ready with the new funding output
 	ChannelReady {
  /// The `channel_id` of the channel.
  channel_id: ChannelId,
@@ -208,6 +212,14 @@ pub enum Event {
  ///
  /// This will be `None` for events serialized by LDK Node v0.1.0 and prior.
  counterparty_node_id: Option<PublicKey>,
+ /// The outpoint of the channel's funding transaction.
+ ///
+ /// This represents the channel's current funding output, which may change when the
+ /// channel is spliced. For spliced channels, this will contain the new funding output
+ /// from the confirmed splice transaction.
+ ///
+ /// This will be `None` for events serialized by LDK Node v0.6.0 and prior.
+ funding_txo: Option<OutPoint>,
 	},
 	/// A channel has been closed.
 	ChannelClosed {
@@ -222,6 +234,28 @@ pub enum Event {
  /// This will be `None` for events serialized by LDK Node v0.2.1 and prior.
  reason: Option<ClosureReason>,
 	},
+	/// A channel splice is pending confirmation on-chain.
+	SplicePending {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction.
+ new_funding_txo: OutPoint,
+	},
+	/// A channel splice has failed.
+	SpliceFailed {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction, if one was created.
+ abandoned_funding_txo: Option<OutPoint>,
+	},
 }
 
 impl_writeable_tlv_based_enum!(Event,
@@ -246,6 +280,7 @@ impl_writeable_tlv_based_enum!(Event,
  (0, channel_id, required),
  (1, counterparty_node_id, option),
  (2, user_channel_id, required),
+ (3, funding_txo, option),
 	},
 	(4, ChannelPending) => {
  (0, channel_id, required),
@@ -278,7 +313,19 @@ impl_writeable_tlv_based_enum!(Event,
  (10, skimmed_fee_msat, option),
  (12, claim_from_onchain_tx, required),
  (14, outbound_amount_forwarded_msat, option),
-	}
+	},
+	(8, SplicePending) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, new_funding_txo, required),
+	},
+	(9, SpliceFailed) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, abandoned_funding_txo, option),
+	},
 );
 
 pub struct EventQueue<L: Deref>
@@ -1397,14 +1444,28 @@ where
  }
  },
  LdkEvent::ChannelReady {
- channel_id, user_channel_id, counterparty_node_id, ..
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ funding_txo,
+ ..
  } => {
- log_info!(
- self.logger,
- "Channel {} with counterparty {} ready to be used.",
- channel_id,
- counterparty_node_id,
- );
+ if let Some(funding_txo) = funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
 
  if let Some(liquidity_source) = self.liquidity_source.as_ref() {
  liquidity_source
@@ -1416,6 +1477,7 @@ where
  channel_id,
  user_channel_id: UserChannelId(user_channel_id),
  counterparty_node_id: Some(counterparty_node_id),
+ funding_txo,
  };
  match self.event_queue.add_event(event).await {
  Ok(_) => {},
@@ -1614,20 +1676,116 @@ where
  }
  }
  },
- LdkEvent::FundingTransactionReadyForSigning { .. } => {
- debug_assert!(false, "We currently don't support interactive-tx, so this event should never be emitted.");
+ // TODO(splicing): Revisit error handling once splicing API is settled in LDK 0.3
+ LdkEvent::FundingTransactionReadyForSigning {
+ channel_id,
+ counterparty_node_id,
+ unsigned_transaction,
+ ..
+ } => match self.wallet.sign_owned_inputs(unsigned_transaction) {
+ Ok(partially_signed_tx) => {
+ match self.channel_manager.funding_transaction_signed(
+ &channel_id,
+ &counterparty_node_id,
+ partially_signed_tx,
+ ) {
+ Ok(()) => {
+ log_info!(
+ self.logger,
+ "Signed funding transaction for channel {} with counterparty {}",
+ channel_id,
+ counterparty_node_id
+ );
+ },
+ Err(e) => {
+ // TODO(splicing): Abort splice once supported in LDK 0.3
+ debug_assert!(false, "Failed signing funding transaction: {:?}", e);
+ log_error!(self.logger, "Failed signing funding transaction: {:?}", e);
+ },
+ }
+ },
+ Err(()) => log_error!(self.logger, "Failed signing funding transaction"),
  },
- LdkEvent::SplicePending { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
+ LdkEvent::SplicePending {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ new_funding_txo,
+ ..
+ } => {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} pending splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ new_funding_txo,
  );
+
+ let event = Event::SplicePending {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ new_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
- LdkEvent::SpliceFailed { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
- );
+ LdkEvent::SpliceFailed {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ abandoned_funding_txo,
+ contributed_outputs,
+ ..
+ } => {
+ if let Some(funding_txo) = abandoned_funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
+
+ let tx = bitcoin::Transaction {
+ version: bitcoin::transaction::Version::TWO,
+ lock_time: bitcoin::absolute::LockTime::ZERO,
+ input: vec![],
+ output: contributed_outputs,
+ };
+ if let Err(e) = self.wallet.cancel_tx(&tx) {
+ log_error!(self.logger, "Failed reclaiming unused addresses: {}", e);
+ return Err(ReplayEvent());
+ }
+
+ let event = Event::SpliceFailed {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ abandoned_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
  }
  Ok(())
@@ -1655,6 +1813,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
  event_queue.add_event(expected_event.clone()).await.unwrap();
 
@@ -1692,6 +1851,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
 
  // Check `next_event_async` won't return if the queue is empty and always rather timeout.

bindings/ldk_node.udl

@@ -150,6 +150,10 @@ interface Node {
 	[Throws=NodeError]
 	UserChannelId open_announced_channel(PublicKey node_id, SocketAddress address, u64 channel_amount_sats, u64? push_to_counterparty_msat, ChannelConfig? channel_config);
 	[Throws=NodeError]
+	void splice_in([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, u64 splice_amount_sats);
+	[Throws=NodeError]
+	void splice_out([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, [ByRef]Address address, u64 splice_amount_sats);
+	[Throws=NodeError]
 	void close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id);
 	[Throws=NodeError]
 	void force_close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id, string? reason);
@@ -290,6 +294,7 @@ enum NodeError {
 	"ProbeSendingFailed",
 	"ChannelCreationFailed",
 	"ChannelClosingFailed",
+	"ChannelSplicingFailed",
 	"ChannelConfigUpdateFailed",
 	"PersistenceFailed",
 	"FeerateEstimationUpdateFailed",
@@ -393,8 +398,10 @@ interface Event {
 	PaymentForwarded(ChannelId prev_channel_id, ChannelId next_channel_id, UserChannelId?
 	prev_user_channel_id, UserChannelId? next_user_channel_id, PublicKey? prev_node_id, PublicKey? next_node_id, u64? total_fee_earned_msat, u64? skimmed_fee_msat, boolean claim_from_onchain_tx, u64? outbound_amount_forwarded_msat);
 	ChannelPending(ChannelId channel_id, UserChannelId user_channel_id, ChannelId former_temporary_channel_id, PublicKey counterparty_node_id, OutPoint funding_txo);
-	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id);
+	ChannelReady(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, OutPoint? funding_txo);
 	ChannelClosed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id, ClosureReason? reason);
+	SplicePending(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint new_funding_txo);
+	SpliceFailed(ChannelId channel_id, UserChannelId user_channel_id, PublicKey counterparty_node_id, OutPoint? abandoned_funding_txo);
 };
 
 enum PaymentFailureReason {

src/builder.rs

@@ -1795,6 +1795,7 @@ fn build_with_store_internal(
  wallet,
  chain_source,
  tx_broadcaster,
+ fee_estimator,
  event_queue,
  channel_manager,
  chain_monitor,

src/config.rs

@@ -325,6 +325,7 @@ pub(crate) fn default_user_config(config: &Config) -> UserConfig {
 	user_config.manually_accept_inbound_channels = true;
 	user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx =
  config.anchor_channels_config.is_some();
+	user_config.reject_inbound_splices = false;
 
 	if may_announce_channel(config).is_err() {
  user_config.accept_forwards_to_priv_channels = false;

src/error.rs

@@ -43,6 +43,8 @@ pub enum Error {
 	ChannelCreationFailed,
 	/// A channel could not be closed.
 	ChannelClosingFailed,
+	/// A channel could not be spliced.
+	ChannelSplicingFailed,
 	/// A channel configuration could not be updated.
 	ChannelConfigUpdateFailed,
 	/// Persistence failed.
@@ -145,6 +147,7 @@ impl fmt::Display for Error {
  Self::ProbeSendingFailed => write!(f, "Failed to send the given payment probe."),
  Self::ChannelCreationFailed => write!(f, "Failed to create channel."),
  Self::ChannelClosingFailed => write!(f, "Failed to close channel."),
+ Self::ChannelSplicingFailed => write!(f, "Failed to splice channel."),
  Self::ChannelConfigUpdateFailed => write!(f, "Failed to update channel config."),
  Self::PersistenceFailed => write!(f, "Failed to persist data."),
  Self::FeerateEstimationUpdateFailed => {

src/event.rs

@@ -199,6 +199,10 @@ pub enum Event {
  funding_txo: OutPoint,
 	},
 	/// A channel is ready to be used.
+	///
+	/// This event is emitted when:
+	/// - A new channel has been established and is ready for use
+	/// - An existing channel has been spliced and is ready with the new funding output
 	ChannelReady {
  /// The `channel_id` of the channel.
  channel_id: ChannelId,
@@ -208,6 +212,14 @@ pub enum Event {
  ///
  /// This will be `None` for events serialized by LDK Node v0.1.0 and prior.
  counterparty_node_id: Option<PublicKey>,
+ /// The outpoint of the channel's funding transaction.
+ ///
+ /// This represents the channel's current funding output, which may change when the
+ /// channel is spliced. For spliced channels, this will contain the new funding output
+ /// from the confirmed splice transaction.
+ ///
+ /// This will be `None` for events serialized by LDK Node v0.6.0 and prior.
+ funding_txo: Option<OutPoint>,
 	},
 	/// A channel has been closed.
 	ChannelClosed {
@@ -222,6 +234,28 @@ pub enum Event {
  /// This will be `None` for events serialized by LDK Node v0.2.1 and prior.
  reason: Option<ClosureReason>,
 	},
+	/// A channel splice is pending confirmation on-chain.
+	SplicePending {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction.
+ new_funding_txo: OutPoint,
+	},
+	/// A channel splice has failed.
+	SpliceFailed {
+ /// The `channel_id` of the channel.
+ channel_id: ChannelId,
+ /// The `user_channel_id` of the channel.
+ user_channel_id: UserChannelId,
+ /// The `node_id` of the channel counterparty.
+ counterparty_node_id: PublicKey,
+ /// The outpoint of the channel's splice funding transaction, if one was created.
+ abandoned_funding_txo: Option<OutPoint>,
+	},
 }
 
 impl_writeable_tlv_based_enum!(Event,
@@ -246,6 +280,7 @@ impl_writeable_tlv_based_enum!(Event,
  (0, channel_id, required),
  (1, counterparty_node_id, option),
  (2, user_channel_id, required),
+ (3, funding_txo, option),
 	},
 	(4, ChannelPending) => {
  (0, channel_id, required),
@@ -278,7 +313,19 @@ impl_writeable_tlv_based_enum!(Event,
  (10, skimmed_fee_msat, option),
  (12, claim_from_onchain_tx, required),
  (14, outbound_amount_forwarded_msat, option),
-	}
+	},
+	(8, SplicePending) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, new_funding_txo, required),
+	},
+	(9, SpliceFailed) => {
+ (1, channel_id, required),
+ (3, counterparty_node_id, required),
+ (5, user_channel_id, required),
+ (7, abandoned_funding_txo, option),
+	},
 );
 
 pub struct EventQueue<L: Deref>
@@ -1397,14 +1444,28 @@ where
  }
  },
  LdkEvent::ChannelReady {
- channel_id, user_channel_id, counterparty_node_id, ..
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ funding_txo,
+ ..
  } => {
- log_info!(
- self.logger,
- "Channel {} with counterparty {} ready to be used.",
- channel_id,
- counterparty_node_id,
- );
+ if let Some(funding_txo) = funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} ready to be used",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
 
  if let Some(liquidity_source) = self.liquidity_source.as_ref() {
  liquidity_source
@@ -1416,6 +1477,7 @@ where
  channel_id,
  user_channel_id: UserChannelId(user_channel_id),
  counterparty_node_id: Some(counterparty_node_id),
+ funding_txo,
  };
  match self.event_queue.add_event(event).await {
  Ok(_) => {},
@@ -1614,20 +1676,116 @@ where
  }
  }
  },
- LdkEvent::FundingTransactionReadyForSigning { .. } => {
- debug_assert!(false, "We currently don't support interactive-tx, so this event should never be emitted.");
+ // TODO(splicing): Revisit error handling once splicing API is settled in LDK 0.3
+ LdkEvent::FundingTransactionReadyForSigning {
+ channel_id,
+ counterparty_node_id,
+ unsigned_transaction,
+ ..
+ } => match self.wallet.sign_owned_inputs(unsigned_transaction) {
+ Ok(partially_signed_tx) => {
+ match self.channel_manager.funding_transaction_signed(
+ &channel_id,
+ &counterparty_node_id,
+ partially_signed_tx,
+ ) {
+ Ok(()) => {
+ log_info!(
+ self.logger,
+ "Signed funding transaction for channel {} with counterparty {}",
+ channel_id,
+ counterparty_node_id
+ );
+ },
+ Err(e) => {
+ // TODO(splicing): Abort splice once supported in LDK 0.3
+ debug_assert!(false, "Failed signing funding transaction: {:?}", e);
+ log_error!(self.logger, "Failed signing funding transaction: {:?}", e);
+ },
+ }
+ },
+ Err(()) => log_error!(self.logger, "Failed signing funding transaction"),
  },
- LdkEvent::SplicePending { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
+ LdkEvent::SplicePending {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ new_funding_txo,
+ ..
+ } => {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} pending splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ new_funding_txo,
  );
+
+ let event = Event::SplicePending {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ new_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
- LdkEvent::SpliceFailed { .. } => {
- debug_assert!(
- false,
- "We currently don't support splicing, so this event should never be emitted."
- );
+ LdkEvent::SpliceFailed {
+ channel_id,
+ user_channel_id,
+ counterparty_node_id,
+ abandoned_funding_txo,
+ contributed_outputs,
+ ..
+ } => {
+ if let Some(funding_txo) = abandoned_funding_txo {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice with funding_txo {}",
+ channel_id,
+ counterparty_node_id,
+ funding_txo,
+ );
+ } else {
+ log_info!(
+ self.logger,
+ "Channel {} with counterparty {} failed splice",
+ channel_id,
+ counterparty_node_id,
+ );
+ }
+
+ let tx = bitcoin::Transaction {
+ version: bitcoin::transaction::Version::TWO,
+ lock_time: bitcoin::absolute::LockTime::ZERO,
+ input: vec![],
+ output: contributed_outputs,
+ };
+ if let Err(e) = self.wallet.cancel_tx(&tx) {
+ log_error!(self.logger, "Failed reclaiming unused addresses: {}", e);
+ return Err(ReplayEvent());
+ }
+
+ let event = Event::SpliceFailed {
+ channel_id,
+ user_channel_id: UserChannelId(user_channel_id),
+ counterparty_node_id,
+ abandoned_funding_txo,
+ };
+
+ match self.event_queue.add_event(event).await {
+ Ok(_) => {},
+ Err(e) => {
+ log_error!(self.logger, "Failed to push to event queue: {}", e);
+ return Err(ReplayEvent());
+ },
+ };
  },
  }
  Ok(())
@@ -1655,6 +1813,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
  event_queue.add_event(expected_event.clone()).await.unwrap();
 
@@ -1692,6 +1851,7 @@ mod tests {
  channel_id: ChannelId([23u8; 32]),
  user_channel_id: UserChannelId(2323),
  counterparty_node_id: None,
+ funding_txo: None,
  };
 
  // Check `next_event_async` won't return if the queue is empty and always rather timeout.