Use UserConfig to determine advertised InitFeatures by ChannelManager

[rust-lightning] / lightning / src / chain / channelmonitor.rs

diff --git a/lightning/src/chain/channelmonitor.rs b/lightning/src/chain/channelmonitor.rs
index e16a533cb1d608102c91a0fce5e8d8792ab8493d..36c1eac1ab0e5a1db91618fb46b65e1e255e052b 100644 (file)
--- a/lightning/src/chain/channelmonitor.rs
+++ b/lightning/src/chain/channelmonitor.rs
@@ -3704,9 +3704,9 @@ where
 
 const MAX_ALLOC_SIZE: usize = 64*1024;
 
-impl<'a, K: EntropySource + SignerProvider> ReadableArgs<&'a K>
-               for (BlockHash, ChannelMonitor<K::Signer>) {
-       fn read<R: io::Read>(reader: &mut R, keys_manager: &'a K) -> Result<Self, DecodeError> {
+impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP)>
+               for (BlockHash, ChannelMonitor<SP::Signer>) {
+       fn read<R: io::Read>(reader: &mut R, args: (&'a ES, &'b SP)) -> Result<Self, DecodeError> {
                macro_rules! unwrap_obj {
                        ($key: expr) => {
                                match $key {
@@ -3716,6 +3716,8 @@ impl<'a, K: EntropySource + SignerProvider> ReadableArgs<&'a K>
                        }
                }
 
+               let (entropy_source, signer_provider) = args;
+
                let _ver = read_ver_prefix!(reader, SERIALIZATION_VERSION);
 
                let latest_update_id: u64 = Readable::read(reader)?;
@@ -3889,8 +3891,8 @@ impl<'a, K: EntropySource + SignerProvider> ReadableArgs<&'a K>
                                return Err(DecodeError::InvalidValue);
                        }
                }
-               let onchain_tx_handler: OnchainTxHandler<K::Signer> = ReadableArgs::read(
-                       reader, (keys_manager, channel_value_satoshis, channel_keys_id)
+               let onchain_tx_handler: OnchainTxHandler<SP::Signer> = ReadableArgs::read(
+                       reader, (entropy_source, signer_provider, channel_value_satoshis, channel_keys_id)
                )?;
 
                let lockdown_from_offchain = Readable::read(reader)?;
@@ -3930,7 +3932,7 @@ impl<'a, K: EntropySource + SignerProvider> ReadableArgs<&'a K>
                });
 
                let mut secp_ctx = Secp256k1::new();
-               secp_ctx.seeded_randomize(&keys_manager.get_secure_random_bytes());
+               secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
 
                Ok((best_block.block_hash(), ChannelMonitor::from_impl(ChannelMonitorImpl {
                        latest_update_id,
@@ -4019,7 +4021,7 @@ mod tests {
        use crate::ln::{PaymentPreimage, PaymentHash};
        use crate::ln::chan_utils;
        use crate::ln::chan_utils::{HTLCOutputInCommitment, ChannelPublicKeys, ChannelTransactionParameters, HolderCommitmentTransaction, CounterpartyChannelTransactionParameters};
-       use crate::ln::channelmanager::{self, PaymentSendFailure, PaymentId};
+       use crate::ln::channelmanager::{PaymentSendFailure, PaymentId};
        use crate::ln::functional_test_utils::*;
        use crate::ln::script::ShutdownScript;
        use crate::util::errors::APIError;
@@ -4047,10 +4049,8 @@ mod tests {
                let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
                let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
                let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
-               let channel = create_announced_chan_between_nodes(
-                       &nodes, 0, 1, channelmanager::provided_init_features(), channelmanager::provided_init_features());
-               create_announced_chan_between_nodes(
-                       &nodes, 1, 2, channelmanager::provided_init_features(), channelmanager::provided_init_features());
+               let channel = create_announced_chan_between_nodes(&nodes, 0, 1);
+               create_announced_chan_between_nodes(&nodes, 1, 2);
 
                // Rebalance somewhat
                send_payment(&nodes[0], &[&nodes[1]], 10_000_000);
@@ -4079,7 +4079,7 @@ mod tests {
 
                let (_, pre_update_monitor) = <(BlockHash, ChannelMonitor<InMemorySigner>)>::read(
                                                &mut io::Cursor::new(&get_monitor!(nodes[1], channel.2).encode()),
-                                               &nodes[1].keys_manager.backing).unwrap();
+                                               (&nodes[1].keys_manager.backing, &nodes[1].keys_manager.backing)).unwrap();
 
                // If the ChannelManager tries to update the channel, however, the ChainMonitor will pass
                // the update through to the ChannelMonitor which will refuse it (as the channel is closed).