]> git.bitcoin.ninja Git - rust-lightning/commitdiff
Change the new() functions for config to Default::default()
authorSteven Roose <steven@stevenroose.org>
Fri, 18 Oct 2019 13:19:49 +0000 (14:19 +0100)
committerMatt Corallo <git@bluematt.me>
Mon, 9 Dec 2019 20:56:51 +0000 (15:56 -0500)
fuzz/fuzz_targets/chanmon_fail_consistency.rs
fuzz/fuzz_targets/full_stack_target.rs
lightning/src/ln/channel.rs
lightning/src/ln/functional_test_utils.rs
lightning/src/ln/functional_tests.rs
lightning/src/util/config.rs

index 0af9083b5a96dca89c7ffbf1d12cd01cf629768f..b34d2421537648d5989f846868261ac85b03480b 100644 (file)
@@ -190,7 +190,7 @@ pub fn do_test(data: &[u8]) {
                        let monitor = Arc::new(TestChannelMonitor::new(watch.clone(), broadcast.clone(), logger.clone(), fee_est.clone()));
 
                        let keys_manager = Arc::new(KeyProvider { node_id: $node_id, session_id: atomic::AtomicU8::new(0), channel_id: atomic::AtomicU8::new(0) });
-                       let mut config = UserConfig::new();
+                       let mut config = UserConfig::default();
                        config.channel_options.fee_proportional_millionths = 0;
                        config.channel_options.announced_channel = true;
                        config.peer_channel_config_limits.min_dust_limit_satoshis = 0;
@@ -206,7 +206,7 @@ pub fn do_test(data: &[u8]) {
                        let monitor = Arc::new(TestChannelMonitor::new(watch.clone(), broadcast.clone(), logger.clone(), fee_est.clone()));
 
                        let keys_manager = Arc::new(KeyProvider { node_id: $node_id, session_id: atomic::AtomicU8::new(0), channel_id: atomic::AtomicU8::new(0) });
-                       let mut config = UserConfig::new();
+                       let mut config = UserConfig::default();
                        config.channel_options.fee_proportional_millionths = 0;
                        config.channel_options.announced_channel = true;
                        config.peer_channel_config_limits.min_dust_limit_satoshis = 0;
index b267a4647c5b1a16cb7cbbc877848a11c758a2c1..c7821e27056f4106644a96d9b5a2d99d9a058ea8 100644 (file)
@@ -328,7 +328,7 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
        let monitor = channelmonitor::SimpleManyChannelMonitor::new(watch.clone(), broadcast.clone(), Arc::clone(&logger), fee_est.clone());
 
        let keys_manager = Arc::new(KeyProvider { node_secret: our_network_key.clone(), counter: AtomicU64::new(0) });
-       let mut config = UserConfig::new();
+       let mut config = UserConfig::default();
        config.channel_options.fee_proportional_millionths =  slice_to_be32(get_slice!(4));
        config.channel_options.announced_channel = get_slice!(1)[0] != 0;
        config.peer_channel_config_limits.min_dust_limit_satoshis = 0;
index 269aef215f8b82e60a7180a10b18ef72d9085049..e3edc0e9a98d1b5dfcdcdf24592f01c48fdc0f88 100644 (file)
@@ -4225,7 +4225,7 @@ mod tests {
                let keys_provider: Arc<KeysInterface> = Arc::new(Keys { chan_keys });
 
                let their_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
-               let mut config = UserConfig::new();
+               let mut config = UserConfig::default();
                config.channel_options.announced_channel = false;
                let mut chan = Channel::new_outbound(&feeest, &keys_provider, their_node_id, 10000000, 100000, 42, Arc::clone(&logger), &config).unwrap(); // Nothing uses their network key in this test
                chan.their_to_self_delay = 144;
index 4c8f162bcf53dc41c982346ce4335222ce4e451f..4a1b5e8a790cd7ce57cf93b8261a9fdca40a951a 100644 (file)
@@ -845,7 +845,7 @@ pub fn create_network(node_count: usize, node_config: &[Option<UserConfig>]) ->
                let chan_monitor = Arc::new(test_utils::TestChannelMonitor::new(chain_monitor.clone(), tx_broadcaster.clone(), logger.clone(), feeest.clone()));
                let weak_res = Arc::downgrade(&chan_monitor.simple_monitor);
                block_notifier.register_listener(weak_res);
-               let mut default_config = UserConfig::new();
+               let mut default_config = UserConfig::default();
                default_config.channel_options.announced_channel = true;
                default_config.peer_channel_config_limits.force_announced_channel_preference = false;
                let node = ChannelManager::new(Network::Testnet, feeest.clone(), chan_monitor.clone(), tx_broadcaster.clone(), Arc::clone(&logger), keys_manager.clone(), if node_config[i].is_some() { node_config[i].clone().unwrap() } else { default_config }, 0).unwrap();
index 1648538fac81382f77a15310a907523560030e4e..e5d54dab0861dacd749e86e75c425daf475777f4 100644 (file)
@@ -1846,11 +1846,11 @@ fn channel_monitor_network_test() {
 #[test]
 fn test_justice_tx() {
        // Test justice txn built on revoked HTLC-Success tx, against both sides
-       let mut alice_config = UserConfig::new();
+       let mut alice_config = UserConfig::default();
        alice_config.channel_options.announced_channel = true;
        alice_config.peer_channel_config_limits.force_announced_channel_preference = false;
        alice_config.own_channel_config.our_to_self_delay = 6 * 24 * 5;
-       let mut bob_config = UserConfig::new();
+       let mut bob_config = UserConfig::default();
        bob_config.channel_options.announced_channel = true;
        bob_config.peer_channel_config_limits.force_announced_channel_preference = false;
        bob_config.own_channel_config.our_to_self_delay = 6 * 24 * 3;
@@ -3388,7 +3388,7 @@ fn test_no_txn_manager_serialize_deserialize() {
        assert!(chan_0_monitor_read.is_empty());
 
        let mut nodes_0_read = &nodes_0_serialized[..];
-       let config = UserConfig::new();
+       let config = UserConfig::default();
        let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet, Arc::new(test_utils::TestLogger::new())));
        let (_, nodes_0_deserialized) = {
                let mut channel_monitors = HashMap::new();
@@ -3458,7 +3458,7 @@ fn test_simple_manager_serialize_deserialize() {
                let mut channel_monitors = HashMap::new();
                channel_monitors.insert(chan_0_monitor.get_funding_txo().unwrap(), &chan_0_monitor);
                <(Sha256dHash, ChannelManager)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
-                       default_config: UserConfig::new(),
+                       default_config: UserConfig::default(),
                        keys_manager,
                        fee_estimator: Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }),
                        monitor: nodes[0].chan_monitor.clone(),
@@ -3518,7 +3518,7 @@ fn test_manager_serialize_deserialize_inconsistent_monitor() {
        let mut nodes_0_read = &nodes_0_serialized[..];
        let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet, Arc::new(test_utils::TestLogger::new())));
        let (_, nodes_0_deserialized) = <(Sha256dHash, ChannelManager)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
-               default_config: UserConfig::new(),
+               default_config: UserConfig::default(),
                keys_manager,
                fee_estimator: Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }),
                monitor: nodes[0].chan_monitor.clone(),
@@ -5948,7 +5948,7 @@ fn test_upfront_shutdown_script() {
        // BOLT 2 : Option upfront shutdown script, if peer commit its closing_script at channel opening
        // enforce it at shutdown message
 
-       let mut config = UserConfig::new();
+       let mut config = UserConfig::default();
        config.channel_options.announced_channel = true;
        config.peer_channel_config_limits.force_announced_channel_preference = false;
        config.channel_options.commit_upfront_shutdown_pubkey = false;
@@ -6046,9 +6046,9 @@ fn test_upfront_shutdown_script() {
 fn test_user_configurable_csv_delay() {
        // We test our channel constructors yield errors when we pass them absurd csv delay
 
-       let mut low_our_to_self_config = UserConfig::new();
+       let mut low_our_to_self_config = UserConfig::default();
        low_our_to_self_config.own_channel_config.our_to_self_delay = 6;
-       let mut high_their_to_self_config = UserConfig::new();
+       let mut high_their_to_self_config = UserConfig::default();
        high_their_to_self_config.peer_channel_config_limits.their_to_self_delay = 100;
        let cfgs = [Some(high_their_to_self_config.clone()), None];
        let nodes = create_network(2, &cfgs);
@@ -6135,7 +6135,7 @@ fn test_data_loss_protect() {
                monitor: monitor.clone(),
                logger: Arc::clone(&logger),
                tx_broadcaster,
-               default_config: UserConfig::new(),
+               default_config: UserConfig::default(),
                channel_monitors: &channel_monitors
        }).unwrap().1;
        nodes[0].node = Arc::new(node_state_0);
index 0b61a5699ea853489d1a59901584784edcba7c0f..70ba6ae80f44b69117255a000b1572f4db501671 100644 (file)
@@ -14,13 +14,13 @@ pub struct UserConfig {
        pub channel_options: ChannelConfig,
 }
 
-impl UserConfig {
+impl Default for UserConfig {
        /// Provides sane defaults for most configurations (but with 0 relay fees!)
-       pub fn new() -> Self{
+       fn default() -> Self {
                UserConfig {
-                       own_channel_config: ChannelHandshakeConfig::new(),
-                       peer_channel_config_limits: ChannelHandshakeLimits::new(),
-                       channel_options: ChannelConfig::new(),
+                       own_channel_config: ChannelHandshakeConfig::default(),
+                       peer_channel_config_limits: ChannelHandshakeLimits::default(),
+                       channel_options: ChannelConfig::default(),
                }
        }
 }
@@ -46,9 +46,9 @@ pub struct ChannelHandshakeConfig {
        pub our_to_self_delay: u16,
 }
 
-impl ChannelHandshakeConfig {
+impl Default for ChannelHandshakeConfig {
        /// Provides sane defaults for `ChannelHandshakeConfig`
-       pub fn new() -> ChannelHandshakeConfig {
+       fn default() -> ChannelHandshakeConfig {
                ChannelHandshakeConfig {
                        minimum_depth: 6,
                        our_to_self_delay: BREAKDOWN_TIMEOUT,
@@ -112,13 +112,13 @@ pub struct ChannelHandshakeLimits {
        pub their_to_self_delay: u16
 }
 
-impl ChannelHandshakeLimits {
+impl Default for ChannelHandshakeLimits {
        /// Provides sane defaults for most configurations.
        ///
        /// Most additional limits are disabled except those with which specify a default in individual
        /// field documentation. Note that this may result in barely-usable channels, but since they
        /// are applied mostly only to incoming channels that's not much of a problem.
-       pub fn new() -> Self {
+       fn default() -> Self {
                ChannelHandshakeLimits {
                        min_funding_satoshis: 0,
                        max_htlc_minimum_msat: <u64>::max_value(),
@@ -164,9 +164,9 @@ pub struct ChannelConfig {
        pub commit_upfront_shutdown_pubkey: bool
 }
 
-impl ChannelConfig {
+impl Default for ChannelConfig {
        /// Provides sane defaults for most configurations (but with zero relay fees!).
-       pub fn new() -> Self {
+       fn default() -> Self {
                ChannelConfig {
                        fee_proportional_millionths: 0,
                        announced_channel: false,