X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fchannelmanager.rs;h=abfca35f9724765675206a2b903b4683aa746758;hb=7777fc5285724b8fa132490af632b927da98a074;hp=243cf74182205a61f62fae90b66e58f4da0c62bd;hpb=f98a652f11f598aa828acfff64e5b0df8de80f4f;p=rust-lightning

diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
index 243cf741..abfca35f 100644
--- a/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@ -905,7 +905,14 @@ impl <SP: Deref> PeerState<SP> where SP::Target: SignerProvider {
 			return false
 		}
 		!self.channel_by_id.iter().any(|(_, phase)|
-			matches!(phase, ChannelPhase::Funded(_) | ChannelPhase::UnfundedOutboundV1(_))
+			match phase {
+				ChannelPhase::Funded(_) | ChannelPhase::UnfundedOutboundV1(_) => true,
+				ChannelPhase::UnfundedInboundV1(_) => false,
+				#[cfg(dual_funding)]
+				ChannelPhase::UnfundedOutboundV2(_) => true,
+				#[cfg(dual_funding)]
+				ChannelPhase::UnfundedInboundV2(_) => false,
+			}
 		)
 			&& self.monitor_update_blocked_actions.is_empty()
 			&& self.in_flight_monitor_updates.is_empty()
@@ -2092,6 +2099,14 @@ macro_rules! convert_chan_phase_err {
 			ChannelPhase::UnfundedInboundV1(channel) => {
 				convert_chan_phase_err!($self, $err, channel, $channel_id, UNFUNDED_CHANNEL)
 			},
+			#[cfg(dual_funding)]
+			ChannelPhase::UnfundedOutboundV2(channel) => {
+				convert_chan_phase_err!($self, $err, channel, $channel_id, UNFUNDED_CHANNEL)
+			},
+			#[cfg(dual_funding)]
+			ChannelPhase::UnfundedInboundV2(channel) => {
+				convert_chan_phase_err!($self, $err, channel, $channel_id, UNFUNDED_CHANNEL)
+			},
 		}
 	};
 }
@@ -2958,6 +2973,13 @@ where
 						// Unfunded channel has no update
 						(None, chan_phase.context().get_counterparty_node_id())
 					},
+					// TODO(dual_funding): Combine this match arm with above once #[cfg(dual_funding)] is removed.
+					#[cfg(dual_funding)]
+					ChannelPhase::UnfundedOutboundV2(_) | ChannelPhase::UnfundedInboundV2(_) => {
+						self.finish_close_channel(chan_phase.context_mut().force_shutdown(false, closure_reason));
+						// Unfunded channel has no update
+						(None, chan_phase.context().get_counterparty_node_id())
+					},
 				}
 			} else if peer_state.inbound_channel_request_by_id.remove(channel_id).is_some() {
 				log_error!(logger, "Force-closing channel {}", &channel_id);
@@ -4833,10 +4855,6 @@ where
 
 		// If the feerate has decreased by less than half, don't bother
 		if new_feerate <= chan.context.get_feerate_sat_per_1000_weight() && new_feerate * 2 > chan.context.get_feerate_sat_per_1000_weight() {
-			if new_feerate != chan.context.get_feerate_sat_per_1000_weight() {
-				log_trace!(logger, "Channel {} does not qualify for a feerate change from {} to {}.",
-				chan_id, chan.context.get_feerate_sat_per_1000_weight(), new_feerate);
-			}
 			return NotifyOption::SkipPersistNoEvents;
 		}
 		if !chan.context.is_live() {
@@ -5035,6 +5053,16 @@ where
 								process_unfunded_channel_tick(chan_id, &mut chan.context, &mut chan.unfunded_context,
 									pending_msg_events, counterparty_node_id)
 							},
+							#[cfg(dual_funding)]
+							ChannelPhase::UnfundedInboundV2(chan) => {
+								process_unfunded_channel_tick(chan_id, &mut chan.context, &mut chan.unfunded_context,
+									pending_msg_events, counterparty_node_id)
+							},
+							#[cfg(dual_funding)]
+							ChannelPhase::UnfundedOutboundV2(chan) => {
+								process_unfunded_channel_tick(chan_id, &mut chan.context, &mut chan.unfunded_context,
+									pending_msg_events, counterparty_node_id)
+							},
 						}
 					});
 
@@ -6182,9 +6210,25 @@ where
 						num_unfunded_channels += 1;
 					}
 				},
+				// TODO(dual_funding): Combine this match arm with above once #[cfg(dual_funding)] is removed.
+				#[cfg(dual_funding)]
+				ChannelPhase::UnfundedInboundV2(chan) => {
+					// Only inbound V2 channels that are not 0conf and that we do not contribute to will be
+					// included in the unfunded count.
+					if chan.context.minimum_depth().unwrap_or(1) != 0 &&
+						chan.dual_funding_context.our_funding_satoshis == 0 {
+						num_unfunded_channels += 1;
+					}
+				},
 				ChannelPhase::UnfundedOutboundV1(_) => {
 					// Outbound channels don't contribute to the unfunded count in the DoS context.
 					continue;
+				},
+				// TODO(dual_funding): Combine this match arm with above once #[cfg(dual_funding)] is removed.
+				#[cfg(dual_funding)]
+				ChannelPhase::UnfundedOutboundV2(_) => {
+					// Outbound channels don't contribute to the unfunded count in the DoS context.
+					continue;
 				}
 			}
 		}
