Fix amount calculation and track paid fees in PaymentKind::Onchain

We recently started tracking onchain payments in the store. It turns out
the calculated amount was slightly off as in the outbound case it would
include the paid fees. Here, we fix this minor bug and start tracking
the fees separately.

Author: tnull

bindings/ldk_node.udl

@@ -371,7 +371,7 @@ interface ClosureReason {
 
 [Enum]
 interface PaymentKind {
-	Onchain(Txid txid, ConfirmationStatus status);
+	Onchain(Txid txid, ConfirmationStatus status, u64 fee_msat);
 	Bolt11(PaymentHash hash, PaymentPreimage? preimage, PaymentSecret? secret);
 	Bolt11Jit(PaymentHash hash, PaymentPreimage? preimage, PaymentSecret? secret, LSPFeeLimits lsp_fee_limits);
 	Bolt12Offer(PaymentHash? hash, PaymentPreimage? preimage, PaymentSecret? secret, OfferId offer_id, UntrustedString? payer_note, u64? quantity);

src/payment/store.rs

@@ -302,6 +302,8 @@ pub enum PaymentKind {
 		txid: Txid,
 		/// The confirmation status of this payment.
 		status: ConfirmationStatus,
+		/// The on-chain fees that were paid for this payment.
+		fee_msat: u64,
 	},
 	/// A [BOLT 11] payment.
 	///
@@ -394,6 +396,7 @@ impl_writeable_tlv_based_enum!(PaymentKind,
 	(0, Onchain) => {
 		(0, txid, required),
 		(2, status, required),
+		(4, fee_msat, required),
 	},
 	(2, Bolt11) => {
 		(0, hash, required),

src/wallet/mod.rs

@@ -186,17 +186,29 @@ where
 			// create and persist a list of 'static pending outputs' that we could use
 			// here to determine the `PaymentKind`, but that's not really satisfactory, so
 			// we're punting on it until we can come up with a better solution.
-			let kind = crate::payment::PaymentKind::Onchain { txid, status: confirmation_status };
+			let fee = locked_wallet.calculate_fee(&wtx.tx_node.tx).unwrap_or(Amount::ZERO);
+			let fee_msat = fee.to_sat() * 1000;
 			let (sent, received) = locked_wallet.sent_and_received(&wtx.tx_node.tx);
 			let (direction, amount_msat) = if sent > received {
 				let direction = PaymentDirection::Outbound;
-				let amount_msat = Some(sent.to_sat().saturating_sub(received.to_sat()) * 1000);
+				let amount_msat = Some(
+					sent.to_sat().saturating_sub(fee.to_sat()).saturating_sub(received.to_sat())
+						* 1000,
+				);
 				(direction, amount_msat)
 			} else {
 				let direction = PaymentDirection::Inbound;
-				let amount_msat = Some(received.to_sat().saturating_sub(sent.to_sat()) * 1000);
+				let amount_msat = Some(
+					received.to_sat().saturating_sub(sent.to_sat().saturating_sub(fee.to_sat()))
+						* 1000,
+				);
 				(direction, amount_msat)
 			};
+			let kind = crate::payment::PaymentKind::Onchain {
+				txid,
+				status: confirmation_status,
+				fee_msat,
+			};
 
 			let payment = PaymentDetails {
 				id,

tests/integration_tests_rust.rs

@@ -26,6 +26,7 @@ use lightning::util::persist::KVStore;
 
 use bitcoincore_rpc::RpcApi;
 
+use bitcoin::hashes::Hash;
 use bitcoin::Amount;
 use lightning_invoice::{Bolt11InvoiceDescription, Description};
 
@@ -281,7 +282,7 @@ fn start_stop_reinit() {
 }
 
 #[test]
-fn onchain_spend_receive() {
+fn onchain_send_receive() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
 	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
@@ -352,7 +353,7 @@ fn onchain_spend_receive() {
 		node_a.onchain_payment().send_to_address(&addr_b, expected_node_a_balance + 1, None)
 	);
 
-	let amount_to_send_sats = 1000;
+	let amount_to_send_sats = 54321;
 	let txid =
 		node_b.onchain_payment().send_to_address(&addr_a, amount_to_send_sats, None).unwrap();
 	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6);
@@ -371,9 +372,29 @@ fn onchain_spend_receive() {
 	let node_a_payments =
 		node_a.list_payments_with_filter(|p| matches!(p.kind, PaymentKind::Onchain { .. }));
 	assert_eq!(node_a_payments.len(), 2);
-	let node_b_payments =
-		node_b.list_payments_with_filter(|p| matches!(p.kind, PaymentKind::Onchain { .. }));
-	assert_eq!(node_b_payments.len(), 3);
+
+	let payment_id = PaymentId(txid.to_byte_array());
+	let payment_a = node_a.payment(&payment_id).unwrap();
+	assert_eq!(payment_a.amount_msat, Some(amount_to_send_sats * 1000));
+	match payment_a.kind {
+		PaymentKind::Onchain { txid: _txid, status, fee_msat } => {
+			assert_eq!(_txid, txid);
+			assert!(matches!(status, ConfirmationStatus::Confirmed { .. }));
+			assert!(fee_msat != 0);
+		},
+		_ => panic!("Unexpected payment kind"),
+	}
+
+	let payment_b = node_a.payment(&payment_id).unwrap();
+	assert_eq!(payment_b.amount_msat, Some(amount_to_send_sats * 1000));
+	match payment_b.kind {
+		PaymentKind::Onchain { txid: _txid, status, fee_msat } => {
+			assert_eq!(_txid, txid);
+			assert!(matches!(status, ConfirmationStatus::Confirmed { .. }));
+			assert!(fee_msat != 0);
+		},
+		_ => panic!("Unexpected payment kind"),
+	}
 
 	let addr_b = node_b.onchain_payment().new_address().unwrap();
 	let txid = node_a.onchain_payment().send_all_to_address(&addr_b, true, None).unwrap();