Move FundedChannel::get_announcement_sigs to ChannelContext

When processing newly confirmed transactions, if the funding transaction
is found, FundedChannel::get_announcement_sigs is called and result of
which is used for sending an announcement_signatures message. In
preparation for looking for confirmed splice funding transactions,
refactor the method such that it can be used for any FundingScope.

Author: jkczyz

lightning/src/ln/channel.rs

@@ -4842,6 +4842,109 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 		self.counterparty_cur_commitment_point = Some(counterparty_cur_commitment_point_override);
 		self.get_initial_counterparty_commitment_signature(funding, logger)
 	}
+
+	fn get_channel_announcement<NS: Deref>(
+		&self, funding: &FundingScope, node_signer: &NS, chain_hash: ChainHash,
+		user_config: &UserConfig,
+	) -> Result<msgs::UnsignedChannelAnnouncement, ChannelError> where NS::Target: NodeSigner {
+		if !self.config.announce_for_forwarding {
+			return Err(ChannelError::Ignore("Channel is not available for public announcements".to_owned()));
+		}
+		if !self.is_usable() {
+			return Err(ChannelError::Ignore("Cannot get a ChannelAnnouncement if the channel is not currently usable".to_owned()));
+		}
+
+		let short_channel_id = self.get_short_channel_id()
+			.ok_or(ChannelError::Ignore("Cannot get a ChannelAnnouncement if the channel has not been confirmed yet".to_owned()))?;
+		let node_id = NodeId::from_pubkey(&node_signer.get_node_id(Recipient::Node)
+			.map_err(|_| ChannelError::Ignore("Failed to retrieve own public key".to_owned()))?);
+		let counterparty_node_id = NodeId::from_pubkey(&self.get_counterparty_node_id());
+		let were_node_one = node_id.as_slice() < counterparty_node_id.as_slice();
+
+		let msg = msgs::UnsignedChannelAnnouncement {
+			features: channelmanager::provided_channel_features(&user_config),
+			chain_hash,
+			short_channel_id,
+			node_id_1: if were_node_one { node_id } else { counterparty_node_id },
+			node_id_2: if were_node_one { counterparty_node_id } else { node_id },
+			bitcoin_key_1: NodeId::from_pubkey(if were_node_one { &funding.get_holder_pubkeys().funding_pubkey } else { funding.counterparty_funding_pubkey() }),
+			bitcoin_key_2: NodeId::from_pubkey(if were_node_one { funding.counterparty_funding_pubkey() } else { &funding.get_holder_pubkeys().funding_pubkey }),
+			excess_data: Vec::new(),
+		};
+
+		Ok(msg)
+	}
+
+	fn get_announcement_sigs<NS: Deref, L: Deref>(
+		&mut self, funding: &FundingScope, node_signer: &NS, chain_hash: ChainHash,
+		user_config: &UserConfig, best_block_height: u32, logger: &L,
+	) -> Option<msgs::AnnouncementSignatures>
+	where
+		NS::Target: NodeSigner,
+		L::Target: Logger
+	{
+		if self.funding_tx_confirmation_height == 0 || self.funding_tx_confirmation_height + 5 > best_block_height {
+			return None;
+		}
+
+		if !self.is_usable() {
+			return None;
+		}
+
+		if self.channel_state.is_peer_disconnected() {
+			log_trace!(logger, "Cannot create an announcement_signatures as our peer is disconnected");
+			return None;
+		}
+
+		if self.announcement_sigs_state != AnnouncementSigsState::NotSent {
+			return None;
+		}
+
+		log_trace!(logger, "Creating an announcement_signatures message for channel {}", &self.channel_id());
+		let announcement = match self.get_channel_announcement(funding, node_signer, chain_hash, user_config) {
+			Ok(a) => a,
+			Err(e) => {
+				log_trace!(logger, "{:?}", e);
+				return None;
+			}
+		};
+		let our_node_sig = match node_signer.sign_gossip_message(msgs::UnsignedGossipMessage::ChannelAnnouncement(&announcement)) {
+			Err(_) => {
+				log_error!(logger, "Failed to generate node signature for channel_announcement. Channel will not be announced!");
+				return None;
+			},
+			Ok(v) => v
+		};
+		match &self.holder_signer {
+			ChannelSignerType::Ecdsa(ecdsa) => {
+				let our_bitcoin_sig = match ecdsa.sign_channel_announcement_with_funding_key(
+					&funding.channel_transaction_parameters, &announcement, &self.secp_ctx,
+				) {
+					Err(_) => {
+						log_error!(logger, "Signer rejected channel_announcement signing. Channel will not be announced!");
+						return None;
+					},
+					Ok(v) => v
+				};
+				let short_channel_id = match self.get_short_channel_id() {
+					Some(scid) => scid,
+					None => return None,
+				};
+
+				self.announcement_sigs_state = AnnouncementSigsState::MessageSent;
+
+				Some(msgs::AnnouncementSignatures {
+					channel_id: self.channel_id(),
+					short_channel_id,
+					node_signature: our_node_sig,
+					bitcoin_signature: our_bitcoin_sig,
+				})
+			},
+			// TODO (taproot|arik)
+			#[cfg(taproot)]
+			_ => todo!()
+		}
+	}
 }
 
 // Internal utility functions for channels
