Also correct/check links in private item documentation

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

diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs
index ce048f0eeb96df1b429b066a852e42c93dea84dc..16a8829468ec7a0323461369727142eb4bdb5a22 100644 (file)
--- a/lightning/src/ln/channel.rs
+++ b/lightning/src/ln/channel.rs
@@ -37,6 +37,7 @@ use util::ser::{Readable, ReadableArgs, Writeable, Writer, VecWriter};
 use util::logger::Logger;
 use util::errors::APIError;
 use util::config::{UserConfig,ChannelConfig};
+use util::scid_utils::scid_from_parts;
 
 use std;
 use std::{cmp,mem,fmt};
@@ -95,6 +96,7 @@ enum InboundHTLCState {
        /// is used to derive commitment keys, which are used to construct the
        /// signatures in a commitment_signed message.
        /// Implies AwaitingRemoteRevoke.
+       ///
        /// [BOLT #2]: https://github.com/lightningnetwork/lightning-rfc/blob/master/02-peer-protocol.md
        AwaitingRemoteRevokeToAnnounce(PendingHTLCStatus),
        /// Included in a received commitment_signed message (implying we've revoke_and_ack'd it).
@@ -282,6 +284,7 @@ impl HTLCCandidate {
 }
 
 /// Information needed for constructing an invoice route hint for this channel.
+#[derive(Clone)]
 pub struct CounterpartyForwardingInfo {
        /// Base routing fee in millisatoshis.
        pub fee_base_msat: u32,
@@ -3568,14 +3571,11 @@ impl<Signer: Sign> Channel<Signer> {
                                                                }
                                                        }
                                                }
-                                               if height > 0xff_ff_ff || (index_in_block) > 0xff_ff_ff {
-                                                       panic!("Block was bogus - either height 16 million or had > 16 million transactions");
-                                               }
-                                               assert!(txo_idx <= 0xffff); // txo_idx is a (u16 as usize), so this is just listed here for completeness
                                                self.funding_tx_confirmations = 1;
-                                               self.short_channel_id = Some(((height as u64)         << (5*8)) |
-                                                                            ((index_in_block as u64) << (2*8)) |
-                                                                            ((txo_idx as u64)        << (0*8)));
+                                               self.short_channel_id = match scid_from_parts(height as u64, index_in_block as u64, txo_idx as u64) {
+                                                       Ok(scid) => Some(scid),
+                                                       Err(_) => panic!("Block was bogus - either height was > 16 million, had > 16 million transactions, or had > 65k outputs"),
+                                               }
                                        }
                                }
                        }
@@ -4132,6 +4132,11 @@ impl<Signer: Sign> Channel<Signer> {
                }
        }
 
+       /// Get forwarding information for the counterparty.
+       pub fn counterparty_forwarding_info(&self) -> Option<CounterpartyForwardingInfo> {
+               self.counterparty_forwarding_info.clone()
+       }
+
        pub fn channel_update(&mut self, msg: &msgs::ChannelUpdate) -> Result<(), ChannelError> {
                let usable_channel_value_msat = (self.channel_value_satoshis - self.counterparty_selected_channel_reserve_satoshis) * 1000;
                if msg.contents.htlc_minimum_msat >= usable_channel_value_msat {
@@ -4756,7 +4761,7 @@ mod tests {
        use ln::channel::{Channel,Sign,InboundHTLCOutput,OutboundHTLCOutput,InboundHTLCState,OutboundHTLCState,HTLCOutputInCommitment,HTLCCandidate,HTLCInitiator,TxCreationKeys};
        use ln::channel::MAX_FUNDING_SATOSHIS;
        use ln::features::InitFeatures;
-       use ln::msgs::{OptionalField, DataLossProtect, DecodeError};
+       use ln::msgs::{ChannelUpdate, DataLossProtect, DecodeError, OptionalField, UnsignedChannelUpdate};
        use ln::chan_utils;
        use ln::chan_utils::{ChannelPublicKeys, HolderCommitmentTransaction, CounterpartyChannelTransactionParameters, HTLC_SUCCESS_TX_WEIGHT, HTLC_TIMEOUT_TX_WEIGHT};
        use chain::chaininterface::{FeeEstimator,ConfirmationTarget};
@@ -4767,6 +4772,7 @@ mod tests {
        use util::test_utils;
        use util::logger::Logger;
        use bitcoin::secp256k1::{Secp256k1, Message, Signature, All};
+       use bitcoin::secp256k1::ffi::Signature as FFISignature;
        use bitcoin::secp256k1::key::{SecretKey,PublicKey};
        use bitcoin::hashes::sha256::Hash as Sha256;
        use bitcoin::hashes::Hash;
@@ -5023,6 +5029,54 @@ mod tests {
                }
        }
 
+       #[test]
+       fn channel_update() {
+               let feeest = TestFeeEstimator{fee_est: 15000};
+               let secp_ctx = Secp256k1::new();
+               let seed = [42; 32];
+               let network = Network::Testnet;
+               let chain_hash = genesis_block(network).header.block_hash();
+               let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
+
+               // Create a channel.
+               let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
+               let config = UserConfig::default();
+               let mut node_a_chan = Channel::<EnforcingSigner>::new_outbound(&&feeest, &&keys_provider, node_b_node_id, 10000000, 100000, 42, &config).unwrap();
+               assert!(node_a_chan.counterparty_forwarding_info.is_none());
+               assert_eq!(node_a_chan.holder_htlc_minimum_msat, 1); // the default
+               assert!(node_a_chan.counterparty_forwarding_info().is_none());
+
+               // Make sure that receiving a channel update will update the Channel as expected.
+               let update = ChannelUpdate {
+                       contents: UnsignedChannelUpdate {
+                               chain_hash,
+                               short_channel_id: 0,
+                               timestamp: 0,
+                               flags: 0,
+                               cltv_expiry_delta: 100,
+                               htlc_minimum_msat: 5,
+                               htlc_maximum_msat: OptionalField::Absent,
+                               fee_base_msat: 110,
+                               fee_proportional_millionths: 11,
+                               excess_data: Vec::new(),
+                       },
+                       signature: Signature::from(unsafe { FFISignature::new() })
+               };
+               node_a_chan.channel_update(&update).unwrap();
+
+               // The counterparty can send an update with a higher minimum HTLC, but that shouldn't
+               // change our official htlc_minimum_msat.
+               assert_eq!(node_a_chan.holder_htlc_minimum_msat, 1);
+               match node_a_chan.counterparty_forwarding_info() {
+                       Some(info) => {
+                               assert_eq!(info.cltv_expiry_delta, 100);
+                               assert_eq!(info.fee_base_msat, 110);
+                               assert_eq!(info.fee_proportional_millionths, 11);
+                       },
+                       None => panic!("expected counterparty forwarding info to be Some")
+               }
+       }
+
        #[test]
        fn outbound_commitment_test() {
                // Test vectors from BOLT 3 Appendix C: