fix: rebase payer proof branch onto current main

Adjust liquidity, payment forwarding, splicing, and binding surfaces to stay compatible with the payer proof rust-lightning fork on top of the current upstream mainline.

AI-assisted-by: Codex

Author: vincenzopalazzo

Cargo.toml

@@ -125,6 +125,7 @@ check-cfg = [
 	"cfg(cln_test)",
 	"cfg(lnd_test)",
 	"cfg(cycle_tests)",
+	"cfg(lsps1_service)",
 ]
 
 [[bench]]

bindings/ldk_node.udl

@@ -303,7 +303,6 @@ dictionary LSPS1ChannelInfo {
 [Remote]
 enum LSPS1PaymentState {
 	"ExpectPayment",
-	"Hold",
 	"Paid",
 	"Refunded",
 };

src/builder.rs

@@ -1817,6 +1817,11 @@ fn build_with_store_internal(
 				Arc::clone(&wallet),
 				Arc::clone(&channel_manager),
 				Arc::clone(&keys_manager),
+				Arc::clone(&chain_source),
+				ChainParameters {
+					network: config.network.into(),
+					best_block: channel_manager.current_best_block(),
+				},
 				Arc::clone(&tx_broadcaster),
 				Arc::clone(&kv_store),
 				Arc::clone(&config),

src/event.rs

@@ -1379,8 +1379,12 @@ where
 				}
 			},
 			LdkEvent::PaymentForwarded {
-				prev_htlcs,
-				next_htlcs,
+				prev_channel_id,
+				next_channel_id,
+				prev_user_channel_id,
+				next_user_channel_id,
+				prev_node_id,
+				next_node_id,
 				total_fee_earned_msat,
 				skimmed_fee_msat,
 				claim_from_onchain_tx,
@@ -1391,10 +1395,11 @@ where
 					let nodes = read_only_network_graph.nodes();
 					let channels = self.channel_manager.list_channels();
 
-					let node_str = |channel_id: &ChannelId| {
-						channels
-							.iter()
-							.find(|c| c.channel_id == *channel_id)
+					let node_str = |channel_id: &Option<ChannelId>| {
+						channel_id
+							.and_then(|channel_id| {
+								channels.iter().find(|c| c.channel_id == channel_id)
+							})
 							.and_then(|channel| {
 								nodes.get(&NodeId::from_pubkey(&channel.counterparty.node_id))
 							})
@@ -1406,74 +1411,58 @@ where
 									})
 							})
 					};
-					let from_prev_str: String = prev_htlcs
-						.iter()
-						.map(|htlc| {
-							format!("with {} on {}", node_str(&htlc.channel_id), htlc.channel_id)
-						})
-						.collect::<Vec<_>>()
-						.join(", ");
-
-					let to_next_str: String = next_htlcs
-						.iter()
-						.map(|htlc| {
-							format!("with {} on {}", node_str(&htlc.channel_id), htlc.channel_id)
-						})
-						.collect::<Vec<_>>()
-						.join(", ");
+					let channel_str = |channel_id: &Option<ChannelId>| {
+						channel_id
+							.map(|channel_id| format!(" with channel {}", channel_id))
+							.unwrap_or_default()
+					};
+					let from_prev_str = format!(
+						" from {}{}",
+						node_str(&prev_channel_id),
+						channel_str(&prev_channel_id)
+					);
+					let to_next_str = format!(
+						" to {}{}",
+						node_str(&next_channel_id),
+						channel_str(&next_channel_id)
+					);
 
 					let fee_earned = total_fee_earned_msat.unwrap_or(0);
 					if claim_from_onchain_tx {
 						log_info!(
 						self.logger,
-						"Forwarded payment with {} inbound HTLC(s) ({}) and {} outbound HTLC(s) ({}) of {}msat, earning {}msat in fees from claiming onchain.",
-						prev_htlcs.len(),
+						"Forwarded payment{}{} of {}msat, earning {}msat in fees from claiming onchain.",
 						from_prev_str,
-						next_htlcs.len(),
 						to_next_str,
 						outbound_amount_forwarded_msat.unwrap_or(0),
 						fee_earned,
 					);
 					} else {
 						log_info!(
 							self.logger,
-							"Forwarded payment with {} inbound HTLC(s) ({}) and {} outbound HTLC(s) ({}) of {}msat, earning {}msat in fees.",
-							prev_htlcs.len(),
+							"Forwarded payment{}{} of {}msat, earning {}msat in fees.",
 							from_prev_str,
-							next_htlcs.len(),
 							to_next_str,
 							outbound_amount_forwarded_msat.unwrap_or(0),
 							fee_earned,
 						);
 					}
 				}
 
