Include pending HTLC's in ChannelDetails

Author: wvanlint

fuzz/src/router.rs

@@ -271,6 +271,8 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 								config: None,
 								feerate_sat_per_1000_weight: None,
 								channel_shutdown_state: Some(channelmanager::ChannelShutdownState::NotShuttingDown),
+								pending_inbound_htlcs: Vec::new(),
+								pending_outbound_htlcs: Vec::new(),
 							});
 						}
 						Some(&first_hops_vec[..])

lightning/src/ln/channel.rs

@@ -449,6 +449,25 @@ struct HTLCStats {
 	on_holder_tx_holding_cell_htlcs_count: u32, // dust HTLCs *non*-included
 }
 
+#[derive(Clone, Debug, PartialEq)]
+pub struct HTLCDetails {
+	htlc_id: Option<u64>,
+	amount_msat: u64,
+	cltv_expiry: u32,
+	payment_hash: PaymentHash,
+	skimmed_fee_msat: Option<u64>,
+	is_dust: bool,
+}
+
+impl_writeable_tlv_based!(HTLCDetails, {
+	(0, htlc_id, required),
+	(2, amount_msat, required),
+	(4, cltv_expiry, required),
+	(6, payment_hash, required),
+	(8, skimmed_fee_msat, required),
+	(10, is_dust, required),
+});
+
 /// An enum gathering stats on commitment transaction, either local or remote.
 struct CommitmentStats<'a> {
 	tx: CommitmentTransaction, // the transaction info
@@ -1598,6 +1617,70 @@ impl<Signer: ChannelSigner> ChannelContext<Signer> {
 		stats
 	}
 
+	/// Returns information on all pending inbound HTLCs.
+	pub fn get_pending_inbound_htlc_details(&self) -> Vec<HTLCDetails> {
+		let mut inbound_details = Vec::new();
+		let htlc_success_dust_limit = if self.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
+			0
+		} else {
+			let dust_buffer_feerate = self.get_dust_buffer_feerate(None) as u64;
+			dust_buffer_feerate * htlc_success_tx_weight(self.get_channel_type()) / 1000
+		};
+		let holder_dust_limit_success_sat = htlc_success_dust_limit + self.holder_dust_limit_satoshis;
+		for ref htlc in self.pending_inbound_htlcs.iter() {
+			inbound_details.push(HTLCDetails{
+				htlc_id: Some(htlc.htlc_id),
+				amount_msat: htlc.amount_msat,
+				cltv_expiry: htlc.cltv_expiry,
+				payment_hash: htlc.payment_hash,
+				skimmed_fee_msat: None,
+				is_dust: htlc.amount_msat / 1000 < holder_dust_limit_success_sat,
+			});
+		}
+		inbound_details
+	}
+
+	/// Returns information on all pending outbound HTLCs.
+	pub fn get_pending_outbound_htlc_details(&self) -> Vec<HTLCDetails> {
+		let mut outbound_details = Vec::new();
+		let htlc_timeout_dust_limit = if self.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
+			0
+		} else {
+			let dust_buffer_feerate = self.get_dust_buffer_feerate(None) as u64;
+			dust_buffer_feerate * htlc_success_tx_weight(self.get_channel_type()) / 1000
+		};
+		let holder_dust_limit_timeout_sat = htlc_timeout_dust_limit + self.holder_dust_limit_satoshis;
+		for ref htlc in self.pending_outbound_htlcs.iter() {
+			outbound_details.push(HTLCDetails{
+				htlc_id: Some(htlc.htlc_id),
+				amount_msat: htlc.amount_msat,
+				cltv_expiry: htlc.cltv_expiry,
+				payment_hash: htlc.payment_hash,
+				skimmed_fee_msat: htlc.skimmed_fee_msat,
+				is_dust: htlc.amount_msat / 1000 < holder_dust_limit_timeout_sat,
+			});
+		}
+		for update in self.holding_cell_htlc_updates.iter() {
+			if let &HTLCUpdateAwaitingACK::AddHTLC {
+				amount_msat,
+				cltv_expiry,
+				payment_hash,
+				skimmed_fee_msat,
+				..
+			} = update {
+				outbound_details.push(HTLCDetails{
+					htlc_id: None,
+					amount_msat: amount_msat,
+					cltv_expiry: cltv_expiry,
+					payment_hash: payment_hash,
+					skimmed_fee_msat: skimmed_fee_msat,
+					is_dust: amount_msat / 1000 < holder_dust_limit_timeout_sat,
+				});
+			}
+		}
+		outbound_details
+	}
+
 	/// Get the available balances, see [`AvailableBalances`]'s fields for more info.
 	/// Doesn't bother handling the
 	/// if-we-removed-it-already-but-haven't-fully-resolved-they-can-still-send-an-inbound-HTLC
