Add CounterpartyForwardingInfo field to channel.

This will be filled in in upcoming commits, then exposed in ChannelDetails
to allow constructing route hints for invoices.

Also update the cltv_expiry_deta comment in msgs::ChannelUpdate

Co-authored-by: Valentine Wallace <vwallace@protonmail.com>
Co-authored-by: Antoine Riard <ariard@student.42.fr>

diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs
index 9e4bb081c1a98ddc5bd17c4b818a835a37f10a65..426083dd832e243fcf24ce15082c79be800725a3 100644 (file)
--- a/lightning/src/ln/channel.rs
+++ b/lightning/src/ln/channel.rs
@@ -281,6 +281,18 @@ impl HTLCCandidate {
        }
 }
 
+/// Information needed for constructing an invoice route hint for this channel.
+pub struct CounterpartyForwardingInfo {
+       /// Base routing fee in millisatoshis.
+       pub fee_base_msat: u32,
+       /// Amount in millionths of a satoshi the channel will charge per transferred satoshi.
+       pub fee_proportional_millionths: u32,
+       /// The minimum difference in cltv_expiry between an ingoing HTLC and its outgoing counterpart,
+       /// such that the outgoing HTLC is forwardable to this counterparty. See `msgs::ChannelUpdate`'s
+       /// `cltv_expiry_delta` for more details.
+       pub cltv_expiry_delta: u16,
+}
+
 // TODO: We should refactor this to be an Inbound/OutboundChannel until initial setup handshaking
 // has been completed, and then turn into a Channel to get compiler-time enforcement of things like
 // calling channel_id() before we're set up or things like get_outbound_funding_signed on an
@@ -391,6 +403,8 @@ pub(super) struct Channel<Signer: Sign> {
        //implied by OUR_MAX_HTLCS: max_accepted_htlcs: u16,
        minimum_depth: u32,
 
+       counterparty_forwarding_info: Option<CounterpartyForwardingInfo>,
+
        pub(crate) channel_transaction_parameters: ChannelTransactionParameters,
 
        counterparty_cur_commitment_point: Option<PublicKey>,
@@ -577,6 +591,8 @@ impl<Signer: Sign> Channel<Signer> {
                        counterparty_max_accepted_htlcs: 0,
                        minimum_depth: 0, // Filled in in accept_channel
 
+                       counterparty_forwarding_info: None,
+
                        channel_transaction_parameters: ChannelTransactionParameters {
                                holder_pubkeys: pubkeys,
                                holder_selected_contest_delay: config.own_channel_config.our_to_self_delay,
@@ -813,6 +829,8 @@ impl<Signer: Sign> Channel<Signer> {
                        counterparty_max_accepted_htlcs: msg.max_accepted_htlcs,
                        minimum_depth: config.own_channel_config.minimum_depth,
 
+                       counterparty_forwarding_info: None,
+
                        channel_transaction_parameters: ChannelTransactionParameters {
                                holder_pubkeys: pubkeys,
                                holder_selected_contest_delay: config.own_channel_config.our_to_self_delay,
@@ -4437,6 +4455,16 @@ impl<Signer: Sign> Writeable for Channel<Signer> {
                self.counterparty_max_accepted_htlcs.write(writer)?;
                self.minimum_depth.write(writer)?;
 
+               match &self.counterparty_forwarding_info {
+                       Some(info) => {
+                               1u8.write(writer)?;
+                               info.fee_base_msat.write(writer)?;
+                               info.fee_proportional_millionths.write(writer)?;
+                               info.cltv_expiry_delta.write(writer)?;
+                       },
+                       None => 0u8.write(writer)?
+               }
+
                self.channel_transaction_parameters.write(writer)?;
                self.counterparty_cur_commitment_point.write(writer)?;
 
@@ -4597,6 +4625,16 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<&'a K> for Channel<Signer>
                let counterparty_max_accepted_htlcs = Readable::read(reader)?;
                let minimum_depth = Readable::read(reader)?;
 
+               let counterparty_forwarding_info = match <u8 as Readable>::read(reader)? {
+                       0 => None,
+                       1 => Some(CounterpartyForwardingInfo {
+                               fee_base_msat: Readable::read(reader)?,
+                               fee_proportional_millionths: Readable::read(reader)?,
+                               cltv_expiry_delta: Readable::read(reader)?,
+                       }),
+                       _ => return Err(DecodeError::InvalidValue),
+               };
+
                let channel_parameters = Readable::read(reader)?;
                let counterparty_cur_commitment_point = Readable::read(reader)?;
 
@@ -4667,6 +4705,8 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<&'a K> for Channel<Signer>
                        counterparty_max_accepted_htlcs,
                        minimum_depth,
 
+                       counterparty_forwarding_info,
+
                        channel_transaction_parameters: channel_parameters,
                        counterparty_cur_commitment_point,
 

diff --git a/lightning/src/ln/msgs.rs b/lightning/src/ln/msgs.rs
index 3042b4d32e0a344e185ef9756654aefa759606aa..004bd3d99d318e2458f41e9c31307614afb93b5f 100644 (file)
--- a/lightning/src/ln/msgs.rs
+++ b/lightning/src/ln/msgs.rs
@@ -543,7 +543,14 @@ pub struct UnsignedChannelUpdate {
        pub timestamp: u32,
        /// Channel flags
        pub flags: u8,
-       /// The number of blocks to subtract from incoming HTLC cltv_expiry values
+       /// The number of blocks such that if:
+       /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
+       /// then we need to fail the HTLC backwards. When forwarding an HTLC, cltv_expiry_delta determines
+       /// the outgoing HTLC's minimum cltv_expiry value -- so, if an incoming HTLC comes in with a
+       /// cltv_expiry of 100000, and the node we're forwarding to has a cltv_expiry_delta value of 10,
+       /// then we'll check that the outgoing HTLC's cltv_expiry value is at least 100010 before
+       /// forwarding. Note that the HTLC sender is the one who originally sets this value when
+       /// constructing the route.
        pub cltv_expiry_delta: u16,
        /// The minimum HTLC size incoming to sender, in milli-satoshi
        pub htlc_minimum_msat: u64,