Route the skim site through resolve_skim

Replace the inline compute_forward_fee block in
calculate_htlc_actions_for_peer with a single resolve_skim call against a
literal Flat(Standard) policy. This is the one place the LSP decides what
to skim; routing it through the pure function is what later milestones
need to swap the literal for a per-peer policy lookup.

Not a strict no-op: it inherits the u128 overflow fix from resolve_skim,
so a >9223-BTC HTLC is now skimmed 2% instead of overflowing and
forwarding free. Every realistic HTLC is unchanged. The peer's stored
policy is still ignored; every forward resolves Flat(Standard) until the
lookup lands.

The two old log lines (overflow, skim-ate-the-HTLC) collapse into one:
resolve_skim can't overflow, so a zero skim on a non-zero HTLC can only
mean the fee would have eaten the whole amount.

Author: amackillop

lightning-liquidity/src/lsps4/fee_policy.rs

@@ -60,9 +60,10 @@ impl_writeable_tlv_based_enum!(FeePolicy,
 ///
 /// `standard_ppm` is the LSP's configured proportional rate, used only by [`FeeTier::Standard`].
 ///
-/// The skim is waived in exactly one case: when it would consume the entire HTLC. A zero-value
-/// forward is rejected by the channel (`channel.rs` force-closes on a 0-msat `update_add_htlc`),
-/// so skimming the whole amount would break the forward; that is the only reason we ever waive.
+/// The skim is zero in two distinct cases. [`FeeTier::ZeroFee`] never skims, by design. Any other
+/// tier is additionally forced to zero when its fee would consume the entire HTLC: a zero-value
+/// forward is rejected by the channel (`channel.rs` force-closes on a 0-msat `update_add_htlc`), so
+/// skimming the whole amount would break the forward; dropping to zero forwards it intact instead.
 /// The proportional component is computed in 128-bit precision, so a very large HTLC is skimmed
 /// correctly rather than (as the previous `u64` arithmetic did) overflowing and forwarding the
 /// whole amount for free.

lightning-liquidity/src/lsps4/service.rs

@@ -17,8 +17,8 @@ use crate::lsps0::ser::{
 };
 use crate::lsps4::event::LSPS4ServiceEvent;
 use crate::lsps4::htlc_store::{HTLCStore, InterceptedHtlc};
+use crate::lsps4::fee_policy::{resolve_skim, FeePolicy, FeeTier};
 use crate::lsps4::scid_store::ScidStore;
-use crate::lsps4::utils::compute_forward_fee;
 use crate::message_queue::MessageQueue;
 use crate::prelude::hash_map::Entry;
 use crate::prelude::{new_hash_map, HashMap};
@@ -740,33 +740,24 @@ where
 				}
 
 				let htlc_id = htlc.id();
-				let mut fee_msat = match crate::lsps4::utils::compute_forward_fee(
+				let skimmed_fee_msat = resolve_skim(
+					&FeePolicy::Flat(FeeTier::Standard),
 					expected_outbound_msat,
 					self.config.forwarding_fee_proportional_millionths,
-				) {
-					Some(fee) => core::cmp::min(fee, expected_outbound_msat),
-					None => {
-						log_error!(
-						self.logger,
-						"Overflow while computing skimmed fee for intercepted HTLC {:?}. Skipping skim.",
-						htlc_id
-					);
-						0
-					},
-				};
-
-				let mut amount_to_forward_msat = expected_outbound_msat.saturating_sub(fee_msat);
-				if amount_to_forward_msat == 0 && fee_msat > 0 {
+				);
+				if skimmed_fee_msat == 0 {
+					// The policy here is always Flat(Standard), so a zero skim can only mean the
+					// fee would have consumed the entire HTLC; it is never a ZeroFee waiver yet.
 					log_error!(
 						self.logger,
-						"Skimmed fee equaled the entire HTLC amount for {:?}. Skipping skim.",
+						"Standard skim would have consumed the entire HTLC {:?}; forwarding the full amount.",
 						htlc_id
 					);
-					fee_msat = 0;
-					amount_to_forward_msat = expected_outbound_msat;
 				}
 
-				ComputedHtlc { htlc, amount_to_forward_msat, skimmed_fee_msat: fee_msat }
+				let amount_to_forward_msat = expected_outbound_msat.saturating_sub(skimmed_fee_msat);
+
+				ComputedHtlc { htlc, amount_to_forward_msat, skimmed_fee_msat }
 			})
 			.collect();