WIP: splice in

Author: benthecarman

examples/cli/src/main.rs

@@ -192,6 +192,13 @@ impl WalletState {
 								fee_msat
 							);
 						},
+						Event::SplicePending { new_funding_txo, .. } => {
+							println!(
+								"{} Splice pending: {}",
+								"🔄".bright_yellow(),
+								new_funding_txo
+							);
+						},
 					}
 
 					w.event_handled().unwrap();

graduated-rebalancer/src/lib.rs

@@ -108,6 +108,9 @@ pub trait LightningWallet: Send + Sync {
 		&self, payment_hash: [u8; 32],
 	) -> Pin<Box<dyn Future<Output = Option<ReceivedLightningPayment>> + Send + '_>>;
 
+	/// Check if we already have a channel with the LSP
+	fn has_channel_with_lsp(&self) -> bool;
+
 	/// Open a channel with the LSP using on-chain funds
 	fn open_channel_with_lsp(
 		&self, amt: Amount,
@@ -117,6 +120,16 @@ pub trait LightningWallet: Send + Sync {
 	fn await_channel_pending(
 		&self, channel_id: u128,
 	) -> Pin<Box<dyn Future<Output = OutPoint> + Send + '_>>;
+
+	/// Splice funds from on-chain to an existing channel with the LSP
+	fn splice_to_lsp_channel(
+		&self, amt: Amount,
+	) -> Pin<Box<dyn Future<Output = Result<u128, Self::Error>> + Send + '_>>;
+
+	/// Wait for a splice pending notification, returns the splice outpoint
+	fn await_splice_pending(
+		&self, channel_id: u128,
+	) -> Pin<Box<dyn Future<Output = OutPoint> + Send + '_>>;
 }
 
 /// Represents a payment from the lightning wallet
@@ -313,32 +326,51 @@ where
 		}
 	}
 
-	/// Perform on-chain to lightning rebalance by opening a channel
+	/// Perform on-chain to lightning rebalance by opening a channel or splicing into an existing one
 	async fn do_onchain_rebalance(&self, params: TriggerParams) {
-		// This should open a channel with the LSP using available on-chain funds
-
 		let _ = self.balance_mutex.lock().await;
 
-		log_info!(self.logger, "Opening channel with LSP with on-chain funds");
+		let (channel_outpoint, user_channel_id) = if self.ln_wallet.has_channel_with_lsp() {
+			log_info!(self.logger, "Splicing into channel with LSP with on-chain funds");
 
-		// todo for now we can only open a channel, eventually move to splicing
-		let user_chan_id = match self.ln_wallet.open_channel_with_lsp(params.amount).await {
-			Ok(chan_id) => chan_id,
-			Err(e) => {
-				log_error!(self.logger, "Failed to open channel with LSP: {e:?}");
-				return;
-			},
-		};
+			let user_chan_id = match self.ln_wallet.splice_to_lsp_channel(params.amount).await {
+				Ok(chan_id) => chan_id,
+				Err(e) => {
+					log_error!(self.logger, "Failed to open channel with LSP: {e:?}");
+					return;
+				},
+			};
+
+			log_info!(self.logger, "Initiated splice opened with LSP");
+
+			let channel_outpoint = self.ln_wallet.await_splice_pending(user_chan_id).await;
+
+			log_info!(self.logger, "Splice initiated at: {channel_outpoint}");
+
+			(channel_outpoint, user_chan_id)
+		} else {
+			log_info!(self.logger, "Opening channel with LSP with on-chain funds");
 
-		log_info!(self.logger, "Initiated channel opened with LSP");
+			let user_chan_id = match self.ln_wallet.open_channel_with_lsp(params.amount).await {
+				Ok(chan_id) => chan_id,
+				Err(e) => {
+					log_error!(self.logger, "Failed to open channel with LSP: {e:?}");
+					return;
+				},
+			};
+
+			log_info!(self.logger, "Initiated channel opened with LSP");
 
-		let channel_outpoint = self.ln_wallet.await_channel_pending(user_chan_id).await;
+			let channel_outpoint = self.ln_wallet.await_channel_pending(user_chan_id).await;
 
-		log_info!(self.logger, "Channel open succeeded at: {channel_outpoint}",);
+			log_info!(self.logger, "Channel open succeeded at: {channel_outpoint}");
+
+			(channel_outpoint, user_chan_id)
+		};
 
 		self.event_handler.handle_event(RebalancerEvent::OnChainRebalanceInitiated {
 			trigger_id: params.id,
-			user_channel_id: user_chan_id,
+			user_channel_id,
 			channel_outpoint,
 		});
 	}

