Rename FundedChannel::holder_commitment_point

The previous commitment point will be tracked in an upcoming commit.
Rename existing HolderCommitmentPoint fields to avoid ambiguity.

Author: jkczyz

lightning/src/ln/channel.rs

@@ -1790,7 +1790,7 @@ where
 								&mut funding,
 								&mut signing_session,
 								true,
-								chan.holder_commitment_point.transaction_number(),
+								chan.next_holder_commitment_point.transaction_number(),
 								&&logger,
 							)?;
 
@@ -1851,7 +1851,7 @@ where
 					pending_funding: vec![],
 					context: chan.context,
 					interactive_tx_signing_session: chan.interactive_tx_signing_session,
-					holder_commitment_point: initial_holder_commitment_point,
+					next_holder_commitment_point: initial_holder_commitment_point,
 					#[cfg(splicing)]
 					pending_splice: None,
 				};
@@ -6065,7 +6065,10 @@ where
 	///
 	/// This field is cleared once our counterparty sends a `channel_ready`.
 	pub interactive_tx_signing_session: Option<InteractiveTxSigningSession>,
-	holder_commitment_point: HolderCommitmentPoint,
+
+	/// The commitment point used for the next commitment transaction.
+	next_holder_commitment_point: HolderCommitmentPoint,
+
 	/// Info about an in-progress, pending splice (if any), on the pre-splice channel
 	#[cfg(splicing)]
 	pending_splice: Option<PendingSplice>,
@@ -6944,12 +6947,12 @@ where
 			return Err(ChannelError::Close((msg.to_owned(), reason)));
 		}
 
-		let holder_commitment_point = &mut self.holder_commitment_point.clone();
-		self.context.assert_no_commitment_advancement(holder_commitment_point.transaction_number(), "initial commitment_signed");
+		let next_holder_commitment_point = &mut self.next_holder_commitment_point.clone();
+		self.context.assert_no_commitment_advancement(next_holder_commitment_point.transaction_number(), "initial commitment_signed");
 
 		let (channel_monitor, _) = self.initial_commitment_signed(
-			self.context.channel_id(), msg.signature, holder_commitment_point, best_block, signer_provider, logger)?;
-		self.holder_commitment_point = *holder_commitment_point;
+			self.context.channel_id(), msg.signature, next_holder_commitment_point, best_block, signer_provider, logger)?;
+		self.next_holder_commitment_point = *next_holder_commitment_point;
 
 		log_info!(logger, "Received initial commitment_signed from peer for channel {}", &self.context.channel_id());
 
@@ -6996,7 +6999,7 @@ where
 			.expect("Funding must exist for negotiated pending splice");
 		let (holder_commitment_tx, _) = self.context.validate_commitment_signed(
 			pending_splice_funding,
-			&self.holder_commitment_point,
+			&self.next_holder_commitment_point,
 			msg,
 			logger,
 		)?;
@@ -7082,7 +7085,12 @@ where
 
 		let update = self
 			.context
-			.validate_commitment_signed(&self.funding, &self.holder_commitment_point, msg, logger)
+			.validate_commitment_signed(
+				&self.funding,
+				&self.next_holder_commitment_point,
+				msg,
+				logger,
+			)
 			.map(|(commitment_tx, htlcs_included)| {
 				let (nondust_htlc_sources, dust_htlcs) =
 					Self::get_commitment_htlc_data(&htlcs_included);
@@ -7146,7 +7154,7 @@ where
 			})?;
 			let (commitment_tx, htlcs_included) = self.context.validate_commitment_signed(
 				funding,
-				&self.holder_commitment_point,
+				&self.next_holder_commitment_point,
 				msg,
 				logger,
 			)?;
