Introduce a ChannelType enum in lieu of opt_anchors

Author: arik-so

lightning/src/chain/channelmonitor.rs

@@ -1566,7 +1566,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 					debug_assert!(htlc_input_idx_opt.is_some());
 					BitcoinOutPoint::new(*txid, htlc_input_idx_opt.unwrap_or(0))
 				} else {
-					debug_assert!(!self.onchain_tx_handler.opt_anchors());
+					debug_assert!(!self.onchain_tx_handler.channel_type().supports_anchors());
 					BitcoinOutPoint::new(*txid, 0)
 				}
 			} else {
@@ -2425,10 +2425,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 						// If the channel supports anchor outputs, we'll need to emit an external
 						// event to be consumed such that a child transaction is broadcast with a
 						// high enough feerate for the parent commitment transaction to confirm.
-						if self.onchain_tx_handler.opt_anchors() {
+						if self.onchain_tx_handler.channel_type().supports_anchors() {
 							let funding_output = HolderFundingOutput::build(
 								self.funding_redeemscript.clone(), self.channel_value_satoshis,
-								self.onchain_tx_handler.opt_anchors(),
+								self.onchain_tx_handler.channel_type().supports_anchors(),
 							);
 							let best_block_height = self.best_block.height();
 							let commitment_package = PackageTemplate::build_package(
@@ -2617,7 +2617,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 			// First, process non-htlc outputs (to_holder & to_counterparty)
 			for (idx, outp) in tx.output.iter().enumerate() {
 				if outp.script_pubkey == revokeable_p2wsh {
-					let revk_outp = RevokedOutput::build(per_commitment_point, self.counterparty_commitment_params.counterparty_delayed_payment_base_key, self.counterparty_commitment_params.counterparty_htlc_base_key, per_commitment_key, outp.value, self.counterparty_commitment_params.on_counterparty_tx_csv, self.onchain_tx_handler.opt_anchors());
+					let revk_outp = RevokedOutput::build(per_commitment_point, self.counterparty_commitment_params.counterparty_delayed_payment_base_key, self.counterparty_commitment_params.counterparty_htlc_base_key, per_commitment_key, outp.value, self.counterparty_commitment_params.on_counterparty_tx_csv, self.onchain_tx_handler.channel_type().supports_anchors());
 					let justice_package = PackageTemplate::build_package(commitment_txid, idx as u32, PackageSolvingData::RevokedOutput(revk_outp), height + self.counterparty_commitment_params.on_counterparty_tx_csv as u32, height);
 					claimable_outpoints.push(justice_package);
 					to_counterparty_output_info =
@@ -2635,7 +2635,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 							return (claimable_outpoints, (commitment_txid, watch_outputs),
 								to_counterparty_output_info);
 						}
-						let revk_htlc_outp = RevokedHTLCOutput::build(per_commitment_point, self.counterparty_commitment_params.counterparty_delayed_payment_base_key, self.counterparty_commitment_params.counterparty_htlc_base_key, per_commitment_key, htlc.amount_msat / 1000, htlc.clone(), self.onchain_tx_handler.channel_transaction_parameters.opt_anchors.is_some());
+						let revk_htlc_outp = RevokedHTLCOutput::build(per_commitment_point, self.counterparty_commitment_params.counterparty_delayed_payment_base_key, self.counterparty_commitment_params.counterparty_htlc_base_key, per_commitment_key, htlc.amount_msat / 1000, htlc.clone(), &self.onchain_tx_handler.channel_transaction_parameters.channel_type);
 						let justice_package = PackageTemplate::build_package(commitment_txid, transaction_output_index, PackageSolvingData::RevokedHTLCOutput(revk_htlc_outp), htlc.cltv_expiry, height);
 						claimable_outpoints.push(justice_package);
 					}
@@ -2753,13 +2753,13 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 							CounterpartyOfferedHTLCOutput::build(*per_commitment_point,
 								self.counterparty_commitment_params.counterparty_delayed_payment_base_key,
 								self.counterparty_commitment_params.counterparty_htlc_base_key,
-								preimage.unwrap(), htlc.clone(), self.onchain_tx_handler.opt_anchors()))
+								preimage.unwrap(), htlc.clone(), self.onchain_tx_handler.channel_type().supports_anchors()))
 					} else {
 						PackageSolvingData::CounterpartyReceivedHTLCOutput(
 							CounterpartyReceivedHTLCOutput::build(*per_commitment_point,
 								self.counterparty_commitment_params.counterparty_delayed_payment_base_key,
 								self.counterparty_commitment_params.counterparty_htlc_base_key,
-								htlc.clone(), self.onchain_tx_handler.opt_anchors()))
+								htlc.clone(), self.onchain_tx_handler.channel_type().supports_anchors()))
 					};
 					let counterparty_package = PackageTemplate::build_package(commitment_txid, transaction_output_index, counterparty_htlc_outp, htlc.cltv_expiry, 0);
 					claimable_outpoints.push(counterparty_package);
