Insert channel funding outputs into Wallet

When doing a splice, to properly calculate fees we need the channel's
funding utxo in our wallet, otherwise our wallet won't know the
channel's original size. This adds the channel funding txo on
ChannelReady events and modifies the splicing test to make sure we can
calculate fees on splice-ins.

Author: benthecarman

src/event.rs

@@ -1458,6 +1458,31 @@ where
 						counterparty_node_id,
 						funding_txo,
 					);
+
+					let chans =
+						self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
+					let chan_output = chans
+						.iter()
+						.find(|c| c.user_channel_id == user_channel_id)
+						.and_then(|c| c.get_funding_output());
+					match chan_output {
+						None => {
+							log_error!(
+								self.logger,
+								"Failed to find channel info for pending channel {channel_id} with counterparty {counterparty_node_id}"
+							);
+							return Err(ReplayEvent());
+						},
+						Some(output) => {
+							if let Err(e) = self.wallet.insert_txo(funding_txo, output) {
+								log_error!(
+									self.logger,
+									"Failed to insert funding TXO into wallet: {e}"
+								);
+								return Err(ReplayEvent());
+							}
+						},
+					}
 				} else {
 					log_info!(
 						self.logger,

src/wallet/mod.rs

@@ -26,7 +26,7 @@ use bitcoin::secp256k1::ecdh::SharedSecret;
 use bitcoin::secp256k1::ecdsa::{RecoverableSignature, Signature};
 use bitcoin::secp256k1::{All, PublicKey, Scalar, Secp256k1, SecretKey};
 use bitcoin::{
-	Address, Amount, FeeRate, ScriptBuf, Transaction, TxOut, Txid, WPubkeyHash, Weight,
+	Address, Amount, FeeRate, OutPoint, ScriptBuf, Transaction, TxOut, Txid, WPubkeyHash, Weight,
 	WitnessProgram, WitnessVersion,
 };
 use lightning::chain::chaininterface::BroadcasterInterface;
@@ -153,6 +153,19 @@ impl Wallet {
 		Ok(())
 	}
 
+	pub(crate) fn insert_txo(&self, outpoint: OutPoint, txout: TxOut) -> Result<(), Error> {
+		let mut locked_wallet = self.inner.lock().unwrap();
+		locked_wallet.insert_txout(outpoint, txout);
+
+		let mut locked_persister = self.persister.lock().unwrap();
+		locked_wallet.persist(&mut locked_persister).map_err(|e| {
+			log_error!(self.logger, "Failed to persist wallet: {}", e);
+			Error::PersistenceFailed
+		})?;
+
+		Ok(())
+	}
+
 	fn update_payment_store<'a>(
 		&self, locked_wallet: &'a mut PersistedWallet<KVStoreWalletPersister>,
 	) -> Result<(), Error> {

tests/integration_tests_rust.rs

@@ -995,7 +995,7 @@ async fn splice_channel() {
 	// Splice-in funds for Node B so that it has outbound liquidity to make a payment
 	node_b.splice_in(&user_channel_id_b, node_a.node_id(), 4_000_000).unwrap();
 
-	expect_splice_pending_event!(node_a, node_b.node_id());
+	let txo = expect_splice_pending_event!(node_a, node_b.node_id());
 	expect_splice_pending_event!(node_b, node_a.node_id());
 
 	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6).await;
@@ -1006,11 +1006,16 @@ async fn splice_channel() {
 	expect_channel_ready_event!(node_a, node_b.node_id());
 	expect_channel_ready_event!(node_b, node_a.node_id());
 
-	let splice_in_fee_sat = 252;
+	let expected_splice_in_fee_sat = 252;
+
+	let payments = node_b.list_payments();
+	let payment =
+		payments.into_iter().find(|p| p.id == PaymentId(txo.txid.to_byte_array())).unwrap();
+	assert_eq!(payment.fee_paid_msat, Some(expected_splice_in_fee_sat * 1_000));
 
 	assert_eq!(
 		node_b.list_balances().total_onchain_balance_sats,
-		premine_amount_sat - 4_000_000 - splice_in_fee_sat
+		premine_amount_sat - 4_000_000 - expected_splice_in_fee_sat
 	);
 	assert_eq!(node_b.list_balances().total_lightning_balance_sats, 4_000_000);