[Custom Transactions] Define the TxBuilder trait

Author: tankyleo

lightning/src/ln/channel.rs

@@ -840,7 +840,7 @@ struct HTLCStats {
 }
 
 /// An enum gathering stats on commitment transaction, either local or remote.
-struct CommitmentStats<'a> {
+pub(crate) struct CommitmentStats<'a> {
 	tx: CommitmentTransaction, // the transaction info
 	feerate_per_kw: u32, // the feerate included to build the transaction
 	total_fee_sat: u64, // the total fee included in the transaction

lightning/src/sign/mod.rs

@@ -81,6 +81,7 @@ pub(crate) mod type_resolver;
 pub mod ecdsa;
 #[cfg(taproot)]
 pub mod taproot;
+pub(crate) mod tx_builder;
 
 /// Information about a spendable output to a P2WSH script.
 ///

lightning/src/sign/tx_builder.rs

@@ -0,0 +1,181 @@
+//! Defines the `TxBuilder` trait, and the `SpecTxBuilder` type
+#![allow(dead_code)]
+#![allow(unused_variables)]
+
+use bitcoin::secp256k1::{self, PublicKey, Secp256k1};
+
+use crate::ln::chan_utils::{
+	self, ChannelTransactionParameters, CommitmentTransaction, HTLCOutputInCommitment,
+	TxCreationKeys,
+};
+use crate::ln::channel::CommitmentStats;
+use crate::ln::channelmanager::HTLCSource;
+use crate::prelude::*;
+
+/// A trait for types that can build commitment transactions, both for the holder, and the counterparty.
+pub(crate) trait TxBuilder {
+	/// Build a commitment transaction, and populate the elements of `htlcs` with their output indices.
+	fn build_commitment_transaction<'a>(
+		&self, local: bool, commitment_number: u64, per_commitment_point: &PublicKey,
+		channel_parameters: &ChannelTransactionParameters, secp_ctx: &Secp256k1<secp256k1::All>,
+		channel_value_satoshis: u64, value_to_self_with_offset_msat: u64,
+		htlcs_included: Vec<(HTLCOutputInCommitment, Option<&'a HTLCSource>)>, feerate_per_kw: u32,
+		broadcaster_dust_limit_satoshis: u64,
+	) -> CommitmentStats<'a>;
+}
+
+/// A type that builds commitment transactions according to the Lightning Specification.
+#[derive(Clone, Debug, Default)]
+pub struct SpecTxBuilder {}
+
+impl TxBuilder for SpecTxBuilder {
+	fn build_commitment_transaction<'a>(
+		&self, local: bool, commitment_number: u64, per_commitment_point: &PublicKey,
+		channel_parameters: &ChannelTransactionParameters, secp_ctx: &Secp256k1<secp256k1::All>,
+		channel_value_satoshis: u64, value_to_self_with_offset_msat: u64,
+		htlcs_included: Vec<(HTLCOutputInCommitment, Option<&'a HTLCSource>)>, feerate_per_kw: u32,
+		broadcaster_dust_limit_satoshis: u64,
+	) -> CommitmentStats<'a> {
+		let mut local_htlc_total_msat = 0;
+		let mut remote_htlc_total_msat = 0;
+		let mut included_dust_htlcs = Vec::new();
+		let mut included_non_dust_htlcs = Vec::with_capacity(htlcs_included.len());
+		let mut value_to_self_msat = value_to_self_with_offset_msat;
+
+		let params = if local {
+			channel_parameters.as_holder_broadcastable()
+		} else {
+			channel_parameters.as_counterparty_broadcastable()
+		};
+
+		// Sort dust vs non-dust HTLCs
+		for (htlc, source_opt) in htlcs_included {
+			if htlc.offered {
+				if local {
+					local_htlc_total_msat += htlc.amount_msat;
+				} else {
+					remote_htlc_total_msat += htlc.amount_msat
+				}
+				let htlc_tx_fee =
+					if params.channel_type_features().supports_anchors_zero_fee_htlc_tx() {
+						0
+					} else {
+						feerate_per_kw as u64
+							* chan_utils::htlc_timeout_tx_weight(params.channel_type_features())
+							/ 1000
+					};
+				if htlc.amount_msat / 1000 >= broadcaster_dust_limit_satoshis + htlc_tx_fee {
+					// log_trace!(logger, "   ...including {} {} HTLC {} (hash {}) with value {}", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, &$htlc.payment_hash, $htlc.amount_msat);
+					included_non_dust_htlcs.push((htlc, source_opt));
+				} else {
+					// log_trace!(logger, "   ...including {} {} dust HTLC {} (hash {}) with value {} due to dust limit", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, &$htlc.payment_hash, $htlc.amount_msat);
+					included_dust_htlcs.push((htlc, source_opt));
+				}
+			} else {
+				if local {
+					remote_htlc_total_msat += htlc.amount_msat
+				} else {
+					local_htlc_total_msat += htlc.amount_msat;
+				}
+				let htlc_tx_fee =
+					if params.channel_type_features().supports_anchors_zero_fee_htlc_tx() {
+						0
+					} else {
+						feerate_per_kw as u64
+							* chan_utils::htlc_success_tx_weight(params.channel_type_features())
+							/ 1000
+					};
+				if htlc.amount_msat / 1000 >= broadcaster_dust_limit_satoshis + htlc_tx_fee {
+					// log_trace!(logger, "   ...including {} {} HTLC {} (hash {}) with value {}", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, &$htlc.payment_hash, $htlc.amount_msat);
+					included_non_dust_htlcs.push((htlc, source_opt));
+				} else {
+					// log_trace!(logger, "   ...including {} {} dust HTLC {} (hash {}) with value {}", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, &$htlc.payment_hash, $htlc.amount_msat);
+					included_dust_htlcs.push((htlc, source_opt));
+				}
+			}
+		}
+
+		// Subtract the HTLC amounts from the to_self, to_remote balances
+		// Note that in case they have several just-awaiting-last-RAA fulfills in-progress (ie
+		// AwaitingRemoteRevokeToRemove or AwaitingRemovedRemoteRevoke) we may have allowed them to
+		// "violate" their reserve value by counting those against it. Thus we do checked subtraction,
+		// as otherwise we can overflow.
+		let mut value_to_remote_msat =
+			u64::checked_sub(channel_value_satoshis * 1000, value_to_self_msat).unwrap();
+		value_to_self_msat = u64::checked_sub(value_to_self_msat, local_htlc_total_msat).unwrap();
+		value_to_remote_msat =
+			u64::checked_sub(value_to_remote_msat, remote_htlc_total_msat).unwrap();
+
+		// Subtract the fees, and the anchor amounts from the channel funder
+		let total_fee_sat = chan_utils::commit_tx_fee_sat(
+			feerate_per_kw,
+			included_non_dust_htlcs.len(),
+			params.channel_type_features(),
+		);
+		let anchors_val = if params.channel_type_features().supports_anchors_zero_fee_htlc_tx() {
+			crate::ln::channel::ANCHOR_OUTPUT_VALUE_SATOSHI * 2
+		} else {
+			0
+		};
+		let (value_to_self, value_to_remote) = if channel_parameters.is_outbound_from_holder {
+			(
+				(value_to_self_msat / 1000)
+					.saturating_sub(anchors_val)
+					.saturating_sub(total_fee_sat),
+				value_to_remote_msat / 1000,
+			)
+		} else {
+			(
+				value_to_self_msat / 1000,
+				(value_to_remote_msat / 1000)
+					.saturating_sub(anchors_val)
+					.saturating_sub(total_fee_sat),
+			)
+		};
+		let mut value_to_a = if local { value_to_self } else { value_to_remote };
+		let mut value_to_b = if local { value_to_remote } else { value_to_self };
+
+		// Trim the to_local, to_remote outputs if any are below the dust limit
+		if value_to_a >= broadcaster_dust_limit_satoshis {
+			// log_trace!(logger, "   ...including {} output with value {}", if local { "to_local" } else { "to_remote" }, value_to_a);
+		} else {
+			value_to_a = 0;
+		}
+		if value_to_b >= broadcaster_dust_limit_satoshis {
+			// log_trace!(logger, "   ...including {} output with value {}", if local { "to_remote" } else { "to_local" }, value_to_b);
+		} else {
+			value_to_b = 0;
+		}
+
+		let (funding_pubkey_a, funding_pubkey_b) = (
+			params.broadcaster_pubkeys().funding_pubkey,
+			params.countersignatory_pubkeys().funding_pubkey,
+		);
+		let keys = TxCreationKeys::from_channel_static_keys(
+			per_commitment_point,
+			params.broadcaster_pubkeys(),
+			params.countersignatory_pubkeys(),
+			&secp_ctx,
+		);
+
+		let tx = CommitmentTransaction::new_with_auxiliary_htlc_data(
+			commitment_number,
+			value_to_a,
+			value_to_b,
+			funding_pubkey_a,
+			funding_pubkey_b,
+			keys,
+			feerate_per_kw,
+			&mut included_non_dust_htlcs,
+			&params,
+		);
+
+		// Sort the non-dust HTLCs by their output index, then append the dust htlcs
+		let mut htlcs_included = included_non_dust_htlcs;
+		// The unwrap is safe, because all non-dust HTLCs have been assigned an output index
+		htlcs_included.sort_unstable_by_key(|h| h.0.transaction_output_index.unwrap());
+		htlcs_included.append(&mut included_dust_htlcs);
+
+		todo!();
+	}
+}