@@ -1611,13 +1694,7 @@ impl<Signer: ChannelSigner> ChannelContext<Signer> {
 		let inbound_stats = context.get_inbound_pending_htlc_stats(None);
 		let outbound_stats = context.get_outbound_pending_htlc_stats(None);
 
-		let mut balance_msat = context.value_to_self_msat;
-		for ref htlc in context.pending_inbound_htlcs.iter() {
-			if let InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill(_)) = htlc.state {
-				balance_msat += htlc.amount_msat;
-			}
-		}
-		balance_msat -= outbound_stats.pending_htlcs_value_msat;
+		let balance_msat = context.value_to_self_msat - outbound_stats.pending_htlcs_value_msat;
 
 		let outbound_capacity_msat = context.value_to_self_msat
 				.saturating_sub(outbound_stats.pending_htlcs_value_msat)
@@ -7455,16 +7532,17 @@ mod tests {
 	use bitcoin::blockdata::opcodes;
 	use bitcoin::network::constants::Network;
 	use hex;
-	use crate::ln::PaymentHash;
-	use crate::ln::channelmanager::{self, HTLCSource, PaymentId};
+	use crate::ln::{PaymentHash, PaymentPreimage};
+	use crate::ln::channelmanager::{self, HTLCSource, PaymentId, PendingHTLCRouting, PendingHTLCStatus, PendingHTLCInfo};
 	use crate::ln::channel::InitFeatures;
-	use crate::ln::channel::{Channel, InboundHTLCOutput, OutboundV1Channel, InboundV1Channel, OutboundHTLCOutput, InboundHTLCState, OutboundHTLCState, HTLCCandidate, HTLCInitiator, commit_tx_fee_msat};
+	use crate::ln::channel::{Channel, InboundHTLCOutput, InboundHTLCRemovalReason, OutboundV1Channel, InboundV1Channel, OutboundHTLCOutput, InboundHTLCState, OutboundHTLCState, HTLCCandidate, HTLCInitiator, commit_tx_fee_msat, HTLCUpdateAwaitingACK, OutboundHTLCOutcome};
 	use crate::ln::channel::{MAX_FUNDING_SATOSHIS_NO_WUMBO, TOTAL_BITCOIN_SUPPLY_SATOSHIS, MIN_THEIR_CHAN_RESERVE_SATOSHIS};
 	use crate::ln::features::ChannelTypeFeatures;
-	use crate::ln::msgs::{ChannelUpdate, DecodeError, UnsignedChannelUpdate, MAX_VALUE_MSAT};
+	use crate::ln::msgs::{ChannelUpdate, DecodeError, UnsignedChannelUpdate, MAX_VALUE_MSAT, OnionPacket, OnionErrorPacket};
 	use crate::ln::script::ShutdownScript;
 	use crate::ln::chan_utils;
 	use crate::ln::chan_utils::{htlc_success_tx_weight, htlc_timeout_tx_weight};
+	use crate::ln::onion_utils::HTLCFailReason;
 	use crate::chain::BestBlock;
 	use crate::chain::chaininterface::{FeeEstimator, LowerBoundedFeeEstimator, ConfirmationTarget};
 	use crate::sign::{ChannelSigner, InMemorySigner, EntropySource, SignerProvider};
@@ -8933,4 +9011,168 @@ mod tests {
 		);
 		assert!(res.is_err());
 	}
