From: Elias Rohrer Date: Mon, 30 May 2022 21:39:04 +0000 (-0700) Subject: Rename `FundingLocked` to `ChannelReady`. X-Git-Tag: v0.0.107~11^2 X-Git-Url: http://git.bitcoin.ninja/?a=commitdiff_plain;h=e98f68aee626becf056f443a87207ff6c81003a3;p=rust-lightning Rename `FundingLocked` to `ChannelReady`. --- diff --git a/fuzz/src/bin/gen_target.sh b/fuzz/src/bin/gen_target.sh index 72fefe516..b88b72503 100755 --- a/fuzz/src/bin/gen_target.sh +++ b/fuzz/src/bin/gen_target.sh @@ -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 index 000000000..d11068b73 --- /dev/null +++ b/fuzz/src/bin/msg_channel_ready_target.rs @@ -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 or the MIT license +// , 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 = 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 = 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 index 986f7f898..000000000 --- a/fuzz/src/bin/msg_funding_locked_target.rs +++ /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 or the MIT license -// , 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 = 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 = 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!(); - } -} diff --git a/fuzz/src/chanmon_consistency.rs b/fuzz/src/chanmon_consistency.rs index 540b4e4c4..9625677c2 100644 --- a/fuzz/src/chanmon_consistency.rs +++ b/fuzz/src/chanmon_consistency.rs @@ -490,10 +490,10 @@ pub fn do_test(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(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(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(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(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! diff --git a/fuzz/src/full_stack.rs b/fuzz/src/full_stack.rs index e3c8290b1..00b123b84 100644 --- a/fuzz/src/full_stack.rs +++ b/fuzz/src/full_stack.rs @@ -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 diff --git a/fuzz/src/msg_targets/gen_target.sh b/fuzz/src/msg_targets/gen_target.sh index 0e930cfa1..848793db5 100755 --- a/fuzz/src/msg_targets/gen_target.sh +++ b/fuzz/src/msg_targets/gen_target.sh @@ -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 "" diff --git a/fuzz/src/msg_targets/mod.rs b/fuzz/src/msg_targets/mod.rs index 8acb690b0..dd1540ce5 100644 --- a/fuzz/src/msg_targets/mod.rs +++ b/fuzz/src/msg_targets/mod.rs @@ -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 index 000000000..e5f3b25c6 --- /dev/null +++ b/fuzz/src/msg_targets/msg_channel_ready.rs @@ -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 or the MIT license +// , 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(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 index 2c6ad63c9..000000000 --- a/fuzz/src/msg_targets/msg_funding_locked.rs +++ /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 or the MIT license -// , 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(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); -} diff --git a/fuzz/src/router.rs b/fuzz/src/router.rs index 80ea1f1bc..bb6ba2c6e 100644 --- a/fuzz/src/router.rs +++ b/fuzz/src/router.rs @@ -228,7 +228,7 @@ pub fn do_test(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), diff --git a/fuzz/targets.h b/fuzz/targets.h index 798fb6647..d142aa648 100644 --- a/fuzz/targets.h +++ b/fuzz/targets.h @@ -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); diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs index dab376178..95c753bca 100644 --- a/lightning-background-processor/src/lib.rs +++ b/lightning-background-processor/src/lib.rs @@ -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()); diff --git a/lightning-invoice/src/utils.rs b/lightning-invoice/src/utils.rs index 9b3b41afb..9f6691564 100644 --- a/lightning-invoice/src/utils.rs +++ b/lightning-invoice/src/utils.rs @@ -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 diff --git a/lightning-net-tokio/src/lib.rs b/lightning-net-tokio/src/lib.rs index f7e42b663..2ac10762b 100644 --- a/lightning-net-tokio/src/lib.rs +++ b/lightning-net-tokio/src/lib.rs @@ -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) {} diff --git a/lightning/src/ln/chanmon_update_fail_tests.rs b/lightning/src/ln/chanmon_update_fail_tests.rs index fe80d350c..770fe8139 100644 --- a/lightning/src/ln/chanmon_update_fail_tests.rs +++ b/lightning/src/ln/chanmon_update_fail_tests.rs @@ -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()); diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs index 01cd6890a..ca02f0a9a 100644 --- a/lightning/src/ln/channel.rs +++ b/lightning/src/ln/channel.rs @@ -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, pub funding_broadcastable: Option, - pub funding_locked: Option, + pub channel_ready: Option, pub announcement_sigs: Option, } /// The return value of `channel_reestablish` pub(super) struct ReestablishResponses { - pub funding_locked: Option, + pub channel_ready: Option, pub raa: Option, pub commitment_update: Option, pub order: RAACommitmentOrder, @@ -543,7 +543,7 @@ pub(super) struct Channel { /// 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 { /// 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 - pub workaround_lnd_bug_4006: Option, + pub workaround_lnd_bug_4006: Option, #[cfg(any(test, fuzzing))] // When we receive an HTLC fulfill on an outbound path, we may immediately fulfill the @@ -960,7 +960,7 @@ impl Channel { 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 Channel { 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 Channel { &self.get_counterparty_pubkeys().funding_pubkey } - pub fn funding_created(&mut self, msg: &msgs::FundingCreated, best_block: BestBlock, logger: &L) -> Result<(msgs::FundingSigned, ChannelMonitor, Option), ChannelError> where L::Target: Logger { + pub fn funding_created(&mut self, msg: &msgs::FundingCreated, best_block: BestBlock, logger: &L) -> Result<(msgs::FundingSigned, ChannelMonitor, Option), 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 Channel { 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(&mut self, msg: &msgs::FundingSigned, best_block: BestBlock, logger: &L) -> Result<(ChannelMonitor, Transaction, Option), ChannelError> where L::Target: Logger { + pub fn funding_signed(&mut self, msg: &msgs::FundingSigned, best_block: BestBlock, logger: &L) -> Result<(ChannelMonitor, Transaction, Option), 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 Channel { 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(&mut self, msg: &msgs::FundingLocked, node_pk: PublicKey, genesis_block_hash: BlockHash, best_block: &BestBlock, logger: &L) -> Result, ChannelError> where L::Target: Logger { + pub fn channel_ready(&mut self, msg: &msgs::ChannelReady, node_pk: PublicKey, genesis_block_hash: BlockHash, best_block: &BestBlock, logger: &L) -> Result, 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 Channel { 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 Channel { // 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 Channel { /// 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 ) { 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 Channel { // 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 Channel { 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 Channel { 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 Channel { 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 Channel { }); } - // 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 Channel { 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 Channel { // 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 Channel { 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 Channel { }, 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 Channel { } } 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 Channel { 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 Channel { &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 { @@ -4572,7 +4572,7 @@ impl Channel { /// 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 Channel { 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 Channel { self.channel_update_status = status; } - fn check_get_funding_locked(&mut self, height: u32) -> Option { + fn check_get_channel_ready(&mut self, height: u32) -> Option { if self.funding_tx_confirmation_height == 0 && self.minimum_depth != Some(0) { return None; } @@ -4643,13 +4643,13 @@ impl Channel { 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 Channel { 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 Channel { /// In the second, we simply return an Err indicating we need to be force-closed now. pub fn transactions_confirmed(&mut self, block_hash: &BlockHash, height: u32, txdata: &TransactionData, genesis_block_hash: BlockHash, node_pk: PublicKey, logger: &L) - -> Result<(Option, Option), ClosureReason> where L::Target: Logger { + -> Result<(Option, Option), 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 Channel { } } } - // 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 Channel { /// May return some HTLCs (and their payment_hash) which have timed out and should be failed /// back. pub fn best_block_updated(&mut self, height: u32, highest_header_time: u32, genesis_block_hash: BlockHash, node_pk: PublicKey, logger: &L) - -> Result<(Option, Vec<(HTLCSource, PaymentHash)>, Option), ClosureReason> where L::Target: Logger { + -> Result<(Option, Vec<(HTLCSource, PaymentHash)>, Option), 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(&mut self, height: u32, highest_header_time: u32, genesis_node_pk: Option<(BlockHash, PublicKey)>, logger: &L) - -> Result<(Option, Vec<(HTLCSource, PaymentHash)>, Option), ClosureReason> where L::Target: Logger { + -> Result<(Option, Vec<(HTLCSource, PaymentHash)>, Option), 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 Channel { 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 Channel { 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 Channel { /// 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(&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 Channel { // 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 Channel { } /// 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 Writeable for Channel { 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 _ => 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 resend_order, - monitor_pending_funding_locked, + monitor_pending_channel_ready, monitor_pending_revoke_and_ack, monitor_pending_commitment_signed, monitor_pending_forwards, diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs index 3de325290..17a52e29e 100644 --- a/lightning/src/ln/channelmanager.rs +++ b/lightning/src/ln/channelmanager.rs @@ -1074,18 +1074,18 @@ pub struct ChannelDetails { pub force_close_spend_delay: Option, /// 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 = $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 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 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 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 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 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 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 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 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 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 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 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 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 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) -> Result<(Option, Vec<(HTLCSource, PaymentHash)>, Option), ClosureReason>> + fn do_chain_event) -> Result<(Option, Vec<(HTLCSource, PaymentHash)>, Option), ClosureReason>> (&self, height_opt: Option, 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 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 &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!(), diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs index 31fdc6ffa..8929a9774 100644 --- a/lightning/src/ln/functional_test_utils.rs +++ b/lightning/src/ln/functional_test_utils.rs @@ -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>, 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>, 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>, 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); diff --git a/lightning/src/ln/functional_tests.rs b/lightning/src/ln/functional_tests.rs index 8eb001941..d1dbad472 100644 --- a/lightning/src/ln/functional_tests.rs +++ b/lightning/src/ln/functional_tests.rs @@ -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 - 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 = { diff --git a/lightning/src/ln/msgs.rs b/lightning/src/ln/msgs.rs index 5aa48c32b..0e5b2e07e 100644 --- a/lightning/src/ln/msgs.rs +++ b/lightning/src/ln/msgs.rs @@ -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); } diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index f128f6c52..68a7ef952 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -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 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 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); diff --git a/lightning/src/ln/priv_short_conf_tests.rs b/lightning/src/ln/priv_short_conf_tests.rs index f4f52a8ba..754e20a4f 100644 --- a/lightning/src/ln/priv_short_conf_tests.rs +++ b/lightning/src/ln/priv_short_conf_tests.rs @@ -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"), } diff --git a/lightning/src/ln/shutdown_tests.rs b/lightning/src/ln/shutdown_tests.rs index 58d505943..3dc245877 100644 --- a/lightning/src/ln/shutdown_tests.rs +++ b/lightning/src/ln/shutdown_tests.rs @@ -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]); diff --git a/lightning/src/ln/wire.rs b/lightning/src/ln/wire.rs index a0b549452..cbf5c77d6 100644 --- a/lightning/src/ln/wire.rs +++ b/lightning/src/ln/wire.rs @@ -57,7 +57,7 @@ pub(crate) enum Message 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 Message 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(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; } diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index 6c8f40017..8731e66da 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -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, diff --git a/lightning/src/util/events.rs b/lightning/src/util/events.rs index 34a8a410b..0a886b93f 100644 --- a/lightning/src/util/events.rs +++ b/lightning/src/util/events.rs @@ -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 { diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs index fe756b73a..4f3d800be 100644 --- a/lightning/src/util/test_utils.rs +++ b/lightning/src/util/test_utils.rs @@ -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()));