orange-sdk/src/event.rs

@@ -131,6 +131,17 @@ pub enum Event {
 		/// The fee paid, in msats, for the rebalance payment.
 		fee_msat: u64,
 	},
+	/// We have initiated a splice and are waiting for it to confirm.
+	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,
+	},
 }
 
 impl_writeable_tlv_based_enum!(Event,
@@ -182,6 +193,12 @@ impl_writeable_tlv_based_enum!(Event,
 		(6, amount_msat, required),
 		(8, fee_msat, required),
 	},
+	(8, SplicePending) => {
+		(1, channel_id, required),
+		(3, counterparty_node_id, required),
+		(5, user_channel_id, required),
+		(7, new_funding_txo, required),
+	},
 );
 
 /// A queue for events emitted by the [`Wallet`].
@@ -301,6 +318,7 @@ pub(crate) struct LdkEventHandler {
 	pub(crate) tx_metadata: store::TxMetadataStore,
 	pub(crate) payment_receipt_sender: watch::Sender<()>,
 	pub(crate) channel_pending_sender: watch::Sender<u128>,
+	pub(crate) splice_pending_sender: watch::Sender<u128>,
 	pub(crate) logger: Arc<Logger>,
 }
 
@@ -415,11 +433,28 @@ impl LdkEventHandler {
 					return;
 				}
 			},
-			ldk_node::Event::SplicePending { .. } => {
-				log_debug!(self.logger, "Received SplicePending event");
+			ldk_node::Event::SplicePending {
+				channel_id,
+				user_channel_id,
+				counterparty_node_id,
+				new_funding_txo,
+			} => {
+				log_debug!(self.logger, "Received SplicePending event {event:?}");
+				let _ = self.splice_pending_sender.send(user_channel_id.0);
+
+				if let Err(e) = self.event_queue.add_event(Event::SplicePending {
+					channel_id,
+					user_channel_id,
+					counterparty_node_id,
+					new_funding_txo,
+				}) {
+					log_error!(self.logger, "Failed to add SplicePending event: {e:?}");
+					return;
+				}
 			},
 			ldk_node::Event::SpliceFailed { .. } => {
-				log_debug!(self.logger, "Received SpliceFailed event");
+				println!("===========splice failed============");
+				log_warn!(self.logger, "Received SpliceFailed event: {event:?}");
 			},
 		}
 

orange-sdk/src/ffi/orange/mod.rs

@@ -262,6 +262,17 @@ pub enum Event {
 		/// The fee paid, in msats, for the rebalance payment.
 		fee_msat: u64,
 	},
+	/// We have initiated a splice and are waiting for it to confirm.
+	SplicePending {
+		/// The `channel_id` of the channel.
+		channel_id: Vec<u8>,
+		/// The `user_channel_id` of the channel.
+		user_channel_id: Vec<u8>,
+		/// The `node_id` of the channel counterparty.
+		counterparty_node_id: Vec<u8>,
+		/// The outpoint of the channel's splice funding transaction.
+		new_funding_txo: String,
+	},
 }
 
 impl From<OrangeEvent> for Event {
@@ -349,6 +360,17 @@ impl From<OrangeEvent> for Event {
 				amount_msat,
 				fee_msat,
 			},
+			OrangeEvent::SplicePending {
+				channel_id,
+				user_channel_id,
+				counterparty_node_id,
+				new_funding_txo,
+			} => Event::SplicePending {
+				channel_id: channel_id.0.to_vec(),
+				user_channel_id: user_channel_id.0.to_be_bytes().to_vec(),
+				counterparty_node_id: counterparty_node_id.serialize().to_vec(),
+				new_funding_txo: new_funding_txo.to_string(),
+			},
 		}
 	}
 }