+
+	#[test]
+	fn test_channel_balance_slices() {
+		let fee_est = TestFeeEstimator{fee_est: 15000};
+		let secp_ctx = Secp256k1::new();
+		let signer = InMemorySigner::new(
+			&secp_ctx,
+			SecretKey::from_slice(&hex::decode("30ff4956bbdd3222d44cc5e8a1261dab1e07957bdac5ae88fe3261ef321f3749").unwrap()[..]).unwrap(),
+			SecretKey::from_slice(&hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap(),
+			SecretKey::from_slice(&hex::decode("1111111111111111111111111111111111111111111111111111111111111111").unwrap()[..]).unwrap(),
+			SecretKey::from_slice(&hex::decode("3333333333333333333333333333333333333333333333333333333333333333").unwrap()[..]).unwrap(),
+			SecretKey::from_slice(&hex::decode("1111111111111111111111111111111111111111111111111111111111111111").unwrap()[..]).unwrap(),
+			// These aren't set in the test vectors:
+			[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff],
+			10_000_000,
+			[0; 32],
+			[0; 32],
+		);
+		let keys_provider = Keys { signer: signer.clone() };
+		let counterparty_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
+		let config = UserConfig::default();
+		let mut chan = OutboundV1Channel::<InMemorySigner>::new(&LowerBoundedFeeEstimator::new(&fee_est), &&keys_provider, &&keys_provider, counterparty_node_id, &channelmanager::provided_init_features(&config), 10_000_000, 0, 42, &config, 0, 42).unwrap();
+
+		chan.context.counterparty_selected_channel_reserve_satoshis = Some(123_456);
+		chan.context.value_to_self_msat = 7_000_000_000;
+		chan.context.feerate_per_kw = 0;
+		chan.context.counterparty_max_htlc_value_in_flight_msat = 1_000_000_000;
+
+		chan.context.pending_inbound_htlcs.push(InboundHTLCOutput{
+			htlc_id: 0,
+			amount_msat: 1_000_000,
+			cltv_expiry: 500,
+			payment_hash: PaymentHash(Sha256::hash(&[1; 32]).into_inner()),
+			state: InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill(PaymentPreimage([1; 32]))),
+		});
+		chan.context.pending_inbound_htlcs.push(InboundHTLCOutput{
+			htlc_id: 1,
+			amount_msat: 2_000_000,
+			cltv_expiry: 501,
+			payment_hash: PaymentHash(Sha256::hash(&[1; 32]).into_inner()),
+			state: InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailRelay(OnionErrorPacket { data: [1; 32].to_vec() })),
+		});
+		chan.context.pending_inbound_htlcs.push(InboundHTLCOutput{
+				htlc_id: 2,
+				amount_msat: 4_000_000,
+				cltv_expiry: 502,
+				payment_hash: PaymentHash(Sha256::hash(&[2; 32]).into_inner()),
+				state: InboundHTLCState::Committed,
+		});
+		chan.context.pending_inbound_htlcs.push(InboundHTLCOutput{
+				htlc_id: 3,
+				amount_msat: 8_000_000,
+				cltv_expiry: 503,
+				payment_hash: PaymentHash(Sha256::hash(&[3; 32]).into_inner()),
+				state: InboundHTLCState::RemoteAnnounced(PendingHTLCStatus::Forward(PendingHTLCInfo{
+					routing: PendingHTLCRouting::Forward {
+						onion_packet: OnionPacket{
+							version: 0,
+							public_key: Ok(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap())),
+							hop_data: [0; 20*65],
+							hmac: [0; 32],
+						},
+						short_channel_id: 0,
+					},
+					incoming_shared_secret: [0; 32],
+					payment_hash: PaymentHash(Sha256::hash(&[3; 32]).into_inner()),
+					incoming_amt_msat: Some(4_000_000),
+					outgoing_amt_msat: 4_000_000,
+					outgoing_cltv_value: 10000,
+					skimmed_fee_msat: None,
+				})),
+		});
+		chan.context.pending_outbound_htlcs.push(OutboundHTLCOutput{
+			htlc_id: 4,
+			amount_msat: 16_000_000,
+			cltv_expiry: 504,
+			payment_hash: PaymentHash(Sha256::hash(&[3; 32]).into_inner()),
+			state: OutboundHTLCState::Committed,
+			source: HTLCSource::OutboundRoute {
+				path: Path { hops: Vec::new(), blinded_tail: None },
+				session_priv: SecretKey::from_slice(&[4; 32]).unwrap(),
+				first_hop_htlc_msat: 0,
+				payment_id: PaymentId([5; 32]),
+			},
+			skimmed_fee_msat: None,
+		});
+		chan.context.pending_outbound_htlcs.push(OutboundHTLCOutput{
+			htlc_id: 5,
+			amount_msat: 32_000_000,
+			cltv_expiry: 505,
+			payment_hash: PaymentHash(Sha256::hash(&[3; 32]).into_inner()),
+			state: OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(None)),
+			source: HTLCSource::OutboundRoute {
+				path: Path { hops: Vec::new(), blinded_tail: None },
+				session_priv: SecretKey::from_slice(&[4; 32]).unwrap(),
+				first_hop_htlc_msat: 0,
+				payment_id: PaymentId([5; 32]),
+			},
+			skimmed_fee_msat: None,
+		});
+		chan.context.pending_outbound_htlcs.push(OutboundHTLCOutput{
+			htlc_id: 6,
+			amount_msat: 64_000_000,
+			cltv_expiry: 506,
+			payment_hash: PaymentHash(Sha256::hash(&[3; 32]).into_inner()),
+			state: OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Failure(HTLCFailReason::from_failure_code(0x4000 | 8))),
+			source: HTLCSource::OutboundRoute {
+				path: Path { hops: Vec::new(), blinded_tail: None },
+				session_priv: SecretKey::from_slice(&[4; 32]).unwrap(),
+				first_hop_htlc_msat: 0,
+				payment_id: PaymentId([5; 32]),
+			},
+			skimmed_fee_msat: None,
+		});
+		chan.context.pending_outbound_htlcs.push(OutboundHTLCOutput{
+			htlc_id: 7,
+			amount_msat: 128_000_000,
+			cltv_expiry: 507,
+			payment_hash: PaymentHash(Sha256::hash(&[3; 32]).into_inner()),
+			state: OutboundHTLCState::LocalAnnounced(Box::new(OnionPacket{
+				version: 0,
+				public_key: Ok(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap())),
+				hop_data: [0; 20*65],
+				hmac: [0; 32],
+			})),
+			source: HTLCSource::OutboundRoute {
+				path: Path { hops: Vec::new(), blinded_tail: None },
+				session_priv: SecretKey::from_slice(&[4; 32]).unwrap(),
+				first_hop_htlc_msat: 0,
+				payment_id: PaymentId([5; 32]),
+			},
+			skimmed_fee_msat: None,
+		});
+		chan.context.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::AddHTLC {
+			amount_msat: 256_000_000,
+			payment_hash: PaymentHash(Sha256::hash(&[3; 32]).into_inner()),
+			cltv_expiry: 506,
+			source: HTLCSource::OutboundRoute {
+				path: Path { hops: Vec::new(), blinded_tail: None },
+				session_priv: SecretKey::from_slice(&[4; 32]).unwrap(),
+				first_hop_htlc_msat: 0,
+				payment_id: PaymentId([5; 32]),
+			},
+			onion_routing_packet: OnionPacket{
+				version: 0,
+				public_key: Ok(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap())),
+				hop_data: [0; 20*65],
+				hmac: [0; 32],
+			},
+			skimmed_fee_msat: None,
+		});
+
+		let pending_inbound_total_msat: u64 = chan.context.get_pending_inbound_htlc_details().iter().map(|details| details.amount_msat).sum();
+		let pending_outbound_total_msat: u64 = chan.context.get_pending_outbound_htlc_details().iter().map(|details| details.amount_msat).sum();
+		let balances = chan.context.get_available_balances(&LowerBoundedFeeEstimator::new(&fee_est));
+
+		assert_eq!(
+			chan.context.channel_value_satoshis * 1000,
+			pending_inbound_total_msat + pending_outbound_total_msat +
+			balances.inbound_capacity_msat + balances.outbound_capacity_msat +
+			chan.context.counterparty_selected_channel_reserve_satoshis.unwrap_or(0) * 1000 +
+			chan.context.holder_selected_channel_reserve_satoshis * 1000
+		);
+	}
 }