@@ -2830,7 +2830,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 			if let Some(transaction_output_index) = htlc.transaction_output_index {
 				let htlc_output = if htlc.offered {
 					let htlc_output = HolderHTLCOutput::build_offered(
-						htlc.amount_msat, htlc.cltv_expiry, self.onchain_tx_handler.opt_anchors()
+						htlc.amount_msat, htlc.cltv_expiry, self.onchain_tx_handler.channel_type().supports_anchors()
 					);
 					htlc_output
 				} else {
@@ -2841,7 +2841,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 						continue;
 					};
 					let htlc_output = HolderHTLCOutput::build_accepted(
-						payment_preimage, htlc.amount_msat, self.onchain_tx_handler.opt_anchors()
+						payment_preimage, htlc.amount_msat, self.onchain_tx_handler.channel_type().supports_anchors()
 					);
 					htlc_output
 				};
@@ -2925,7 +2925,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 		let mut holder_transactions = vec![commitment_tx];
 		// When anchor outputs are present, the HTLC transactions are only valid once the commitment
 		// transaction confirms.
-		if self.onchain_tx_handler.opt_anchors() {
+		if self.onchain_tx_handler.channel_type().supports_anchors() {
 			return holder_transactions;
 		}
 		for htlc in self.current_holder_commitment_tx.htlc_outputs.iter() {
@@ -3187,7 +3187,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 
 		let should_broadcast = self.should_broadcast_holder_commitment_txn(logger);
 		if should_broadcast {
-			let funding_outp = HolderFundingOutput::build(self.funding_redeemscript.clone(), self.channel_value_satoshis, self.onchain_tx_handler.opt_anchors());
+			let funding_outp = HolderFundingOutput::build(self.funding_redeemscript.clone(), self.channel_value_satoshis, self.onchain_tx_handler.channel_type().supports_anchors());
 			let commitment_package = PackageTemplate::build_package(self.funding_info.0.txid.clone(), self.funding_info.0.index as u32, PackageSolvingData::HolderFundingOutput(funding_outp), self.best_block.height(), self.best_block.height());
 			claimable_outpoints.push(commitment_package);
 			self.pending_monitor_events.push(MonitorEvent::CommitmentTxConfirmed(self.funding_info.0));
@@ -3196,7 +3196,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 			// We can't broadcast our HTLC transactions while the commitment transaction is
 			// unconfirmed. We'll delay doing so until we detect the confirmed commitment in
 			// `transactions_confirmed`.
-			if !self.onchain_tx_handler.opt_anchors() {
+			if !self.onchain_tx_handler.channel_type().supports_anchors() {
 				// Because we're broadcasting a commitment transaction, we should construct the package
 				// assuming it gets confirmed in the next block. Sadly, we have code which considers
 				// "not yet confirmed" things as discardable, so we cannot do that here.

lightning/src/chain/onchaintx.rs

@@ -49,6 +49,7 @@ use core::mem::replace;
 #[cfg(anchors)]
 use core::mem::swap;
 use bitcoin::hashes::Hash;
+use crate::ln::channel::ChannelType;
 
 const MAX_ALLOC_SIZE: usize = 64*1024;
 
@@ -1209,8 +1210,8 @@ impl<ChannelSigner: WriteableEcdsaChannelSigner> OnchainTxHandler<ChannelSigner>
 			.or_else(|| self.prev_holder_commitment.as_ref().map(|c| find_htlc(c)).flatten())
 	}
 
-	pub(crate) fn opt_anchors(&self) -> bool {
-		self.channel_transaction_parameters.opt_anchors.is_some()
+	pub(crate) fn channel_type(&self) -> ChannelType {
+		self.channel_transaction_parameters.channel_type.clone()
 	}
 
 	#[cfg(any(test,feature = "unsafe_revoked_tx_signing"))]

lightning/src/chain/package.rs

@@ -40,24 +40,25 @@ use core::convert::TryInto;
 use core::mem;
 use core::ops::Deref;
 use bitcoin::{PackedLockTime, Sequence, Witness};
+use crate::ln::channel::ChannelType;
 
 use super::chaininterface::LowerBoundedFeeEstimator;
 
 const MAX_ALLOC_SIZE: usize = 64*1024;
 
 
-pub(crate) fn weight_revoked_offered_htlc(opt_anchors: bool) -> u64 {
+pub(crate) fn weight_revoked_offered_htlc(channel_type: &ChannelType) -> u64 {
 	// number_of_witness_elements + sig_length + revocation_sig + pubkey_length + revocationpubkey + witness_script_length + witness_script
 	const WEIGHT_REVOKED_OFFERED_HTLC: u64 = 1 + 1 + 73 + 1 + 33 + 1 + 133;
 	const WEIGHT_REVOKED_OFFERED_HTLC_ANCHORS: u64 = WEIGHT_REVOKED_OFFERED_HTLC + 3; // + OP_1 + OP_CSV + OP_DROP
-	if opt_anchors { WEIGHT_REVOKED_OFFERED_HTLC_ANCHORS } else { WEIGHT_REVOKED_OFFERED_HTLC }
+	if channel_type.supports_anchors() { WEIGHT_REVOKED_OFFERED_HTLC_ANCHORS } else { WEIGHT_REVOKED_OFFERED_HTLC }
 }
 
-pub(crate) fn weight_revoked_received_htlc(opt_anchors: bool) -> u64 {
+pub(crate) fn weight_revoked_received_htlc(channel_type: &ChannelType) -> u64 {
 	// number_of_witness_elements + sig_length + revocation_sig + pubkey_length + revocationpubkey + witness_script_length + witness_script
 	const WEIGHT_REVOKED_RECEIVED_HTLC: u64 = 1 + 1 + 73 + 1 + 33 + 1 +  139;
 	const WEIGHT_REVOKED_RECEIVED_HTLC_ANCHORS: u64 = WEIGHT_REVOKED_RECEIVED_HTLC + 3; // + OP_1 + OP_CSV + OP_DROP
-	if opt_anchors { WEIGHT_REVOKED_RECEIVED_HTLC_ANCHORS } else { WEIGHT_REVOKED_RECEIVED_HTLC }
+	if channel_type.supports_anchors() { WEIGHT_REVOKED_RECEIVED_HTLC_ANCHORS } else { WEIGHT_REVOKED_RECEIVED_HTLC }
 }
 
 pub(crate) fn weight_offered_htlc(opt_anchors: bool) -> u64 {
@@ -147,8 +148,8 @@ pub(crate) struct RevokedHTLCOutput {
 }
 
 impl RevokedHTLCOutput {
-	pub(crate) fn build(per_commitment_point: PublicKey, counterparty_delayed_payment_base_key: PublicKey, counterparty_htlc_base_key: PublicKey, per_commitment_key: SecretKey, amount: u64, htlc: HTLCOutputInCommitment, opt_anchors: bool) -> Self {
-		let weight = if htlc.offered { weight_revoked_offered_htlc(opt_anchors) } else { weight_revoked_received_htlc(opt_anchors) };
+	pub(crate) fn build(per_commitment_point: PublicKey, counterparty_delayed_payment_base_key: PublicKey, counterparty_htlc_base_key: PublicKey, per_commitment_key: SecretKey, amount: u64, htlc: HTLCOutputInCommitment, channel_type: &ChannelType) -> Self {
+		let weight = if htlc.offered { weight_revoked_offered_htlc(channel_type) } else { weight_revoked_received_htlc(channel_type) };
 		RevokedHTLCOutput {
 			per_commitment_point,
 			counterparty_delayed_payment_base_key,
@@ -411,7 +412,7 @@ impl PackageSolvingData {
 			},
 			PackageSolvingData::RevokedHTLCOutput(ref outp) => {
 				let chan_keys = TxCreationKeys::derive_new(&onchain_handler.secp_ctx, &outp.per_commitment_point, &outp.counterparty_delayed_payment_base_key, &outp.counterparty_htlc_base_key, &onchain_handler.signer.pubkeys().revocation_basepoint, &onchain_handler.signer.pubkeys().htlc_basepoint);
-				let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys(&outp.htlc, onchain_handler.opt_anchors(), &chan_keys.broadcaster_htlc_key, &chan_keys.countersignatory_htlc_key, &chan_keys.revocation_key);
+				let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys(&outp.htlc, onchain_handler.channel_type().supports_anchors(), &chan_keys.broadcaster_htlc_key, &chan_keys.countersignatory_htlc_key, &chan_keys.revocation_key);
 				//TODO: should we panic on signer failure ?
 				if let Ok(sig) = onchain_handler.signer.sign_justice_revoked_htlc(&bumped_tx, i, outp.amount, &outp.per_commitment_key, &outp.htlc, &onchain_handler.secp_ctx) {
 					let mut ser_sig = sig.serialize_der().to_vec();
@@ -423,7 +424,7 @@ impl PackageSolvingData {
 			},
 			PackageSolvingData::CounterpartyOfferedHTLCOutput(ref outp) => {
 				let chan_keys = TxCreationKeys::derive_new(&onchain_handler.secp_ctx, &outp.per_commitment_point, &outp.counterparty_delayed_payment_base_key, &outp.counterparty_htlc_base_key, &onchain_handler.signer.pubkeys().revocation_basepoint, &onchain_handler.signer.pubkeys().htlc_basepoint);
-				let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys(&outp.htlc, onchain_handler.opt_anchors(), &chan_keys.broadcaster_htlc_key, &chan_keys.countersignatory_htlc_key, &chan_keys.revocation_key);
+				let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys(&outp.htlc, onchain_handler.channel_type().supports_anchors(), &chan_keys.broadcaster_htlc_key, &chan_keys.countersignatory_htlc_key, &chan_keys.revocation_key);
 
 				if let Ok(sig) = onchain_handler.signer.sign_counterparty_htlc_transaction(&bumped_tx, i, &outp.htlc.amount_msat / 1000, &outp.per_commitment_point, &outp.htlc, &onchain_handler.secp_ctx) {
 					let mut ser_sig = sig.serialize_der().to_vec();
@@ -435,7 +436,7 @@ impl PackageSolvingData {
 			},
 			PackageSolvingData::CounterpartyReceivedHTLCOutput(ref outp) => {
 				let chan_keys = TxCreationKeys::derive_new(&onchain_handler.secp_ctx, &outp.per_commitment_point, &outp.counterparty_delayed_payment_base_key, &outp.counterparty_htlc_base_key, &onchain_handler.signer.pubkeys().revocation_basepoint, &onchain_handler.signer.pubkeys().htlc_basepoint);
-				let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys(&outp.htlc, onchain_handler.opt_anchors(), &chan_keys.broadcaster_htlc_key, &chan_keys.countersignatory_htlc_key, &chan_keys.revocation_key);
+				let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys(&outp.htlc, onchain_handler.channel_type().supports_anchors(), &chan_keys.broadcaster_htlc_key, &chan_keys.countersignatory_htlc_key, &chan_keys.revocation_key);
 
 				if let Ok(sig) = onchain_handler.signer.sign_counterparty_htlc_transaction(&bumped_tx, i, &outp.htlc.amount_msat / 1000, &outp.per_commitment_point, &outp.htlc, &onchain_handler.secp_ctx) {
 					let mut ser_sig = sig.serialize_der().to_vec();

lightning/src/ln/chan_utils.rs

@@ -24,7 +24,7 @@ use bitcoin::hash_types::{Txid, PubkeyHash};
 use crate::sign::EntropySource;
 use crate::ln::{PaymentHash, PaymentPreimage};
 use crate::ln::msgs::DecodeError;
-use crate::util::ser::{Readable, Writeable, Writer};
+use crate::util::ser::{Readable, RequiredWrapper, Writeable, Writer};
 use crate::util::transaction_utils;
 
 use bitcoin::secp256k1::{SecretKey, PublicKey, Scalar};
@@ -37,8 +37,9 @@ use crate::prelude::*;
 use core::cmp;
 use crate::ln::chan_utils;
 use crate::util::transaction_utils::sort_outputs;
-use crate::ln::channel::{INITIAL_COMMITMENT_NUMBER, ANCHOR_OUTPUT_VALUE_SATOSHI};
+use crate::ln::channel::{INITIAL_COMMITMENT_NUMBER, ANCHOR_OUTPUT_VALUE_SATOSHI, ChannelType};
 use core::ops::Deref;
+use std::io::{Error, Read};
 use crate::chain;
 use crate::util::crypto::{sign, sign_with_aux_rand};
 
@@ -826,9 +827,8 @@ pub struct ChannelTransactionParameters {
 	pub counterparty_parameters: Option<CounterpartyChannelTransactionParameters>,
 	/// The late-bound funding outpoint
 	pub funding_outpoint: Option<chain::transaction::OutPoint>,
-	/// Are anchors (zero fee HTLC transaction variant) used for this channel. Boolean is
-	/// serialization backwards-compatible.
-	pub opt_anchors: Option<()>,
+	/// Describes the channel type
+	pub channel_type: ChannelType,
 	/// Are non-zero-fee anchors are enabled (used in conjuction with opt_anchors)
 	/// It is intended merely for backwards compatibility with signers that need it.
 	/// There is no support for this feature in LDK channel negotiation.
@@ -880,15 +880,55 @@ impl_writeable_tlv_based!(CounterpartyChannelTransactionParameters, {
 	(2, selected_contest_delay, required),
 });
 
-impl_writeable_tlv_based!(ChannelTransactionParameters, {
-	(0, holder_pubkeys, required),
-	(2, holder_selected_contest_delay, required),
-	(4, is_outbound_from_holder, required),
-	(6, counterparty_parameters, option),
-	(8, funding_outpoint, option),
-	(10, opt_anchors, option),
-	(12, opt_non_zero_fee_anchors, option),
-});
+impl Writeable for ChannelTransactionParameters {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), Error> {
+		let mut channel_type = Some(self.channel_type.clone());
+		match self.channel_type {
+			ChannelType::Legacy => { channel_type = None }
+			_ => {}
+		};
+		encode_tlv_stream!(w, {
+			(0, self.holder_pubkeys, required),
+			(2, self.holder_selected_contest_delay, required),
+			(4, self.is_outbound_from_holder, required),
+			(6, self.counterparty_parameters, option),
+			(8, self.funding_outpoint, option),
+			(10, channel_type, option),
+			(12, self.opt_non_zero_fee_anchors, option),
+		});
+		Ok(())
+	}
+}
+
+impl Readable for ChannelTransactionParameters {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		let mut holder_pubkeys = RequiredWrapper(None);
+		let mut holder_selected_contest_delay = RequiredWrapper(None);
+		let mut is_outbound_from_holder = RequiredWrapper(None);
+		let mut counterparty_parameters = None;
+		let mut funding_outpoint = None;
+		let mut channel_type = Some(ChannelType::Legacy);
+		let mut opt_non_zero_fee_anchors = None;
+		decode_tlv_stream!(r, {
+			(0, holder_pubkeys, required),
+			(2, holder_selected_contest_delay, required),
+			(4, is_outbound_from_holder, required),
+			(6, counterparty_parameters, option),
+			(8, funding_outpoint, option),
+			(10, channel_type, option),
+			(12, opt_non_zero_fee_anchors, option),
+		});
+		Ok(Self {
+			holder_pubkeys: holder_pubkeys.0.unwrap(),
+			holder_selected_contest_delay: holder_selected_contest_delay.0.unwrap(),
+			is_outbound_from_holder: is_outbound_from_holder.0.unwrap(),
+			counterparty_parameters,
+			funding_outpoint,
+			channel_type: channel_type.unwrap(),
+			opt_non_zero_fee_anchors,
+		})
+	}
+}
 
 /// Static channel fields used to build transactions given per-commitment fields, organized by
 /// broadcaster/countersignatory.
@@ -941,9 +981,9 @@ impl<'a> DirectedChannelTransactionParameters<'a> {
 		self.inner.funding_outpoint.unwrap().into_bitcoin_outpoint()
 	}
 
-	/// Whether to use anchors for this channel
-	pub fn opt_anchors(&self) -> bool {
-		self.inner.opt_anchors.is_some()
+	/// Returns channel type enum
+	pub fn channel_type(&self) -> ChannelType {
+		self.inner.channel_type.clone()
 	}
 }
 
@@ -1010,7 +1050,7 @@ impl HolderCommitmentTransaction {
 			is_outbound_from_holder: false,
 			counterparty_parameters: Some(CounterpartyChannelTransactionParameters { pubkeys: channel_pubkeys.clone(), selected_contest_delay: 0 }),
 			funding_outpoint: Some(chain::transaction::OutPoint { txid: Txid::all_zeros(), index: 0 }),
-			opt_anchors: None,
+			channel_type: ChannelType::Legacy,
 			opt_non_zero_fee_anchors: None,
 		};
 		let mut counterparty_htlc_sigs = Vec::new();