@@ -6251,7 +6295,7 @@ where
 		// If we're doing manual acceptance checks on the channel, then defer creation until we're sure we want to accept.
 		if self.default_configuration.manually_accept_inbound_channels {
 			let channel_type = channel::channel_type_from_open_channel(
-					&msg, &peer_state.latest_features, &self.channel_type_features()
+					&msg.common_fields, &peer_state.latest_features, &self.channel_type_features()
 				).map_err(|e|
 					MsgHandleErrInternal::from_chan_no_close(e, msg.common_fields.temporary_channel_id)
 				)?;
@@ -6607,6 +6651,14 @@ where
 						let mut chan = remove_channel_phase!(self, chan_phase_entry);
 						finish_shutdown = Some(chan.context_mut().force_shutdown(false, ClosureReason::CounterpartyCoopClosedUnfundedChannel));
 					},
+					// TODO(dual_funding): Combine this match arm with above.
+					#[cfg(dual_funding)]
+					ChannelPhase::UnfundedInboundV2(_) | ChannelPhase::UnfundedOutboundV2(_) => {
+						let context = phase.context_mut();
+						log_error!(self.logger, "Immediately closing unfunded channel {} as peer asked to cooperatively shut it down (which is unnecessary)", &msg.channel_id);
+						let mut chan = remove_channel_phase!(self, chan_phase_entry);
+						finish_shutdown = Some(chan.context_mut().force_shutdown(false, ClosureReason::CounterpartyCoopClosedUnfundedChannel));
+					},
 				}
 			} else {
 				return Err(MsgHandleErrInternal::send_err_msg_no_close(format!("Got a message for a channel from the wrong node! No such channel for the passed counterparty_node_id {}", counterparty_node_id), msg.channel_id))
@@ -8474,6 +8526,9 @@ where
 					match phase {
 						// Retain unfunded channels.
 						ChannelPhase::UnfundedOutboundV1(_) | ChannelPhase::UnfundedInboundV1(_) => true,
+						// TODO(dual_funding): Combine this match arm with above.
+						#[cfg(dual_funding)]
+						ChannelPhase::UnfundedOutboundV2(_) | ChannelPhase::UnfundedInboundV2(_) => true,
 						ChannelPhase::Funded(channel) => {
 							let res = f(channel);
 							if let Ok((channel_ready_opt, mut timed_out_pending_htlcs, announcement_sigs)) = res {
@@ -8943,6 +8998,14 @@ where
 						ChannelPhase::UnfundedInboundV1(chan) => {
 							&mut chan.context
 						},
+						#[cfg(dual_funding)]
+						ChannelPhase::UnfundedOutboundV2(chan) => {
+							&mut chan.context
+						},
+						#[cfg(dual_funding)]
+						ChannelPhase::UnfundedInboundV2(chan) => {
+							&mut chan.context
+						},
 					};
 					// Clean up for removal.
 					update_maps_on_chan_removal!(self, &context);
@@ -9095,12 +9158,30 @@ where
 							});
 						}
 
+						// TODO(dual_funding): Combine this match arm with above once #[cfg(dual_funding)] is removed.
+						#[cfg(dual_funding)]
+						ChannelPhase::UnfundedOutboundV2(chan) => {
+							pending_msg_events.push(events::MessageSendEvent::SendOpenChannelV2 {
+								node_id: chan.context.get_counterparty_node_id(),
+								msg: chan.get_open_channel_v2(self.chain_hash),
+							});
+						},
+
 						ChannelPhase::UnfundedInboundV1(_) => {
 							// Since unfunded inbound channel maps are cleared upon disconnecting a peer,
 							// they are not persisted and won't be recovered after a crash.
 							// Therefore, they shouldn't exist at this point.
 							debug_assert!(false);
 						}
+
+						// TODO(dual_funding): Combine this match arm with above once #[cfg(dual_funding)] is removed.
+						#[cfg(dual_funding)]
+						ChannelPhase::UnfundedInboundV2(channel) => {
+							// Since unfunded inbound channel maps are cleared upon disconnecting a peer,
+							// they are not persisted and won't be recovered after a crash.
+							// Therefore, they shouldn't exist at this point.
+							debug_assert!(false);
+						},
 					}
 				}
 			}
@@ -9178,14 +9259,29 @@ where
 				if peer_state_mutex_opt.is_none() { return; }
 				let mut peer_state_lock = peer_state_mutex_opt.unwrap().lock().unwrap();
 				let peer_state = &mut *peer_state_lock;
-				if let Some(ChannelPhase::UnfundedOutboundV1(chan)) = peer_state.channel_by_id.get_mut(&msg.channel_id) {
-					if let Ok(msg) = chan.maybe_handle_error_without_close(self.chain_hash, &self.fee_estimator) {
-						peer_state.pending_msg_events.push(events::MessageSendEvent::SendOpenChannel {
-							node_id: *counterparty_node_id,
-							msg,
-						});
-						return;
-					}
+				match peer_state.channel_by_id.get_mut(&msg.channel_id) {
+					Some(ChannelPhase::UnfundedOutboundV1(ref mut chan)) => {
+						if let Ok(msg) = chan.maybe_handle_error_without_close(self.chain_hash, &self.fee_estimator) {
+							peer_state.pending_msg_events.push(events::MessageSendEvent::SendOpenChannel {
+								node_id: *counterparty_node_id,
+								msg,
+							});
+							return;
+						}
+					},
+					#[cfg(dual_funding)]
+					Some(ChannelPhase::UnfundedOutboundV2(ref mut chan)) => {
+						if let Ok(msg) = chan.maybe_handle_error_without_close(self.chain_hash, &self.fee_estimator) {
+							peer_state.pending_msg_events.push(events::MessageSendEvent::SendOpenChannelV2 {
+								node_id: *counterparty_node_id,
+								msg,
+							});
+							return;
+						}
+					},
+					None | Some(ChannelPhase::UnfundedInboundV1(_) | ChannelPhase::Funded(_)) => (),
+					#[cfg(dual_funding)]
+					Some(ChannelPhase::UnfundedInboundV2(_)) => (),
 				}
 			}