@@ -8383,32 +8486,7 @@ impl<SP: Deref> FundedChannel<SP> where
 	fn get_channel_announcement<NS: Deref>(
 		&self, node_signer: &NS, chain_hash: ChainHash, user_config: &UserConfig,
 	) -> Result<msgs::UnsignedChannelAnnouncement, ChannelError> where NS::Target: NodeSigner {
-		if !self.context.config.announce_for_forwarding {
-			return Err(ChannelError::Ignore("Channel is not available for public announcements".to_owned()));
-		}
-		if !self.context.is_usable() {
-			return Err(ChannelError::Ignore("Cannot get a ChannelAnnouncement if the channel is not currently usable".to_owned()));
-		}
-
-		let short_channel_id = self.context.get_short_channel_id()
-			.ok_or(ChannelError::Ignore("Cannot get a ChannelAnnouncement if the channel has not been confirmed yet".to_owned()))?;
-		let node_id = NodeId::from_pubkey(&node_signer.get_node_id(Recipient::Node)
-			.map_err(|_| ChannelError::Ignore("Failed to retrieve own public key".to_owned()))?);
-		let counterparty_node_id = NodeId::from_pubkey(&self.context.get_counterparty_node_id());
-		let were_node_one = node_id.as_slice() < counterparty_node_id.as_slice();
-
-		let msg = msgs::UnsignedChannelAnnouncement {
-			features: channelmanager::provided_channel_features(&user_config),
-			chain_hash,
-			short_channel_id,
-			node_id_1: if were_node_one { node_id } else { counterparty_node_id },
-			node_id_2: if were_node_one { counterparty_node_id } else { node_id },
-			bitcoin_key_1: NodeId::from_pubkey(if were_node_one { &self.funding.get_holder_pubkeys().funding_pubkey } else { self.funding.counterparty_funding_pubkey() }),
-			bitcoin_key_2: NodeId::from_pubkey(if were_node_one { self.funding.counterparty_funding_pubkey() } else { &self.funding.get_holder_pubkeys().funding_pubkey }),
-			excess_data: Vec::new(),
-		};
-
-		Ok(msg)
+		self.context.get_channel_announcement(&self.funding, node_signer, chain_hash, user_config)
 	}
 
 	fn get_announcement_sigs<NS: Deref, L: Deref>(
@@ -8419,67 +8497,7 @@ impl<SP: Deref> FundedChannel<SP> where
 		NS::Target: NodeSigner,
 		L::Target: Logger
 	{
-		if self.context.funding_tx_confirmation_height == 0 || self.context.funding_tx_confirmation_height + 5 > best_block_height {
-			return None;
-		}
-
-		if !self.context.is_usable() {
-			return None;
-		}
-
-		if self.context.channel_state.is_peer_disconnected() {
-			log_trace!(logger, "Cannot create an announcement_signatures as our peer is disconnected");
-			return None;
-		}
-
-		if self.context.announcement_sigs_state != AnnouncementSigsState::NotSent {
-			return None;
-		}
-
-		log_trace!(logger, "Creating an announcement_signatures message for channel {}", &self.context.channel_id());
-		let announcement = match self.get_channel_announcement(node_signer, chain_hash, user_config) {
-			Ok(a) => a,
-			Err(e) => {
-				log_trace!(logger, "{:?}", e);
-				return None;
-			}
-		};
-		let our_node_sig = match node_signer.sign_gossip_message(msgs::UnsignedGossipMessage::ChannelAnnouncement(&announcement)) {
-			Err(_) => {
-				log_error!(logger, "Failed to generate node signature for channel_announcement. Channel will not be announced!");
-				return None;
-			},
-			Ok(v) => v
-		};
-		match &self.context.holder_signer {
-			ChannelSignerType::Ecdsa(ecdsa) => {
-				let our_bitcoin_sig = match ecdsa.sign_channel_announcement_with_funding_key(
-					&self.funding.channel_transaction_parameters, &announcement, &self.context.secp_ctx,
-				) {
-					Err(_) => {
-						log_error!(logger, "Signer rejected channel_announcement signing. Channel will not be announced!");
-						return None;
-					},
-					Ok(v) => v
-				};
-				let short_channel_id = match self.context.get_short_channel_id() {
-					Some(scid) => scid,
-					None => return None,
-				};
-
-				self.context.announcement_sigs_state = AnnouncementSigsState::MessageSent;
-
-				Some(msgs::AnnouncementSignatures {
-					channel_id: self.context.channel_id(),
-					short_channel_id,
-					node_signature: our_node_sig,
-					bitcoin_signature: our_bitcoin_sig,
-				})
-			},
-			// TODO (taproot|arik)
-			#[cfg(taproot)]
-			_ => todo!()
-		}
+		self.context.get_announcement_sigs(&self.funding, node_signer, chain_hash, user_config, best_block_height, logger)
 	}
 
 	/// Signs the given channel announcement, returning a ChannelError::Ignore if no keys are