Report the confirmed splice candidate's fee, not the last broadcast's

A splice funding payment can be fee-bumped via RBF, producing several
candidate transactions with increasing fees. The payment recorded the
last-broadcast candidate's amount and fee and kept them on confirmation, but
the candidate that actually confirms need not be the last one broadcast — so
an earlier, lower-fee candidate confirming left the payment over-reporting
its fee.

Record each candidate's amount and fee, keyed by txid, so that on
confirmation the payment reflects the candidate that actually confirmed.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: jkczyz

src/payment/mod.rs

@@ -20,6 +20,7 @@ pub use bolt11::Bolt11Payment;
 pub(crate) use bolt11::PaymentMetadata;
 pub use bolt12::Bolt12Payment;
 pub use onchain::OnchainPayment;
+pub(crate) use pending_payment_store::FundingTxCandidate;
 pub(crate) use pending_payment_store::PendingPaymentDetails;
 pub use spontaneous::SpontaneousPayment;
 pub use store::{

src/payment/pending_payment_store.rs

@@ -13,31 +13,67 @@ use crate::data_store::{StorableObject, StorableObjectUpdate};
 use crate::payment::store::PaymentDetailsUpdate;
 use crate::payment::{PaymentDetails, PaymentKind};
 
+/// One candidate transaction in an interactive-funding (splice) RBF history, holding this node's
+/// share of the funding amount and fee for that candidate. Both are `None` for a candidate this
+/// node did not contribute to — e.g. a counterparty-initiated round before our `splice_in` joined
+/// it via RBF. Recorded per pending payment so that, on confirmation, the payment reports the
+/// figures of the candidate that actually confirmed, which need not be the last one broadcast.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct FundingTxCandidate {
+	/// The candidate's broadcast transaction id.
+	pub txid: Txid,
+	/// This node's share of the funding amount for this candidate, in millisatoshis, or `None` if
+	/// this node did not contribute to it.
+	pub amount_msat: Option<u64>,
+	/// This node's share of the on-chain fee for this candidate, in millisatoshis, or `None` if
+	/// this node did not contribute to it.
+	pub fee_paid_msat: Option<u64>,
+}
+
+impl_writeable_tlv_based!(FundingTxCandidate, {
+	(0, txid, required),
+	(2, amount_msat, option),
+	(4, fee_paid_msat, option),
+});
+
 /// Represents a pending payment
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct PendingPaymentDetails {
 	/// The full payment details
 	pub details: PaymentDetails,
 	/// Transaction IDs that have replaced or conflict with this payment.
 	pub conflicting_txids: Vec<Txid>,
+	/// For interactive funding (splices), this node's per-candidate funding figures across the
+	/// RBF history, keyed by each candidate's txid. Empty for non-funding payments and for
+	/// records written before per-candidate tracking existed.
+	pub(crate) candidates: Vec<FundingTxCandidate>,
 }
 
 impl PendingPaymentDetails {
-	pub(crate) fn new(details: PaymentDetails, conflicting_txids: Vec<Txid>) -> Self {
-		Self { details, conflicting_txids }
+	pub(crate) fn new(
+		details: PaymentDetails, conflicting_txids: Vec<Txid>, candidates: Vec<FundingTxCandidate>,
+	) -> Self {
+		Self { details, conflicting_txids, candidates }
+	}
+
+	/// Returns this node's recorded funding figures for the candidate with the given txid, if any.
+	pub(crate) fn candidate(&self, txid: Txid) -> Option<&FundingTxCandidate> {
+		self.candidates.iter().find(|candidate| candidate.txid == txid)
 	}
 }
 
 impl_writeable_tlv_based!(PendingPaymentDetails, {
 	(0, details, required),
 	(2, conflicting_txids, optional_vec),
+	(4, candidates, optional_vec),
 });
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct PendingPaymentDetailsUpdate {
 	pub id: PaymentId,
 	pub payment_update: Option<PaymentDetailsUpdate>,
 	pub conflicting_txids: Option<Vec<Txid>>,
+	pub candidates: Vec<FundingTxCandidate>,
 }
 
 impl StorableObject for PendingPaymentDetails {
@@ -69,6 +105,13 @@ impl StorableObject for PendingPaymentDetails {
 			updated |= self.conflicting_txids.len() != conflicts_len;
 		}
 
+		// Each classify passes the complete candidate history, so a non-empty update replaces the
+		// stored list. An empty update (e.g. a non-funding payment) leaves it untouched.
+		if !update.candidates.is_empty() && self.candidates != update.candidates {
+			self.candidates = update.candidates;
+			updated = true;
+		}
+
 		updated
 	}
 
@@ -90,16 +133,73 @@ impl From<&PendingPaymentDetails> for PendingPaymentDetailsUpdate {
 		} else {
 			Some(value.conflicting_txids.clone())
 		};
-		Self { id: value.id(), payment_update: Some(value.details.to_update()), conflicting_txids }
+		Self {
+			id: value.id(),
+			payment_update: Some(value.details.to_update()),
+			conflicting_txids,
+			candidates: value.candidates.clone(),
+		}
 	}
 }
 
 #[cfg(test)]
 mod tests {
+	use super::*;
+	use crate::payment::store::ConfirmationStatus;
+	use crate::payment::{PaymentDirection, PaymentKind, PaymentStatus};
 	use bitcoin::hashes::Hash;
 
-	use super::*;
-	use crate::payment::{ConfirmationStatus, PaymentDirection, PaymentKind, PaymentStatus};
+	#[test]
+	fn pending_payment_candidate_lookup() {
+		let payment_id = PaymentId([1u8; 32]);
+		let first_txid = Txid::from_byte_array([2u8; 32]);
+		let rbf_txid = Txid::from_byte_array([3u8; 32]);
+
+		// A leading counterparty-initiated round we didn't contribute to (no figures), then our own
+		// original and RBF candidates.
+		let counterparty_txid = Txid::from_byte_array([4u8; 32]);
+		let candidates = vec![
+			FundingTxCandidate { txid: counterparty_txid, amount_msat: None, fee_paid_msat: None },
+			FundingTxCandidate {
+				txid: first_txid,
+				amount_msat: Some(1_000_000),
+				fee_paid_msat: Some(1_000),
+			},
+			FundingTxCandidate {
+				txid: rbf_txid,
+				amount_msat: Some(1_000_000),
+				fee_paid_msat: Some(5_000),
+			},
+		];
+
+		// The stored details only need to be a valid funding payment; `candidate` resolves figures
+		// purely from the recorded candidate list.
+		let details = PaymentDetails::new(
+			payment_id,
+			PaymentKind::Onchain {
+				txid: rbf_txid,
+				status: ConfirmationStatus::Unconfirmed,
+				tx_type: None,
+			},
+			Some(1_000_000),
+			Some(5_000),
+			PaymentDirection::Outbound,
+			PaymentStatus::Pending,
+		);
+		let pending =
+			PendingPaymentDetails::new(details, vec![first_txid, counterparty_txid], candidates);
+
+		// Each candidate resolves to its own figures, so a non-last candidate that confirms reports
+		// its own (lower) fee rather than the last-broadcast candidate's.
+		assert_eq!(pending.candidate(first_txid).and_then(|c| c.fee_paid_msat), Some(1_000));
+		assert_eq!(pending.candidate(rbf_txid).and_then(|c| c.fee_paid_msat), Some(5_000));
+		// A candidate we didn't contribute to carries no figures, so the payment reports `None`
+		// rather than another candidate's stale figures.
+		let counterparty = pending.candidate(counterparty_txid).expect("candidate is recorded");
+		assert_eq!(counterparty.amount_msat, None);
+		assert_eq!(counterparty.fee_paid_msat, None);
+		assert_eq!(pending.candidate(Txid::from_byte_array([9u8; 32])), None);
+	}
 
 	fn test_txid(byte: u8) -> Txid {
 		Txid::from_byte_array([byte; 32])
@@ -125,10 +225,12 @@ mod tests {
 		let mut pending_payment = PendingPaymentDetails::new(
 			pending_onchain_payment(payment_id, replacement_txid),
 			vec![original_txid],
+			Vec::new(),
 		);
 		let update = PendingPaymentDetails::new(
 			pending_onchain_payment(payment_id, original_txid),
 			Vec::new(),
+			Vec::new(),
 		)
 		.to_update();
 

src/wallet/mod.rs

@@ -58,8 +58,8 @@ use crate::fee_estimator::{ConfirmationTarget, FeeEstimator, OnchainFeeEstimator
 use crate::logger::{log_debug, log_error, log_info, log_trace, LdkLogger, Logger};
 use crate::payment::store::ConfirmationStatus;
 use crate::payment::{
-	PaymentDetails, PaymentDirection, PaymentKind, PaymentStatus, PendingPaymentDetails,
-	TransactionType,
+	FundingTxCandidate, PaymentDetails, PaymentDirection, PaymentKind, PaymentStatus,
+	PendingPaymentDetails, TransactionType,
 };
 use crate::runtime::Runtime;
 use crate::types::{Broadcaster, PaymentStore, PendingPaymentStore};
@@ -1235,7 +1235,7 @@ impl Wallet {
 			direction,
 			PaymentStatus::Pending,
 		);
-		self.persist_funding_payment(details).await?;
+		self.persist_funding_payment(details, Vec::new()).await?;
 		log_debug!(
 			self.logger,
 			"Recorded channel-funding broadcast {} for channel {}",
@@ -1298,6 +1298,23 @@ impl Wallet {
 		// Anchor the `PaymentId` to the first negotiated candidate so the record stays stable
 		// across RBF replacements.
 		let payment_id = PaymentId(first.txid.to_byte_array());
+
+		// Record every candidate's figures (`None` for any round we didn't contribute to, e.g. a
+		// counterparty-initiated splice our `splice_in` later joined via RBF) so the confirmed
+		// candidate's amount/fee can be applied on confirmation, even if it isn't the last one
+		// broadcast or one we contributed to.
+		let candidate_records: Vec<FundingTxCandidate> = candidates
+			.iter()
+			.map(|candidate| {
+				let aggregate = aggregate_local_stakes(candidate);
+				FundingTxCandidate {
+					txid: candidate.txid,
+					amount_msat: aggregate.amount_msat,
+					fee_paid_msat: aggregate.fee_paid_msat,
+				}
+			})
+			.collect();
+
 		let details = PaymentDetails::new(
 			payment_id,
 			PaymentKind::Onchain {
@@ -1310,7 +1327,7 @@ impl Wallet {
 			direction,
 			PaymentStatus::Pending,
 		);
-		self.persist_funding_payment(details).await?;
+		self.persist_funding_payment(details, candidate_records).await?;
 		log_debug!(
 			self.logger,
 			"Recorded interactive-funding broadcast {} ({} candidates, {} channels)",
@@ -1323,9 +1340,11 @@ impl Wallet {
 
 	/// Writes a freshly-classified funding payment to the authoritative payment store and adds a
 	/// pending-store index entry, so wallet sync graduates it through `ANTI_REORG_DELAY`.
-	async fn persist_funding_payment(&self, details: PaymentDetails) -> Result<(), Error> {
+	async fn persist_funding_payment(
+		&self, details: PaymentDetails, candidates: Vec<FundingTxCandidate>,
+	) -> Result<(), Error> {
 		self.payment_store.insert_or_update(details.clone()).await?;
-		let pending = PendingPaymentDetails::new(details, Vec::new());
+		let pending = PendingPaymentDetails::new(details, Vec::new(), candidates);
 		self.pending_payment_store.insert_or_update(pending).await?;
 		Ok(())
 	}
@@ -1395,7 +1414,7 @@ impl Wallet {
 	fn create_pending_payment_from_tx(
 		&self, payment: PaymentDetails, conflicting_txids: Vec<Txid>,
 	) -> PendingPaymentDetails {
-		PendingPaymentDetails::new(payment, conflicting_txids)
+		PendingPaymentDetails::new(payment, conflicting_txids, Vec::new())
 	}
 
 	fn find_payment_by_txid(&self, target_txid: Txid) -> Option<PaymentId> {
@@ -1441,6 +1460,17 @@ impl Wallet {
 			} => tx_type.clone(),
 			_ => return Ok(false),
 		};
+		// Report the figures of the candidate that actually confirmed, which need not be the last
+		// one broadcast (an earlier, lower-fee candidate may win) and may carry no figures at all
+		// (`None`) for a round we didn't contribute to. (`direction` is invariant across a splice's
+		// candidates and cannot be changed through the store anyway.)
+		if let Some(pending) = self.pending_payment_store.get(&payment_id) {
+			if let Some(candidate) = pending.candidate(event_txid) {
+				payment.amount_msat = candidate.amount_msat;
+				payment.fee_paid_msat = candidate.fee_paid_msat;
+			}
+		}
+
 		payment.kind =
 			PaymentKind::Onchain { txid: event_txid, status: confirmation_status, tx_type };
 		self.runtime.block_on(self.payment_store.insert_or_update(payment.clone()))?;