lightning/src/ln/channelmanager.rs

@@ -40,7 +40,7 @@ use crate::events::{Event, EventHandler, EventsProvider, MessageSendEvent, Messa
 // Since this struct is returned in `list_channels` methods, expose it here in case users want to
 // construct one themselves.
 use crate::ln::{inbound_payment, PaymentHash, PaymentPreimage, PaymentSecret};
-use crate::ln::channel::{Channel, ChannelContext, ChannelError, ChannelUpdateStatus, ShutdownResult, UnfundedChannelContext, UpdateFulfillCommitFetch, OutboundV1Channel, InboundV1Channel};
+use crate::ln::channel::{Channel, ChannelContext, ChannelError, ChannelUpdateStatus, ShutdownResult, UnfundedChannelContext, UpdateFulfillCommitFetch, OutboundV1Channel, InboundV1Channel, HTLCDetails};
 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
 #[cfg(any(feature = "_test_utils", test))]
 use crate::ln::features::Bolt11InvoiceFeatures;
@@ -124,6 +124,9 @@ pub(super) enum PendingHTLCRouting {
 pub(super) struct PendingHTLCInfo {
 	pub(super) routing: PendingHTLCRouting,
 	pub(super) incoming_shared_secret: [u8; 32],
+	#[cfg(test)]
+	pub(super) payment_hash: PaymentHash,
+	#[cfg(not(test))]
 	payment_hash: PaymentHash,
 	/// Amount received
 	pub(super) incoming_amt_msat: Option<u64>, // Added in 0.0.113
@@ -1505,6 +1508,14 @@ pub struct ChannelDetails {
 	///
 	/// This field is only `None` for `ChannelDetails` objects serialized prior to LDK 0.0.109.
 	pub config: Option<ChannelConfig>,
+	/// Pending inbound HTLCs.
+	///
+	/// This field is empty for objects serialized with LDK versions prior to 0.0.117.
+	pub pending_inbound_htlcs: Vec<HTLCDetails>,
+	/// Pending outbound HTLCs.
+	///
+	/// This field is empty for objects serialized with LDK versions prior to 0.0.117.
+	pub pending_outbound_htlcs: Vec<HTLCDetails>,
 }
 
 impl ChannelDetails {
@@ -1580,6 +1591,8 @@ impl ChannelDetails {
 			inbound_htlc_maximum_msat: context.get_holder_htlc_maximum_msat(),
 			config: Some(context.config()),
 			channel_shutdown_state: Some(context.shutdown_state()),
+			pending_inbound_htlcs: context.get_pending_inbound_htlc_details(),
+			pending_outbound_htlcs: context.get_pending_outbound_htlc_details(),
 		}
 	}
 }
@@ -7528,6 +7541,8 @@ impl Writeable for ChannelDetails {
 			(37, user_channel_id_high_opt, option),
 			(39, self.feerate_sat_per_1000_weight, option),
 			(41, self.channel_shutdown_state, option),
+			(43, self.pending_inbound_htlcs, optional_vec),
+			(45, self.pending_outbound_htlcs, optional_vec),
 		});
 		Ok(())
 	}
