Refactor ChannelManager with ChannelPhase

Author: dunxen

lightning/src/ln/chanmon_update_fail_tests.rs

@@ -20,7 +20,7 @@ use crate::chain::transaction::OutPoint;
 use crate::chain::{ChannelMonitorUpdateStatus, Listen, Watch};
 use crate::events::{Event, MessageSendEvent, MessageSendEventsProvider, PaymentPurpose, ClosureReason, HTLCDestination};
 use crate::ln::channelmanager::{ChannelManager, RAACommitmentOrder, PaymentSendFailure, PaymentId, RecipientOnionFields};
-use crate::ln::channel::AnnouncementSigsState;
+use crate::ln::channel::{AnnouncementSigsState, ChannelPhase};
 use crate::ln::msgs;
 use crate::ln::msgs::{ChannelMessageHandler, RoutingMessageHandler};
 use crate::util::enforcing_trait_impls::EnforcingSigner;
@@ -136,15 +136,18 @@ fn test_monitor_and_persister_update_fail() {
 	{
 		let mut node_0_per_peer_lock;
 		let mut node_0_peer_state_lock;
-		let mut channel = get_channel_ref!(nodes[0], nodes[1], node_0_per_peer_lock, node_0_peer_state_lock, chan.2);
-		if let Ok(Some(update)) = channel.commitment_signed(&updates.commitment_signed, &node_cfgs[0].logger) {
-			// Check that even though the persister is returning a InProgress,
-			// because the update is bogus, ultimately the error that's returned
-			// should be a PermanentFailure.
-			if let ChannelMonitorUpdateStatus::PermanentFailure = chain_mon.chain_monitor.update_channel(outpoint, &update) {} else { panic!("Expected monitor error to be permanent"); }
-			logger.assert_log_regex("lightning::chain::chainmonitor", regex::Regex::new("Persistence of ChannelMonitorUpdate for channel [0-9a-f]* in progress").unwrap(), 1);
-			assert_eq!(nodes[0].chain_monitor.update_channel(outpoint, &update), ChannelMonitorUpdateStatus::Completed);
-		} else { assert!(false); }
+		if let ChannelPhase::Funded(ref mut channel) = get_channel_ref!(nodes[0], nodes[1], node_0_per_peer_lock, node_0_peer_state_lock, chan.2) {
+			if let Ok(Some(update)) = channel.commitment_signed(&updates.commitment_signed, &node_cfgs[0].logger) {
+				// Check that even though the persister is returning a InProgress,
+				// because the update is bogus, ultimately the error that's returned
+				// should be a PermanentFailure.
+				if let ChannelMonitorUpdateStatus::PermanentFailure = chain_mon.chain_monitor.update_channel(outpoint, &update) {} else { panic!("Expected monitor error to be permanent"); }
+				logger.assert_log_regex("lightning::chain::chainmonitor", regex::Regex::new("Persistence of ChannelMonitorUpdate for channel [0-9a-f]* in progress").unwrap(), 1);
+				assert_eq!(nodes[0].chain_monitor.update_channel(outpoint, &update), ChannelMonitorUpdateStatus::Completed);
+			} else { assert!(false); }
+		} else {
+			assert!(false);
+		}
 	}
 
 	check_added_monitors!(nodes[0], 1);
@@ -1459,12 +1462,12 @@ fn monitor_failed_no_reestablish_response() {
 	{
 		let mut node_0_per_peer_lock;
 		let mut node_0_peer_state_lock;
-		get_channel_ref!(nodes[0], nodes[1], node_0_per_peer_lock, node_0_peer_state_lock, channel_id).context.announcement_sigs_state = AnnouncementSigsState::PeerReceived;
+		get_channel_ref!(nodes[0], nodes[1], node_0_per_peer_lock, node_0_peer_state_lock, channel_id).chan_context_mut().announcement_sigs_state = AnnouncementSigsState::PeerReceived;
 	}
 	{
 		let mut node_1_per_peer_lock;
 		let mut node_1_peer_state_lock;
-		get_channel_ref!(nodes[1], nodes[0], node_1_per_peer_lock, node_1_peer_state_lock, channel_id).context.announcement_sigs_state = AnnouncementSigsState::PeerReceived;
+		get_channel_ref!(nodes[1], nodes[0], node_1_per_peer_lock, node_1_peer_state_lock, channel_id).chan_context_mut().announcement_sigs_state = AnnouncementSigsState::PeerReceived;
 	}
 
 	// Route the payment and deliver the initial commitment_signed (with a monitor update failure

lightning/src/ln/channel.rs

@@ -610,15 +610,15 @@ pub(super) enum ChannelPhase<Signer: ChannelSigner> {
 }
 
 impl<'a, Signer: ChannelSigner> ChannelPhase<Signer> {
-	pub fn context(&'a self) -> &'a ChannelContext<Signer> {
+	pub fn chan_context(&'a self) -> &'a ChannelContext<Signer> {
 		match self {
 			ChannelPhase::Funded(chan) => &chan.context,
 			ChannelPhase::UnfundedOutboundV1(chan) => &chan.context,
 			ChannelPhase::UnfundedInboundV1(chan) => &chan.context,
 		}
 	}
 
-	pub fn context_mut(&'a mut self) -> &'a mut ChannelContext<Signer> {
+	pub fn chan_context_mut(&'a mut self) -> &'a mut ChannelContext<Signer> {
 		match self {
 			ChannelPhase::Funded(ref mut chan) => &mut chan.context,
 			ChannelPhase::UnfundedOutboundV1(ref mut chan) => &mut chan.context,

lightning/src/ln/channelmanager.rs

@@ -839,8 +839,8 @@ macro_rules! get_feerate {
 		{
 			let mut per_peer_state_lock;
 			let mut peer_state_lock;
-			let chan = get_channel_ref!($node, $counterparty_node, per_peer_state_lock, peer_state_lock, $channel_id);
-			chan.context.get_feerate_sat_per_1000_weight()
+			let phase = get_channel_ref!($node, $counterparty_node, per_peer_state_lock, peer_state_lock, $channel_id);
+			phase.chan_context().get_feerate_sat_per_1000_weight()
 		}
 	}
 }
@@ -852,7 +852,7 @@ macro_rules! get_channel_type_features {
 			let mut per_peer_state_lock;
 			let mut peer_state_lock;
 			let chan = get_channel_ref!($node, $counterparty_node, per_peer_state_lock, peer_state_lock, $channel_id);
-			chan.context.get_channel_type().clone()
+			chan.chan_context().get_channel_type().clone()
 		}
 	}
 }
@@ -2335,10 +2335,10 @@ pub fn pass_claimed_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, '
 						let peer_state = per_peer_state.get(&$prev_node.node.get_our_node_id())
 							.unwrap().lock().unwrap();
 						let channel = peer_state.channel_by_id.get(&next_msgs.as_ref().unwrap().0.channel_id).unwrap();
-						if let Some(prev_config) = channel.context.prev_config() {
+						if let Some(prev_config) = channel.chan_context().prev_config() {
 							prev_config.forwarding_fee_base_msat
 						} else {
-							channel.context.config().forwarding_fee_base_msat
+							channel.chan_context().config().forwarding_fee_base_msat
 						}
 					};
 					if $idx == 1 { fee += expected_extra_fees[i]; }
@@ -2857,7 +2857,9 @@ macro_rules! get_channel_value_stat {
 	($node: expr, $counterparty_node: expr, $channel_id: expr) => {{
 		let peer_state_lock = $node.node.per_peer_state.read().unwrap();
 		let chan_lock = peer_state_lock.get(&$counterparty_node.node.get_our_node_id()).unwrap().lock().unwrap();
-		let chan = chan_lock.channel_by_id.get(&$channel_id).unwrap();
+		let chan = chan_lock.channel_by_id.get(&$channel_id).map(
+			|phase| if let ChannelPhase::Funded(chan) = phase { Some(chan) } else { None }
+		).flatten().unwrap();
 		chan.get_value_stat()
 	}}
 }