Merge pull request #841 from valentinewallace/207-replacement

[rust-lightning] / lightning / src / ln / msgs.rs

diff --git a/lightning/src/ln/msgs.rs b/lightning/src/ln/msgs.rs
index 5319742cbe22b9408c481ed17665ce28911ad3b5..01a4378456498d7c20706784da60ea13790e3d26 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,
@@ -752,7 +759,7 @@ pub trait ChannelMessageHandler : MessageSendEventsProvider + Send + Sync {
 
        // Channl close:
        /// Handle an incoming shutdown message from the given peer.
-       fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
+       fn handle_shutdown(&self, their_node_id: &PublicKey, their_features: &InitFeatures, msg: &Shutdown);
        /// Handle an incoming closing_signed message from the given peer.
        fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
 
@@ -789,6 +796,9 @@ pub trait ChannelMessageHandler : MessageSendEventsProvider + Send + Sync {
        /// Handle an incoming channel_reestablish message from the given peer.
        fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
 
+       /// Handle an incoming channel update from the given peer.
+       fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
+
        // Error:
        /// Handle an incoming error message from the given peer.
        fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
@@ -1682,6 +1692,19 @@ impl Writeable for ReplyShortChannelIdsEnd {
        }
 }
 
+impl QueryChannelRange {
+       /**
+        * Calculates the overflow safe ending block height for the query.
+        * Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`
+        */
+       pub fn end_blocknum(&self) -> u32 {
+               match self.first_blocknum.checked_add(self.number_of_blocks) {
+                       Some(block) => block,
+                       None => u32::max_value(),
+               }
+       }
+}
+
 impl Readable for QueryChannelRange {
        fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
                let chain_hash: BlockHash = Readable::read(r)?;
@@ -2523,6 +2546,24 @@ mod tests {
                assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
        }
 
+       #[test]
+       fn query_channel_range_end_blocknum() {
+               let tests: Vec<(u32, u32, u32)> = vec![
+                       (10000, 1500, 11500),
+                       (0, 0xffffffff, 0xffffffff),
+                       (1, 0xffffffff, 0xffffffff),
+               ];
+
+               for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
+                       let sut = msgs::QueryChannelRange {
+                               chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
+                               first_blocknum,
+                               number_of_blocks,
+                       };
+                       assert_eq!(sut.end_blocknum(), expected);
+               }
+       }
+
        #[test]
        fn encoding_query_channel_range() {
                let mut query_channel_range = msgs::QueryChannelRange {