@@ -7566,6 +7581,8 @@ impl Readable for ChannelDetails {
 			(37, user_channel_id_high_opt, option),
 			(39, feerate_sat_per_1000_weight, option),
 			(41, channel_shutdown_state, option),
+			(43, pending_inbound_htlcs, optional_vec),
+			(45, pending_outbound_htlcs, optional_vec),
 		});
 
 		// `user_channel_id` used to be a single u64 value. In order to remain backwards compatible with
@@ -7602,6 +7619,8 @@ impl Readable for ChannelDetails {
 			inbound_htlc_maximum_msat,
 			feerate_sat_per_1000_weight,
 			channel_shutdown_state,
+			pending_inbound_htlcs: pending_inbound_htlcs.unwrap_or(Vec::new()),
+			pending_outbound_htlcs: pending_outbound_htlcs.unwrap_or(Vec::new()),
 		})
 	}
 }

lightning/src/routing/router.rs

@@ -2740,6 +2740,8 @@ mod tests {
 			config: None,
 			feerate_sat_per_1000_weight: None,
 			channel_shutdown_state: Some(channelmanager::ChannelShutdownState::NotShuttingDown),
+			pending_inbound_htlcs: Vec::new(),
+			pending_outbound_htlcs: Vec::new(),
 		}
 	}
 
@@ -6811,6 +6813,8 @@ pub(crate) mod bench_utils {
 			config: None,
 			feerate_sat_per_1000_weight: None,
 			channel_shutdown_state: Some(channelmanager::ChannelShutdownState::NotShuttingDown),
+			pending_inbound_htlcs: Vec::new(),
+			pending_outbound_htlcs: Vec::new(),
 		}
 	}