Rename payment_point to payment_basepoint

.. to align the field naming with the spec for clarity.

Author: tnull

lightning/src/chain/channelmonitor.rs

@@ -1347,7 +1347,7 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitor<Signer> {
 
 		assert!(commitment_transaction_number_obscure_factor <= (1 << 48));
 		let counterparty_payment_script = chan_utils::get_counterparty_payment_script(
-			&channel_parameters.channel_type_features, &keys.pubkeys().payment_point
+			&channel_parameters.channel_type_features, &keys.pubkeys().payment_basepoint
 		);
 
 		let counterparty_channel_parameters = channel_parameters.counterparty_parameters.as_ref().unwrap();
@@ -4971,9 +4971,9 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 		if onchain_tx_handler.channel_type_features().supports_anchors_zero_fee_htlc_tx() &&
 			counterparty_payment_script.is_p2wpkh()
 		{
-			let payment_point = onchain_tx_handler.channel_transaction_parameters.holder_pubkeys.payment_point;
+			let payment_basepoint = onchain_tx_handler.channel_transaction_parameters.holder_pubkeys.payment_basepoint;
 			counterparty_payment_script =
-				chan_utils::get_to_countersignatory_with_anchors_redeemscript(&payment_point).to_p2wsh();
+				chan_utils::get_to_countersignatory_with_anchors_redeemscript(&payment_basepoint).to_p2wsh();
 		}
 
 		Ok((best_block.block_hash, ChannelMonitor::from_impl(ChannelMonitorImpl {
@@ -5243,7 +5243,7 @@ mod tests {
 		let counterparty_pubkeys = ChannelPublicKeys {
 			funding_pubkey: PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[44; 32]).unwrap()),
 			revocation_basepoint: RevocationBasepoint::from(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[45; 32]).unwrap())),
-			payment_point: PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[46; 32]).unwrap()),
+			payment_basepoint: PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[46; 32]).unwrap()),
 			delayed_payment_basepoint: DelayedPaymentBasepoint::from(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[47; 32]).unwrap())),
 			htlc_basepoint: HtlcBasepoint::from(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[48; 32]).unwrap()))
 		};
@@ -5495,7 +5495,7 @@ mod tests {
 		let counterparty_pubkeys = ChannelPublicKeys {
 			funding_pubkey: PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[44; 32]).unwrap()),
 			revocation_basepoint: RevocationBasepoint::from(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[45; 32]).unwrap())),
-			payment_point: PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[46; 32]).unwrap()),
+			payment_basepoint: PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[46; 32]).unwrap()),
 			delayed_payment_basepoint: DelayedPaymentBasepoint::from(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[47; 32]).unwrap())),
 			htlc_basepoint: HtlcBasepoint::from(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[48; 32]).unwrap())),
 		};

lightning/src/ln/chan_utils.rs