orange-sdk/src/lib.rs

@@ -665,11 +665,14 @@ impl Wallet {
 	/// Lists the transactions which have been made.
 	pub async fn list_transactions(&self) -> Result<Vec<Transaction>, WalletError> {
 		let trusted_payments = self.inner.trusted.list_payments().await?;
-		let lightning_payments = self.inner.ln_wallet.list_payments();
+		let mut lightning_payments = self.inner.ln_wallet.list_payments();
+		lightning_payments.sort_by_key(|l| l.latest_update_timestamp);
 
 		let mut res = Vec::with_capacity(trusted_payments.len() + lightning_payments.len());
 		let tx_metadata = self.inner.tx_metadata.read();
 
+		println!("\n\n=======================");
+
 		let mut internal_transfers = HashMap::new();
 		#[derive(Debug, Default)]
 		struct InternalTransfer {
@@ -773,6 +776,7 @@ impl Wallet {
 				});
 			}
 		}
+		println!("ln payments: {:#?}", lightning_payments);
 		for payment in lightning_payments {
 			use ldk_node::payment::PaymentDirection;
 			let lightning_receive_fee = match payment.kind {
@@ -792,6 +796,7 @@ impl Wallet {
 				),
 			};
 			if let Some(tx_metadata) = tx_metadata.get(&PaymentId::SelfCustodial(payment.id.0)) {
+				println!("Found metadata for lightning payment {} got {:?}", payment.id, tx_metadata.ty);
 				match &tx_metadata.ty {
 					TxType::TrustedToLightning {
 						trusted_payment: _,
@@ -814,6 +819,7 @@ impl Wallet {
 							.or_insert(InternalTransfer::default());
 						if &payment.id.0 == channel_txid.as_byte_array() {
 							debug_assert!(entry.send_fee.is_none());
+							println!("onchain to ln fee: {:?}", payment.fee_paid_msat);
 							entry.send_fee = payment
 								.fee_paid_msat
 								.map(|fee| Amount::from_milli_sats(fee).expect("Must be valid"));
@@ -831,6 +837,8 @@ impl Wallet {
 							});
 						debug_assert!(entry.transaction.is_none());
 
+						println!("trigger: {:?}", payment.fee_paid_msat);
+
 						entry.transaction = Some(Transaction {
 							id: PaymentId::SelfCustodial(payment.id.0),
 							status: payment.status.into(),

orange-sdk/src/lightning_wallet.rs

@@ -38,8 +38,10 @@ pub(crate) struct LightningWalletBalance {
 
 pub(crate) struct LightningWalletImpl {
 	pub(crate) ldk_node: Arc<ldk_node::Node>,
+	logger: Arc<Logger>,
 	payment_receipt_flag: watch::Receiver<()>,
 	channel_pending_receipt_flag: watch::Receiver<u128>,
+	splice_pending_receipt_flag: watch::Receiver<u128>,
 	lsp_node_id: PublicKey,
 	lsp_socket_addr: SocketAddress,
 }
@@ -163,18 +165,22 @@ impl LightningWallet {
 		let ldk_node = Arc::new(builder.build_with_store(Arc::clone(&store))?);
 		let (payment_receipt_sender, payment_receipt_flag) = watch::channel(());
 		let (channel_pending_sender, channel_pending_receipt_flag) = watch::channel(0);
+		let (splice_pending_sender, splice_pending_receipt_flag) = watch::channel(0);
 		let ev_handler = Arc::new(LdkEventHandler {
 			event_queue,
 			ldk_node: Arc::clone(&ldk_node),
 			tx_metadata,
 			payment_receipt_sender,
 			channel_pending_sender,
-			logger,
+			splice_pending_sender,
+			logger: Arc::clone(&logger),
 		});
 		let inner = Arc::new(LightningWalletImpl {
 			ldk_node,
+			logger,
 			payment_receipt_flag,
 			channel_pending_receipt_flag,
+			splice_pending_receipt_flag,
 			lsp_node_id,
 			lsp_socket_addr,
 		});
@@ -204,6 +210,12 @@ impl LightningWallet {
 		flag.wait_for(|t| t == &channel_id).await.expect("channel pending not received");
 	}
 
+	pub(crate) async fn await_splice_pending(&self, channel_id: u128) {
+		let mut flag = self.inner.splice_pending_receipt_flag.clone();
+		flag.mark_unchanged();
+		flag.wait_for(|t| t == &channel_id).await.expect("splice pending not received");
+	}
+
 	pub(crate) fn get_on_chain_address(&self) -> Result<Address, NodeError> {
 		self.inner.ldk_node.onchain_payment().new_address()
 	}
@@ -295,6 +307,32 @@ impl LightningWallet {
 		}
 	}
 
+	pub(crate) async fn splice_balance_into_channel(
+		&self, amount: Amount,
+	) -> Result<UserChannelId, NodeError> {
+		// find existing channel to splice into
+		let channels = self.inner.ldk_node.list_channels();
+		let channel = channels.iter().find(|c| c.counterparty_node_id == self.inner.lsp_node_id);
+
+		// todo fix this, for now leave some onchain balance for fees
+		let amt = amount.saturating_sub(Amount::from_sats(10_000).unwrap());
+
+		match channel {
+			Some(chan) => {
+				self.inner.ldk_node.splice_in(
+					&chan.user_channel_id,
+					chan.counterparty_node_id,
+					amt.sats_rounding_up(),
+				)?;
+				Ok(chan.user_channel_id)
+			},
+			None => {
+				log_error!(self.inner.logger, "No existing channel to splice into");
+				Err(NodeError::WalletOperationFailed)
+			},
+		}
+	}
+
 	pub(crate) async fn open_channel_with_lsp(&self) -> Result<UserChannelId, NodeError> {
 		let bal = self.inner.ldk_node.list_balances().spendable_onchain_balance_sats;
 
@@ -407,6 +445,11 @@ impl graduated_rebalancer::LightningWallet for LightningWallet {
 		})
 	}
 
+	fn has_channel_with_lsp(&self) -> bool {
+		let channels = self.inner.ldk_node.list_channels();
+		channels.iter().any(|c| c.counterparty_node_id == self.inner.lsp_node_id)
+	}
+
 	fn open_channel_with_lsp(
 		&self, _amt: Amount,
 	) -> Pin<Box<dyn Future<Output = Result<u128, Self::Error>> + Send + '_>> {
@@ -435,6 +478,38 @@ impl graduated_rebalancer::LightningWallet for LightningWallet {
 			}
 		})
 	}
+
+	fn splice_to_lsp_channel(
+		&self, amt: Amount,
+	) -> Pin<Box<dyn Future<Output = Result<u128, Self::Error>> + Send + '_>> {
+		Box::pin(async move { self.splice_balance_into_channel(amt).await.map(|c| c.0) })
+	}
+
+	fn await_splice_pending(
+		&self, channel_id: u128,
+	) -> Pin<Box<dyn Future<Output = OutPoint> + Send + '_>> {
+		Box::pin(async move {
+			// todo since we can't see if we have any active splices, we just await the next splice pending event
+			// this is kinda race-y hopefully we can fix
+			self.await_splice_pending(channel_id).await;
+			loop {
+				let channels = self.inner.ldk_node.list_channels();
+				let chan = channels
+					.into_iter()
+					.find(|c| c.user_channel_id.0 == channel_id && c.funding_txo.is_some());
+				match chan {
+					Some(c) => {
+						println!("\nRETURNING HERE\n");
+						return c.funding_txo.expect("channel has no funding txo")
+					},
+					None => {
+						self.await_splice_pending(channel_id).await;
+						// Wait for the next channel pending event
+					},
+				}
+			}
+		})
+	}
 }
 
 impl From<PaymentStatus> for TxStatus {