Let ChannelSigner provide spks and weights compliant with LN spec

Author: tankyleo

lightning/src/sign/mod.rs

@@ -796,6 +796,9 @@ pub trait ChannelSigner {
 	/// channel_parameters.is_populated() MUST be true.
 	fn provide_channel_parameters(&mut self, channel_parameters: &ChannelTransactionParameters);
 
+	/// Returns the parameters of this signer
+	fn get_channel_parameters(&self) -> Option<&ChannelTransactionParameters>;
+
 	/// Returns the script pubkey that should be placed in the `to_remote` output of commitment
 	/// transactions.
 	///
@@ -804,7 +807,15 @@ pub trait ChannelSigner {
 	///
 	/// If `is_holder_tx` is set, return the `to_remote` script pubkey for the local party's commitment
 	/// transaction, otherwise, for the remote party's.
-	fn get_counterparty_payment_script(&self, is_holder_tx: bool) -> ScriptBuf;
+	fn get_counterparty_payment_script(&self, is_holder_tx: bool) -> ScriptBuf {
+		let params = if is_holder_tx {
+			self.get_channel_parameters().unwrap().as_holder_broadcastable()
+		} else {
+			self.get_channel_parameters().unwrap().as_counterparty_broadcastable()
+		};
+		let payment_point = &params.countersignatory_pubkeys().payment_point;
+		get_counterparty_payment_script(params.channel_type_features(), payment_point)
+	}
 
 	/// Returns the script pubkey that should be placed in the `to_local` output of commitment
 	/// transactions, and in the output of second level HTLC transactions.
@@ -815,9 +826,28 @@ pub trait ChannelSigner {
 	/// If `is_holder_tx` is set, return the revokeable script pubkey for local party's
 	/// commitment / htlc transaction, otherwise, for the remote party's.
 	fn get_revokeable_spk(
-		&self, is_holder_tx: bool, commitment_number: u64, per_commitment_point: &PublicKey,
+		&self, is_holder_tx: bool, _commitment_number: u64, per_commitment_point: &PublicKey,
 		secp_ctx: &Secp256k1<secp256k1::All>,
-	) -> ScriptBuf;
+	) -> ScriptBuf {
+		let params = if is_holder_tx {
+			self.get_channel_parameters().unwrap().as_holder_broadcastable()
+		} else {
+			self.get_channel_parameters().unwrap().as_counterparty_broadcastable()
+		};
+		let contest_delay = params.contest_delay();
+		let keys = TxCreationKeys::from_channel_static_keys(
+			per_commitment_point,
+			params.broadcaster_pubkeys(),
+			params.countersignatory_pubkeys(),
+			secp_ctx,
+		);
+		get_revokeable_redeemscript(
+			&keys.revocation_key,
+			contest_delay,
+			&keys.broadcaster_delayed_payment_key,
+		)
+		.to_p2wsh()
+	}
 
 	/// Finalize the given input in a transaction spending an HTLC transaction output
 	/// or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
@@ -850,7 +880,9 @@ pub trait ChannelSigner {
 
 	/// Return the total weight of the witness required to spend the justice path of the revokeable
 	/// output.
-	fn get_punishment_witness_weight(&self) -> u64;
+	fn get_punishment_witness_weight(&self) -> u64 {
+		WEIGHT_REVOKED_OUTPUT
+	}
 
 	/// Finalize the given input in a transaction spending a revoked HTLC output in a commitment
 	/// transaction when our counterparty broadcasts an old state.
@@ -884,7 +916,14 @@ pub trait ChannelSigner {
 
 	/// Return the total weight of the witness required to spend the justice path of a HTLC output in a
 	/// commitment transaction.
-	fn get_htlc_punishment_witness_weight(&self, offered: bool) -> u64;
+	fn get_htlc_punishment_witness_weight(&self, offered: bool) -> u64 {
+		let features = &self.get_channel_parameters().unwrap().channel_type_features;
+		if offered {
+			weight_revoked_offered_htlc(features)
+		} else {
+			weight_revoked_received_htlc(features)
+		}
+	}
 
 	/// Sweep a HTLC output on a counterparty commitment transaction. Sweep an offered htlc output if
 	/// the preimage is provided, otherwise, sweep a received htlc output.
@@ -895,7 +934,15 @@ pub trait ChannelSigner {
 	) -> Result<Transaction, ()>;
 
 	/// Weight of the witness that sweeps htlc outputs in counterparty commitment transactions
-	fn counterparty_htlc_output_witness_weight(&self, offered: bool) -> u64;
+	fn counterparty_htlc_output_witness_weight(&self, offered: bool) -> u64 {
+		let features = &self.get_channel_parameters().unwrap().channel_type_features;
+		if offered {
+			weight_offered_htlc(features)
+		} else {
+			weight_received_htlc(features)
+		}
+	}
+
 	/// Creates a signature for a holder's commitment transaction.
 	///
 	/// This will be called
@@ -950,24 +997,65 @@ pub trait ChannelSigner {
 
 	/// Gets the weight of the witness of the input that spends the htlc output of a
 	/// holder commitment transaction
-	fn get_holder_htlc_transaction_witness_weight(&self, offered: bool) -> u64;
+	fn get_holder_htlc_transaction_witness_weight(&self, offered: bool) -> u64 {
+		if offered {
+			chan_utils::HTLC_SUCCESS_INPUT_ANCHOR_WITNESS_WEIGHT
+		} else {
+			chan_utils::HTLC_TIMEOUT_INPUT_ANCHOR_WITNESS_WEIGHT
+		}
+	}
 
 	/// Gets the script pubkey of a htlc output in a commitment transaction
 	fn get_htlc_spk(
 		&self, htlc: &HTLCOutputInCommitment, is_holder_tx: bool, per_commitment_point: &PublicKey,
 		secp_ctx: &Secp256k1<secp256k1::All>,
-	) -> ScriptBuf;
+	) -> ScriptBuf {
+		let params = if is_holder_tx {
+			self.get_channel_parameters().unwrap().as_holder_broadcastable()
+		} else {
+			self.get_channel_parameters().unwrap().as_counterparty_broadcastable()
+		};
+		let keys = TxCreationKeys::from_channel_static_keys(
+			per_commitment_point,
+			params.broadcaster_pubkeys(),
+			params.countersignatory_pubkeys(),
+			secp_ctx,
+		);
+		chan_utils::get_htlc_redeemscript(htlc, params.channel_type_features(), &keys).to_p2wsh()
+	}
 
 	/// Get the anchor output of a commit tx
-	fn get_anchor_txout(&self, is_holder_tx: bool, is_broadcaster_anchor: bool) -> Option<TxOut>;
+	fn get_anchor_txout(&self, is_holder_tx: bool, is_broadcaster_anchor: bool) -> Option<TxOut> {
+		let channel_parameters = self.get_channel_parameters().unwrap();
+		if channel_parameters.channel_type_features.supports_anchors_zero_fee_htlc_tx() {
+			let params = if is_holder_tx {
+				channel_parameters.as_holder_broadcastable()
+			} else {
+				channel_parameters.as_counterparty_broadcastable()
+			};
+			let funding_key = if is_broadcaster_anchor {
+				params.broadcaster_pubkeys().funding_pubkey
+			} else {
+				params.countersignatory_pubkeys().funding_pubkey
+			};
+			Some(TxOut {
+				script_pubkey: get_anchor_redeemscript(&funding_key).to_p2wsh(),
+				value: Amount::from_sat(ANCHOR_OUTPUT_VALUE_SATOSHI),
+			})
+		} else {
+			None
+		}
+	}
 
 	/// Spend the holder anchor input
 	fn spend_holder_anchor_input(
 		&self, anchor_tx: &Transaction, input_idx: usize, secp_ctx: &Secp256k1<secp256k1::All>,
 	) -> Result<Transaction, ()>;
 
 	/// Get the weight of the witness to spend the holder anchor input
-	fn get_holder_anchor_input_witness_weight(&self) -> u64;
+	fn get_holder_anchor_input_witness_weight(&self) -> u64 {
+		ANCHOR_INPUT_WITNESS_WEIGHT
+	}
 }
 
 /// Specifies the recipient of an invoice.
@@ -1338,15 +1426,6 @@ impl InMemorySigner {
 		self.get_channel_parameters().map(|params| params.funding_outpoint.as_ref()).flatten()
 	}
 
-	/// Returns a [`ChannelTransactionParameters`] for this channel, to be used when verifying or
-	/// building transactions.
-	///
-	/// Will return `None` if [`ChannelSigner::provide_channel_parameters`] has not been called.
-	/// In general, this is safe to `unwrap` only in [`ChannelSigner`] implementation.
-	pub fn get_channel_parameters(&self) -> Option<&ChannelTransactionParameters> {
-		self.channel_parameters.as_ref()
-	}
-
 	/// Returns the channel type features of the channel parameters. Should be helpful for
 	/// determining a channel's category, i. e. legacy/anchors/taproot/etc.
 	///
@@ -1561,38 +1640,8 @@ impl ChannelSigner for InMemorySigner {
 		self.channel_parameters = Some(channel_parameters.clone());
 	}
 
-	fn get_counterparty_payment_script(&self, is_holder_tx: bool) -> ScriptBuf {
-		let params = if is_holder_tx {
-			self.channel_parameters.as_ref().unwrap().as_holder_broadcastable()
-		} else {
-			self.channel_parameters.as_ref().unwrap().as_counterparty_broadcastable()
-		};
-		let payment_point = &params.countersignatory_pubkeys().payment_point;
-		get_counterparty_payment_script(params.channel_type_features(), payment_point)
-	}
-
-	fn get_revokeable_spk(
-		&self, is_holder_tx: bool, _commitment_number: u64, per_commitment_point: &PublicKey,
-		secp_ctx: &Secp256k1<secp256k1::All>,
-	) -> ScriptBuf {
-		let params = if is_holder_tx {
-			self.channel_parameters.as_ref().unwrap().as_holder_broadcastable()
-		} else {
-			self.channel_parameters.as_ref().unwrap().as_counterparty_broadcastable()
-		};
-		let contest_delay = params.contest_delay();
-		let keys = TxCreationKeys::from_channel_static_keys(
-			per_commitment_point,
-			params.broadcaster_pubkeys(),
-			params.countersignatory_pubkeys(),
-			secp_ctx,
-		);
-		get_revokeable_redeemscript(
-			&keys.revocation_key,
-			contest_delay,
-			&keys.broadcaster_delayed_payment_key,
-		)
-		.to_p2wsh()
+	fn get_channel_parameters(&self) -> Option<&ChannelTransactionParameters> {
+		self.channel_parameters.as_ref()
 	}
 
 	fn punish_revokeable_output(
@@ -1629,10 +1678,6 @@ impl ChannelSigner for InMemorySigner {
 		Ok(justice_tx)
 	}
 
-	fn get_punishment_witness_weight(&self) -> u64 {
-		WEIGHT_REVOKED_OUTPUT
-	}
-
 	fn punish_htlc_output(
 		&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey,
 		secp_ctx: &Secp256k1<secp256k1::All>, per_commitment_point: &PublicKey,
@@ -1667,15 +1712,6 @@ impl ChannelSigner for InMemorySigner {
 		Ok(justice_tx)
 	}
 
-	fn get_htlc_punishment_witness_weight(&self, offered: bool) -> u64 {
-		let features = &self.channel_parameters.as_ref().unwrap().channel_type_features;
-		if offered {
-			weight_revoked_offered_htlc(features)
-		} else {
-			weight_revoked_received_htlc(features)
-		}
-	}
-
 	fn sweep_counterparty_htlc_output(
 		&self, sweep_tx: &Transaction, input: usize, amount: u64,
 		secp_ctx: &Secp256k1<secp256k1::All>, per_commitment_point: &PublicKey,
@@ -1711,15 +1747,6 @@ impl ChannelSigner for InMemorySigner {
 		Ok(sweep_tx)
 	}
 
-	fn counterparty_htlc_output_witness_weight(&self, offered: bool) -> u64 {
-		let features = &self.channel_parameters.as_ref().unwrap().channel_type_features;
-		if offered {
-			weight_offered_htlc(features)
-		} else {
-			weight_received_htlc(features)
-		}
-	}
-
 	fn sign_holder_commitment(
 		&self, commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1<secp256k1::All>,
 	) -> Result<Transaction, ()> {
@@ -1791,59 +1818,6 @@ impl ChannelSigner for InMemorySigner {
 		Ok(signed_tx)
 	}
 
-	fn get_holder_htlc_transaction_witness_weight(&self, offered: bool) -> u64 {
-		if offered {
-			chan_utils::HTLC_SUCCESS_INPUT_ANCHOR_WITNESS_WEIGHT
-		} else {
-			chan_utils::HTLC_TIMEOUT_INPUT_ANCHOR_WITNESS_WEIGHT
-		}
-	}
-
-	fn get_htlc_spk(
-		&self, htlc: &HTLCOutputInCommitment, is_holder_tx: bool, per_commitment_point: &PublicKey,
-		secp_ctx: &Secp256k1<secp256k1::All>,
-	) -> ScriptBuf {
-		let params = if is_holder_tx {
-			self.channel_parameters.as_ref().unwrap().as_holder_broadcastable()
-		} else {
-			self.channel_parameters.as_ref().unwrap().as_counterparty_broadcastable()
-		};
-		let keys = TxCreationKeys::from_channel_static_keys(
-			per_commitment_point,
-			params.broadcaster_pubkeys(),
-			params.countersignatory_pubkeys(),
-			secp_ctx,
-		);
-		chan_utils::get_htlc_redeemscript(htlc, params.channel_type_features(), &keys).to_p2wsh()
-	}
-
-	fn get_anchor_txout(&self, is_holder_tx: bool, is_broadcaster_anchor: bool) -> Option<TxOut> {
-		if self
-			.channel_parameters
-			.as_ref()
-			.unwrap()
-			.channel_type_features
-			.supports_anchors_zero_fee_htlc_tx()
-		{
-			let params = if is_holder_tx {
-				self.channel_parameters.as_ref().unwrap().as_holder_broadcastable()
-			} else {
-				self.channel_parameters.as_ref().unwrap().as_counterparty_broadcastable()
-			};
-			let funding_key = if is_broadcaster_anchor {
-				params.broadcaster_pubkeys().funding_pubkey
-			} else {
-				params.countersignatory_pubkeys().funding_pubkey
-			};
-			Some(TxOut {
-				script_pubkey: get_anchor_redeemscript(&funding_key).to_p2wsh(),
-				value: Amount::from_sat(ANCHOR_OUTPUT_VALUE_SATOSHI),
-			})
-		} else {
-			None
-		}
-	}
-
 	fn spend_holder_anchor_input(
 		&self, anchor_tx: &Transaction, input_idx: usize, secp_ctx: &Secp256k1<secp256k1::All>,
 	) -> Result<Transaction, ()> {
@@ -1855,10 +1829,6 @@ impl ChannelSigner for InMemorySigner {
 		tx.input[input_idx].witness = witness;
 		Ok(tx)
 	}
-
-	fn get_holder_anchor_input_witness_weight(&self) -> u64 {
-		ANCHOR_INPUT_WITNESS_WEIGHT
-	}
 }
 
 const MISSING_PARAMS_ERR: &'static str =