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

@@ -1,4 +1,4 @@
-#![deny(missing_docs)]
+#![deny(missing_docs)]
 
 //! A library implementing the full backend for a modern, highly usable, Bitcoin wallet focusing on
 //! maximizing security and self-custody without trading off user experience.
@@ -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,10 @@ 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 +822,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 +840,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(),