]> git.bitcoin.ninja Git - rust-lightning/commitdiff
Rename `FundingLocked` to `ChannelReady`.
authorElias Rohrer <ero@tnull.de>
Mon, 30 May 2022 21:39:04 +0000 (14:39 -0700)
committerElias Rohrer <ero@tnull.de>
Tue, 31 May 2022 00:07:09 +0000 (17:07 -0700)
27 files changed:
fuzz/src/bin/gen_target.sh
fuzz/src/bin/msg_channel_ready_target.rs [new file with mode: 0644]
fuzz/src/bin/msg_funding_locked_target.rs [deleted file]
fuzz/src/chanmon_consistency.rs
fuzz/src/full_stack.rs
fuzz/src/msg_targets/gen_target.sh
fuzz/src/msg_targets/mod.rs
fuzz/src/msg_targets/msg_channel_ready.rs [new file with mode: 0644]
fuzz/src/msg_targets/msg_funding_locked.rs [deleted file]
fuzz/src/router.rs
fuzz/targets.h
lightning-background-processor/src/lib.rs
lightning-invoice/src/utils.rs
lightning-net-tokio/src/lib.rs
lightning/src/ln/chanmon_update_fail_tests.rs
lightning/src/ln/channel.rs
lightning/src/ln/channelmanager.rs
lightning/src/ln/functional_test_utils.rs
lightning/src/ln/functional_tests.rs
lightning/src/ln/msgs.rs
lightning/src/ln/peer_handler.rs
lightning/src/ln/priv_short_conf_tests.rs
lightning/src/ln/shutdown_tests.rs
lightning/src/ln/wire.rs
lightning/src/routing/router.rs
lightning/src/util/events.rs
lightning/src/util/test_utils.rs

index 72fefe51609103c7ed7c8cbf74ed2b33f6b9552f..b88b72503779d72854fbbb213a77b0f82e474336 100755 (executable)
@@ -21,7 +21,7 @@ GEN_TEST msg_closing_signed msg_targets::
 GEN_TEST msg_commitment_signed msg_targets::
 GEN_TEST msg_decoded_onion_error_packet msg_targets::
 GEN_TEST msg_funding_created msg_targets::
-GEN_TEST msg_funding_locked msg_targets::
+GEN_TEST msg_channel_ready msg_targets::
 GEN_TEST msg_funding_signed msg_targets::
 GEN_TEST msg_init msg_targets::
 GEN_TEST msg_open_channel msg_targets::
diff --git a/fuzz/src/bin/msg_channel_ready_target.rs b/fuzz/src/bin/msg_channel_ready_target.rs
new file mode 100644 (file)
index 0000000..d11068b
--- /dev/null
@@ -0,0 +1,113 @@
+// This file is Copyright its original authors, visible in version control
+// history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
+// This file is auto-generated by gen_target.sh based on target_template.txt
+// To modify it, modify target_template.txt and run gen_target.sh instead.
+
+#![cfg_attr(feature = "libfuzzer_fuzz", no_main)]
+
+#[cfg(not(fuzzing))]
+compile_error!("Fuzz targets need cfg=fuzzing");
+
+extern crate lightning_fuzz;
+use lightning_fuzz::msg_targets::msg_channel_ready::*;
+
+#[cfg(feature = "afl")]
+#[macro_use] extern crate afl;
+#[cfg(feature = "afl")]
+fn main() {
+       fuzz!(|data| {
+               msg_channel_ready_run(data.as_ptr(), data.len());
+       });
+}
+
+#[cfg(feature = "honggfuzz")]
+#[macro_use] extern crate honggfuzz;
+#[cfg(feature = "honggfuzz")]
+fn main() {
+       loop {
+               fuzz!(|data| {
+                       msg_channel_ready_run(data.as_ptr(), data.len());
+               });
+       }
+}
+
+#[cfg(feature = "libfuzzer_fuzz")]
+#[macro_use] extern crate libfuzzer_sys;
+#[cfg(feature = "libfuzzer_fuzz")]
+fuzz_target!(|data: &[u8]| {
+       msg_channel_ready_run(data.as_ptr(), data.len());
+});
+
+#[cfg(feature = "stdin_fuzz")]
+fn main() {
+       use std::io::Read;
+
+       let mut data = Vec::with_capacity(8192);
+       std::io::stdin().read_to_end(&mut data).unwrap();
+       msg_channel_ready_run(data.as_ptr(), data.len());
+}
+
+#[test]
+fn run_test_cases() {
+       use std::fs;
+       use std::io::Read;
+       use lightning_fuzz::utils::test_logger::StringBuffer;
+
+       use std::sync::{atomic, Arc};
+       {
+               let data: Vec<u8> = vec![0];
+               msg_channel_ready_run(data.as_ptr(), data.len());
+       }
+       let mut threads = Vec::new();
+       let threads_running = Arc::new(atomic::AtomicUsize::new(0));
+       if let Ok(tests) = fs::read_dir("test_cases/msg_channel_ready") {
+               for test in tests {
+                       let mut data: Vec<u8> = Vec::new();
+                       let path = test.unwrap().path();
+                       fs::File::open(&path).unwrap().read_to_end(&mut data).unwrap();
+                       threads_running.fetch_add(1, atomic::Ordering::AcqRel);
+
+                       let thread_count_ref = Arc::clone(&threads_running);
+                       let main_thread_ref = std::thread::current();
+                       threads.push((path.file_name().unwrap().to_str().unwrap().to_string(),
+                               std::thread::spawn(move || {
+                                       let string_logger = StringBuffer::new();
+
+                                       let panic_logger = string_logger.clone();
+                                       let res = if ::std::panic::catch_unwind(move || {
+                                               msg_channel_ready_test(&data, panic_logger);
+                                       }).is_err() {
+                                               Some(string_logger.into_string())
+                                       } else { None };
+                                       thread_count_ref.fetch_sub(1, atomic::Ordering::AcqRel);
+                                       main_thread_ref.unpark();
+                                       res
+                               })
+                       ));
+                       while threads_running.load(atomic::Ordering::Acquire) > 32 {
+                               std::thread::park();
+                       }
+               }
+       }
+       let mut failed_outputs = Vec::new();
+       for (test, thread) in threads.drain(..) {
+               if let Some(output) = thread.join().unwrap() {
+                       println!("\nOutput of {}:\n{}\n", test, output);
+                       failed_outputs.push(test);
+               }
+       }
+       if !failed_outputs.is_empty() {
+               println!("Test cases which failed: ");
+               for case in failed_outputs {
+                       println!("{}", case);
+               }
+               panic!();
+       }
+}
diff --git a/fuzz/src/bin/msg_funding_locked_target.rs b/fuzz/src/bin/msg_funding_locked_target.rs
deleted file mode 100644 (file)
index 986f7f8..0000000
+++ /dev/null
@@ -1,113 +0,0 @@
-// This file is Copyright its original authors, visible in version control
-// history.
-//
-// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
-// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// You may not use this file except in accordance with one or both of these
-// licenses.
-
-// This file is auto-generated by gen_target.sh based on target_template.txt
-// To modify it, modify target_template.txt and run gen_target.sh instead.
-
-#![cfg_attr(feature = "libfuzzer_fuzz", no_main)]
-
-#[cfg(not(fuzzing))]
-compile_error!("Fuzz targets need cfg=fuzzing");
-
-extern crate lightning_fuzz;
-use lightning_fuzz::msg_targets::msg_funding_locked::*;
-
-#[cfg(feature = "afl")]
-#[macro_use] extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-       fuzz!(|data| {
-               msg_funding_locked_run(data.as_ptr(), data.len());
-       });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
-fn main() {
-       loop {
-               fuzz!(|data| {
-                       msg_funding_locked_run(data.as_ptr(), data.len());
-               });
-       }
-}
-
-#[cfg(feature = "libfuzzer_fuzz")]
-#[macro_use] extern crate libfuzzer_sys;
-#[cfg(feature = "libfuzzer_fuzz")]
-fuzz_target!(|data: &[u8]| {
-       msg_funding_locked_run(data.as_ptr(), data.len());
-});
-
-#[cfg(feature = "stdin_fuzz")]
-fn main() {
-       use std::io::Read;
-
-       let mut data = Vec::with_capacity(8192);
-       std::io::stdin().read_to_end(&mut data).unwrap();
-       msg_funding_locked_run(data.as_ptr(), data.len());
-}
-
-#[test]
-fn run_test_cases() {
-       use std::fs;
-       use std::io::Read;
-       use lightning_fuzz::utils::test_logger::StringBuffer;
-
-       use std::sync::{atomic, Arc};
-       {
-               let data: Vec<u8> = vec![0];
-               msg_funding_locked_run(data.as_ptr(), data.len());
-       }
-       let mut threads = Vec::new();
-       let threads_running = Arc::new(atomic::AtomicUsize::new(0));
-       if let Ok(tests) = fs::read_dir("test_cases/msg_funding_locked") {
-               for test in tests {
-                       let mut data: Vec<u8> = Vec::new();
-                       let path = test.unwrap().path();
-                       fs::File::open(&path).unwrap().read_to_end(&mut data).unwrap();
-                       threads_running.fetch_add(1, atomic::Ordering::AcqRel);
-
-                       let thread_count_ref = Arc::clone(&threads_running);
-                       let main_thread_ref = std::thread::current();
-                       threads.push((path.file_name().unwrap().to_str().unwrap().to_string(),
-                               std::thread::spawn(move || {
-                                       let string_logger = StringBuffer::new();
-
-                                       let panic_logger = string_logger.clone();
-                                       let res = if ::std::panic::catch_unwind(move || {
-                                               msg_funding_locked_test(&data, panic_logger);
-                                       }).is_err() {
-                                               Some(string_logger.into_string())
-                                       } else { None };
-                                       thread_count_ref.fetch_sub(1, atomic::Ordering::AcqRel);
-                                       main_thread_ref.unpark();
-                                       res
-                               })
-                       ));
-                       while threads_running.load(atomic::Ordering::Acquire) > 32 {
-                               std::thread::park();
-                       }
-               }
-       }
-       let mut failed_outputs = Vec::new();
-       for (test, thread) in threads.drain(..) {
-               if let Some(output) = thread.join().unwrap() {
-                       println!("\nOutput of {}:\n{}\n", test, output);
-                       failed_outputs.push(test);
-               }
-       }
-       if !failed_outputs.is_empty() {
-               println!("Test cases which failed: ");
-               for case in failed_outputs {
-                       println!("{}", case);
-               }
-               panic!();
-       }
-}
index 540b4e4c497f7e87da935f9acf4098eceef481f5..9625677c263378f3a9eed66be03e78989def25d4 100644 (file)
@@ -490,10 +490,10 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out) {
                        }
                        for (idx, node_event) in node_events.iter().enumerate() {
                                for event in node_event {
-                                       if let events::MessageSendEvent::SendFundingLocked { ref node_id, ref msg } = event {
+                                       if let events::MessageSendEvent::SendChannelReady { ref node_id, ref msg } = event {
                                                for node in $nodes.iter() {
                                                        if node.get_our_node_id() == *node_id {
-                                                               node.handle_funding_locked(&$nodes[idx].get_our_node_id(), msg);
+                                                               node.handle_channel_ready(&$nodes[idx].get_our_node_id(), msg);
                                                        }
                                                }
                                        } else { panic!("Wrong event type"); }
@@ -597,7 +597,7 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out) {
                                                        if Some(*node_id) == expect_drop_id { panic!("peer_disconnected should drop msgs bound for the disconnected peer"); }
                                                        *node_id == a_id
                                                },
-                                               events::MessageSendEvent::SendFundingLocked { .. } => continue,
+                                               events::MessageSendEvent::SendChannelReady { .. } => continue,
                                                events::MessageSendEvent::SendAnnouncementSignatures { .. } => continue,
                                                events::MessageSendEvent::SendChannelUpdate { ref node_id, ref msg } => {
                                                        assert_eq!(msg.contents.flags & 2, 0); // The disable bit must never be set!
@@ -725,7 +725,7 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out) {
                                                                }
                                                        }
                                                },
