Expose counterparty forwarding info in ChannelDetails.

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

diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs
index ce048f0eeb96df1b429b066a852e42c93dea84dc..a6049e915e9fdc71de34cd62725743c6006ef6f1 100644 (file)
--- a/lightning/src/ln/channel.rs
+++ b/lightning/src/ln/channel.rs
@@ -282,6 +282,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,
@@ -4132,6 +4133,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 +4762,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 +4773,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 +5030,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: