Track remote peer forwarding parameters on local channel

Author: Antoine Riard

fuzz/fuzz_targets/router_target.rs

@@ -206,6 +206,10 @@ pub fn do_test(data: &[u8]) {
 								remote_network_id: get_pubkey!(),
 								channel_value_satoshis: slice_to_be64(get_slice!(8)),
 								user_id: 0,
+								their_to_self_delay: 0,
+								their_htlc_minimum_msat: 0,
+								their_fee_base_msat: 0,
+								their_fee_proportional_millionths: 0,
 							});
 						}
 						Some(&first_hops_vec[..])

src/ln/channel.rs

@@ -325,6 +325,8 @@ pub(super) struct Channel {
 	their_to_self_delay: u16,
 	//implied by BREAKDOWN_TIMEOUT: our_to_self_delay: u16,
 	their_max_accepted_htlcs: u16,
+	their_fee_base_msat: u32,
+	their_fee_proportional_millionths: u32,
 	//implied by OUR_MAX_HTLCS: our_max_accepted_htlcs: u16,
 	minimum_depth: u32,
 
@@ -491,6 +493,8 @@ impl Channel {
 			our_htlc_minimum_msat: Channel::derive_our_htlc_minimum_msat(feerate),
 			their_to_self_delay: 0,
 			their_max_accepted_htlcs: 0,
+			their_fee_base_msat: 0,
+			their_fee_proportional_millionths: 0,
 			minimum_depth: 0, // Filled in in accept_channel
 
 			their_funding_pubkey: None,
@@ -681,6 +685,8 @@ impl Channel {
 			our_htlc_minimum_msat: Channel::derive_our_htlc_minimum_msat(msg.feerate_per_kw as u64),
 			their_to_self_delay: msg.to_self_delay,
 			their_max_accepted_htlcs: msg.max_accepted_htlcs,
+			their_fee_base_msat: 0,
+			their_fee_proportional_millionths: 0,
 			minimum_depth: Channel::derive_minimum_depth(msg.funding_satoshis*1000, msg.push_msat),
 
 			their_funding_pubkey: Some(msg.funding_pubkey),
@@ -2040,6 +2046,14 @@ impl Channel {
 
 	}
 
+	/// Set channel fields with remote peer forwarding parameters, used mainly by ChannelDetails to feed the Router
+	pub fn channel_update(&mut self, msg: &msgs::ChannelUpdate) {
+		self.their_to_self_delay = msg.contents.cltv_expiry_delta;
+		self.their_htlc_minimum_msat = msg.contents.htlc_minimum_msat;
+		self.their_fee_base_msat = msg.contents.fee_base_msat;
+		self.their_fee_proportional_millionths = msg.contents.fee_proportional_millionths;
+	}
+
 	/// Adds a pending update to this channel. See the doc for send_htlc for
 	/// further details on the optionness of the return value.
 	/// You MUST call send_commitment prior to any other calls on this Channel
@@ -2641,6 +2655,18 @@ impl Channel {
 		self.our_htlc_minimum_msat
 	}
 
+	pub fn get_their_to_self_delay(&self) -> u16 {
+		self.their_to_self_delay
+	}
+
+	pub fn get_their_fee_base_msat(&self) -> u32 {
+		self.their_fee_base_msat
+	}
+
+	pub fn get_their_fee_proportional_millionths(&self) -> u32 {
+		self.their_fee_proportional_millionths
+	}
+
 	pub fn get_value_satoshis(&self) -> u64 {
 		self.channel_value_satoshis
 	}
@@ -3587,6 +3613,8 @@ impl Writeable for Channel {
 		self.our_htlc_minimum_msat.write(writer)?;
 		self.their_to_self_delay.write(writer)?;
 		self.their_max_accepted_htlcs.write(writer)?;
+		self.their_fee_base_msat.write(writer)?;
+		self.their_fee_proportional_millionths.write(writer)?;
 		self.minimum_depth.write(writer)?;
 
 		write_option!(self.their_funding_pubkey);
@@ -3761,6 +3789,8 @@ impl<R : ::std::io::Read> ReadableArgs<R, Arc<Logger>> for Channel {
 		let our_htlc_minimum_msat = Readable::read(reader)?;
 		let their_to_self_delay = Readable::read(reader)?;
 		let their_max_accepted_htlcs = Readable::read(reader)?;
+		let their_fee_base_msat = Readable::read(reader)?;
+		let their_fee_proportional_millionths = Readable::read(reader)?;
 		let minimum_depth = Readable::read(reader)?;
 
 		let their_funding_pubkey = read_option!();
@@ -3838,6 +3868,8 @@ impl<R : ::std::io::Read> ReadableArgs<R, Arc<Logger>> for Channel {
 			our_htlc_minimum_msat,
 			their_to_self_delay,
 			their_max_accepted_htlcs,
+			their_fee_base_msat,
+			their_fee_proportional_millionths,
 			minimum_depth,
 
 			their_funding_pubkey,

src/ln/channelmanager.rs

@@ -384,6 +384,14 @@ pub struct ChannelDetails {
 	pub channel_value_satoshis: u64,
 	/// The user_id passed in to create_channel, or 0 if the channel was inbound.
 	pub user_id: u64,
+	/// The CLTV delta added for the remote peer as a forwarding node
+	pub their_to_self_delay: u16,
+	/// The minimum HTLC amount for which the remote peer as a forwarding node is ready to relay
+	pub their_htlc_minimum_msat: u64,
+	/// The base fee the remote peer as a forwarding node will take to relay any HTLC.
+	pub their_fee_base_msat: u32,
+	/// The proportional fee on amount forwarded by a HTLC the remote peer will take to relay.
+	pub their_fee_proportional_millionths: u32,
 }
 
 macro_rules! handle_error {
@@ -539,6 +547,10 @@ impl ChannelManager {
 				remote_network_id: channel.get_their_node_id(),
 				channel_value_satoshis: channel.get_value_satoshis(),
 				user_id: channel.get_user_id(),
+				their_to_self_delay: channel.get_their_to_self_delay(),
+				their_htlc_minimum_msat: channel.get_their_htlc_minimum_msat(),
+				their_fee_base_msat: channel.get_their_fee_base_msat(),
+				their_fee_proportional_millionths: channel.get_their_fee_proportional_millionths(),
 			});
 		}
 		res
@@ -560,6 +572,10 @@ impl ChannelManager {
 					remote_network_id: channel.get_their_node_id(),
 					channel_value_satoshis: channel.get_value_satoshis(),
 					user_id: channel.get_user_id(),
+					their_to_self_delay: channel.get_their_to_self_delay(),
+					their_htlc_minimum_msat: channel.get_their_htlc_minimum_msat(),
+					their_fee_base_msat: channel.get_their_fee_base_msat(),
+					their_fee_proportional_millionths: channel.get_their_fee_proportional_millionths(),
 				});
 			}
 		}
@@ -2776,6 +2792,17 @@ impl ChannelMessageHandler for ChannelManager {
 		handle_error!(self, self.internal_announcement_signatures(their_node_id, msg), their_node_id)
 	}
 
+	fn handle_channel_update(&self, msg: &msgs::ChannelUpdate) -> Result<(), HandleError> {
+		let mut channel_state_lock = self.channel_state.lock().unwrap();
+		let channel_state = channel_state_lock.borrow_parts();
+		if let Some(channel_id) = channel_state.short_to_id.get(&msg.contents.short_channel_id) {
+			if let Some(chan) = channel_state.by_id.get_mut(channel_id) {
+				chan.channel_update(&msg);
+			}
+		}
+		Ok(())
+	}
+
 	fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &msgs::ChannelReestablish) -> Result<(), HandleError> {
 		let _ = self.total_consistency_lock.read().unwrap();
 		handle_error!(self, self.internal_channel_reestablish(their_node_id, msg), their_node_id)
@@ -8130,4 +8157,5 @@ mod tests {
 		assert_eq!(spend_txn.len(), 1);
 		check_spends!(spend_txn[0], closing_tx);
 	}
+
 }

src/ln/msgs.rs

@@ -559,6 +559,8 @@ pub trait ChannelMessageHandler : events::MessageSendEventsProvider + Send + Syn
 	// Channel-to-announce:
 	/// Handle an incoming announcement_signatures message from the given peer.
 	fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures) -> Result<(), HandleError>;
+	/// Handle an incoming channel_update message from the given peer.
+	fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<(), HandleError>;
 
 	// Connection loss/reestablish:
 	/// Indicates a connection to the peer failed/an existing connection was lost. If no connection

src/ln/peer_handler.rs

@@ -739,6 +739,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
 											},
 											258 => {
 												let msg = try_potential_decodeerror!(msgs::ChannelUpdate::read(&mut reader));
+												try_potential_handleerror!(self.message_handler.chan_handler.handle_channel_update(&msg));
 												let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_channel_update(&msg));
 
 												if should_forward {

src/ln/router.rs

@@ -1292,6 +1292,10 @@ mod tests {
 				remote_network_id: node8.clone(),
 				channel_value_satoshis: 0,
 				user_id: 0,
+				their_to_self_delay: 0,
+				their_htlc_minimum_msat: 0,
+				their_fee_base_msat: 0,
+				their_fee_proportional_millionths: 0,
 			}];
 			let route = router.get_route(&node3, Some(&our_chans), &Vec::new(), 100, 42).unwrap();
 			assert_eq!(route.hops.len(), 2);
@@ -1367,6 +1371,10 @@ mod tests {
 				remote_network_id: node4.clone(),
 				channel_value_satoshis: 0,
 				user_id: 0,
+				their_to_self_delay: 0,
+				their_htlc_minimum_msat: 0,
+				their_fee_base_msat: 0,
+				their_fee_proportional_millionths: 0,
 			}];
 			let route = router.get_route(&node7, Some(&our_chans), &last_hops, 100, 42).unwrap();
 			assert_eq!(route.hops.len(), 2);

src/util/test_utils.rs

@@ -133,6 +133,9 @@ impl msgs::ChannelMessageHandler for TestChannelMessageHandler {
 	fn handle_announcement_signatures(&self, _their_node_id: &PublicKey, _msg: &msgs::AnnouncementSignatures) -> Result<(), HandleError> {
 		Err(HandleError { err: "", action: None })
 	}
+	fn handle_channel_update(&self, _msg: &msgs::ChannelUpdate) -> Result<(), HandleError> {
+		Err(HandleError { err: "", action: None })
+	}
 	fn handle_channel_reestablish(&self, _their_node_id: &PublicKey, _msg: &msgs::ChannelReestablish) -> Result<(), HandleError> {
 		Err(HandleError { err: "", action: None })
 	}