Insert channel funding utxo before a splice

We insert a channel's funding utxo into our wallet so we can later
calculate the fees for the transaction, otherwise our wallet would have
incomplete information. We do it before the splice as we only really
need this information for splices and not for all channels.

Author: benthecarman

src/lib.rs

@@ -1303,6 +1303,10 @@ impl Node {
 					Error::ChannelSplicingFailed
 				})?;
 
+			// insert channel's funding utxo into the wallet so we can later calculate fees
+			// correctly when viewing this splice-in.
+			self.wallet.insert_txo(funding_txo.into_bitcoin_outpoint(), funding_output)?;
+
 			let change_address = self.wallet.get_new_internal_address()?;
 
 			let contribution = SpliceContribution::SpliceIn {
@@ -1398,6 +1402,18 @@ impl Node {
 				},
 			};
 
+			let funding_txo = channel_details.funding_txo.ok_or_else(|| {
+				log_error!(self.logger, "Failed to splice channel: channel not yet ready",);
+				Error::ChannelSplicingFailed
+			})?;
+
+			let funding_output = channel_details.get_funding_output().ok_or_else(|| {
+				log_error!(self.logger, "Failed to splice channel: channel not yet ready");
+				Error::ChannelSplicingFailed
+			})?;
+
+			self.wallet.insert_txo(funding_txo.into_bitcoin_outpoint(), funding_output)?;
+
 			self.channel_manager
 				.splice_channel(
 					&channel_details.channel_id,

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

@@ -927,10 +927,13 @@ async fn concurrent_connections_succeed() {
 	}
 }
 
-#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
-async fn splice_channel() {
+async fn run_splice_channel_test(bitcoind_chain_source: bool) {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let chain_source = TestChainSource::Esplora(&electrsd);
+	let chain_source = if bitcoind_chain_source {
+		TestChainSource::BitcoindRpcSync(&bitcoind)
+	} else {
+		TestChainSource::Esplora(&electrsd)
+	};
 	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
 
 	let address_a = node_a.onchain_payment().new_address().unwrap();
@@ -995,7 +998,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 +1009,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);
 
@@ -1033,7 +1041,7 @@ async fn splice_channel() {
 	let address = node_a.onchain_payment().new_address().unwrap();
 	node_a.splice_out(&user_channel_id_a, node_b.node_id(), &address, amount_msat / 1000).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;
@@ -1044,18 +1052,29 @@ 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_out_fee_sat = 183;
+	let expected_splice_out_fee_sat = 183;
+
+	let payments = node_a.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_out_fee_sat * 1_000));
 
 	assert_eq!(
 		node_a.list_balances().total_onchain_balance_sats,
 		premine_amount_sat - 4_000_000 - opening_transaction_fee_sat + amount_msat / 1000
 	);
 	assert_eq!(
 		node_a.list_balances().total_lightning_balance_sats,
-		4_000_000 - closing_transaction_fee_sat - anchor_output_sat - splice_out_fee_sat
+		4_000_000 - closing_transaction_fee_sat - anchor_output_sat - expected_splice_out_fee_sat
 	);
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+async fn splice_channel() {
+	run_splice_channel_test(false).await;
+	run_splice_channel_test(true).await;
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn simple_bolt12_send_receive() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();