@@ -7205,7 +7213,7 @@ where
 		L::Target: Logger,
 	{
 		if self
-			.holder_commitment_point
+			.next_holder_commitment_point
 			.advance(&self.context.holder_signer, &self.context.secp_ctx, logger)
 			.is_err()
 		{
@@ -8389,9 +8397,9 @@ where
 	/// blocked.
 	#[rustfmt::skip]
 	pub fn signer_maybe_unblocked<L: Deref>(&mut self, logger: &L) -> SignerResumeUpdates where L::Target: Logger {
-		if !self.holder_commitment_point.can_advance() {
+		if !self.next_holder_commitment_point.can_advance() {
 			log_trace!(logger, "Attempting to update holder per-commitment point...");
-			self.holder_commitment_point.try_resolve_pending(&self.context.holder_signer, &self.context.secp_ctx, logger);
+			self.next_holder_commitment_point.try_resolve_pending(&self.context.holder_signer, &self.context.secp_ctx, logger);
 		}
 		let funding_signed = if self.context.signer_pending_funding && !self.funding.is_outbound() {
 			let commitment_data = self.context.build_commitment_transaction(&self.funding,
@@ -8486,30 +8494,30 @@ where
 
 	#[rustfmt::skip]
 	fn get_last_revoke_and_ack<L: Deref>(&mut self, logger: &L) -> Option<msgs::RevokeAndACK> where L::Target: Logger {
-		debug_assert!(self.holder_commitment_point.transaction_number() <= INITIAL_COMMITMENT_NUMBER - 2);
-		self.holder_commitment_point.try_resolve_pending(&self.context.holder_signer, &self.context.secp_ctx, logger);
+		debug_assert!(self.next_holder_commitment_point.transaction_number() <= INITIAL_COMMITMENT_NUMBER - 2);
+		self.next_holder_commitment_point.try_resolve_pending(&self.context.holder_signer, &self.context.secp_ctx, logger);
 		let per_commitment_secret = self.context.holder_signer.as_ref()
-			.release_commitment_secret(self.holder_commitment_point.transaction_number() + 2).ok();
+			.release_commitment_secret(self.next_holder_commitment_point.transaction_number() + 2).ok();
 		if let Some(per_commitment_secret) = per_commitment_secret {
-			if self.holder_commitment_point.can_advance() {
+			if self.next_holder_commitment_point.can_advance() {
 				self.context.signer_pending_revoke_and_ack = false;
 				return Some(msgs::RevokeAndACK {
 					channel_id: self.context.channel_id,
 					per_commitment_secret,
-					next_per_commitment_point: self.holder_commitment_point.point(),
+					next_per_commitment_point: self.next_holder_commitment_point.point(),
 					#[cfg(taproot)]
 					next_local_nonce: None,
 				})
 			}
 		}
-		if !self.holder_commitment_point.can_advance() {
+		if !self.next_holder_commitment_point.can_advance() {
 			log_trace!(logger, "Last revoke-and-ack pending in channel {} for sequence {} because the next per-commitment point is not available",
-				&self.context.channel_id(), self.holder_commitment_point.transaction_number());
+				&self.context.channel_id(), self.next_holder_commitment_point.transaction_number());
 		}
 		if per_commitment_secret.is_none() {
 			log_trace!(logger, "Last revoke-and-ack pending in channel {} for sequence {} because the next per-commitment secret for {} is not available",
-				&self.context.channel_id(), self.holder_commitment_point.transaction_number(),
-				self.holder_commitment_point.transaction_number() + 2);
+				&self.context.channel_id(), self.next_holder_commitment_point.transaction_number(),
+				self.next_holder_commitment_point.transaction_number() + 2);
 		}
 		// Technically if HolderCommitmentPoint::can_advance is false,
 		// we have a commitment point ready to send in an RAA, however we
@@ -8518,7 +8526,7 @@ where
 		// RAA here is a convenient way to make sure that post-funding
 		// we're only ever waiting on one commitment point at a time.
 		log_trace!(logger, "Last revoke-and-ack pending in channel {} for sequence {} because the next per-commitment point is not available",
-			&self.context.channel_id(), self.holder_commitment_point.transaction_number());
+			&self.context.channel_id(), self.next_holder_commitment_point.transaction_number());
 		self.context.signer_pending_revoke_and_ack = true;
 		None
 	}
@@ -8666,7 +8674,7 @@ where
 			return Err(ChannelError::close("Peer sent an invalid channel_reestablish to force close in a non-standard way".to_owned()));
 		}
 
-		let our_commitment_transaction = INITIAL_COMMITMENT_NUMBER - self.holder_commitment_point.transaction_number() - 1;
+		let our_commitment_transaction = INITIAL_COMMITMENT_NUMBER - self.next_holder_commitment_point.transaction_number() - 1;
 		if msg.next_remote_commitment_number > 0 {
 			let expected_point = self.context.holder_signer.as_ref()
 				.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - msg.next_remote_commitment_number + 1, &self.context.secp_ctx)
@@ -8768,7 +8776,7 @@ where
 		let is_awaiting_remote_revoke = self.context.channel_state.is_awaiting_remote_revoke();
 		let next_counterparty_commitment_number = INITIAL_COMMITMENT_NUMBER - self.context.cur_counterparty_commitment_transaction_number + if is_awaiting_remote_revoke { 1 } else { 0 };
 
-		let channel_ready = if msg.next_local_commitment_number == 1 && INITIAL_COMMITMENT_NUMBER - self.holder_commitment_point.transaction_number() == 1 {
+		let channel_ready = if msg.next_local_commitment_number == 1 && INITIAL_COMMITMENT_NUMBER - self.next_holder_commitment_point.transaction_number() == 1 {
 			// We should never have to worry about MonitorUpdateInProgress resending ChannelReady
 			self.get_channel_ready(logger)
 		} else { None };
@@ -9593,7 +9601,7 @@ where
 	}
 
 	pub fn get_cur_holder_commitment_transaction_number(&self) -> u64 {
-		self.holder_commitment_point.transaction_number() + 1
+		self.next_holder_commitment_point.transaction_number() + 1
 	}
 
 	pub fn get_cur_counterparty_commitment_transaction_number(&self) -> u64 {
@@ -9717,7 +9725,7 @@ where
 			debug_assert!(self.context.minimum_depth.unwrap_or(1) > 0);
 			return true;
 		}
-		if self.holder_commitment_point.transaction_number() == INITIAL_COMMITMENT_NUMBER - 1 &&
+		if self.next_holder_commitment_point.transaction_number() == INITIAL_COMMITMENT_NUMBER - 1 &&
 			self.context.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 {
 			// If we're a 0-conf channel, we'll move beyond AwaitingChannelReady immediately even while
 			// waiting for the initial monitor persistence. Thus, we check if our commitment
@@ -9851,11 +9859,11 @@ where
 	fn get_channel_ready<L: Deref>(
 		&mut self, logger: &L
 	) -> Option<msgs::ChannelReady> where L::Target: Logger {
-		if self.holder_commitment_point.can_advance() {
+		if self.next_holder_commitment_point.can_advance() {
 			self.context.signer_pending_channel_ready = false;
 			Some(msgs::ChannelReady {
 				channel_id: self.context.channel_id(),
-				next_per_commitment_point: self.holder_commitment_point.point(),
+				next_per_commitment_point: self.next_holder_commitment_point.point(),
 				short_channel_id_alias: Some(self.context.outbound_scid_alias),
 			})
 		} else {
@@ -10527,8 +10535,8 @@ where
 		assert_ne!(self.context.cur_counterparty_commitment_transaction_number, INITIAL_COMMITMENT_NUMBER);
 		// This is generally the first function which gets called on any given channel once we're
 		// up and running normally. Thus, we take this opportunity to attempt to resolve the
-		// `holder_commitment_point` to get any keys which we are currently missing.
-		self.holder_commitment_point.try_resolve_pending(
+		// `next_holder_commitment_point` to get any keys which we are currently missing.
+		self.next_holder_commitment_point.try_resolve_pending(
 			&self.context.holder_signer, &self.context.secp_ctx, logger,
 		);
 		// Prior to static_remotekey, my_current_per_commitment_point was critical to claiming
@@ -10558,7 +10566,7 @@ where
 
 			// next_local_commitment_number is the next commitment_signed number we expect to
 			// receive (indicating if they need to resend one that we missed).
-			next_local_commitment_number: INITIAL_COMMITMENT_NUMBER - self.holder_commitment_point.transaction_number(),
+			next_local_commitment_number: INITIAL_COMMITMENT_NUMBER - self.next_holder_commitment_point.transaction_number(),
 			// We have to set next_remote_commitment_number to the next revoke_and_ack we expect to
 			// receive, however we track it by the next commitment number for a remote transaction
 			// (which is one further, as they always revoke previous commitment transaction, not
@@ -12055,7 +12063,7 @@ where
 			pending_funding: vec![],
 			context: self.context,
 			interactive_tx_signing_session: None,
-			holder_commitment_point: initial_holder_commitment_point,
+			next_holder_commitment_point: initial_holder_commitment_point,
 			#[cfg(splicing)]
 			pending_splice: None,
 		};
@@ -12341,7 +12349,7 @@ where
 			pending_funding: vec![],
 			context: self.context,
 			interactive_tx_signing_session: None,
-			holder_commitment_point: initial_holder_commitment_point,
+			next_holder_commitment_point: initial_holder_commitment_point,
 			#[cfg(splicing)]
 			pending_splice: None,
 		};
@@ -12869,7 +12877,7 @@ where
 		}
 		self.context.destination_script.write(writer)?;
 
-		self.holder_commitment_point.transaction_number().write(writer)?;
+		self.next_holder_commitment_point.transaction_number().write(writer)?;
 		self.context.cur_counterparty_commitment_transaction_number.write(writer)?;
 		self.funding.value_to_self_msat.write(writer)?;
 
@@ -13201,8 +13209,9 @@ where
 		let is_manual_broadcast = Some(self.context.is_manual_broadcast);
 
 		// `HolderCommitmentPoint::point` will become optional when async signing is implemented.
-		let holder_commitment_point = Some(self.holder_commitment_point.point());
-		let holder_commitment_point_next_advance = self.holder_commitment_point.next_point();
+		let next_holder_commitment_point = Some(self.next_holder_commitment_point.point());
+		let next_holder_commitment_point_next_advance =
+			self.next_holder_commitment_point.next_point();
 
 		write_tlv_fields!(writer, {
 			(0, self.context.announcement_sigs, option),
@@ -13240,8 +13249,8 @@ where
 			(39, pending_outbound_blinding_points, optional_vec),
 			(41, holding_cell_blinding_points, optional_vec),
 			(43, malformed_htlcs, optional_vec), // Added in 0.0.119
-			(45, holder_commitment_point, option),
-			(47, holder_commitment_point_next_advance, option),
+			(45, next_holder_commitment_point, option),
+			(47, next_holder_commitment_point_next_advance, option),
 			(49, self.context.local_initiated_shutdown, option), // Added in 0.0.122
 			(51, is_manual_broadcast, option), // Added in 0.0.124
 			(53, funding_tx_broadcast_safe_event_emitted, option), // Added in 0.0.124
@@ -13298,7 +13307,7 @@ where
 		};
 		let destination_script = Readable::read(reader)?;
 
-		let holder_commitment_transaction_number = Readable::read(reader)?;
+		let next_holder_commitment_transaction_number = Readable::read(reader)?;
 		let cur_counterparty_commitment_transaction_number = Readable::read(reader)?;
 		let value_to_self_msat = Readable::read(reader)?;
 
@@ -13601,8 +13610,8 @@ where
 		let mut malformed_htlcs: Option<Vec<(u64, u16, [u8; 32])>> = None;
 		let mut monitor_pending_update_adds: Option<Vec<msgs::UpdateAddHTLC>> = None;
 
-		let mut holder_commitment_point_opt: Option<PublicKey> = None;
-		let mut holder_commitment_point_next_advance_opt: Option<PublicKey> = None;
+		let mut next_holder_commitment_point_opt: Option<PublicKey> = None;
+		let mut next_holder_commitment_point_next_advance_opt: Option<PublicKey> = None;
 		let mut is_manual_broadcast = None;
 
 		let mut pending_funding = Some(Vec::new());
@@ -13642,8 +13651,8 @@ where
 			(39, pending_outbound_blinding_points_opt, optional_vec),
 			(41, holding_cell_blinding_points_opt, optional_vec),
 			(43, malformed_htlcs, optional_vec), // Added in 0.0.119
-			(45, holder_commitment_point_opt, option),
-			(47, holder_commitment_point_next_advance_opt, option),
+			(45, next_holder_commitment_point_opt, option),
+			(47, next_holder_commitment_point_next_advance_opt, option),
 			(49, local_initiated_shutdown, option),
 			(51, is_manual_broadcast, option),
 			(53, funding_tx_broadcast_safe_event_emitted, option),
@@ -13831,31 +13840,33 @@ where
 		// If we're restoring this channel for the first time after an upgrade, then we require that the
 		// signer be available so that we can immediately populate the current commitment point. Channel
 		// restoration will fail if this is not possible.
-		let holder_commitment_point =
-			match (holder_commitment_point_opt, holder_commitment_point_next_advance_opt) {
-				(Some(point), next_point) => HolderCommitmentPoint {
-					transaction_number: holder_commitment_transaction_number,
-					point,
-					next_point,
-				},
-				(_, _) => {
-					let point = holder_signer.get_per_commitment_point(holder_commitment_transaction_number, &secp_ctx)
+		let next_holder_commitment_point = match (
+			next_holder_commitment_point_opt,
+			next_holder_commitment_point_next_advance_opt,
+		) {
+			(Some(point), next_point) => HolderCommitmentPoint {
+				transaction_number: next_holder_commitment_transaction_number,
+				point,
+				next_point,
+			},
+			(_, _) => {
+				let point = holder_signer.get_per_commitment_point(next_holder_commitment_transaction_number, &secp_ctx)
 						.expect("Must be able to derive the current commitment point upon channel restoration");
-					let next_point = holder_signer
-						.get_per_commitment_point(
-							holder_commitment_transaction_number - 1,
-							&secp_ctx,
-						)
-						.expect(
-							"Must be able to derive the next commitment point upon channel restoration",
-						);
-					HolderCommitmentPoint {
-						transaction_number: holder_commitment_transaction_number,
-						point,
-						next_point: Some(next_point),
-					}
-				},
-			};
+				let next_point = holder_signer
+					.get_per_commitment_point(
+						next_holder_commitment_transaction_number - 1,
+						&secp_ctx,
+					)
+					.expect(
+						"Must be able to derive the next commitment point upon channel restoration",
+					);
+				HolderCommitmentPoint {
+					transaction_number: next_holder_commitment_transaction_number,
+					point,
+					next_point: Some(next_point),
+				}
+			},
+		};
 
 		Ok(FundedChannel {
 			funding: FundingScope {
@@ -13994,7 +14005,7 @@ where
 				is_holder_quiescence_initiator: None,
 			},
 			interactive_tx_signing_session,
-			holder_commitment_point,
+			next_holder_commitment_point,
 			#[cfg(splicing)]
 			pending_splice: None,
 		})