-                                               events::MessageSendEvent::SendFundingLocked { .. } => {
+                                               events::MessageSendEvent::SendChannelReady { .. } => {
                                                        // Can be generated as a reestablish response
                                                },
                                                events::MessageSendEvent::SendAnnouncementSignatures { .. } => {
@@ -771,7 +771,7 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out) {
                                                        events::MessageSendEvent::UpdateHTLCs { .. } => {},
                                                        events::MessageSendEvent::SendRevokeAndACK { .. } => {},
                                                        events::MessageSendEvent::SendChannelReestablish { .. } => {},
-                                                       events::MessageSendEvent::SendFundingLocked { .. } => {},
+                                                       events::MessageSendEvent::SendChannelReady { .. } => {},
                                                        events::MessageSendEvent::SendAnnouncementSignatures { .. } => {},
                                                        events::MessageSendEvent::SendChannelUpdate { ref msg, .. } => {
                                                                assert_eq!(msg.contents.flags & 2, 0); // The disable bit must never be set!
@@ -792,7 +792,7 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out) {
                                                        events::MessageSendEvent::UpdateHTLCs { .. } => {},
                                                        events::MessageSendEvent::SendRevokeAndACK { .. } => {},
                                                        events::MessageSendEvent::SendChannelReestablish { .. } => {},
-                                                       events::MessageSendEvent::SendFundingLocked { .. } => {},
+                                                       events::MessageSendEvent::SendChannelReady { .. } => {},
                                                        events::MessageSendEvent::SendAnnouncementSignatures { .. } => {},
                                                        events::MessageSendEvent::SendChannelUpdate { ref msg, .. } => {
                                                                assert_eq!(msg.contents.flags & 2, 0); // The disable bit must never be set!
index e3c8290b16ea820e4a26bf585a5684384f1f46c3..00b123b84dd1942da7f20d1be5fdf10f2cd8a1fd 100644 (file)
@@ -739,12 +739,12 @@ mod tests {
                // 0c0000 - connect a block with no transactions
                // 0c0000 - connect a block with no transactions
                // 0c0000 - connect a block with no transactions
-               // - by now client should have sent a funding_locked (CHECK 3: SendFundingLocked to 03000000 for chan 3d000000)
+               // - by now client should have sent a channel_ready (CHECK 3: SendChannelReady to 03000000 for chan 3d000000)
                //
                // 030012 - inbound read from peer id 0 of len 18
                // 0043 03000000000000000000000000000000 - message header indicating message length 67
                // 030053 - inbound read from peer id 0 of len 83
-               // 0024 3d00000000000000000000000000000000000000000000000000000000000000 020800000000000000000000000000000000000000000000000000000000000000 03000000000000000000000000000000 - funding_locked and mac
+               // 0024 3d00000000000000000000000000000000000000000000000000000000000000 020800000000000000000000000000000000000000000000000000000000000000 03000000000000000000000000000000 - channel_ready and mac
                //
                // 01 - new inbound connection with id 1
                // 030132 - inbound read from peer id 1 of len 50
@@ -775,12 +775,12 @@ mod tests {
                // 0023 3a00000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000007c0001000000000000000000000000000000000000000000000000000000000000 01000000000000000000000000000000 - funding_signed message and mac
                //
                // 0b - broadcast funding transaction
-               // - by now client should have sent a funding_locked (CHECK 4: SendFundingLocked to 03020000 for chan 3f000000)
+               // - by now client should have sent a channel_ready (CHECK 4: SendChannelReady to 03020000 for chan 3f000000)
                //
                // 030112 - inbound read from peer id 1 of len 18
                // 0043 01000000000000000000000000000000 - message header indicating message length 67
                // 030153 - inbound read from peer id 1 of len 83
-               // 0024 3a00000000000000000000000000000000000000000000000000000000000000 026700000000000000000000000000000000000000000000000000000000000000 01000000000000000000000000000000 - funding_locked and mac
+               // 0024 3a00000000000000000000000000000000000000000000000000000000000000 026700000000000000000000000000000000000000000000000000000000000000 01000000000000000000000000000000 - channel_ready and mac
                //
                // 030012 - inbound read from peer id 0 of len 18
                // 05ac 03000000000000000000000000000000 - message header indicating message length 1452
@@ -964,8 +964,8 @@ mod tests {
                let log_entries = logger.lines.lock().unwrap();
                assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Handling SendAcceptChannel event in peer_handler for node 030000000000000000000000000000000000000000000000000000000000000002 for channel ff4f00f805273c1b203bb5ebf8436bfde57b3be8c2f5e95d9491dbb181909679".to_string())), Some(&1)); // 1
                assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Handling SendFundingSigned event in peer_handler for node 030000000000000000000000000000000000000000000000000000000000000002 for channel 3d00000000000000000000000000000000000000000000000000000000000000".to_string())), Some(&1)); // 2
-               assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Handling SendFundingLocked event in peer_handler for node 030000000000000000000000000000000000000000000000000000000000000002 for channel 3d00000000000000000000000000000000000000000000000000000000000000".to_string())), Some(&1)); // 3
-               assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Handling SendFundingLocked event in peer_handler for node 030200000000000000000000000000000000000000000000000000000000000000 for channel 3a00000000000000000000000000000000000000000000000000000000000000".to_string())), Some(&1)); // 4
+               assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Handling SendChannelReady event in peer_handler for node 030000000000000000000000000000000000000000000000000000000000000002 for channel 3d00000000000000000000000000000000000000000000000000000000000000".to_string())), Some(&1)); // 3
+               assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Handling SendChannelReady event in peer_handler for node 030200000000000000000000000000000000000000000000000000000000000000 for channel 3a00000000000000000000000000000000000000000000000000000000000000".to_string())), Some(&1)); // 4
                assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Handling SendRevokeAndACK event in peer_handler for node 030000000000000000000000000000000000000000000000000000000000000002 for channel 3d00000000000000000000000000000000000000000000000000000000000000".to_string())), Some(&4)); // 5
                assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Handling UpdateHTLCs event in peer_handler for node 030000000000000000000000000000000000000000000000000000000000000002 with 0 adds, 0 fulfills, 0 fails for channel 3d00000000000000000000000000000000000000000000000000000000000000".to_string())), Some(&3)); // 6
                assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Handling UpdateHTLCs event in peer_handler for node 030200000000000000000000000000000000000000000000000000000000000000 with 1 adds, 0 fulfills, 0 fails for channel 3a00000000000000000000000000000000000000000000000000000000000000".to_string())), Some(&3)); // 7
index 0e930cfa1ac7b85b1f871c0bc745bdb752e128eb..848793db50082b20cbe1c520dd430bde30466140 100755 (executable)
@@ -16,7 +16,7 @@ GEN_TEST AnnouncementSignatures test_msg_simple ""
 GEN_TEST ClosingSigned test_msg_simple ""
 GEN_TEST CommitmentSigned test_msg_simple ""
 GEN_TEST FundingCreated test_msg_simple ""
-GEN_TEST FundingLocked test_msg_simple ""
+GEN_TEST ChannelReady test_msg_simple ""
 GEN_TEST FundingSigned test_msg_simple ""
 GEN_TEST GossipTimestampFilter test_msg_simple ""
 GEN_TEST Init test_msg_simple ""
index 8acb690b04bf92a0f1df4028fbc6f00eef0cc8b1..dd1540ce51ec51f21c3bdc28fed92d31bd194127 100644 (file)
@@ -4,7 +4,7 @@ pub mod msg_announcement_signatures;
 pub mod msg_closing_signed;
 pub mod msg_commitment_signed;
 pub mod msg_funding_created;
-pub mod msg_funding_locked;
+pub mod msg_channel_ready;
 pub mod msg_funding_signed;
 pub mod msg_gossip_timestamp_filter;
 pub mod msg_init;
diff --git a/fuzz/src/msg_targets/msg_channel_ready.rs b/fuzz/src/msg_targets/msg_channel_ready.rs
new file mode 100644 (file)
index 0000000..e5f3b25
--- /dev/null
@@ -0,0 +1,27 @@
+// This file is Copyright its original authors, visible in version control
+// history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
+// This file is auto-generated by gen_target.sh based on msg_target_template.txt
+// To modify it, modify msg_target_template.txt and run gen_target.sh instead.
+
+use lightning::ln::msgs;
+
+use msg_targets::utils::VecWriter;
+use utils::test_logger;
+
+#[inline]
+pub fn msg_channel_ready_test<Out: test_logger::Output>(data: &[u8], _out: Out) {
+       test_msg_simple!(msgs::ChannelReady, data);
+}
+
+#[no_mangle]
+pub extern "C" fn msg_channel_ready_run(data: *const u8, datalen: usize) {
+       let data = unsafe { std::slice::from_raw_parts(data, datalen) };
+       test_msg_simple!(msgs::ChannelReady, data);
+}
diff --git a/fuzz/src/msg_targets/msg_funding_locked.rs b/fuzz/src/msg_targets/msg_funding_locked.rs
deleted file mode 100644 (file)
index 2c6ad63..0000000
+++ /dev/null
@@ -1,27 +0,0 @@
-// This file is Copyright its original authors, visible in version control
-// history.
-//
-// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
-// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// You may not use this file except in accordance with one or both of these
-// licenses.
-
-// This file is auto-generated by gen_target.sh based on msg_target_template.txt
-// To modify it, modify msg_target_template.txt and run gen_target.sh instead.
-
-use lightning::ln::msgs;
-
-use msg_targets::utils::VecWriter;
-use utils::test_logger;
-
-#[inline]
-pub fn msg_funding_locked_test<Out: test_logger::Output>(data: &[u8], _out: Out) {
-       test_msg_simple!(msgs::FundingLocked, data);
-}
-
-#[no_mangle]
-pub extern "C" fn msg_funding_locked_run(data: *const u8, datalen: usize) {
-       let data = unsafe { std::slice::from_raw_parts(data, datalen) };
-       test_msg_simple!(msgs::FundingLocked, data);
-}
index 80ea1f1bc73d6932e4ab3db1a2da8904b0f77f14..bb6ba2c6e51cb0a2ac65d86023279c08954532b9 100644 (file)
@@ -228,7 +228,7 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
                                                                unspendable_punishment_reserve: None,
                                                                confirmations_required: None,
                                                                force_close_spend_delay: None,
-                                                               is_outbound: true, is_funding_locked: true,
+                                                               is_outbound: true, is_channel_ready: true,
                                                                is_usable: true, is_public: true,
                                                                balance_msat: 0,
                                                                outbound_capacity_msat: capacity.saturating_mul(1000),
index 798fb66479519cf9b00a84ce3d5873787c449b58..d142aa6487eb36e8e436457be951d84771162f8f 100644 (file)
@@ -13,7 +13,7 @@ void msg_closing_signed_run(const unsigned char* data, size_t data_len);
 void msg_commitment_signed_run(const unsigned char* data, size_t data_len);
 void msg_decoded_onion_error_packet_run(const unsigned char* data, size_t data_len);
 void msg_funding_created_run(const unsigned char* data, size_t data_len);
-void msg_funding_locked_run(const unsigned char* data, size_t data_len);
+void msg_channel_ready_run(const unsigned char* data, size_t data_len);
 void msg_funding_signed_run(const unsigned char* data, size_t data_len);
 void msg_init_run(const unsigned char* data, size_t data_len);
 void msg_open_channel_run(const unsigned char* data, size_t data_len);
index dab376178488654d70322155400c0bd263b740a4..95c753bca80521ef9bf203b00f94d477881ec386 100644 (file)
@@ -759,12 +759,12 @@ mod tests {
 
                // Confirm the funding transaction.
                confirm_transaction(&mut nodes[0], &funding_tx);
-               let as_funding = get_event_msg!(nodes[0], MessageSendEvent::SendFundingLocked, nodes[1].node.get_our_node_id());
+               let as_funding = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, nodes[1].node.get_our_node_id());
                confirm_transaction(&mut nodes[1], &funding_tx);
-               let bs_funding = get_event_msg!(nodes[1], MessageSendEvent::SendFundingLocked, nodes[0].node.get_our_node_id());
-               nodes[0].node.handle_funding_locked(&nodes[1].node.get_our_node_id(), &bs_funding);
+               let bs_funding = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, nodes[0].node.get_our_node_id());
+               nodes[0].node.handle_channel_ready(&nodes[1].node.get_our_node_id(), &bs_funding);
                let _as_channel_update = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id());
-               nodes[1].node.handle_funding_locked(&nodes[0].node.get_our_node_id(), &as_funding);
+               nodes[1].node.handle_channel_ready(&nodes[0].node.get_our_node_id(), &as_funding);
                let _bs_channel_update = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[0].node.get_our_node_id());
 
                assert!(bg_processor.stop().is_ok());
index 9b3b41afbedae5f938c01968f221a843870d376c..9f6691564ca64399b9e3299096783248187bc043 100644 (file)
@@ -672,10 +672,10 @@ mod test {
                connect_blocks(&nodes[2], CHAN_CONFIRM_DEPTH - 1);
                confirm_transaction_at(&nodes[0], &tx, conf_height);
                connect_blocks(&nodes[0], CHAN_CONFIRM_DEPTH - 1);
-               let as_funding_locked = get_event_msg!(nodes[2], MessageSendEvent::SendFundingLocked, nodes[0].node.get_our_node_id());
-               nodes[2].node.handle_funding_locked(&nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendFundingLocked, nodes[2].node.get_our_node_id()));
+               let as_channel_ready = get_event_msg!(nodes[2], MessageSendEvent::SendChannelReady, nodes[0].node.get_our_node_id());
+               nodes[2].node.handle_channel_ready(&nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, nodes[2].node.get_our_node_id()));
                get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[0].node.get_our_node_id());
-               nodes[0].node.handle_funding_locked(&nodes[2].node.get_our_node_id(), &as_funding_locked);
+               nodes[0].node.handle_channel_ready(&nodes[2].node.get_our_node_id(), &as_channel_ready);
                get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[2].node.get_our_node_id());
 
                // As `msgs::ChannelUpdate` was never handled for the participating node(s) of the second
@@ -1059,10 +1059,10 @@ mod test {
                connect_blocks(&nodes[1], CHAN_CONFIRM_DEPTH - 1);
                confirm_transaction_at(&nodes[3], &tx, conf_height);
                connect_blocks(&nodes[3], CHAN_CONFIRM_DEPTH - 1);
-               let as_funding_locked = get_event_msg!(nodes[1], MessageSendEvent::SendFundingLocked, nodes[3].node.get_our_node_id());
-               nodes[1].node.handle_funding_locked(&nodes[3].node.get_our_node_id(), &get_event_msg!(nodes[3], MessageSendEvent::SendFundingLocked, nodes[1].node.get_our_node_id()));
+               let as_channel_ready = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, nodes[3].node.get_our_node_id());
+               nodes[1].node.handle_channel_ready(&nodes[3].node.get_our_node_id(), &get_event_msg!(nodes[3], MessageSendEvent::SendChannelReady, nodes[1].node.get_our_node_id()));
                get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[3].node.get_our_node_id());
-               nodes[3].node.handle_funding_locked(&nodes[1].node.get_our_node_id(), &as_funding_locked);
+               nodes[3].node.handle_channel_ready(&nodes[1].node.get_our_node_id(), &as_channel_ready);
                get_event_msg!(nodes[3], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id());
 
                // As `msgs::ChannelUpdate` was never handled for the participating node(s) of the third
index f7e42b6634147d405e2cfebe1278801940e0a771..2ac10762b04eaf23f602bc3d8dcc987438542cae 100644 (file)
@@ -549,7 +549,7 @@ mod tests {
                fn handle_accept_channel(&self, _their_node_id: &PublicKey, _their_features: InitFeatures, _msg: &AcceptChannel) {}
                fn handle_funding_created(&self, _their_node_id: &PublicKey, _msg: &FundingCreated) {}
                fn handle_funding_signed(&self, _their_node_id: &PublicKey, _msg: &FundingSigned) {}
-               fn handle_funding_locked(&self, _their_node_id: &PublicKey, _msg: &FundingLocked) {}
+               fn handle_channel_ready(&self, _their_node_id: &PublicKey, _msg: &ChannelReady) {}
                fn handle_shutdown(&self, _their_node_id: &PublicKey, _their_features: &InitFeatures, _msg: &Shutdown) {}
                fn handle_closing_signed(&self, _their_node_id: &PublicKey, _msg: &ClosingSigned) {}
                fn handle_update_add_htlc(&self, _their_node_id: &PublicKey, _msg: &UpdateAddHTLC) {}
index fe80d350cd7de4010058453c6bd31fef543b6e3f..770fe8139413446bcc498086d00572db696f7dbc 100644 (file)
@@ -1848,7 +1848,7 @@ fn do_during_funding_monitor_fail(confirm_a_first: bool, restore_b_before_conf:
 
        if confirm_a_first {
                confirm_transaction(&nodes[0], &funding_tx);
-               nodes[1].node.handle_funding_locked(&nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendFundingLocked, nodes[1].node.get_our_node_id()));
+               nodes[1].node.handle_channel_ready(&nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, nodes[1].node.get_our_node_id()));
                assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
                assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
        } else {
@@ -1857,7 +1857,7 @@ fn do_during_funding_monitor_fail(confirm_a_first: bool, restore_b_before_conf:
                assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
        }
 
-       // Make sure nodes[1] isn't stupid enough to re-send the FundingLocked on reconnect
+       // Make sure nodes[1] isn't stupid enough to re-send the ChannelReady on reconnect
        nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
        nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
        reconnect_nodes(&nodes[0], &nodes[1], (false, confirm_a_first), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
@@ -1871,7 +1871,7 @@ fn do_during_funding_monitor_fail(confirm_a_first: bool, restore_b_before_conf:
        }
        if !confirm_a_first && !restore_b_before_lock {
                confirm_transaction(&nodes[0], &funding_tx);
-               nodes[1].node.handle_funding_locked(&nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendFundingLocked, nodes[1].node.get_our_node_id()));
+               nodes[1].node.handle_channel_ready(&nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, nodes[1].node.get_our_node_id()));
                assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
                assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
        }