-				// We only allow multiple HTLCs in/out for trampoline forwards, which have not yet
-				// been fully implemented in LDK, so we do not lose any information by just
-				// reporting the first HTLC in each vec.
-				debug_assert_eq!(prev_htlcs.len(), 1, "unexpected number of prev_htlcs");
-				debug_assert_eq!(next_htlcs.len(), 1, "unexpected number of next_htlcs");
-				let prev_htlc = prev_htlcs
-					.first()
-					.expect("we expect at least one prev_htlc for PaymentForwarded");
-				let next_htlc = next_htlcs
-					.first()
-					.expect("we expect at least one next_htlc for PaymentForwarded");
-
 				if let Some(liquidity_source) = self.liquidity_source.as_ref() {
 					let skimmed_fee_msat = skimmed_fee_msat.unwrap_or(0);
 					liquidity_source
-						.handle_payment_forwarded(Some(next_htlc.channel_id), skimmed_fee_msat)
+						.handle_payment_forwarded(next_channel_id, skimmed_fee_msat)
 						.await;
 				}
 
 				let event = Event::PaymentForwarded {
-					prev_channel_id: prev_htlc.channel_id,
-					next_channel_id: next_htlc.channel_id,
-					prev_user_channel_id: prev_htlc.user_channel_id.map(UserChannelId),
-					next_user_channel_id: next_htlc.user_channel_id.map(UserChannelId),
-					prev_node_id: prev_htlc.node_id,
-					next_node_id: next_htlc.node_id,
+					prev_channel_id: prev_channel_id.expect("prev_channel_id expected for events generated by LDK versions greater than 0.0.107."),
+					next_channel_id: next_channel_id.expect("next_channel_id expected for events generated by LDK versions greater than 0.0.107."),
+					prev_user_channel_id: prev_user_channel_id.map(UserChannelId),
+					next_user_channel_id: next_user_channel_id.map(UserChannelId),
+					prev_node_id,
+					next_node_id,
 					total_fee_earned_msat,
 					skimmed_fee_msat,
 					claim_from_onchain_tx,

src/lib.rs

@@ -118,11 +118,11 @@ pub use balance::{BalanceDetails, LightningBalance, PendingSweepBalance};
 pub use bip39;
 pub use bitcoin;
 use bitcoin::secp256k1::PublicKey;
+#[cfg(not(feature = "uniffi"))]
+use bitcoin::Address;
+use bitcoin::Amount;
 #[cfg(feature = "uniffi")]
 pub use bitcoin::FeeRate;
-#[cfg(not(feature = "uniffi"))]
-use bitcoin::FeeRate;
-use bitcoin::{Address, Amount};
 #[cfg(feature = "uniffi")]
 pub use builder::ArcedNodeBuilder as Builder;
 pub use builder::BuildError;
@@ -1413,7 +1413,6 @@ impl Node {
 		{
 			let min_feerate =
 				self.fee_estimator.estimate_fee_rate(ConfirmationTarget::ChannelFunding);
-			let max_feerate = FeeRate::from_sat_per_kwu(min_feerate.to_sat_per_kwu() * 3 / 2);
 
 			let splice_amount_sats = match splice_amount_sats {
 				FundingAmount::Exact { amount_sats } => amount_sats,
@@ -1473,12 +1472,7 @@ impl Node {
 
 			let funding_template = self
 				.channel_manager
-				.splice_channel(
-					&channel_details.channel_id,
-					&counterparty_node_id,
-					min_feerate,
-					max_feerate,
-				)
+				.splice_channel(&channel_details.channel_id, &counterparty_node_id, min_feerate)
 				.map_err(|e| {
 					log_error!(self.logger, "Failed to splice channel: {:?}", e);
 					Error::ChannelSplicingFailed
@@ -1585,16 +1579,10 @@ impl Node {
 
 			let min_feerate =
 				self.fee_estimator.estimate_fee_rate(ConfirmationTarget::ChannelFunding);
-			let max_feerate = FeeRate::from_sat_per_kwu(min_feerate.to_sat_per_kwu() * 3 / 2);
 
 			let funding_template = self
 				.channel_manager
-				.splice_channel(
-					&channel_details.channel_id,
-					&counterparty_node_id,
-					min_feerate,
-					max_feerate,
-				)
+				.splice_channel(&channel_details.channel_id, &counterparty_node_id, min_feerate)
 				.map_err(|e| {
 					log_error!(self.logger, "Failed to splice channel: {:?}", e);
 					Error::ChannelSplicingFailed

src/liquidity.rs

@@ -16,7 +16,7 @@ use bitcoin::secp256k1::{PublicKey, Secp256k1};
 use bitcoin::Transaction;
 use chrono::Utc;
 use lightning::events::HTLCHandlingFailureType;
-use lightning::ln::channelmanager::{InterceptId, MIN_FINAL_CLTV_EXPIRY_DELTA};
+use lightning::ln::channelmanager::{ChainParameters, InterceptId, MIN_FINAL_CLTV_EXPIRY_DELTA};
 use lightning::ln::msgs::SocketAddress;
 use lightning::ln::types::ChannelId;
 use lightning::routing::router::{RouteHint, RouteHintHop};
@@ -39,6 +39,7 @@ use lightning_types::payment::PaymentHash;
 use tokio::sync::oneshot;
 
 use crate::builder::BuildError;
+use crate::chain::ChainSource;
 use crate::connection::ConnectionManager;
 use crate::logger::{log_debug, log_error, log_info, LdkLogger, Logger};
 use crate::runtime::Runtime;
@@ -154,6 +155,8 @@ where
 	wallet: Arc<Wallet>,
 	channel_manager: Arc<ChannelManager>,
 	keys_manager: Arc<KeysManager>,
+	chain_source: Arc<ChainSource>,
+	chain_params: ChainParameters,
 	tx_broadcaster: Arc<Broadcaster>,
 	kv_store: Arc<DynStore>,
 	config: Arc<Config>,
@@ -166,6 +169,7 @@ where
 {
 	pub(crate) fn new(
 		wallet: Arc<Wallet>, channel_manager: Arc<ChannelManager>, keys_manager: Arc<KeysManager>,
+		chain_source: Arc<ChainSource>, chain_params: ChainParameters,
 		tx_broadcaster: Arc<Broadcaster>, kv_store: Arc<DynStore>, config: Arc<Config>, logger: L,
 	) -> Self {
 		let lsps1_client = None;
@@ -178,6 +182,8 @@ where
 			wallet,
 			channel_manager,
 			keys_manager,
+			chain_source,
+			chain_params,
 			tx_broadcaster,
 			kv_store,
 			config,
@@ -236,6 +242,7 @@ where
 			let lsps5_service_config = None;
 			let advertise_service = s.service_config.advertise_service;
 			LiquidityServiceConfig {
+				#[cfg(lsps1_service)]
 				lsps1_service_config: None,
 				lsps2_service_config,
 				lsps5_service_config,
@@ -257,6 +264,8 @@ where
 				Arc::clone(&self.keys_manager),
 				Arc::clone(&self.keys_manager),
 				Arc::clone(&self.channel_manager),
+				Some(Arc::clone(&self.chain_source)),
+				Some(self.chain_params),
 				Arc::clone(&self.kv_store),
 				Arc::clone(&self.tx_broadcaster),
 				liquidity_service_config,

src/types.rs

@@ -232,6 +232,7 @@ pub(crate) type LiquidityManager = lightning_liquidity::LiquidityManager<
 	Arc<KeysManager>,
 	Arc<KeysManager>,
 	Arc<ChannelManager>,
+	Arc<ChainSource>,
 	Arc<DynStore>,
 	DefaultTimeProvider,
 	Arc<Broadcaster>,