@@ -478,7 +478,7 @@ pub struct ChannelPublicKeys {
 	/// The public key on which the non-broadcaster (ie the countersignatory) receives an immediately
 	/// spendable primary channel balance on the broadcaster's commitment transaction. This key is
 	/// static across every commitment transaction.
-	pub payment_point: PublicKey,
+	pub payment_basepoint: PublicKey,
 	/// The base point which is used (with derive_public_key) to derive a per-commitment payment
 	/// public key which receives non-HTLC-encumbered funds which are only available for spending
 	/// after some delay (or can be claimed via the revocation path).
@@ -491,7 +491,7 @@ pub struct ChannelPublicKeys {
 impl_writeable_tlv_based!(ChannelPublicKeys, {
 	(0, funding_pubkey, required),
 	(2, revocation_basepoint, required),
-	(4, payment_point, required),
+	(4, payment_basepoint, required),
 	(6, delayed_payment_basepoint, required),
 	(8, htlc_basepoint, required),
 });
@@ -816,9 +816,9 @@ pub(crate) fn legacy_deserialization_prevention_marker_for_channel_type_features
 
 /// Gets the witnessScript for the to_remote output when anchors are enabled.
 #[inline]
-pub fn get_to_countersignatory_with_anchors_redeemscript(payment_point: &PublicKey) -> ScriptBuf {
+pub fn get_to_countersignatory_with_anchors_redeemscript(payment_basepoint: &PublicKey) -> ScriptBuf {
 	Builder::new()
-		.push_slice(payment_point.serialize())
+		.push_slice(payment_basepoint.serialize())
 		.push_opcode(opcodes::all::OP_CHECKSIGVERIFY)
 		.push_int(1)
 		.push_opcode(opcodes::all::OP_CSV)
@@ -933,7 +933,7 @@ impl ChannelTransactionParameters {
 		let dummy_keys = ChannelPublicKeys {
 			funding_pubkey: PublicKey::from_slice(&[2; 33]).unwrap(),
 			revocation_basepoint: PublicKey::from_slice(&[2; 33]).unwrap().into(),
-			payment_point: PublicKey::from_slice(&[2; 33]).unwrap(),
+			payment_basepoint: PublicKey::from_slice(&[2; 33]).unwrap(),
 			delayed_payment_basepoint: PublicKey::from_slice(&[2; 33]).unwrap().into(),
 			htlc_basepoint: PublicKey::from_slice(&[2; 33]).unwrap().into(),
 		};
@@ -1119,7 +1119,7 @@ impl HolderCommitmentTransaction {
 		let channel_pubkeys = ChannelPublicKeys {
 			funding_pubkey: dummy_key.clone(),
 			revocation_basepoint: RevocationBasepoint::from(dummy_key),
-			payment_point: dummy_key.clone(),
+			payment_basepoint: dummy_key.clone(),
 			delayed_payment_basepoint: DelayedPaymentBasepoint::from(dummy_key.clone()),
 			htlc_basepoint: HtlcBasepoint::from(dummy_key.clone())
 		};
@@ -1515,9 +1515,9 @@ impl CommitmentTransaction {
 
 		if to_countersignatory_value_sat > Amount::ZERO {
 			let script = if channel_parameters.channel_type_features().supports_anchors_zero_fee_htlc_tx() {
-				get_to_countersignatory_with_anchors_redeemscript(&countersignatory_pubkeys.payment_point).to_p2wsh()
+				get_to_countersignatory_with_anchors_redeemscript(&countersignatory_pubkeys.payment_basepoint).to_p2wsh()
 			} else {
-				ScriptBuf::new_p2wpkh(&Hash160::hash(&countersignatory_pubkeys.payment_point.serialize()).into())
+				ScriptBuf::new_p2wpkh(&Hash160::hash(&countersignatory_pubkeys.payment_basepoint.serialize()).into())
 			};
 			txouts.push((
 				TxOut {
@@ -1608,8 +1608,8 @@ impl CommitmentTransaction {
 		let broadcaster_pubkeys = channel_parameters.broadcaster_pubkeys();
 		let countersignatory_pubkeys = channel_parameters.countersignatory_pubkeys();
 		let commitment_transaction_number_obscure_factor = get_commitment_transaction_number_obscure_factor(
-			&broadcaster_pubkeys.payment_point,
-			&countersignatory_pubkeys.payment_point,
+			&broadcaster_pubkeys.payment_basepoint,
+			&countersignatory_pubkeys.payment_basepoint,
 			channel_parameters.is_outbound(),
 		);
 
@@ -1974,13 +1974,13 @@ mod tests {
 		// Generate broadcaster and counterparty outputs
 		let tx = builder.build(1000, 2000);
 		assert_eq!(tx.built.transaction.output.len(), 2);
-		assert_eq!(tx.built.transaction.output[1].script_pubkey, bitcoin::address::Address::p2wpkh(&CompressedPublicKey(builder.counterparty_pubkeys.payment_point), Network::Testnet).script_pubkey());
+		assert_eq!(tx.built.transaction.output[1].script_pubkey, bitcoin::address::Address::p2wpkh(&CompressedPublicKey(builder.counterparty_pubkeys.payment_basepoint), Network::Testnet).script_pubkey());
 
 		// Generate broadcaster and counterparty outputs as well as two anchors
 		builder.channel_parameters.channel_type_features = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
 		let tx = builder.build(1000, 2000);
 		assert_eq!(tx.built.transaction.output.len(), 4);
-		assert_eq!(tx.built.transaction.output[3].script_pubkey, get_to_countersignatory_with_anchors_redeemscript(&builder.counterparty_pubkeys.payment_point).to_p2wsh());
+		assert_eq!(tx.built.transaction.output[3].script_pubkey, get_to_countersignatory_with_anchors_redeemscript(&builder.counterparty_pubkeys.payment_basepoint).to_p2wsh());
 
 		// Generate broadcaster output and anchor
 		let tx = builder.build(3000, 0);

lightning/src/ln/channel.rs

@@ -1588,7 +1588,7 @@ trait InitialRemoteCommitmentReceiver<SP: Deref> where SP::Target: SignerProvide
 		let funding_redeemscript = context.get_funding_redeemscript();
 		let funding_txo = context.get_funding_txo().unwrap();
 		let funding_txo_script = funding_redeemscript.to_p2wsh();
-		let obscure_factor = get_commitment_transaction_number_obscure_factor(&context.get_holder_pubkeys().payment_point, &context.get_counterparty_pubkeys().payment_point, context.is_outbound());
+		let obscure_factor = get_commitment_transaction_number_obscure_factor(&context.get_holder_pubkeys().payment_basepoint, &context.get_counterparty_pubkeys().payment_basepoint, context.is_outbound());
 		let shutdown_script = context.shutdown_scriptpubkey.clone().map(|script| script.into_inner());
 		let mut monitor_signer = signer_provider.derive_channel_signer(context.channel_value_satoshis, context.channel_keys_id);
 		monitor_signer.provide_channel_parameters(&context.channel_transaction_parameters);
@@ -2483,7 +2483,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 		let counterparty_pubkeys = ChannelPublicKeys {
 			funding_pubkey: common_fields.funding_pubkey,
 			revocation_basepoint: RevocationBasepoint::from(common_fields.revocation_basepoint),
-			payment_point: common_fields.payment_basepoint,
+			payment_basepoint: common_fields.payment_basepoint,
 			delayed_payment_basepoint: DelayedPaymentBasepoint::from(common_fields.delayed_payment_basepoint),
 			htlc_basepoint: HtlcBasepoint::from(common_fields.htlc_basepoint)
 		};
@@ -2749,7 +2749,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 
 		log_trace!(logger, "Building commitment transaction number {} (really {} xor {}) for channel {} for {}, generated by {} with fee {}...",
 			commitment_number, (INITIAL_COMMITMENT_NUMBER - commitment_number),
-			get_commitment_transaction_number_obscure_factor(&self.get_holder_pubkeys().payment_point, &self.get_counterparty_pubkeys().payment_point, self.is_outbound()),
+			get_commitment_transaction_number_obscure_factor(&self.get_holder_pubkeys().payment_basepoint, &self.get_counterparty_pubkeys().payment_basepoint, self.is_outbound()),
 			&self.channel_id,
 			if local { "us" } else { "remote" }, if generated_by_local { "us" } else { "remote" }, feerate_per_kw);
 
@@ -7975,7 +7975,7 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
 				max_accepted_htlcs: self.context.holder_max_accepted_htlcs,
 				funding_pubkey: keys.funding_pubkey,
 				revocation_basepoint: keys.revocation_basepoint.to_public_key(),
-				payment_basepoint: keys.payment_point,
+				payment_basepoint: keys.payment_basepoint,
 				delayed_payment_basepoint: keys.delayed_payment_basepoint.to_public_key(),
 				htlc_basepoint: keys.htlc_basepoint.to_public_key(),
 				first_per_commitment_point,
@@ -8116,7 +8116,7 @@ impl<SP: Deref> InboundV1Channel<SP> where SP::Target: SignerProvider {
 		let counterparty_pubkeys = ChannelPublicKeys {
 			funding_pubkey: msg.common_fields.funding_pubkey,
 			revocation_basepoint: RevocationBasepoint::from(msg.common_fields.revocation_basepoint),
-			payment_point: msg.common_fields.payment_basepoint,
+			payment_basepoint: msg.common_fields.payment_basepoint,
 			delayed_payment_basepoint: DelayedPaymentBasepoint::from(msg.common_fields.delayed_payment_basepoint),
 			htlc_basepoint: HtlcBasepoint::from(msg.common_fields.htlc_basepoint)
 		};
@@ -8189,7 +8189,7 @@ impl<SP: Deref> InboundV1Channel<SP> where SP::Target: SignerProvider {
 				max_accepted_htlcs: self.context.holder_max_accepted_htlcs,
 				funding_pubkey: keys.funding_pubkey,
 				revocation_basepoint: keys.revocation_basepoint.to_public_key(),
-				payment_basepoint: keys.payment_point,
+				payment_basepoint: keys.payment_basepoint,
 				delayed_payment_basepoint: keys.delayed_payment_basepoint.to_public_key(),
 				htlc_basepoint: keys.htlc_basepoint.to_public_key(),
 				first_per_commitment_point,
@@ -8381,7 +8381,7 @@ impl<SP: Deref> OutboundV2Channel<SP> where SP::Target: SignerProvider {
 				max_accepted_htlcs: self.context.holder_max_accepted_htlcs,
 				funding_pubkey: keys.funding_pubkey,
 				revocation_basepoint: keys.revocation_basepoint.to_public_key(),
-				payment_basepoint: keys.payment_point,
+				payment_basepoint: keys.payment_basepoint,
 				delayed_payment_basepoint: keys.delayed_payment_basepoint.to_public_key(),
 				htlc_basepoint: keys.htlc_basepoint.to_public_key(),
 				first_per_commitment_point,
@@ -8439,7 +8439,7 @@ impl<SP: Deref> InboundV2Channel<SP> where SP::Target: SignerProvider {
 		let counterparty_pubkeys = ChannelPublicKeys {
 			funding_pubkey: msg.common_fields.funding_pubkey,
 			revocation_basepoint: RevocationBasepoint(msg.common_fields.revocation_basepoint),
-			payment_point: msg.common_fields.payment_basepoint,
+			payment_basepoint: msg.common_fields.payment_basepoint,
 			delayed_payment_basepoint: DelayedPaymentBasepoint(msg.common_fields.delayed_payment_basepoint),
 			htlc_basepoint: HtlcBasepoint(msg.common_fields.htlc_basepoint)
 		};
@@ -8530,7 +8530,7 @@ impl<SP: Deref> InboundV2Channel<SP> where SP::Target: SignerProvider {
 				max_accepted_htlcs: self.context.holder_max_accepted_htlcs,
 				funding_pubkey: keys.funding_pubkey,
 				revocation_basepoint: keys.revocation_basepoint.to_public_key(),
-				payment_basepoint: keys.payment_point,
+				payment_basepoint: keys.payment_basepoint,
 				delayed_payment_basepoint: keys.delayed_payment_basepoint.to_public_key(),
 				htlc_basepoint: keys.htlc_basepoint.to_public_key(),
 				first_per_commitment_point,
@@ -10367,7 +10367,7 @@ mod tests {
 		let counterparty_pubkeys = ChannelPublicKeys {
 			funding_pubkey: public_from_secret_hex(&secp_ctx, "1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13"),
 			revocation_basepoint: RevocationBasepoint::from(PublicKey::from_slice(&<Vec<u8>>::from_hex("02466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27").unwrap()[..]).unwrap()),
-			payment_point: public_from_secret_hex(&secp_ctx, "4444444444444444444444444444444444444444444444444444444444444444"),
+			payment_basepoint: public_from_secret_hex(&secp_ctx, "4444444444444444444444444444444444444444444444444444444444444444"),
 			delayed_payment_basepoint: DelayedPaymentBasepoint::from(public_from_secret_hex(&secp_ctx, "1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13")),
 			htlc_basepoint: HtlcBasepoint::from(public_from_secret_hex(&secp_ctx, "4444444444444444444444444444444444444444444444444444444444444444"))
 		};
@@ -10379,7 +10379,7 @@ mod tests {
 		chan.context.channel_transaction_parameters.funding_outpoint = Some(funding_info);
 		signer.provide_channel_parameters(&chan.context.channel_transaction_parameters);
 
-		assert_eq!(counterparty_pubkeys.payment_point.serialize()[..],
+		assert_eq!(counterparty_pubkeys.payment_basepoint.serialize()[..],
 		           <Vec<u8>>::from_hex("032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991").unwrap()[..]);
 
 		assert_eq!(counterparty_pubkeys.funding_pubkey.serialize()[..],

lightning/src/sign/mod.rs

@@ -178,8 +178,10 @@ impl StaticPaymentOutputDescriptor {
 	pub fn witness_script(&self) -> Option<ScriptBuf> {
 		self.channel_transaction_parameters.as_ref().and_then(|channel_params| {
 			if channel_params.supports_anchors() {
-				let payment_point = channel_params.holder_pubkeys.payment_point;
-				Some(chan_utils::get_to_countersignatory_with_anchors_redeemscript(&payment_point))
+				let payment_basepoint = channel_params.holder_pubkeys.payment_basepoint;
+				Some(chan_utils::get_to_countersignatory_with_anchors_redeemscript(
+					&payment_basepoint,
+				))
 			} else {
 				None
 			}
@@ -282,7 +284,7 @@ pub enum SpendableOutputDescriptor {
 	/// [`chan_utils::get_revokeable_redeemscript`].
 	DelayedPaymentOutput(DelayedPaymentOutputDescriptor),
 	/// An output spendable exclusively by our payment key (i.e., the private key that corresponds
-	/// to the `payment_point` in [`ChannelSigner::pubkeys`]). The output type depends on the
+	/// to the `payment_basepoint` in [`ChannelSigner::pubkeys`]). The output type depends on the
 	/// channel type negotiated.
 	///
 	/// On an anchor outputs channel, the witness in the spending input is:
@@ -1125,7 +1127,7 @@ impl InMemorySigner {
 		ChannelPublicKeys {
 			funding_pubkey: from_secret(&funding_key),
 			revocation_basepoint: RevocationBasepoint::from(from_secret(&revocation_base_key)),
-			payment_point: from_secret(&payment_key),
+			payment_basepoint: from_secret(&payment_key),
 			delayed_payment_basepoint: DelayedPaymentBasepoint::from(from_secret(
 				&delayed_payment_base_key,
 			)),
@@ -1226,7 +1228,7 @@ impl InMemorySigner {
 			return Err(());
 		}
 
-		let remotepubkey = bitcoin::PublicKey::new(self.pubkeys().payment_point);
+		let remotepubkey = bitcoin::PublicKey::new(self.pubkeys().payment_basepoint);
 		// We cannot always assume that `channel_parameters` is set, so can't just call
 		// `self.channel_parameters()` or anything that relies on it
 		let supports_anchors_zero_fee_htlc_tx = self