@@ -1883,13 +1883,13 @@ fn do_during_funding_monitor_fail(confirm_a_first: bool, restore_b_before_conf:
 
        let (channel_id, (announcement, as_update, bs_update)) = if !confirm_a_first {
                if !restore_b_before_lock {
-                       let (funding_locked, channel_id) = create_chan_between_nodes_with_value_confirm_second(&nodes[0], &nodes[1]);
-                       (channel_id, create_chan_between_nodes_with_value_b(&nodes[1], &nodes[0], &funding_locked))
+                       let (channel_ready, channel_id) = create_chan_between_nodes_with_value_confirm_second(&nodes[0], &nodes[1]);
+                       (channel_id, create_chan_between_nodes_with_value_b(&nodes[1], &nodes[0], &channel_ready))
                } else {
-                       nodes[0].node.handle_funding_locked(&nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendFundingLocked, nodes[0].node.get_our_node_id()));
+                       nodes[0].node.handle_channel_ready(&nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, nodes[0].node.get_our_node_id()));
                        confirm_transaction(&nodes[0], &funding_tx);
-                       let (funding_locked, channel_id) = create_chan_between_nodes_with_value_confirm_second(&nodes[1], &nodes[0]);
-                       (channel_id, create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked))
+                       let (channel_ready, channel_id) = create_chan_between_nodes_with_value_confirm_second(&nodes[1], &nodes[0]);
+                       (channel_id, create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &channel_ready))
                }
        } else {
                if restore_b_before_conf {
@@ -1897,8 +1897,8 @@ fn do_during_funding_monitor_fail(confirm_a_first: bool, restore_b_before_conf:
                        assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
                        confirm_transaction(&nodes[1], &funding_tx);
                }
-               let (funding_locked, channel_id) = create_chan_between_nodes_with_value_confirm_second(&nodes[0], &nodes[1]);
-               (channel_id, create_chan_between_nodes_with_value_b(&nodes[1], &nodes[0], &funding_locked))
+               let (channel_ready, channel_id) = create_chan_between_nodes_with_value_confirm_second(&nodes[0], &nodes[1]);
+               (channel_id, create_chan_between_nodes_with_value_b(&nodes[1], &nodes[0], &channel_ready))
        };
        for node in nodes.iter() {
                assert!(node.net_graph_msg_handler.handle_channel_announcement(&announcement).unwrap());
index 01cd6890a9f58100a54e0fe11d790822521cfa2a..ca02f0a9ac9e302ae10047025097ff24c1fcc7cd 100644 (file)
@@ -243,7 +243,7 @@ enum HTLCUpdateAwaitingACK {
 
 /// There are a few "states" and then a number of flags which can be applied:
 /// We first move through init with OurInitSent -> TheirInitSent -> FundingCreated -> FundingSent.
-/// TheirFundingLocked and OurFundingLocked then get set on FundingSent, and when both are set we
+/// TheirChannelReady and OurChannelReady then get set on FundingSent, and when both are set we
 /// move on to ChannelFunded.
 /// Note that PeerDisconnected can be set on both ChannelFunded and FundingSent.
 /// ChannelFunded can then get all remaining flags set on it, until we finish shutdown, then we
@@ -258,15 +258,15 @@ enum ChannelState {
        /// upon receipt of funding_created, so simply skip this state.
        FundingCreated = 4,
        /// Set when we have received/sent funding_created and funding_signed and are thus now waiting
-       /// on the funding transaction to confirm. The FundingLocked flags are set to indicate when we
+       /// on the funding transaction to confirm. The ChannelReady flags are set to indicate when we
        /// and our counterparty consider the funding transaction confirmed.
        FundingSent = 8,
-       /// Flag which can be set on FundingSent to indicate they sent us a funding_locked message.
-       /// Once both TheirFundingLocked and OurFundingLocked are set, state moves on to ChannelFunded.
-       TheirFundingLocked = 1 << 4,
-       /// Flag which can be set on FundingSent to indicate we sent them a funding_locked message.
-       /// Once both TheirFundingLocked and OurFundingLocked are set, state moves on to ChannelFunded.
-       OurFundingLocked = 1 << 5,
+       /// Flag which can be set on FundingSent to indicate they sent us a channel_ready message.
+       /// Once both TheirChannelReady and OurChannelReady are set, state moves on to ChannelFunded.
+       TheirChannelReady = 1 << 4,
+       /// Flag which can be set on FundingSent to indicate we sent them a channel_ready message.
+       /// Once both TheirChannelReady and OurChannelReady are set, state moves on to ChannelFunded.
+       OurChannelReady = 1 << 5,
        ChannelFunded = 64,
        /// Flag which is set on ChannelFunded and FundingSent indicating remote side is considered
        /// "disconnected" and no updates are allowed until after we've done a channel_reestablish
@@ -429,13 +429,13 @@ pub(super) struct MonitorRestoreUpdates {
        pub failed_htlcs: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
        pub finalized_claimed_htlcs: Vec<HTLCSource>,
        pub funding_broadcastable: Option<Transaction>,
-       pub funding_locked: Option<msgs::FundingLocked>,
+       pub channel_ready: Option<msgs::ChannelReady>,
        pub announcement_sigs: Option<msgs::AnnouncementSignatures>,
 }
 
 /// The return value of `channel_reestablish`
 pub(super) struct ReestablishResponses {
-       pub funding_locked: Option<msgs::FundingLocked>,
+       pub channel_ready: Option<msgs::ChannelReady>,
        pub raa: Option<msgs::RevokeAndACK>,
        pub commitment_update: Option<msgs::CommitmentUpdate>,
        pub order: RAACommitmentOrder,
@@ -543,7 +543,7 @@ pub(super) struct Channel<Signer: Sign> {
        /// send it first.
        resend_order: RAACommitmentOrder,
 
-       monitor_pending_funding_locked: bool,
+       monitor_pending_channel_ready: bool,
        monitor_pending_revoke_and_ack: bool,
        monitor_pending_commitment_signed: bool,
        monitor_pending_forwards: Vec<(PendingHTLCInfo, u64)>,
@@ -688,12 +688,12 @@ pub(super) struct Channel<Signer: Sign> {
 
        /// lnd has a long-standing bug where, upon reconnection, if the channel is not yet confirmed
        /// they will not send a channel_reestablish until the channel locks in. Then, they will send a
-       /// funding_locked *before* sending the channel_reestablish (which is clearly a violation of
-       /// the BOLT specs). We copy c-lightning's workaround here and simply store the funding_locked
+       /// channel_ready *before* sending the channel_reestablish (which is clearly a violation of
+       /// the BOLT specs). We copy c-lightning's workaround here and simply store the channel_ready
        /// message until we receive a channel_reestablish.
        ///
        /// See-also <https://github.com/lightningnetwork/lnd/issues/4006>
-       pub workaround_lnd_bug_4006: Option<msgs::FundingLocked>,
+       pub workaround_lnd_bug_4006: Option<msgs::ChannelReady>,
 
        #[cfg(any(test, fuzzing))]
        // When we receive an HTLC fulfill on an outbound path, we may immediately fulfill the
@@ -960,7 +960,7 @@ impl<Signer: Sign> Channel<Signer> {
 
                        resend_order: RAACommitmentOrder::CommitmentFirst,
 
-                       monitor_pending_funding_locked: false,
+                       monitor_pending_channel_ready: false,
                        monitor_pending_revoke_and_ack: false,
                        monitor_pending_commitment_signed: false,
                        monitor_pending_forwards: Vec::new(),
@@ -1277,7 +1277,7 @@ impl<Signer: Sign> Channel<Signer> {
 
                        resend_order: RAACommitmentOrder::CommitmentFirst,
 
-                       monitor_pending_funding_locked: false,
+                       monitor_pending_channel_ready: false,
                        monitor_pending_revoke_and_ack: false,
                        monitor_pending_commitment_signed: false,
                        monitor_pending_forwards: Vec::new(),
@@ -2119,7 +2119,7 @@ impl<Signer: Sign> Channel<Signer> {
                &self.get_counterparty_pubkeys().funding_pubkey
        }
 
-       pub fn funding_created<L: Deref>(&mut self, msg: &msgs::FundingCreated, best_block: BestBlock, logger: &L) -> Result<(msgs::FundingSigned, ChannelMonitor<Signer>, Option<msgs::FundingLocked>), ChannelError> where L::Target: Logger {
+       pub fn funding_created<L: Deref>(&mut self, msg: &msgs::FundingCreated, best_block: BestBlock, logger: &L) -> Result<(msgs::FundingSigned, ChannelMonitor<Signer>, Option<msgs::ChannelReady>), ChannelError> where L::Target: Logger {
                if self.is_outbound() {
                        return Err(ChannelError::Close("Received funding_created for an outbound channel?".to_owned()));
                }
@@ -2194,12 +2194,12 @@ impl<Signer: Sign> Channel<Signer> {
                Ok((msgs::FundingSigned {
                        channel_id: self.channel_id,
                        signature
-               }, channel_monitor, self.check_get_funding_locked(0)))
+               }, channel_monitor, self.check_get_channel_ready(0)))
        }
 
        /// Handles a funding_signed message from the remote end.
        /// If this call is successful, broadcast the funding transaction (and not before!)
-       pub fn funding_signed<L: Deref>(&mut self, msg: &msgs::FundingSigned, best_block: BestBlock, logger: &L) -> Result<(ChannelMonitor<Signer>, Transaction, Option<msgs::FundingLocked>), ChannelError> where L::Target: Logger {
+       pub fn funding_signed<L: Deref>(&mut self, msg: &msgs::FundingSigned, best_block: BestBlock, logger: &L) -> Result<(ChannelMonitor<Signer>, Transaction, Option<msgs::ChannelReady>), ChannelError> where L::Target: Logger {
                if !self.is_outbound() {
                        return Err(ChannelError::Close("Received funding_signed for an inbound channel?".to_owned()));
                }
@@ -2268,16 +2268,16 @@ impl<Signer: Sign> Channel<Signer> {
 
                log_info!(logger, "Received funding_signed from peer for channel {}", log_bytes!(self.channel_id()));
 
-               Ok((channel_monitor, self.funding_transaction.as_ref().cloned().unwrap(), self.check_get_funding_locked(0)))
+               Ok((channel_monitor, self.funding_transaction.as_ref().cloned().unwrap(), self.check_get_channel_ready(0)))
        }
 
-       /// Handles a funding_locked message from our peer. If we've already sent our funding_locked
+       /// Handles a channel_ready message from our peer. If we've already sent our channel_ready
        /// and the channel is now usable (and public), this may generate an announcement_signatures to
        /// reply with.
-       pub fn funding_locked<L: Deref>(&mut self, msg: &msgs::FundingLocked, node_pk: PublicKey, genesis_block_hash: BlockHash, best_block: &BestBlock, logger: &L) -> Result<Option<msgs::AnnouncementSignatures>, ChannelError> where L::Target: Logger {
+       pub fn channel_ready<L: Deref>(&mut self, msg: &msgs::ChannelReady, node_pk: PublicKey, genesis_block_hash: BlockHash, best_block: &BestBlock, logger: &L) -> Result<Option<msgs::AnnouncementSignatures>, ChannelError> where L::Target: Logger {
                if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
                        self.workaround_lnd_bug_4006 = Some(msg.clone());
-                       return Err(ChannelError::Ignore("Peer sent funding_locked when we needed a channel_reestablish. The peer is likely lnd, see https://github.com/lightningnetwork/lnd/issues/4006".to_owned()));
+                       return Err(ChannelError::Ignore("Peer sent channel_ready when we needed a channel_reestablish. The peer is likely lnd, see https://github.com/lightningnetwork/lnd/issues/4006".to_owned()));
                }
 
                if let Some(scid_alias) = msg.short_channel_id_alias {
@@ -2292,16 +2292,16 @@ impl<Signer: Sign> Channel<Signer> {
                let non_shutdown_state = self.channel_state & (!MULTI_STATE_FLAGS);
 
                if non_shutdown_state == ChannelState::FundingSent as u32 {
-                       self.channel_state |= ChannelState::TheirFundingLocked as u32;
-               } else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::OurFundingLocked as u32) {
+                       self.channel_state |= ChannelState::TheirChannelReady as u32;
+               } else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::OurChannelReady as u32) {
                        self.channel_state = ChannelState::ChannelFunded as u32 | (self.channel_state & MULTI_STATE_FLAGS);
                        self.update_time_counter += 1;
                } else if self.channel_state & (ChannelState::ChannelFunded as u32) != 0 ||
-                       // If we reconnected before sending our funding locked they may still resend theirs:
-                       (self.channel_state & (ChannelState::FundingSent as u32 | ChannelState::TheirFundingLocked as u32) ==
-                                             (ChannelState::FundingSent as u32 | ChannelState::TheirFundingLocked as u32))
+                       // If we reconnected before sending our `channel_ready` they may still resend theirs:
+                       (self.channel_state & (ChannelState::FundingSent as u32 | ChannelState::TheirChannelReady as u32) ==
+                                             (ChannelState::FundingSent as u32 | ChannelState::TheirChannelReady as u32))
                {
-                       // They probably disconnected/reconnected and re-sent the funding_locked, which is
+                       // They probably disconnected/reconnected and re-sent the channel_ready, which is
                        // required, or they're sending a fresh SCID alias.
                        let expected_point =
                                if self.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 {
@@ -2309,24 +2309,24 @@ impl<Signer: Sign> Channel<Signer> {
                                        // the current one.
                                        self.counterparty_cur_commitment_point
                                } else {
-                                       // If they have sent updated points, funding_locked is always supposed to match
+                                       // If they have sent updated points, channel_ready is always supposed to match
                                        // their "first" point, which we re-derive here.
                                        Some(PublicKey::from_secret_key(&self.secp_ctx, &SecretKey::from_slice(
                                                        &self.commitment_secrets.get_secret(INITIAL_COMMITMENT_NUMBER - 1).expect("We should have all prev secrets available")
                                                ).expect("We already advanced, so previous secret keys should have been validated already")))
                                };
                        if expected_point != Some(msg.next_per_commitment_point) {
-                               return Err(ChannelError::Close("Peer sent a reconnect funding_locked with a different point".to_owned()));
+                               return Err(ChannelError::Close("Peer sent a reconnect channel_ready with a different point".to_owned()));
                        }
                        return Ok(None);
                } else {
-                       return Err(ChannelError::Close("Peer sent a funding_locked at a strange time".to_owned()));
+                       return Err(ChannelError::Close("Peer sent a channel_ready at a strange time".to_owned()));
                }
 
                self.counterparty_prev_commitment_point = self.counterparty_cur_commitment_point;
                self.counterparty_cur_commitment_point = Some(msg.next_per_commitment_point);
 
-               log_info!(logger, "Received funding_locked from peer for channel {}", log_bytes!(self.channel_id()));
+               log_info!(logger, "Received channel_ready from peer for channel {}", log_bytes!(self.channel_id()));
 
                Ok(self.get_announcement_sigs(node_pk, genesis_block_hash, best_block.height(), logger))
        }
@@ -3570,13 +3570,13 @@ impl<Signer: Sign> Channel<Signer> {
        /// monitor update failure must *not* have been sent to the remote end, and must instead
        /// have been dropped. They will be regenerated when monitor_updating_restored is called.
        pub fn monitor_update_failed(&mut self, resend_raa: bool, resend_commitment: bool,
-               resend_funding_locked: bool, mut pending_forwards: Vec<(PendingHTLCInfo, u64)>,
+               resend_channel_ready: bool, mut pending_forwards: Vec<(PendingHTLCInfo, u64)>,
                mut pending_fails: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
                mut pending_finalized_claimed_htlcs: Vec<HTLCSource>
        ) {
                self.monitor_pending_revoke_and_ack |= resend_raa;
                self.monitor_pending_commitment_signed |= resend_commitment;
-               self.monitor_pending_funding_locked |= resend_funding_locked;
+               self.monitor_pending_channel_ready |= resend_channel_ready;
                self.monitor_pending_forwards.append(&mut pending_forwards);
                self.monitor_pending_failures.append(&mut pending_fails);
                self.monitor_pending_finalized_fulfills.append(&mut pending_finalized_claimed_htlcs);
@@ -3605,16 +3605,16 @@ impl<Signer: Sign> Channel<Signer> {
 
                // We will never broadcast the funding transaction when we're in MonitorUpdateFailed (and
                // we assume the user never directly broadcasts the funding transaction and waits for us to
-               // do it). Thus, we can only ever hit monitor_pending_funding_locked when we're
+               // do it). Thus, we can only ever hit monitor_pending_channel_ready when we're
                // * an inbound channel that failed to persist the monitor on funding_created and we got
                //   the funding transaction confirmed before the monitor was persisted, or
-               // * a 0-conf channel and intended to send the funding_locked before any broadcast at all.
-               let funding_locked = if self.monitor_pending_funding_locked {
+               // * a 0-conf channel and intended to send the channel_ready before any broadcast at all.
+               let channel_ready = if self.monitor_pending_channel_ready {
                        assert!(!self.is_outbound() || self.minimum_depth == Some(0),
                                "Funding transaction broadcast by the local client before it should have - LDK didn't do it!");
-                       self.monitor_pending_funding_locked = false;
+                       self.monitor_pending_channel_ready = false;
                        let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
-                       Some(msgs::FundingLocked {
+                       Some(msgs::ChannelReady {
                                channel_id: self.channel_id(),
                                next_per_commitment_point,
                                short_channel_id_alias: Some(self.outbound_scid_alias),
@@ -3635,7 +3635,7 @@ impl<Signer: Sign> Channel<Signer> {
                        self.monitor_pending_commitment_signed = false;
                        return MonitorRestoreUpdates {
                                raa: None, commitment_update: None, order: RAACommitmentOrder::RevokeAndACKFirst,
-                               accepted_htlcs, failed_htlcs, finalized_claimed_htlcs, funding_broadcastable, funding_locked, announcement_sigs
+                               accepted_htlcs, failed_htlcs, finalized_claimed_htlcs, funding_broadcastable, channel_ready, announcement_sigs
                        };
                }
 
@@ -3654,7 +3654,7 @@ impl<Signer: Sign> Channel<Signer> {
                        if commitment_update.is_some() { "a" } else { "no" }, if raa.is_some() { "an" } else { "no" },
                        match order { RAACommitmentOrder::CommitmentFirst => "commitment", RAACommitmentOrder::RevokeAndACKFirst => "RAA"});
                MonitorRestoreUpdates {
-                       raa, commitment_update, order, accepted_htlcs, failed_htlcs, finalized_claimed_htlcs, funding_broadcastable, funding_locked, announcement_sigs
+                       raa, commitment_update, order, accepted_htlcs, failed_htlcs, finalized_claimed_htlcs, funding_broadcastable, channel_ready, announcement_sigs
                }
        }
 
@@ -3826,15 +3826,15 @@ impl<Signer: Sign> Channel<Signer> {
                let announcement_sigs = self.get_announcement_sigs(node_pk, genesis_block_hash, best_block.height(), logger);
 
                if self.channel_state & (ChannelState::FundingSent as u32) == ChannelState::FundingSent as u32 {
-                       // If we're waiting on a monitor update, we shouldn't re-send any funding_locked's.
-                       if self.channel_state & (ChannelState::OurFundingLocked as u32) == 0 ||
+                       // If we're waiting on a monitor update, we shouldn't re-send any channel_ready's.
+                       if self.channel_state & (ChannelState::OurChannelReady as u32) == 0 ||
                                        self.channel_state & (ChannelState::MonitorUpdateFailed as u32) != 0 {
                                if msg.next_remote_commitment_number != 0 {
-                                       return Err(ChannelError::Close("Peer claimed they saw a revoke_and_ack but we haven't sent funding_locked yet".to_owned()));
+                                       return Err(ChannelError::Close("Peer claimed they saw a revoke_and_ack but we haven't sent channel_ready yet".to_owned()));
                                }
                                // Short circuit the whole handler as there is nothing we can resend them
                                return Ok(ReestablishResponses {
-                                       funding_locked: None,
+                                       channel_ready: None,
                                        raa: None, commitment_update: None, mon_update: None,
                                        order: RAACommitmentOrder::CommitmentFirst,
                                        holding_cell_failed_htlcs: Vec::new(),
@@ -3842,10 +3842,10 @@ impl<Signer: Sign> Channel<Signer> {
                                });
                        }
 
-                       // We have OurFundingLocked set!
+                       // We have OurChannelReady set!
                        let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
                        return Ok(ReestablishResponses {
-                               funding_locked: Some(msgs::FundingLocked {
+                               channel_ready: Some(msgs::ChannelReady {
                                        channel_id: self.channel_id(),
                                        next_per_commitment_point,
                                        short_channel_id_alias: Some(self.outbound_scid_alias),
@@ -3859,7 +3859,7 @@ impl<Signer: Sign> Channel<Signer> {
 
                let required_revoke = if msg.next_remote_commitment_number + 1 == INITIAL_COMMITMENT_NUMBER - self.cur_holder_commitment_transaction_number {
                        // Remote isn't waiting on any RevokeAndACK from us!
-                       // Note that if we need to repeat our FundingLocked we'll do that in the next if block.
+                       // Note that if we need to repeat our ChannelReady we'll do that in the next if block.
                        None
                } else if msg.next_remote_commitment_number + 1 == (INITIAL_COMMITMENT_NUMBER - 1) - self.cur_holder_commitment_transaction_number {
                        if self.channel_state & (ChannelState::MonitorUpdateFailed as u32) != 0 {
@@ -3878,10 +3878,10 @@ impl<Signer: Sign> Channel<Signer> {
                // the corresponding revoke_and_ack back yet.
                let next_counterparty_commitment_number = INITIAL_COMMITMENT_NUMBER - self.cur_counterparty_commitment_transaction_number + if (self.channel_state & ChannelState::AwaitingRemoteRevoke as u32) != 0 { 1 } else { 0 };
 
-               let funding_locked = if msg.next_local_commitment_number == 1 && INITIAL_COMMITMENT_NUMBER - self.cur_holder_commitment_transaction_number == 1 {
-                       // We should never have to worry about MonitorUpdateFailed resending FundingLocked
+               let channel_ready = if msg.next_local_commitment_number == 1 && INITIAL_COMMITMENT_NUMBER - self.cur_holder_commitment_transaction_number == 1 {
+                       // We should never have to worry about MonitorUpdateFailed resending ChannelReady
                        let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
-                       Some(msgs::FundingLocked {
+                       Some(msgs::ChannelReady {
                                channel_id: self.channel_id(),
                                next_per_commitment_point,
                                short_channel_id_alias: Some(self.outbound_scid_alias),
@@ -3906,7 +3906,7 @@ impl<Signer: Sign> Channel<Signer> {
                                                panic!("Got non-channel-failing result from free_holding_cell_htlcs"),
                                        Ok((Some((commitment_update, monitor_update)), holding_cell_failed_htlcs)) => {
                                                Ok(ReestablishResponses {
-                                                       funding_locked, shutdown_msg, announcement_sigs,
+                                                       channel_ready, shutdown_msg, announcement_sigs,
                                                        raa: required_revoke,
                                                        commitment_update: Some(commitment_update),
                                                        order: self.resend_order.clone(),
@@ -3916,7 +3916,7 @@ impl<Signer: Sign> Channel<Signer> {
                                        },
                                        Ok((None, holding_cell_failed_htlcs)) => {
                                                Ok(ReestablishResponses {
-                                                       funding_locked, shutdown_msg, announcement_sigs,
+                                                       channel_ready, shutdown_msg, announcement_sigs,
                                                        raa: required_revoke,
                                                        commitment_update: None,
                                                        order: self.resend_order.clone(),
@@ -3927,7 +3927,7 @@ impl<Signer: Sign> Channel<Signer> {
                                }
                        } else {
                                Ok(ReestablishResponses {
-                                       funding_locked, shutdown_msg, announcement_sigs,
+                                       channel_ready, shutdown_msg, announcement_sigs,
                                        raa: required_revoke,
                                        commitment_update: None,
                                        order: self.resend_order.clone(),
@@ -3945,14 +3945,14 @@ impl<Signer: Sign> Channel<Signer> {
                        if self.channel_state & (ChannelState::MonitorUpdateFailed as u32) != 0 {
                                self.monitor_pending_commitment_signed = true;
                                Ok(ReestablishResponses {
-                                       funding_locked, shutdown_msg, announcement_sigs,
+                                       channel_ready, shutdown_msg, announcement_sigs,
                                        commitment_update: None, raa: None, mon_update: None,
                                        order: self.resend_order.clone(),
                                        holding_cell_failed_htlcs: Vec::new(),
                                })
                        } else {
                                Ok(ReestablishResponses {
-                                       funding_locked, shutdown_msg, announcement_sigs,
+                                       channel_ready, shutdown_msg, announcement_sigs,
                                        raa: required_revoke,
                                        commitment_update: Some(self.get_last_commitment_update(logger)),
                                        order: self.resend_order.clone(),
@@ -4367,7 +4367,7 @@ impl<Signer: Sign> Channel<Signer> {
                &self.channel_type
        }
 
-       /// Guaranteed to be Some after both FundingLocked messages have been exchanged (and, thus,
+       /// Guaranteed to be Some after both ChannelReady messages have been exchanged (and, thus,
        /// is_usable() returns true).
        /// Allowed in any state (including after shutdown)
        pub fn get_short_channel_id(&self) -> Option<u64> {
@@ -4572,7 +4572,7 @@ impl<Signer: Sign> Channel<Signer> {
        /// Allowed in any state (including after shutdown)
        pub fn is_usable(&self) -> bool {
                let mask = ChannelState::ChannelFunded as u32 | BOTH_SIDES_SHUTDOWN_MASK;
-               (self.channel_state & mask) == (ChannelState::ChannelFunded as u32) && !self.monitor_pending_funding_locked
+               (self.channel_state & mask) == (ChannelState::ChannelFunded as u32) && !self.monitor_pending_channel_ready
        }
 
        /// Returns true if this channel is currently available for use. This is a superset of
@@ -4593,9 +4593,9 @@ impl<Signer: Sign> Channel<Signer> {
                self.channel_state >= ChannelState::FundingSent as u32
        }
 
-       /// Returns true if our funding_locked has been sent
-       pub fn is_our_funding_locked(&self) -> bool {
-               (self.channel_state & ChannelState::OurFundingLocked as u32) != 0 || self.channel_state >= ChannelState::ChannelFunded as u32
+       /// Returns true if our channel_ready has been sent
+       pub fn is_our_channel_ready(&self) -> bool {
+               (self.channel_state & ChannelState::OurChannelReady as u32) != 0 || self.channel_state >= ChannelState::ChannelFunded as u32
        }
 
        /// Returns true if our peer has either initiated or agreed to shut down the channel.
@@ -4627,7 +4627,7 @@ impl<Signer: Sign> Channel<Signer> {
                self.channel_update_status = status;
        }
 
-       fn check_get_funding_locked(&mut self, height: u32) -> Option<msgs::FundingLocked> {
+       fn check_get_channel_ready(&mut self, height: u32) -> Option<msgs::ChannelReady> {
                if self.funding_tx_confirmation_height == 0 && self.minimum_depth != Some(0) {
                        return None;
                }
@@ -4643,13 +4643,13 @@ impl<Signer: Sign> Channel<Signer> {
 
                let non_shutdown_state = self.channel_state & (!MULTI_STATE_FLAGS);
                let need_commitment_update = if non_shutdown_state == ChannelState::FundingSent as u32 {
-                       self.channel_state |= ChannelState::OurFundingLocked as u32;
+                       self.channel_state |= ChannelState::OurChannelReady as u32;
                        true
-               } else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::TheirFundingLocked as u32) {
+               } else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::TheirChannelReady as u32) {
                        self.channel_state = ChannelState::ChannelFunded as u32 | (self.channel_state & MULTI_STATE_FLAGS);
                        self.update_time_counter += 1;
                        true
-               } else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::OurFundingLocked as u32) {
+               } else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::OurChannelReady as u32) {
                        // We got a reorg but not enough to trigger a force close, just ignore.
                        false
                } else if self.channel_state < ChannelState::ChannelFunded as u32 {
@@ -4664,14 +4664,14 @@ impl<Signer: Sign> Channel<Signer> {
                                if self.channel_state & (ChannelState::PeerDisconnected as u32) == 0 {
                                        let next_per_commitment_point =
                                                self.holder_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - 1, &self.secp_ctx);
-                                       return Some(msgs::FundingLocked {
+                                       return Some(msgs::ChannelReady {
                                                channel_id: self.channel_id,
                                                next_per_commitment_point,
                                                short_channel_id_alias: Some(self.outbound_scid_alias),
                                        });
                                }
                        } else {
-                               self.monitor_pending_funding_locked = true;
+                               self.monitor_pending_channel_ready = true;
                        }
                }
                None
@@ -4682,7 +4682,7 @@ impl<Signer: Sign> Channel<Signer> {
        /// In the second, we simply return an Err indicating we need to be force-closed now.
        pub fn transactions_confirmed<L: Deref>(&mut self, block_hash: &BlockHash, height: u32,
                txdata: &TransactionData, genesis_block_hash: BlockHash, node_pk: PublicKey, logger: &L)
-       -> Result<(Option<msgs::FundingLocked>, Option<msgs::AnnouncementSignatures>), ClosureReason> where L::Target: Logger {
+       -> Result<(Option<msgs::ChannelReady>, Option<msgs::AnnouncementSignatures>), ClosureReason> where L::Target: Logger {
                if let Some(funding_txo) = self.get_funding_txo() {
                        for &(index_in_block, tx) in txdata.iter() {
                                // Check if the transaction is the expected funding transaction, and if it is,
@@ -4723,13 +4723,13 @@ impl<Signer: Sign> Channel<Signer> {
                                                        }
                                                }
                                        }
-                                       // If we allow 1-conf funding, we may need to check for funding_locked here and
+                                       // If we allow 1-conf funding, we may need to check for channel_ready here and
                                        // send it immediately instead of waiting for a best_block_updated call (which
                                        // may have already happened for this block).
-                                       if let Some(funding_locked) = self.check_get_funding_locked(height) {
-                                               log_info!(logger, "Sending a funding_locked to our peer for channel {}", log_bytes!(self.channel_id));
+                                       if let Some(channel_ready) = self.check_get_channel_ready(height) {
+                                               log_info!(logger, "Sending a channel_ready to our peer for channel {}", log_bytes!(self.channel_id));
                                                let announcement_sigs = self.get_announcement_sigs(node_pk, genesis_block_hash, height, logger);
-                                               return Ok((Some(funding_locked), announcement_sigs));
+                                               return Ok((Some(channel_ready), announcement_sigs));
                                        }
                                }
                                for inp in tx.input.iter() {
@@ -4755,12 +4755,12 @@ impl<Signer: Sign> Channel<Signer> {
        /// May return some HTLCs (and their payment_hash) which have timed out and should be failed
        /// back.
        pub fn best_block_updated<L: Deref>(&mut self, height: u32, highest_header_time: u32, genesis_block_hash: BlockHash, node_pk: PublicKey, logger: &L)
-       -> Result<(Option<msgs::FundingLocked>, Vec<(HTLCSource, PaymentHash)>, Option<msgs::AnnouncementSignatures>), ClosureReason> where L::Target: Logger {
+       -> Result<(Option<msgs::ChannelReady>, Vec<(HTLCSource, PaymentHash)>, Option<msgs::AnnouncementSignatures>), ClosureReason> where L::Target: Logger {
                self.do_best_block_updated(height, highest_header_time, Some((genesis_block_hash, node_pk)), logger)
        }
 
        fn do_best_block_updated<L: Deref>(&mut self, height: u32, highest_header_time: u32, genesis_node_pk: Option<(BlockHash, PublicKey)>, logger: &L)
-       -> Result<(Option<msgs::FundingLocked>, Vec<(HTLCSource, PaymentHash)>, Option<msgs::AnnouncementSignatures>), ClosureReason> where L::Target: Logger {
+       -> Result<(Option<msgs::ChannelReady>, Vec<(HTLCSource, PaymentHash)>, Option<msgs::AnnouncementSignatures>), ClosureReason> where L::Target: Logger {
                let mut timed_out_htlcs = Vec::new();
                // This mirrors the check in ChannelManager::decode_update_add_htlc_onion, refusing to
                // forward an HTLC when our counterparty should almost certainly just fail it for expiring
@@ -4780,26 +4780,26 @@ impl<Signer: Sign> Channel<Signer> {
 
                self.update_time_counter = cmp::max(self.update_time_counter, highest_header_time);
 
-               if let Some(funding_locked) = self.check_get_funding_locked(height) {
+               if let Some(channel_ready) = self.check_get_channel_ready(height) {
                        let announcement_sigs = if let Some((genesis_block_hash, node_pk)) = genesis_node_pk {
                                self.get_announcement_sigs(node_pk, genesis_block_hash, height, logger)
                        } else { None };
-                       log_info!(logger, "Sending a funding_locked to our peer for channel {}", log_bytes!(self.channel_id));
-                       return Ok((Some(funding_locked), timed_out_htlcs, announcement_sigs));
+                       log_info!(logger, "Sending a channel_ready to our peer for channel {}", log_bytes!(self.channel_id));
+                       return Ok((Some(channel_ready), timed_out_htlcs, announcement_sigs));
                }
 
                let non_shutdown_state = self.channel_state & (!MULTI_STATE_FLAGS);
                if non_shutdown_state >= ChannelState::ChannelFunded as u32 ||
-                  (non_shutdown_state & ChannelState::OurFundingLocked as u32) == ChannelState::OurFundingLocked as u32 {
+                  (non_shutdown_state & ChannelState::OurChannelReady as u32) == ChannelState::OurChannelReady as u32 {
                        let mut funding_tx_confirmations = height as i64 - self.funding_tx_confirmation_height as i64 + 1;
                        if self.funding_tx_confirmation_height == 0 {
-                               // Note that check_get_funding_locked may reset funding_tx_confirmation_height to
+                               // Note that check_get_channel_ready may reset funding_tx_confirmation_height to
                                // zero if it has been reorged out, however in either case, our state flags
-                               // indicate we've already sent a funding_locked
+                               // indicate we've already sent a channel_ready
                                funding_tx_confirmations = 0;
                        }
 
-                       // If we've sent funding_locked (or have both sent and received funding_locked), and
+                       // If we've sent channel_ready (or have both sent and received channel_ready), and
                        // the funding transaction has become unconfirmed,
                        // close the channel and hope we can get the latest state on chain (because presumably
                        // the funding transaction is at least still in the mempool of most nodes).
@@ -4817,7 +4817,7 @@ impl<Signer: Sign> Channel<Signer> {
                        log_info!(logger, "Closing channel {} due to funding timeout", log_bytes!(self.channel_id));
                        // If funding_tx_confirmed_in is unset, the channel must not be active
                        assert!(non_shutdown_state <= ChannelState::ChannelFunded as u32);
-                       assert_eq!(non_shutdown_state & ChannelState::OurFundingLocked as u32, 0);
+                       assert_eq!(non_shutdown_state & ChannelState::OurChannelReady as u32, 0);
                        return Err(ClosureReason::FundingTimedOut);
                }
 
@@ -4829,7 +4829,7 @@ impl<Signer: Sign> Channel<Signer> {
 
        /// Indicates the funding transaction is no longer confirmed in the main chain. This may
        /// force-close the channel, but may also indicate a harmless reorganization of a block or two
-       /// before the channel has reached funding_locked and we can just wait for more blocks.
+       /// before the channel has reached channel_ready and we can just wait for more blocks.
        pub fn funding_transaction_unconfirmed<L: Deref>(&mut self, logger: &L) -> Result<(), ClosureReason> where L::Target: Logger {
                if self.funding_tx_confirmation_height != 0 {
                        // We handle the funding disconnection by calling best_block_updated with a height one
@@ -4840,8 +4840,8 @@ impl<Signer: Sign> Channel<Signer> {
                        // time we saw and it will be ignored.
                        let best_time = self.update_time_counter;
                        match self.do_best_block_updated(reorg_height, best_time, None, logger) {
-                               Ok((funding_locked, timed_out_htlcs, announcement_sigs)) => {
-                                       assert!(funding_locked.is_none(), "We can't generate a funding with 0 confirmations?");
+                               Ok((channel_ready, timed_out_htlcs, announcement_sigs)) => {
+                                       assert!(channel_ready.is_none(), "We can't generate a funding with 0 confirmations?");
                                        assert!(timed_out_htlcs.is_empty(), "We can't have accepted HTLCs with a timeout before our funding confirmation?");
                                        assert!(announcement_sigs.is_none(), "We can't generate an announcement_sigs with 0 confirmations?");
                                        Ok(())
@@ -5031,7 +5031,7 @@ impl<Signer: Sign> Channel<Signer> {
        }
 
        /// Gets an UnsignedChannelAnnouncement for this channel. The channel must be publicly
-       /// announceable and available for use (have exchanged FundingLocked messages in both
+       /// announceable and available for use (have exchanged ChannelReady messages in both
        /// directions). Should be used for both broadcasted announcements and in response to an
        /// AnnouncementSignatures message from the remote peer.
        ///
@@ -5871,7 +5871,7 @@ impl<Signer: Sign> Writeable for Channel<Signer> {
                        RAACommitmentOrder::RevokeAndACKFirst => 1u8.write(writer)?,
                }
 
-               self.monitor_pending_funding_locked.write(writer)?;
+               self.monitor_pending_channel_ready.write(writer)?;
                self.monitor_pending_revoke_and_ack.write(writer)?;
                self.monitor_pending_commitment_signed.write(writer)?;
 
@@ -6132,7 +6132,7 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<(&'a K, u32)> for Channel<Signer>
                        _ => return Err(DecodeError::InvalidValue),
                };
 
-               let monitor_pending_funding_locked = Readable::read(reader)?;
+               let monitor_pending_channel_ready = Readable::read(reader)?;
                let monitor_pending_revoke_and_ack = Readable::read(reader)?;
                let monitor_pending_commitment_signed = Readable::read(reader)?;
 
@@ -6342,7 +6342,7 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<(&'a K, u32)> for Channel<Signer>
 
                        resend_order,
 
-                       monitor_pending_funding_locked,
+                       monitor_pending_channel_ready,
                        monitor_pending_revoke_and_ack,
                        monitor_pending_commitment_signed,
                        monitor_pending_forwards,
index 3de32529085e77c37f6030e8acd2a4b232c10795..17a52e29e4a5eecb210fe9d3f10c2edc4306f233 100644 (file)
@@ -1074,18 +1074,18 @@ pub struct ChannelDetails {
        pub force_close_spend_delay: Option<u16>,
        /// True if the channel was initiated (and thus funded) by us.
        pub is_outbound: bool,
-       /// True if the channel is confirmed, funding_locked messages have been exchanged, and the
-       /// channel is not currently being shut down. `funding_locked` message exchange implies the
+       /// True if the channel is confirmed, channel_ready messages have been exchanged, and the
+       /// channel is not currently being shut down. `channel_ready` message exchange implies the
        /// required confirmation count has been reached (and we were connected to the peer at some
        /// point after the funding transaction received enough confirmations). The required
        /// confirmation count is provided in [`confirmations_required`].
        ///
        /// [`confirmations_required`]: ChannelDetails::confirmations_required
-       pub is_funding_locked: bool,
-       /// True if the channel is (a) confirmed and funding_locked messages have been exchanged, (b)
+       pub is_channel_ready: bool,
+       /// True if the channel is (a) confirmed and channel_ready messages have been exchanged, (b)
        /// the peer is connected, and (c) the channel is not currently negotiating a shutdown.
        ///
-       /// This is a strict superset of `is_funding_locked`.
+       /// This is a strict superset of `is_channel_ready`.
        pub is_usable: bool,
        /// True if this channel is (or will be) publicly-announced.
        pub is_public: bool,
@@ -1314,7 +1314,7 @@ macro_rules! remove_channel {
 }
 
 macro_rules! handle_monitor_err {
-       ($self: ident, $err: expr, $short_to_id: expr, $chan: expr, $action_type: path, $resend_raa: expr, $resend_commitment: expr, $resend_funding_locked: expr, $failed_forwards: expr, $failed_fails: expr, $failed_finalized_fulfills: expr, $chan_id: expr) => {
+       ($self: ident, $err: expr, $short_to_id: expr, $chan: expr, $action_type: path, $resend_raa: expr, $resend_commitment: expr, $resend_channel_ready: expr, $failed_forwards: expr, $failed_fails: expr, $failed_finalized_fulfills: expr, $chan_id: expr) => {
                match $err {
                        ChannelMonitorUpdateErr::PermanentFailure => {
                                log_error!($self.logger, "Closing channel {} due to monitor update ChannelMonitorUpdateErr::PermanentFailure", log_bytes!($chan_id[..]));
@@ -1352,13 +1352,13 @@ macro_rules! handle_monitor_err {
                                if !$resend_raa {
                                        debug_assert!($action_type == RAACommitmentOrder::CommitmentFirst || !$resend_commitment);
                                }
-                               $chan.monitor_update_failed($resend_raa, $resend_commitment, $resend_funding_locked, $failed_forwards, $failed_fails, $failed_finalized_fulfills);
+                               $chan.monitor_update_failed($resend_raa, $resend_commitment, $resend_channel_ready, $failed_forwards, $failed_fails, $failed_finalized_fulfills);
                                (Err(MsgHandleErrInternal::from_chan_no_close(ChannelError::Ignore("Failed to update ChannelMonitor".to_owned()), *$chan_id)), false)
                        },
                }
        };
-       ($self: ident, $err: expr, $channel_state: expr, $entry: expr, $action_type: path, $resend_raa: expr, $resend_commitment: expr, $resend_funding_locked: expr, $failed_forwards: expr, $failed_fails: expr, $failed_finalized_fulfills: expr) => { {
-               let (res, drop) = handle_monitor_err!($self, $err, $channel_state.short_to_id, $entry.get_mut(), $action_type, $resend_raa, $resend_commitment, $resend_funding_locked, $failed_forwards, $failed_fails, $failed_finalized_fulfills, $entry.key());
+       ($self: ident, $err: expr, $channel_state: expr, $entry: expr, $action_type: path, $resend_raa: expr, $resend_commitment: expr, $resend_channel_ready: expr, $failed_forwards: expr, $failed_fails: expr, $failed_finalized_fulfills: expr) => { {
+               let (res, drop) = handle_monitor_err!($self, $err, $channel_state.short_to_id, $entry.get_mut(), $action_type, $resend_raa, $resend_commitment, $resend_channel_ready, $failed_forwards, $failed_fails, $failed_finalized_fulfills, $entry.key());
                if drop {
                        $entry.remove_entry();
                }
@@ -1371,8 +1371,8 @@ macro_rules! handle_monitor_err {
        ($self: ident, $err: expr, $channel_state: expr, $entry: expr, $action_type: path, $chan_id: expr, NO_UPDATE) => {
                handle_monitor_err!($self, $err, $channel_state, $entry, $action_type, false, false, false, Vec::new(), Vec::new(), Vec::new(), $chan_id)
        };
-       ($self: ident, $err: expr, $channel_state: expr, $entry: expr, $action_type: path, $resend_funding_locked: expr, OPTIONALLY_RESEND_FUNDING_LOCKED) => {
-               handle_monitor_err!($self, $err, $channel_state, $entry, $action_type, false, false, $resend_funding_locked, Vec::new(), Vec::new(), Vec::new())
+       ($self: ident, $err: expr, $channel_state: expr, $entry: expr, $action_type: path, $resend_channel_ready: expr, OPTIONALLY_RESEND_FUNDING_LOCKED) => {
+               handle_monitor_err!($self, $err, $channel_state, $entry, $action_type, false, false, $resend_channel_ready, Vec::new(), Vec::new(), Vec::new())
        };
        ($self: ident, $err: expr, $channel_state: expr, $entry: expr, $action_type: path, $resend_raa: expr, $resend_commitment: expr) => {
                handle_monitor_err!($self, $err, $channel_state, $entry, $action_type, $resend_raa, $resend_commitment, false, Vec::new(), Vec::new(), Vec::new())
@@ -1403,13 +1403,13 @@ macro_rules! maybe_break_monitor_err {
        }
 }
 
-macro_rules! send_funding_locked {
-       ($short_to_id: expr, $pending_msg_events: expr, $channel: expr, $funding_locked_msg: expr) => {
-               $pending_msg_events.push(events::MessageSendEvent::SendFundingLocked {
+macro_rules! send_channel_ready {
+       ($short_to_id: expr, $pending_msg_events: expr, $channel: expr, $channel_ready_msg: expr) => {
+               $pending_msg_events.push(events::MessageSendEvent::SendChannelReady {
                        node_id: $channel.get_counterparty_node_id(),
-                       msg: $funding_locked_msg,
+                       msg: $channel_ready_msg,
                });
-               // Note that we may send a funding locked multiple times for a channel if we reconnect, so
+               // Note that we may send a `channel_ready` multiple times for a channel if we reconnect, so
                // we allow collisions, but we shouldn't ever be updating the channel ID pointed to.
                let outbound_alias_insert = $short_to_id.insert($channel.outbound_scid_alias(), $channel.channel_id());
                assert!(outbound_alias_insert.is_none() || outbound_alias_insert.unwrap() == $channel.channel_id(),
@@ -1425,7 +1425,7 @@ macro_rules! send_funding_locked {
 macro_rules! handle_chan_restoration_locked {
        ($self: ident, $channel_lock: expr, $channel_state: expr, $channel_entry: expr,
         $raa: expr, $commitment_update: expr, $order: expr, $chanmon_update: expr,
-        $pending_forwards: expr, $funding_broadcastable: expr, $funding_locked: expr, $announcement_sigs: expr) => { {
+        $pending_forwards: expr, $funding_broadcastable: expr, $channel_ready: expr, $announcement_sigs: expr) => { {
                let mut htlc_forwards = None;
 
                let chanmon_update: Option<ChannelMonitorUpdate> = $chanmon_update; // Force type-checking to resolve
@@ -1439,24 +1439,24 @@ macro_rules! handle_chan_restoration_locked {
                        }
 
                        if chanmon_update.is_some() {
-                               // On reconnect, we, by definition, only resend a funding_locked if there have been
+                               // On reconnect, we, by definition, only resend a channel_ready if there have been
                                // no commitment updates, so the only channel monitor update which could also be
-                               // associated with a funding_locked would be the funding_created/funding_signed
+                               // associated with a channel_ready would be the funding_created/funding_signed
                                // monitor update. That monitor update failing implies that we won't send
-                               // funding_locked until it's been updated, so we can't have a funding_locked and a
+                               // channel_ready until it's been updated, so we can't have a channel_ready and a
                                // monitor update here (so we don't bother to handle it correctly below).
-                               assert!($funding_locked.is_none());
-                               // A channel monitor update makes no sense without either a funding_locked or a
-                               // commitment update to process after it. Since we can't have a funding_locked, we
+                               assert!($channel_ready.is_none());
+                               // A channel monitor update makes no sense without either a channel_ready or a
+                               // commitment update to process after it. Since we can't have a channel_ready, we
                                // only bother to handle the monitor-update + commitment_update case below.
                                assert!($commitment_update.is_some());
                        }
 
-                       if let Some(msg) = $funding_locked {
-                               // Similar to the above, this implies that we're letting the funding_locked fly
+                       if let Some(msg) = $channel_ready {
+                               // Similar to the above, this implies that we're letting the channel_ready fly
                                // before it should be allowed to.
                                assert!(chanmon_update.is_none());
-                               send_funding_locked!($channel_state.short_to_id, $channel_state.pending_msg_events, $channel_entry.get(), msg);
+                               send_channel_ready!($channel_state.short_to_id, $channel_state.pending_msg_events, $channel_entry.get(), msg);
                        }
                        if let Some(msg) = $announcement_sigs {
                                $channel_state.pending_msg_events.push(events::MessageSendEvent::SendAnnouncementSignatures {
@@ -1754,7 +1754,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                                        confirmations_required: channel.minimum_depth(),
                                        force_close_spend_delay: channel.get_counterparty_selected_contest_delay(),
                                        is_outbound: channel.is_outbound(),
-                                       is_funding_locked: channel.is_usable(),
+                                       is_channel_ready: channel.is_usable(),
                                        is_usable: channel.is_live(),
                                        is_public: channel.should_announce(),
                                        inbound_htlc_minimum_msat: Some(channel.get_holder_htlc_minimum_msat()),
@@ -2901,7 +2901,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                                });
                                announced_chans = true;
                        } else {
-                               // If the channel is not public or has not yet reached funding_locked, check the
+                               // If the channel is not public or has not yet reached channel_ready, check the
                                // next channel. If we don't yet have any public channels, we'll skip the broadcast
                                // below as peers may not accept it without channels on chain first.
                        }
@@ -4175,9 +4175,9 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                        }
 
                        let updates = channel.get_mut().monitor_updating_restored(&self.logger, self.get_our_node_id(), self.genesis_hash, self.best_block.read().unwrap().height());
-                       let channel_update = if updates.funding_locked.is_some() && channel.get().is_usable() {
+                       let channel_update = if updates.channel_ready.is_some() && channel.get().is_usable() {
                                // We only send a channel_update in the case where we are just now sending a
-                               // funding_locked and the channel is in a usable state. We may re-send a
+                               // channel_ready and the channel is in a usable state. We may re-send a
                                // channel_update later through the announcement_signatures process for public
                                // channels, but there's no reason not to just inform our counterparty of our fees
                                // now.
@@ -4188,7 +4188,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                                        })
                                } else { None }
                        } else { None };
-                       chan_restoration_res = handle_chan_restoration_locked!(self, channel_lock, channel_state, channel, updates.raa, updates.commitment_update, updates.order, None, updates.accepted_htlcs, updates.funding_broadcastable, updates.funding_locked, updates.announcement_sigs);
+                       chan_restoration_res = handle_chan_restoration_locked!(self, channel_lock, channel_state, channel, updates.raa, updates.commitment_update, updates.order, None, updates.accepted_htlcs, updates.funding_broadcastable, updates.channel_ready, updates.announcement_sigs);
                        if let Some(upd) = channel_update {
                                channel_state.pending_msg_events.push(upd);
                        }
@@ -4344,7 +4344,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
        }
 
        fn internal_funding_created(&self, counterparty_node_id: &PublicKey, msg: &msgs::FundingCreated) -> Result<(), MsgHandleErrInternal> {
-               let ((funding_msg, monitor, mut funding_locked), mut chan) = {
+               let ((funding_msg, monitor, mut channel_ready), mut chan) = {
                        let best_block = *self.best_block.read().unwrap();
                        let mut channel_lock = self.channel_state.lock().unwrap();
                        let channel_state = &mut *channel_lock;
@@ -4377,10 +4377,10 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                                ChannelMonitorUpdateErr::TemporaryFailure => {
                                        // There's no problem signing a counterparty's funding transaction if our monitor
                                        // hasn't persisted to disk yet - we can't lose money on a transaction that we haven't
-                                       // accepted payment from yet. We do, however, need to wait to send our funding_locked
+                                       // accepted payment from yet. We do, however, need to wait to send our channel_ready
                                        // until we have persisted our monitor.
-                                       chan.monitor_update_failed(false, false, funding_locked.is_some(), Vec::new(), Vec::new(), Vec::new());
-                                       funding_locked = None; // Don't send the funding_locked now
+                                       chan.monitor_update_failed(false, false, channel_ready.is_some(), Vec::new(), Vec::new(), Vec::new());
+                                       channel_ready = None; // Don't send the channel_ready now
                                },
                        }
                }
@@ -4395,8 +4395,8 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                                        node_id: counterparty_node_id.clone(),
                                        msg: funding_msg,
                                });
-                               if let Some(msg) = funding_locked {
-                                       send_funding_locked!(channel_state.short_to_id, channel_state.pending_msg_events, chan, msg);
+                               if let Some(msg) = channel_ready {
+                                       send_channel_ready!(channel_state.short_to_id, channel_state.pending_msg_events, chan, msg);
                                }
                                e.insert(chan);
                        }
@@ -4414,12 +4414,12 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                                        if chan.get().get_counterparty_node_id() != *counterparty_node_id {
                                                return Err(MsgHandleErrInternal::send_err_msg_no_close("Got a message for a channel from the wrong node!".to_owned(), msg.channel_id));
                                        }
-                                       let (monitor, funding_tx, funding_locked) = match chan.get_mut().funding_signed(&msg, best_block, &self.logger) {
+                                       let (monitor, funding_tx, channel_ready) = match chan.get_mut().funding_signed(&msg, best_block, &self.logger) {
                                                Ok(update) => update,
                                                Err(e) => try_chan_entry!(self, Err(e), channel_state, chan),
                                        };
                                        if let Err(e) = self.chain_monitor.watch_channel(chan.get().get_funding_txo().unwrap(), monitor) {
-                                               let mut res = handle_monitor_err!(self, e, channel_state, chan, RAACommitmentOrder::RevokeAndACKFirst, funding_locked.is_some(), OPTIONALLY_RESEND_FUNDING_LOCKED);
+                                               let mut res = handle_monitor_err!(self, e, channel_state, chan, RAACommitmentOrder::RevokeAndACKFirst, channel_ready.is_some(), OPTIONALLY_RESEND_FUNDING_LOCKED);
                                                if let Err(MsgHandleErrInternal { ref mut shutdown_finish, .. }) = res {
                                                        // We weren't able to watch the channel to begin with, so no updates should be made on
                                                        // it. Previously, full_stack_target found an (unreachable) panic when the
@@ -4430,8 +4430,8 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                                                }
                                                return res
                                        }
-                                       if let Some(msg) = funding_locked {
-                                               send_funding_locked!(channel_state.short_to_id, channel_state.pending_msg_events, chan.get(), msg);
+                                       if let Some(msg) = channel_ready {
+                                               send_channel_ready!(channel_state.short_to_id, channel_state.pending_msg_events, chan.get(), msg);
                                        }
                                        funding_tx
                                },
@@ -4443,7 +4443,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                Ok(())
        }
 
-       fn internal_funding_locked(&self, counterparty_node_id: &PublicKey, msg: &msgs::FundingLocked) -> Result<(), MsgHandleErrInternal> {
+       fn internal_channel_ready(&self, counterparty_node_id: &PublicKey, msg: &msgs::ChannelReady) -> Result<(), MsgHandleErrInternal> {
                let mut channel_state_lock = self.channel_state.lock().unwrap();
                let channel_state = &mut *channel_state_lock;
                match channel_state.by_id.entry(msg.channel_id) {
@@ -4451,7 +4451,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                                if chan.get().get_counterparty_node_id() != *counterparty_node_id {
                                        return Err(MsgHandleErrInternal::send_err_msg_no_close("Got a message for a channel from the wrong node!".to_owned(), msg.channel_id));
                                }
-                               let announcement_sigs_opt = try_chan_entry!(self, chan.get_mut().funding_locked(&msg, self.get_our_node_id(),
+                               let announcement_sigs_opt = try_chan_entry!(self, chan.get_mut().channel_ready(&msg, self.get_our_node_id(),
                                        self.genesis_hash.clone(), &self.best_block.read().unwrap(), &self.logger), channel_state, chan);
                                if let Some(announcement_sigs) = announcement_sigs_opt {
                                        log_trace!(self.logger, "Sending announcement_signatures for channel {}", log_bytes!(chan.get().channel_id()));
@@ -4935,7 +4935,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                                        let need_lnd_workaround = chan.get_mut().workaround_lnd_bug_4006.take();
                                        chan_restoration_res = handle_chan_restoration_locked!(
                                                self, channel_state_lock, channel_state, chan, responses.raa, responses.commitment_update, responses.order,
-                                               responses.mon_update, Vec::new(), None, responses.funding_locked, responses.announcement_sigs);
+                                               responses.mon_update, Vec::new(), None, responses.channel_ready, responses.announcement_sigs);
                                        if let Some(upd) = channel_update {
                                                channel_state.pending_msg_events.push(upd);
                                        }
@@ -4947,8 +4947,8 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                post_handle_chan_restoration!(self, chan_restoration_res);
                self.fail_holding_cell_htlcs(htlcs_failed_forward, msg.channel_id);
 
-               if let Some(funding_locked_msg) = need_lnd_workaround {
-                       self.internal_funding_locked(counterparty_node_id, &funding_locked_msg)?;
+               if let Some(channel_ready_msg) = need_lnd_workaround {
+                       self.internal_channel_ready(counterparty_node_id, &channel_ready_msg)?;
                }
                Ok(())
        }
@@ -5585,7 +5585,7 @@ where
        /// Calls a function which handles an on-chain event (blocks dis/connected, transactions
        /// un/confirmed, etc) on each channel, handling any resulting errors or messages generated by
        /// the function.
-       fn do_chain_event<FN: Fn(&mut Channel<Signer>) -> Result<(Option<msgs::FundingLocked>, Vec<(HTLCSource, PaymentHash)>, Option<msgs::AnnouncementSignatures>), ClosureReason>>
+       fn do_chain_event<FN: Fn(&mut Channel<Signer>) -> Result<(Option<msgs::ChannelReady>, Vec<(HTLCSource, PaymentHash)>, Option<msgs::AnnouncementSignatures>), ClosureReason>>
                        (&self, height_opt: Option<u32>, f: FN) {
                // Note that we MUST NOT end up calling methods on self.chain_monitor here - we're called
                // during initialization prior to the chain_monitor being fully configured in some cases.
@@ -5600,17 +5600,17 @@ where
                        let pending_msg_events = &mut channel_state.pending_msg_events;
                        channel_state.by_id.retain(|_, channel| {
                                let res = f(channel);
-                               if let Ok((funding_locked_opt, mut timed_out_pending_htlcs, announcement_sigs)) = res {
+                               if let Ok((channel_ready_opt, mut timed_out_pending_htlcs, announcement_sigs)) = res {
                                        for (source, payment_hash) in timed_out_pending_htlcs.drain(..) {
                                                let (failure_code, data) = self.get_htlc_inbound_temp_fail_err_and_data(0x1000|14 /* expiry_too_soon */, &channel);
                                                timed_out_htlcs.push((source, payment_hash, HTLCFailReason::Reason {
                                                        failure_code, data,
                                                }));
                                        }
-                                       if let Some(funding_locked) = funding_locked_opt {
-                                               send_funding_locked!(short_to_id, pending_msg_events, channel, funding_locked);
+                                       if let Some(channel_ready) = channel_ready_opt {
+                                               send_channel_ready!(short_to_id, pending_msg_events, channel, channel_ready);
                                                if channel.is_usable() {
-                                                       log_trace!(self.logger, "Sending funding_locked with private initial channel_update for our counterparty on channel {}", log_bytes!(channel.channel_id()));
+                                                       log_trace!(self.logger, "Sending channel_ready with private initial channel_update for our counterparty on channel {}", log_bytes!(channel.channel_id()));
                                                        if let Ok(msg) = self.get_channel_update_for_unicast(channel) {
                                                                pending_msg_events.push(events::MessageSendEvent::SendChannelUpdate {
                                                                        node_id: channel.get_counterparty_node_id(),
@@ -5618,7 +5618,7 @@ where
                                                                });
                                                        }
                                                } else {
-                                                       log_trace!(self.logger, "Sending funding_locked WITHOUT channel_update for {}", log_bytes!(channel.channel_id()));
+                                                       log_trace!(self.logger, "Sending channel_ready WITHOUT channel_update for {}", log_bytes!(channel.channel_id()));
                                                }
                                        }
                                        if let Some(announcement_sigs) = announcement_sigs {
@@ -5638,9 +5638,9 @@ where
                                                        }
                                                }
                                        }
-                                       if channel.is_our_funding_locked() {
+                                       if channel.is_our_channel_ready() {
                                                if let Some(real_scid) = channel.get_short_channel_id() {
-                                                       // If we sent a 0conf funding_locked, and now have an SCID, we add it
+                                                       // If we sent a 0conf channel_ready, and now have an SCID, we add it
                                                        // to the short_to_id map here. Note that we check whether we can relay
                                                        // using the real SCID at relay-time (i.e. enforce option_scid_alias
                                                        // then), and if the funding tx is ever un-confirmed we force-close the
@@ -5765,9 +5765,9 @@ impl<Signer: Sign, M: Deref , T: Deref , K: Deref , F: Deref , L: Deref >
                let _ = handle_error!(self, self.internal_funding_signed(counterparty_node_id, msg), *counterparty_node_id);
        }
 
-       fn handle_funding_locked(&self, counterparty_node_id: &PublicKey, msg: &msgs::FundingLocked) {
+       fn handle_channel_ready(&self, counterparty_node_id: &PublicKey, msg: &msgs::ChannelReady) {
                let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(&self.total_consistency_lock, &self.persistence_notifier);
-               let _ = handle_error!(self, self.internal_funding_locked(counterparty_node_id, msg), *counterparty_node_id);
+               let _ = handle_error!(self, self.internal_channel_ready(counterparty_node_id, msg), *counterparty_node_id);
        }
 
        fn handle_shutdown(&self, counterparty_node_id: &PublicKey, their_features: &InitFeatures, msg: &msgs::Shutdown) {
@@ -5865,7 +5865,7 @@ impl<Signer: Sign, M: Deref , T: Deref , K: Deref , F: Deref , L: Deref >
                                        &events::MessageSendEvent::SendOpenChannel { ref node_id, .. } => node_id != counterparty_node_id,
                                        &events::MessageSendEvent::SendFundingCreated { ref node_id, .. } => node_id != counterparty_node_id,
                                        &events::MessageSendEvent::SendFundingSigned { ref node_id, .. } => node_id != counterparty_node_id,
-                                       &events::MessageSendEvent::SendFundingLocked { ref node_id, .. } => node_id != counterparty_node_id,
+                                       &events::MessageSendEvent::SendChannelReady { ref node_id, .. } => node_id != counterparty_node_id,
                                        &events::MessageSendEvent::SendAnnouncementSignatures { ref node_id, .. } => node_id != counterparty_node_id,
                                        &events::MessageSendEvent::UpdateHTLCs { ref node_id, .. } => node_id != counterparty_node_id,
                                        &events::MessageSendEvent::SendRevokeAndACK { ref node_id, .. } => node_id != counterparty_node_id,
@@ -6078,7 +6078,7 @@ impl_writeable_tlv_based!(ChannelDetails, {
        (22, confirmations_required, option),
        (24, force_close_spend_delay, option),
        (26, is_outbound, required),
-       (28, is_funding_locked, required),
+       (28, is_channel_ready, required),
        (30, is_usable, required),
        (32, is_public, required),
        (33, inbound_htlc_minimum_msat, option),
@@ -7652,12 +7652,12 @@ pub mod bench {
                Listen::block_connected(&node_a, &block, 1);
                Listen::block_connected(&node_b, &block, 1);
 
-               node_a.handle_funding_locked(&node_b.get_our_node_id(), &get_event_msg!(node_b_holder, MessageSendEvent::SendFundingLocked, node_a.get_our_node_id()));
+               node_a.handle_channel_ready(&node_b.get_our_node_id(), &get_event_msg!(node_b_holder, MessageSendEvent::SendChannelReady, node_a.get_our_node_id()));
                let msg_events = node_a.get_and_clear_pending_msg_events();
                assert_eq!(msg_events.len(), 2);
                match msg_events[0] {
-                       MessageSendEvent::SendFundingLocked { ref msg, .. } => {
-                               node_b.handle_funding_locked(&node_a.get_our_node_id(), msg);
+                       MessageSendEvent::SendChannelReady { ref msg, .. } => {
+                               node_b.handle_channel_ready(&node_a.get_our_node_id(), msg);
                                get_event_msg!(node_b_holder, MessageSendEvent::SendChannelUpdate, node_a.get_our_node_id());
                        },
                        _ => panic!(),
index 31fdc6ffae4514411b33003574c14c362df69025..8929a9774381e9342f20790e094e51c64b36d959 100644 (file)
@@ -400,8 +400,8 @@ pub fn create_chan_between_nodes<'a, 'b, 'c, 'd>(node_a: &'a Node<'b, 'c, 'd>, n
 }
 
 pub fn create_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
-       let (funding_locked, channel_id, tx) = create_chan_between_nodes_with_value_a(node_a, node_b, channel_value, push_msat, a_flags, b_flags);
-       let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(node_a, node_b, &funding_locked);
+       let (channel_ready, channel_id, tx) = create_chan_between_nodes_with_value_a(node_a, node_b, channel_value, push_msat, a_flags, b_flags);
+       let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(node_a, node_b, &channel_ready);
        (announcement, as_update, bs_update, channel_id, tx)
 }
 
@@ -685,10 +685,10 @@ pub fn create_chan_between_nodes_with_value_init<'a, 'b, 'c>(node_a: &Node<'a, '
 pub fn create_chan_between_nodes_with_value_confirm_first<'a, 'b, 'c, 'd>(node_recv: &'a Node<'b, 'c, 'c>, node_conf: &'a Node<'b, 'c, 'd>, tx: &Transaction, conf_height: u32) {
        confirm_transaction_at(node_conf, tx, conf_height);
        connect_blocks(node_conf, CHAN_CONFIRM_DEPTH - 1);
-       node_recv.node.handle_funding_locked(&node_conf.node.get_our_node_id(), &get_event_msg!(node_conf, MessageSendEvent::SendFundingLocked, node_recv.node.get_our_node_id()));
+       node_recv.node.handle_channel_ready(&node_conf.node.get_our_node_id(), &get_event_msg!(node_conf, MessageSendEvent::SendChannelReady, node_recv.node.get_our_node_id()));
 }
 
-pub fn create_chan_between_nodes_with_value_confirm_second<'a, 'b, 'c>(node_recv: &Node<'a, 'b, 'c>, node_conf: &Node<'a, 'b, 'c>) -> ((msgs::FundingLocked, msgs::AnnouncementSignatures), [u8; 32]) {
+pub fn create_chan_between_nodes_with_value_confirm_second<'a, 'b, 'c>(node_recv: &Node<'a, 'b, 'c>, node_conf: &Node<'a, 'b, 'c>) -> ((msgs::ChannelReady, msgs::AnnouncementSignatures), [u8; 32]) {
        let channel_id;
        let events_6 = node_conf.node.get_and_clear_pending_msg_events();
        assert_eq!(events_6.len(), 3);
@@ -700,7 +700,7 @@ pub fn create_chan_between_nodes_with_value_confirm_second<'a, 'b, 'c>(node_recv
                1
        } else { panic!("Unexpected event: {:?}", events_6[1]); };
        ((match events_6[0] {
-               MessageSendEvent::SendFundingLocked { ref node_id, ref msg } => {
+               MessageSendEvent::SendChannelReady { ref node_id, ref msg } => {
                        channel_id = msg.channel_id.clone();
                        assert_eq!(*node_id, node_recv.node.get_our_node_id());
                        msg.clone()
@@ -715,7 +715,7 @@ pub fn create_chan_between_nodes_with_value_confirm_second<'a, 'b, 'c>(node_recv
        }), channel_id)
 }
 
-pub fn create_chan_between_nodes_with_value_confirm<'a, 'b, 'c, 'd>(node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, tx: &Transaction) -> ((msgs::FundingLocked, msgs::AnnouncementSignatures), [u8; 32]) {
+pub fn create_chan_between_nodes_with_value_confirm<'a, 'b, 'c, 'd>(node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, tx: &Transaction) -> ((msgs::ChannelReady, msgs::AnnouncementSignatures), [u8; 32]) {
        let conf_height = core::cmp::max(node_a.best_block_info().1 + 1, node_b.best_block_info().1 + 1);
        create_chan_between_nodes_with_value_confirm_first(node_a, node_b, tx, conf_height);
        confirm_transaction_at(node_a, tx, conf_height);
@@ -723,14 +723,14 @@ pub fn create_chan_between_nodes_with_value_confirm<'a, 'b, 'c, 'd>(node_a: &'a
        create_chan_between_nodes_with_value_confirm_second(node_b, node_a)
 }
 
-pub fn create_chan_between_nodes_with_value_a<'a, 'b, 'c, 'd>(node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> ((msgs::FundingLocked, msgs::AnnouncementSignatures), [u8; 32], Transaction) {
+pub fn create_chan_between_nodes_with_value_a<'a, 'b, 'c, 'd>(node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> ((msgs::ChannelReady, msgs::AnnouncementSignatures), [u8; 32], Transaction) {
        let tx = create_chan_between_nodes_with_value_init(node_a, node_b, channel_value, push_msat, a_flags, b_flags);
        let (msgs, chan_id) = create_chan_between_nodes_with_value_confirm(node_a, node_b, &tx);
        (msgs, chan_id, tx)
 }
 
-pub fn create_chan_between_nodes_with_value_b<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, as_funding_msgs: &(msgs::FundingLocked, msgs::AnnouncementSignatures)) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate) {
-       node_b.node.handle_funding_locked(&node_a.node.get_our_node_id(), &as_funding_msgs.0);
+pub fn create_chan_between_nodes_with_value_b<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, as_funding_msgs: &(msgs::ChannelReady, msgs::AnnouncementSignatures)) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate) {
+       node_b.node.handle_channel_ready(&node_a.node.get_our_node_id(), &as_funding_msgs.0);
        let bs_announcement_sigs = get_event_msg!(node_b, MessageSendEvent::SendAnnouncementSignatures, node_a.node.get_our_node_id());
        node_b.node.handle_announcement_signatures(&node_a.node.get_our_node_id(), &as_funding_msgs.1);
 
@@ -771,7 +771,7 @@ pub fn create_announced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &'a
        (chan_announcement.1, chan_announcement.2, chan_announcement.3, chan_announcement.4)
 }
 
-pub fn create_unannounced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &'a Vec<Node<'b, 'c, 'd>>, a: usize, b: usize, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::FundingLocked, Transaction) {
+pub fn create_unannounced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &'a Vec<Node<'b, 'c, 'd>>, a: usize, b: usize, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::ChannelReady, Transaction) {
        let mut no_announce_cfg = test_default_channel_config();
        no_announce_cfg.channel_options.announced_channel = false;
        nodes[a].node.create_channel(nodes[b].node.get_our_node_id(), channel_value, push_msat, 42, Some(no_announce_cfg)).unwrap();
@@ -794,10 +794,10 @@ pub fn create_unannounced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &
        connect_blocks(&nodes[a], CHAN_CONFIRM_DEPTH - 1);
        confirm_transaction_at(&nodes[b], &tx, conf_height);
        connect_blocks(&nodes[b], CHAN_CONFIRM_DEPTH - 1);
-       let as_funding_locked = get_event_msg!(nodes[a], MessageSendEvent::SendFundingLocked, nodes[b].node.get_our_node_id());
-       nodes[a].node.handle_funding_locked(&nodes[b].node.get_our_node_id(), &get_event_msg!(nodes[b], MessageSendEvent::SendFundingLocked, nodes[a].node.get_our_node_id()));
+       let as_channel_ready = get_event_msg!(nodes[a], MessageSendEvent::SendChannelReady, nodes[b].node.get_our_node_id());
+       nodes[a].node.handle_channel_ready(&nodes[b].node.get_our_node_id(), &get_event_msg!(nodes[b], MessageSendEvent::SendChannelReady, nodes[a].node.get_our_node_id()));
        let as_update = get_event_msg!(nodes[a], MessageSendEvent::SendChannelUpdate, nodes[b].node.get_our_node_id());
-       nodes[b].node.handle_funding_locked(&nodes[a].node.get_our_node_id(), &as_funding_locked);
+       nodes[b].node.handle_channel_ready(&nodes[a].node.get_our_node_id(), &as_channel_ready);
        let bs_update = get_event_msg!(nodes[b], MessageSendEvent::SendChannelUpdate, nodes[a].node.get_our_node_id());
 
        nodes[a].node.handle_channel_update(&nodes[b].node.get_our_node_id(), &bs_update);
@@ -805,7 +805,7 @@ pub fn create_unannounced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &
 
        let mut found_a = false;
        for chan in nodes[a].node.list_usable_channels() {
-               if chan.channel_id == as_funding_locked.channel_id {
+               if chan.channel_id == as_channel_ready.channel_id {
                        assert!(!found_a);
                        found_a = true;
                        assert!(!chan.is_public);
@@ -815,7 +815,7 @@ pub fn create_unannounced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &
 
        let mut found_b = false;
        for chan in nodes[b].node.list_usable_channels() {
-               if chan.channel_id == as_funding_locked.channel_id {
+               if chan.channel_id == as_channel_ready.channel_id {
                        assert!(!found_b);
                        found_b = true;
                        assert!(!chan.is_public);
@@ -823,7 +823,7 @@ pub fn create_unannounced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &
        }
        assert!(found_b);
 
-       (as_funding_locked, tx)
+       (as_channel_ready, tx)
 }
 
 pub fn update_nodes_with_chan_announce<'a, 'b, 'c, 'd>(nodes: &'a Vec<Node<'b, 'c, 'd>>, a: usize, b: usize, ann: &msgs::ChannelAnnouncement, upd_1: &msgs::ChannelUpdate, upd_2: &msgs::ChannelUpdate) {
@@ -2200,7 +2200,7 @@ macro_rules! handle_chan_reestablish_msgs {
                {
                        let msg_events = $src_node.node.get_and_clear_pending_msg_events();
                        let mut idx = 0;
-                       let funding_locked = if let Some(&MessageSendEvent::SendFundingLocked { ref node_id, ref msg }) = msg_events.get(0) {
+                       let channel_ready = if let Some(&MessageSendEvent::SendChannelReady { ref node_id, ref msg }) = msg_events.get(0) {
                                idx += 1;
                                assert_eq!(*node_id, $dst_node.node.get_our_node_id());
                                Some(msg.clone())
@@ -2261,35 +2261,35 @@ macro_rules! handle_chan_reestablish_msgs {
 
                        assert_eq!(msg_events.len(), idx);
 
-                       (funding_locked, revoke_and_ack, commitment_update, order)
+                       (channel_ready, revoke_and_ack, commitment_update, order)
                }
        }
 }
 
 /// pending_htlc_adds includes both the holding cell and in-flight update_add_htlcs, whereas
 /// for claims/fails they are separated out.
-pub fn reconnect_nodes<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, send_funding_locked: (bool, bool), pending_htlc_adds: (i64, i64), pending_htlc_claims: (usize, usize), pending_htlc_fails: (usize, usize), pending_cell_htlc_claims: (usize, usize), pending_cell_htlc_fails: (usize, usize), pending_raa: (bool, bool))  {
+pub fn reconnect_nodes<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, send_channel_ready: (bool, bool), pending_htlc_adds: (i64, i64), pending_htlc_claims: (usize, usize), pending_htlc_fails: (usize, usize), pending_cell_htlc_claims: (usize, usize), pending_cell_htlc_fails: (usize, usize), pending_raa: (bool, bool))  {
        node_a.node.peer_connected(&node_b.node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty(), remote_network_address: None });
        let reestablish_1 = get_chan_reestablish_msgs!(node_a, node_b);
        node_b.node.peer_connected(&node_a.node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty(), remote_network_address: None });
        let reestablish_2 = get_chan_reestablish_msgs!(node_b, node_a);
 
-       if send_funding_locked.0 {
-               // If a expects a funding_locked, it better not think it has received a revoke_and_ack
+       if send_channel_ready.0 {
+               // If a expects a channel_ready, it better not think it has received a revoke_and_ack
                // from b
                for reestablish in reestablish_1.iter() {
                        assert_eq!(reestablish.next_remote_commitment_number, 0);
                }
        }
-       if send_funding_locked.1 {
-               // If b expects a funding_locked, it better not think it has received a revoke_and_ack
+       if send_channel_ready.1 {
+               // If b expects a channel_ready, it better not think it has received a revoke_and_ack
                // from a
                for reestablish in reestablish_2.iter() {
                        assert_eq!(reestablish.next_remote_commitment_number, 0);
                }
        }
-       if send_funding_locked.0 || send_funding_locked.1 {
-               // If we expect any funding_locked's, both sides better have set
+       if send_channel_ready.0 || send_channel_ready.1 {
+               // If we expect any channel_ready's, both sides better have set
                // next_holder_commitment_number to 1
                for reestablish in reestablish_1.iter() {
                        assert_eq!(reestablish.next_local_commitment_number, 1);
@@ -2328,8 +2328,8 @@ pub fn reconnect_nodes<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a,
                         pending_cell_htlc_claims.1 == 0 && pending_cell_htlc_fails.1 == 0));
 
        for chan_msgs in resp_1.drain(..) {
-               if send_funding_locked.0 {
-                       node_a.node.handle_funding_locked(&node_b.node.get_our_node_id(), &chan_msgs.0.unwrap());
+               if send_channel_ready.0 {
+                       node_a.node.handle_channel_ready(&node_b.node.get_our_node_id(), &chan_msgs.0.unwrap());
                        let announcement_event = node_a.node.get_and_clear_pending_msg_events();
                        if !announcement_event.is_empty() {
                                assert_eq!(announcement_event.len(), 1);
@@ -2385,8 +2385,8 @@ pub fn reconnect_nodes<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a,
        }
 
        for chan_msgs in resp_2.drain(..) {
-               if send_funding_locked.1 {
-                       node_b.node.handle_funding_locked(&node_a.node.get_our_node_id(), &chan_msgs.0.unwrap());
+               if send_channel_ready.1 {
+                       node_b.node.handle_channel_ready(&node_a.node.get_our_node_id(), &chan_msgs.0.unwrap());
                        let announcement_event = node_b.node.get_and_clear_pending_msg_events();
                        if !announcement_event.is_empty() {
                                assert_eq!(announcement_event.len(), 1);
index 8eb001941f763a51fd8a6535f814f8b6e7c528a3..d1dbad4720b814db3fb89476e0e8e8b7cee22193 100644 (file)
@@ -3624,11 +3624,11 @@ fn do_test_drop_messages_peer_disconnect(messages_delivered: u8, simulate_broken
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 
-       let mut as_funding_locked = None;
+       let mut as_channel_ready = None;
        if messages_delivered == 0 {
-               let (funding_locked, _, _) = create_chan_between_nodes_with_value_a(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
-               as_funding_locked = Some(funding_locked);
-               // nodes[1] doesn't receive the funding_locked message (it'll be re-sent on reconnect)
+               let (channel_ready, _, _) = create_chan_between_nodes_with_value_a(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
+               as_channel_ready = Some(channel_ready);
+               // nodes[1] doesn't receive the channel_ready message (it'll be re-sent on reconnect)
                // Note that we store it so that if we're running with `simulate_broken_lnd` we can deliver
                // it before the channel_reestablish message.
        } else {
@@ -3681,17 +3681,17 @@ fn do_test_drop_messages_peer_disconnect(messages_delivered: u8, simulate_broken
        nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
        if messages_delivered < 3 {
                if simulate_broken_lnd {
-                       // lnd has a long-standing bug where they send a funding_locked prior to a
-                       // channel_reestablish if you reconnect prior to funding_locked time.
+                       // lnd has a long-standing bug where they send a channel_ready prior to a
+                       // channel_reestablish if you reconnect prior to channel_ready time.
                        //
-                       // Here we simulate that behavior, delivering a funding_locked immediately on
-                       // reconnect. Note that we don't bother skipping the now-duplicate funding_locked sent
+                       // Here we simulate that behavior, delivering a channel_ready immediately on
+                       // reconnect. Note that we don't bother skipping the now-duplicate channel_ready sent
                        // in `reconnect_nodes` but we currently don't fail based on that.
                        //
                        // See-also <https://github.com/lightningnetwork/lnd/issues/4006>
-                       nodes[1].node.handle_funding_locked(&nodes[0].node.get_our_node_id(), &as_funding_locked.as_ref().unwrap().0);
+                       nodes[1].node.handle_channel_ready(&nodes[0].node.get_our_node_id(), &as_channel_ready.as_ref().unwrap().0);
                }
-               // Even if the funding_locked messages get exchanged, as long as nothing further was
+               // Even if the channel_ready messages get exchanged, as long as nothing further was
                // received on either side, both sides will need to resend them.
                reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 1), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
        } else if messages_delivered == 3 {
@@ -3886,26 +3886,26 @@ fn test_funding_peer_disconnect() {
        nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty(), remote_network_address: None });
        let bs_reestablish = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
 
-       // nodes[0] hasn't yet received a funding_locked, so it only sends that on reconnect.
+       // nodes[0] hasn't yet received a channel_ready, so it only sends that on reconnect.
        nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &bs_reestablish);
        let events_3 = nodes[0].node.get_and_clear_pending_msg_events();
        assert_eq!(events_3.len(), 1);
-       let as_funding_locked = match events_3[0] {
-               MessageSendEvent::SendFundingLocked { ref node_id, ref msg } => {
+       let as_channel_ready = match events_3[0] {
+               MessageSendEvent::SendChannelReady { ref node_id, ref msg } => {
                        assert_eq!(*node_id, nodes[1].node.get_our_node_id());
                        msg.clone()
                },
                _ => panic!("Unexpected event {:?}", events_3[0]),
        };
 
-       // nodes[1] received nodes[0]'s funding_locked on the first reconnect above, so it should send
+       // nodes[1] received nodes[0]'s channel_ready on the first reconnect above, so it should send
        // announcement_signatures as well as channel_update.
        nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &as_reestablish);
        let events_4 = nodes[1].node.get_and_clear_pending_msg_events();
        assert_eq!(events_4.len(), 3);
        let chan_id;
-       let bs_funding_locked = match events_4[0] {
-               MessageSendEvent::SendFundingLocked { ref node_id, ref msg } => {
+       let bs_channel_ready = match events_4[0] {
+               MessageSendEvent::SendChannelReady { ref node_id, ref msg } => {
                        assert_eq!(*node_id, nodes[0].node.get_our_node_id());
                        chan_id = msg.channel_id;
                        msg.clone()
@@ -3926,9 +3926,9 @@ fn test_funding_peer_disconnect() {
                _ => panic!("Unexpected event {:?}", events_4[2]),
        }
 
-       // Re-deliver nodes[0]'s funding_locked, which nodes[1] can safely ignore. It currently
+       // Re-deliver nodes[0]'s channel_ready, which nodes[1] can safely ignore. It currently
        // generates a duplicative private channel_update
-       nodes[1].node.handle_funding_locked(&nodes[0].node.get_our_node_id(), &as_funding_locked);
+       nodes[1].node.handle_channel_ready(&nodes[0].node.get_our_node_id(), &as_channel_ready);
        let events_5 = nodes[1].node.get_and_clear_pending_msg_events();
        assert_eq!(events_5.len(), 1);
        match events_5[0] {
@@ -3938,9 +3938,9 @@ fn test_funding_peer_disconnect() {
                _ => panic!("Unexpected event {:?}", events_5[0]),
        };
 
-       // When we deliver nodes[1]'s funding_locked, however, nodes[0] will generate its
+       // When we deliver nodes[1]'s channel_ready, however, nodes[0] will generate its
        // announcement_signatures.
-       nodes[0].node.handle_funding_locked(&nodes[1].node.get_our_node_id(), &bs_funding_locked);
+       nodes[0].node.handle_channel_ready(&nodes[1].node.get_our_node_id(), &bs_channel_ready);
        let events_6 = nodes[0].node.get_and_clear_pending_msg_events();
        assert_eq!(events_6.len(), 1);
        let as_announcement_sigs = match events_6[0] {
@@ -4043,11 +4043,11 @@ fn test_funding_peer_disconnect() {
 }
 
 #[test]
-fn test_funding_locked_without_best_block_updated() {
+fn test_channel_ready_without_best_block_updated() {
        // Previously, if we were offline when a funding transaction was locked in, and then we came
        // back online, calling best_block_updated once followed by transactions_confirmed, we'd not
-       // generate a funding_locked until a later best_block_updated. This tests that we generate the
-       // funding_locked immediately instead.
+       // generate a channel_ready until a later best_block_updated. This tests that we generate the
+       // channel_ready immediately instead.
        let chanmon_cfgs = create_chanmon_cfgs(2);
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
@@ -4063,9 +4063,9 @@ fn test_funding_locked_without_best_block_updated() {
        let conf_block_header = nodes[0].get_block_header(conf_height);
        nodes[0].node.transactions_confirmed(&conf_block_header, &conf_txn[..], conf_height);
 
-       // Ensure nodes[0] generates a funding_locked after the transactions_confirmed
-       let as_funding_locked = get_event_msg!(nodes[0], MessageSendEvent::SendFundingLocked, nodes[1].node.get_our_node_id());
-       nodes[1].node.handle_funding_locked(&nodes[0].node.get_our_node_id(), &as_funding_locked);
+       // Ensure nodes[0] generates a channel_ready after the transactions_confirmed
+       let as_channel_ready = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, nodes[1].node.get_our_node_id());
+       nodes[1].node.handle_channel_ready(&nodes[0].node.get_our_node_id(), &as_channel_ready);
 }
 
 #[test]
@@ -4418,8 +4418,8 @@ fn test_no_txn_manager_serialize_deserialize() {
        nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
        assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 
-       let (funding_locked, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
-       let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
+       let (channel_ready, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
+       let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &channel_ready);
        for node in nodes.iter() {
                assert!(node.net_graph_msg_handler.handle_channel_announcement(&announcement).unwrap());
                node.net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
@@ -4538,8 +4538,8 @@ fn test_manager_serialize_deserialize_events() {
        nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
        assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 
-       let (funding_locked, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
-       let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
+       let (channel_ready, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
+       let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &channel_ready);
        for node in nodes.iter() {
                assert!(node.net_graph_msg_handler.handle_channel_announcement(&announcement).unwrap());
                node.net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
@@ -9330,8 +9330,8 @@ fn test_duplicate_chan_id() {
        assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
        assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[0], tx);
 
-       let (funding_locked, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
-       let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
+       let (channel_ready, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
+       let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &channel_ready);
        update_nodes_with_chan_announce(&nodes, 0, 1, &announcement, &as_update, &bs_update);
        send_payment(&nodes[0], &[&nodes[1]], 8000000);
 }
@@ -9631,7 +9631,7 @@ fn test_forwardable_regen() {
        check_added_monitors!(nodes[1], 2);
 
        reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
-       // Note that nodes[1] and nodes[2] resend their funding_locked here since they haven't updated
+       // Note that nodes[1] and nodes[2] resend their channel_ready here since they haven't updated
        // the commitment state.
        reconnect_nodes(&nodes[1], &nodes[2], (true, true), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
 
@@ -10213,8 +10213,8 @@ fn do_test_max_dust_htlc_exposure(dust_outbound_balance: bool, exposure_breach_e
        nodes[0].node.handle_funding_signed(&nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id()));
        check_added_monitors!(nodes[0], 1);
 
-       let (funding_locked, channel_id) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
-       let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
+       let (channel_ready, channel_id) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
+       let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &channel_ready);
        update_nodes_with_chan_announce(&nodes, 0, 1, &announcement, &as_update, &bs_update);
 
        let dust_buffer_feerate = {
index 5aa48c32bf07686aba4adad53b9615a6cdd91bb1..0e5b2e07e7a4cea649bc44939a67f2c940f71779 100644 (file)
@@ -239,9 +239,9 @@ pub struct FundingSigned {
        pub signature: Signature,
 }
 
-/// A funding_locked message to be sent or received from a peer
+/// A channel_ready message to be sent or received from a peer
 #[derive(Clone, Debug, PartialEq)]
-pub struct FundingLocked {
+pub struct ChannelReady {
        /// The channel ID
        pub channel_id: [u8; 32],
        /// The per-commitment point of the second commitment transaction
@@ -815,8 +815,8 @@ pub trait ChannelMessageHandler : MessageSendEventsProvider {
        fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
        /// Handle an incoming funding_signed message from the given peer.
        fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
-       /// Handle an incoming funding_locked message from the given peer.
-       fn handle_funding_locked(&self, their_node_id: &PublicKey, msg: &FundingLocked);
+       /// Handle an incoming channel_ready message from the given peer.
+       fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
 
        // Channl close:
        /// Handle an incoming shutdown message from the given peer.
@@ -1163,7 +1163,7 @@ impl_writeable_msg!(FundingSigned, {
        signature
 }, {});
 
-impl_writeable_msg!(FundingLocked, {
+impl_writeable_msg!(ChannelReady, {
        channel_id,
        next_per_commitment_point,
 }, {
@@ -2262,15 +2262,15 @@ mod tests {
        }
 
        #[test]
-       fn encoding_funding_locked() {
+       fn encoding_channel_ready() {
                let secp_ctx = Secp256k1::new();
                let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
-               let funding_locked = msgs::FundingLocked {
+               let channel_ready = msgs::ChannelReady {
                        channel_id: [2; 32],
                        next_per_commitment_point: pubkey_1,
                        short_channel_id_alias: None,
                };
-               let encoded_value = funding_locked.encode();
+               let encoded_value = channel_ready.encode();
                let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
                assert_eq!(encoded_value, target_value);
        }
index f128f6c5259802466cf99f27496b554d7b88f9ea..68a7ef952702b31436ea18ff27bb83f3b67b3fe3 100644 (file)
@@ -151,7 +151,7 @@ impl ChannelMessageHandler for ErroringMessageHandler {
        fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &msgs::FundingSigned) {
                ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
        }
-       fn handle_funding_locked(&self, their_node_id: &PublicKey, msg: &msgs::FundingLocked) {
+       fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &msgs::ChannelReady) {
                ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
        }
        fn handle_shutdown(&self, their_node_id: &PublicKey, _their_features: &InitFeatures, msg: &msgs::Shutdown) {
@@ -1209,8 +1209,8 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, CMH: Deref> P
                        wire::Message::FundingSigned(msg) => {
                                self.message_handler.chan_handler.handle_funding_signed(&their_node_id, &msg);
                        },
-                       wire::Message::FundingLocked(msg) => {
-                               self.message_handler.chan_handler.handle_funding_locked(&their_node_id, &msg);
+                       wire::Message::ChannelReady(msg) => {
+                               self.message_handler.chan_handler.handle_channel_ready(&their_node_id, &msg);
                        },
 
                        wire::Message::Shutdown(msg) => {
@@ -1486,8 +1486,8 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, CMH: Deref> P
                                                                log_bytes!(msg.channel_id));
                                                self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
                                        },
-                                       MessageSendEvent::SendFundingLocked { ref node_id, ref msg } => {
-                                               log_debug!(self.logger, "Handling SendFundingLocked event in peer_handler for node {} for channel {}",
+                                       MessageSendEvent::SendChannelReady { ref node_id, ref msg } => {
+                                               log_debug!(self.logger, "Handling SendChannelReady event in peer_handler for node {} for channel {}",
                                                                log_pubkey!(node_id),
                                                                log_bytes!(msg.channel_id));
                                                self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
index f4f52a8baf49cce4b0d1f586e92e27a72344a328..754e20a4ff11ba0c68a891059a683705892849ff 100644 (file)
@@ -167,7 +167,7 @@ fn test_priv_forwarding_rejection() {
 }
 
 fn do_test_1_conf_open(connect_style: ConnectStyle) {
-       // Previously, if the minium_depth config was set to 1, we'd never send a funding_locked. This
+       // Previously, if the minium_depth config was set to 1, we'd never send a channel_ready. This
        // tests that we properly send one in that case.
        let mut alice_config = UserConfig::default();
        alice_config.own_channel_config.minimum_depth = 1;
@@ -185,13 +185,13 @@ fn do_test_1_conf_open(connect_style: ConnectStyle) {
 
        let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
        mine_transaction(&nodes[1], &tx);
-       nodes[0].node.handle_funding_locked(&nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendFundingLocked, nodes[0].node.get_our_node_id()));
+       nodes[0].node.handle_channel_ready(&nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, nodes[0].node.get_our_node_id()));
        assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 
        mine_transaction(&nodes[0], &tx);
        let as_msg_events = nodes[0].node.get_and_clear_pending_msg_events();
        assert_eq!(as_msg_events.len(), 2);
-       let as_funding_locked = if let MessageSendEvent::SendFundingLocked { ref node_id, ref msg } = as_msg_events[0] {
+       let as_channel_ready = if let MessageSendEvent::SendChannelReady { ref node_id, ref msg } = as_msg_events[0] {
                assert_eq!(*node_id, nodes[1].node.get_our_node_id());
                msg.clone()
        } else { panic!("Unexpected event"); };
@@ -199,7 +199,7 @@ fn do_test_1_conf_open(connect_style: ConnectStyle) {
                assert_eq!(*node_id, nodes[1].node.get_our_node_id());
        } else { panic!("Unexpected event"); }
 
-       nodes[1].node.handle_funding_locked(&nodes[0].node.get_our_node_id(), &as_funding_locked);
+       nodes[1].node.handle_channel_ready(&nodes[0].node.get_our_node_id(), &as_channel_ready);
        let bs_msg_events = nodes[1].node.get_and_clear_pending_msg_events();
        assert_eq!(bs_msg_events.len(), 1);
        if let MessageSendEvent::SendChannelUpdate { ref node_id, msg: _ } = bs_msg_events[0] {
@@ -259,7 +259,7 @@ fn test_routed_scid_alias() {
        let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 
        create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000, InitFeatures::known(), InitFeatures::known()).2;
-       let mut as_funding_locked = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 500_000_000, InitFeatures::known(), InitFeatures::known()).0;
+       let mut as_channel_ready = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 500_000_000, InitFeatures::known(), InitFeatures::known()).0;
 
        let last_hop = nodes[2].node.list_usable_channels();
        let hop_hints = vec![RouteHint(vec![RouteHintHop {
@@ -284,17 +284,17 @@ fn test_routed_scid_alias() {
        pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], 100_000, payment_hash, payment_secret);
        claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
 
-       // Now test that if a peer sends us a second funding_locked after the channel is operational we
+       // Now test that if a peer sends us a second channel_ready after the channel is operational we
        // will use the new alias.
-       as_funding_locked.short_channel_id_alias = Some(0xdeadbeef);
-       nodes[2].node.handle_funding_locked(&nodes[1].node.get_our_node_id(), &as_funding_locked);
-       // Note that we always respond to a funding_locked with a channel_update. Not a lot of reason
+       as_channel_ready.short_channel_id_alias = Some(0xdeadbeef);
+       nodes[2].node.handle_channel_ready(&nodes[1].node.get_our_node_id(), &as_channel_ready);
+       // Note that we always respond to a channel_ready with a channel_update. Not a lot of reason
        // to bother updating that code, so just drop the message here.
        get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id());
        let updated_channel_info = nodes[2].node.list_usable_channels();
        assert_eq!(updated_channel_info.len(), 1);
        assert_eq!(updated_channel_info[0].inbound_scid_alias.unwrap(), 0xdeadbeef);
-       // Note that because we never send a duplicate funding_locked we can't send a payment through
+       // Note that because we never send a duplicate channel_ready we can't send a payment through
        // the 0xdeadbeef SCID alias.
 }
 
@@ -403,10 +403,10 @@ fn test_inbound_scid_privacy() {
        connect_blocks(&nodes[1], CHAN_CONFIRM_DEPTH - 1);
        confirm_transaction_at(&nodes[2], &tx, conf_height);
        connect_blocks(&nodes[2], CHAN_CONFIRM_DEPTH - 1);
-       let bs_funding_locked = get_event_msg!(nodes[1], MessageSendEvent::SendFundingLocked, nodes[2].node.get_our_node_id());
-       nodes[1].node.handle_funding_locked(&nodes[2].node.get_our_node_id(), &get_event_msg!(nodes[2], MessageSendEvent::SendFundingLocked, nodes[1].node.get_our_node_id()));
+       let bs_channel_ready = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, nodes[2].node.get_our_node_id());
+       nodes[1].node.handle_channel_ready(&nodes[2].node.get_our_node_id(), &get_event_msg!(nodes[2], MessageSendEvent::SendChannelReady, nodes[1].node.get_our_node_id()));
        let bs_update = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[2].node.get_our_node_id());
-       nodes[2].node.handle_funding_locked(&nodes[1].node.get_our_node_id(), &bs_funding_locked);
+       nodes[2].node.handle_channel_ready(&nodes[1].node.get_our_node_id(), &bs_channel_ready);
        let cs_update = get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id());
 
        nodes[1].node.handle_channel_update(&nodes[2].node.get_our_node_id(), &cs_update);
@@ -592,7 +592,7 @@ fn open_zero_conf_channel<'a, 'b, 'c, 'd>(initiator: &'a Node<'b, 'c, 'd>, recei
        check_added_monitors!(receiver, 1);
        let bs_signed_locked = receiver.node.get_and_clear_pending_msg_events();
        assert_eq!(bs_signed_locked.len(), 2);
-       let as_funding_locked;
+       let as_channel_ready;
        match &bs_signed_locked[0] {
                MessageSendEvent::SendFundingSigned { node_id, msg } => {
                        assert_eq!(*node_id, initiator.node.get_our_node_id());
@@ -602,19 +602,19 @@ fn open_zero_conf_channel<'a, 'b, 'c, 'd>(initiator: &'a Node<'b, 'c, 'd>, recei
                        assert_eq!(initiator.tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
                        assert_eq!(initiator.tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0)[0], tx);
 
-                       as_funding_locked = get_event_msg!(initiator, MessageSendEvent::SendFundingLocked, receiver.node.get_our_node_id());
+                       as_channel_ready = get_event_msg!(initiator, MessageSendEvent::SendChannelReady, receiver.node.get_our_node_id());
                }
                _ => panic!("Unexpected event"),
        }
        match &bs_signed_locked[1] {
-               MessageSendEvent::SendFundingLocked { node_id, msg } => {
+               MessageSendEvent::SendChannelReady { node_id, msg } => {
                        assert_eq!(*node_id, initiator.node.get_our_node_id());
-                       initiator.node.handle_funding_locked(&receiver.node.get_our_node_id(), &msg);
+                       initiator.node.handle_channel_ready(&receiver.node.get_our_node_id(), &msg);
                }
                _ => panic!("Unexpected event"),
        }
 
-       receiver.node.handle_funding_locked(&initiator.node.get_our_node_id(), &as_funding_locked);
+       receiver.node.handle_channel_ready(&initiator.node.get_our_node_id(), &as_channel_ready);
 
        let as_channel_update = get_event_msg!(initiator, MessageSendEvent::SendChannelUpdate, receiver.node.get_our_node_id());
        let bs_channel_update = get_event_msg!(receiver, MessageSendEvent::SendChannelUpdate, initiator.node.get_our_node_id());
@@ -633,7 +633,7 @@ fn test_simple_0conf_channel() {
        // If our peer tells us they will accept our channel with 0 confs, and we funded the channel,
        // we should trust the funding won't be double-spent (assuming `trust_own_funding_0conf` is
        // set)!
-       // Further, if we `accept_inbound_channel_from_trusted_peer_0conf`, funding locked messages
+       // Further, if we `accept_inbound_channel_from_trusted_peer_0conf`, `channel_ready` messages
        // should fly immediately and the channel should be available for use as soon as they are
        // received.
 
@@ -652,7 +652,7 @@ fn test_simple_0conf_channel() {
 
 #[test]
 fn test_0conf_channel_with_async_monitor() {
-       // Test that we properly send out funding_locked in (both inbound- and outbound-) zero-conf
+       // Test that we properly send out channel_ready in (both inbound- and outbound-) zero-conf
        // channels if ChannelMonitor updates return a `TemporaryFailure` during the initial channel
        // negotiation.
 
@@ -708,9 +708,9 @@ fn test_0conf_channel_with_async_monitor() {
                _ => panic!("Unexpected event"),
        }
        match &bs_signed_locked[1] {
-               MessageSendEvent::SendFundingLocked { node_id, msg } => {
+               MessageSendEvent::SendChannelReady { node_id, msg } => {
                        assert_eq!(*node_id, nodes[0].node.get_our_node_id());
-                       nodes[0].node.handle_funding_locked(&nodes[1].node.get_our_node_id(), &msg);
+                       nodes[0].node.handle_channel_ready(&nodes[1].node.get_our_node_id(), &msg);
                }
                _ => panic!("Unexpected event"),
        }
@@ -727,9 +727,9 @@ fn test_0conf_channel_with_async_monitor() {
        assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0)[0], tx);
 
        match &as_locked_update[0] {
-               MessageSendEvent::SendFundingLocked { node_id, msg } => {
+               MessageSendEvent::SendChannelReady { node_id, msg } => {
                        assert_eq!(*node_id, nodes[1].node.get_our_node_id());
-                       nodes[1].node.handle_funding_locked(&nodes[0].node.get_our_node_id(), &msg);
+                       nodes[1].node.handle_channel_ready(&nodes[0].node.get_our_node_id(), &msg);
                }
                _ => panic!("Unexpected event"),
        }
index 58d505943a686dbd625f387b756624654f42b98d..3dc245877e759fb8816ba0faa846f42386040f1a 100644 (file)
@@ -37,7 +37,7 @@ use ln::msgs::OptionalField::Present;
 
 #[test]
 fn pre_funding_lock_shutdown_test() {
-       // Test sending a shutdown prior to funding_locked after funding generation
+       // Test sending a shutdown prior to channel_ready after funding generation
        let chanmon_cfgs = create_chanmon_cfgs(2);
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
index a0b549452830ecd85f05ba5fa76ab543ae29aa81..cbf5c77d60095d73abe235c7652eeccb8380cf04 100644 (file)
@@ -57,7 +57,7 @@ pub(crate) enum Message<T> where T: core::fmt::Debug + Type + TestEq {
        AcceptChannel(msgs::AcceptChannel),
        FundingCreated(msgs::FundingCreated),
        FundingSigned(msgs::FundingSigned),
-       FundingLocked(msgs::FundingLocked),
+       ChannelReady(msgs::ChannelReady),
        Shutdown(msgs::Shutdown),
        ClosingSigned(msgs::ClosingSigned),
        UpdateAddHTLC(msgs::UpdateAddHTLC),
@@ -97,7 +97,7 @@ impl<T> Message<T> where T: core::fmt::Debug + Type + TestEq {
                        &Message::AcceptChannel(ref msg) => msg.type_id(),
                        &Message::FundingCreated(ref msg) => msg.type_id(),
                        &Message::FundingSigned(ref msg) => msg.type_id(),
-                       &Message::FundingLocked(ref msg) => msg.type_id(),
+                       &Message::ChannelReady(ref msg) => msg.type_id(),
                        &Message::Shutdown(ref msg) => msg.type_id(),
                        &Message::ClosingSigned(ref msg) => msg.type_id(),
                        &Message::UpdateAddHTLC(ref msg) => msg.type_id(),
@@ -176,8 +176,8 @@ fn do_read<R: io::Read, T, H: core::ops::Deref>(buffer: &mut R, message_type: u1
                msgs::FundingSigned::TYPE => {
                        Ok(Message::FundingSigned(Readable::read(buffer)?))
                },
-               msgs::FundingLocked::TYPE => {
-                       Ok(Message::FundingLocked(Readable::read(buffer)?))
+               msgs::ChannelReady::TYPE => {
+                       Ok(Message::ChannelReady(Readable::read(buffer)?))
                },
                msgs::Shutdown::TYPE => {
                        Ok(Message::Shutdown(Readable::read(buffer)?))
@@ -332,7 +332,7 @@ impl Encode for msgs::FundingSigned {
        const TYPE: u16 = 35;
 }
 
-impl Encode for msgs::FundingLocked {
+impl Encode for msgs::ChannelReady {
        const TYPE: u16 = 36;
 }
 
index 6c8f40017811363be882133ecb09e3aaa71338c2..8731e66da9bd866bd82d00bc42c8922cd25508e8 100644 (file)
@@ -1917,7 +1917,7 @@ mod tests {
                        unspendable_punishment_reserve: None,
                        confirmations_required: None,
                        force_close_spend_delay: None,
-                       is_outbound: true, is_funding_locked: true,
+                       is_outbound: true, is_channel_ready: true,
                        is_usable: true, is_public: true,
                        inbound_htlc_minimum_msat: None,
                        inbound_htlc_maximum_msat: None,
@@ -5750,7 +5750,7 @@ mod benches {
                        confirmations_required: None,
                        force_close_spend_delay: None,
                        is_outbound: true,
-                       is_funding_locked: true,
+                       is_channel_ready: true,
                        is_usable: true,
                        is_public: true,
                        inbound_htlc_minimum_msat: None,
index 34a8a410b65d1ad5c603954ee1d2290f4ba4856f..0a886b93f6e01eb3dc70c967bc8d439ee3805b84 100644 (file)
@@ -902,12 +902,12 @@ pub enum MessageSendEvent {
                /// The message which should be sent.
                msg: msgs::FundingSigned,
        },
-       /// Used to indicate that a funding_locked message should be sent to the peer with the given node_id.
-       SendFundingLocked {
+       /// Used to indicate that a channel_ready message should be sent to the peer with the given node_id.
+       SendChannelReady {
                /// The node_id of the node which should receive these message(s)
                node_id: PublicKey,
-               /// The funding_locked message which should be sent.
-               msg: msgs::FundingLocked,
+               /// The channel_ready message which should be sent.
+               msg: msgs::ChannelReady,
        },
        /// Used to indicate that an announcement_signatures message should be sent to the peer with the given node_id.
        SendAnnouncementSignatures {
index fe756b73ad67d28fdbe0ba3cdc9fd73865635100..4f3d800be5dd8479f79a7999318fc627017e7078 100644 (file)
@@ -307,8 +307,8 @@ impl msgs::ChannelMessageHandler for TestChannelMessageHandler {
        fn handle_funding_signed(&self, _their_node_id: &PublicKey, msg: &msgs::FundingSigned) {
                self.received_msg(wire::Message::FundingSigned(msg.clone()));
        }
-       fn handle_funding_locked(&self, _their_node_id: &PublicKey, msg: &msgs::FundingLocked) {
-               self.received_msg(wire::Message::FundingLocked(msg.clone()));
+       fn handle_channel_ready(&self, _their_node_id: &PublicKey, msg: &msgs::ChannelReady) {
+               self.received_msg(wire::Message::ChannelReady(msg.clone()));
        }
        fn handle_shutdown(&self, _their_node_id: &PublicKey, _their_features: &InitFeatures, msg: &msgs::Shutdown) {
                self.received_msg(wire::Message::Shutdown(msg.clone()));