Skip to content

Commit 42d5a79

Browse files
tankyleotankyleo
committed
[Custom Transactions] Define the TxBuilder trait
This commit defines the `TxBuilder` trait to give users the ability to customize the build of the lightning commitment transactions. The `TxBuilder` trait has a single method, `build_commitment_transaction`, which builds the commitment transaction, and populates the output indices of the HTLCs passed in. Besides that, it is mostly a copy paste of chunks of code from `ChannelContext::build_commitment_transaction`.
1 parent 5c97de0 commit 42d5a79

File tree

3 files changed

+236
-109
lines changed

3 files changed

+236
-109
lines changed

‎lightning/src/ln/channel.rs

+13-109
Original file line numberDiff line numberDiff line change
@@ -884,11 +884,11 @@ struct CommitmentData<'a> {
884884
}
885885

886886
/// An enum gathering stats on commitment transaction, either local or remote.
887-
struct CommitmentStats {
888-
tx: CommitmentTransaction, // the transaction info
889-
total_fee_sat: u64, // the total fee included in the transaction
890-
local_balance_msat: u64, // local balance before fees *not* considering dust limits
891-
remote_balance_msat: u64, // remote balance before fees *not* considering dust limits
887+
pub(crate) struct CommitmentStats {
888+
pub(crate) tx: CommitmentTransaction, // the transaction info
889+
pub(crate) total_fee_sat: u64, // the total fee included in the transaction
890+
pub(crate) local_balance_msat: u64, // local balance before fees *not* considering dust limits
891+
pub(crate) remote_balance_msat: u64, // remote balance before fees *not* considering dust limits
892892
}
893893

894894
/// Used when calculating whether we or the remote can afford an additional HTLC.
@@ -3425,14 +3425,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
34253425
// Non-dust htlcs will come first, with their output indices populated, then dust htlcs, with their output indices set to `None`.
34263426
let mut htlcs_in_tx: Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)> = Vec::with_capacity(num_htlcs);
34273427

3428-
// We allocate this vector because we need to count the number of non-dust htlcs and calculate the total fee of the transaction
3429-
// before calling `CommitmentTransaction::new`.
3430-
// We could drop this vector and create two iterators: one to count the number of non-dust htlcs, and another to pass to `CommitmentTransaction::new`
3431-
let mut included_non_dust_htlcs: Vec<&mut HTLCOutputInCommitment> = Vec::with_capacity(num_htlcs);
3432-
34333428
let broadcaster_dust_limit_satoshis = if local { self.holder_dust_limit_satoshis } else { self.counterparty_dust_limit_satoshis };
3434-
let mut remote_htlc_total_msat = 0;
3435-
let mut local_htlc_total_msat = 0;
34363429
let mut value_to_self_msat_offset = 0;
34373430

34383431
let mut feerate_per_kw = self.feerate_per_kw;
@@ -3532,94 +3525,12 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
35323525
}
35333526
}
35343527

3535-
// Trim dust htlcs
3536-
for (htlc, _) in htlcs_in_tx.iter_mut() {
3537-
if htlc.offered {
3538-
let outbound = local;
3539-
if outbound {
3540-
local_htlc_total_msat += htlc.amount_msat;
3541-
} else {
3542-
remote_htlc_total_msat += htlc.amount_msat;
3543-
}
3544-
let htlc_tx_fee = if self.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
3545-
0
3546-
} else {
3547-
feerate_per_kw as u64 * htlc_timeout_tx_weight(self.get_channel_type()) / 1000
3548-
};
3549-
if htlc.amount_msat / 1000 >= broadcaster_dust_limit_satoshis + htlc_tx_fee {
3550-
log_trace!(logger, " ...creating output for {} non-dust HTLC (hash {}) with value {}", if outbound { "outbound" } else { "inbound" }, htlc.payment_hash, htlc.amount_msat);
3551-
included_non_dust_htlcs.push(htlc);
3552-
} else {
3553-
log_trace!(logger, " ...trimming {} HTLC (hash {}) with value {} due to dust limit", if outbound { "outbound" } else { "inbound" }, htlc.payment_hash, htlc.amount_msat);
3554-
}
3555-
} else {
3556-
let outbound = !local;
3557-
if outbound {
3558-
local_htlc_total_msat += htlc.amount_msat;
3559-
} else {
3560-
remote_htlc_total_msat += htlc.amount_msat;
3561-
}
3562-
let htlc_tx_fee = if self.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
3563-
0
3564-
} else {
3565-
feerate_per_kw as u64 * htlc_success_tx_weight(self.get_channel_type()) / 1000
3566-
};
3567-
if htlc.amount_msat / 1000 >= broadcaster_dust_limit_satoshis + htlc_tx_fee {
3568-
log_trace!(logger, " ...creating output for {} non-dust HTLC (hash {}) with value {}", if outbound { "outbound" } else { "inbound" }, htlc.payment_hash, htlc.amount_msat);
3569-
included_non_dust_htlcs.push(htlc);
3570-
} else {
3571-
log_trace!(logger, " ...trimming {} HTLC (hash {}) with value {} due to dust limit", if outbound { "outbound" } else { "inbound" }, htlc.payment_hash, htlc.amount_msat);
3572-
}
3573-
}
3574-
}
3575-
35763528
// TODO: When MSRV >= 1.66.0, use u64::checked_add_signed
3577-
let mut value_to_self_msat = u64::try_from(funding.value_to_self_msat as i64 + value_to_self_msat_offset).unwrap();
3578-
// Note that in case they have several just-awaiting-last-RAA fulfills in-progress (ie
3579-
// AwaitingRemoteRevokeToRemove or AwaitingRemovedRemoteRevoke) we may have allowed them to
3580-
// "violate" their reserve value by couting those against it. Thus, we have to do checked subtraction
3581-
// as otherwise we can overflow.
3582-
let mut value_to_remote_msat = u64::checked_sub(funding.channel_value_satoshis * 1000, value_to_self_msat).unwrap();
3583-
value_to_self_msat = u64::checked_sub(value_to_self_msat, local_htlc_total_msat).unwrap();
3584-
value_to_remote_msat = u64::checked_sub(value_to_remote_msat, remote_htlc_total_msat).unwrap();
3585-
3586-
let total_fee_sat = commit_tx_fee_sat(feerate_per_kw, included_non_dust_htlcs.len(), &self.channel_transaction_parameters.channel_type_features);
3587-
let anchors_val = if self.channel_transaction_parameters.channel_type_features.supports_anchors_zero_fee_htlc_tx() { ANCHOR_OUTPUT_VALUE_SATOSHI * 2 } else { 0 };
3588-
let (value_to_self, value_to_remote) = if self.is_outbound() {
3589-
((value_to_self_msat / 1000).saturating_sub(anchors_val).saturating_sub(total_fee_sat), value_to_remote_msat / 1000)
3590-
} else {
3591-
(value_to_self_msat / 1000, (value_to_remote_msat / 1000).saturating_sub(anchors_val).saturating_sub(total_fee_sat))
3592-
};
3529+
let value_to_self_with_offset_msat = u64::try_from(funding.value_to_self_msat as i64 + value_to_self_msat_offset).unwrap();
35933530

3594-
let mut value_to_a = if local { value_to_self } else { value_to_remote };
3595-
let mut value_to_b = if local { value_to_remote } else { value_to_self };
3596-
3597-
if value_to_a >= broadcaster_dust_limit_satoshis {
3598-
log_trace!(logger, " ...creating {} output with value {}", if local { "to_local" } else { "to_remote" }, value_to_a);
3599-
} else {
3600-
log_trace!(logger, " ...trimming {} output with value {} due to dust limit", if local { "to_local" } else { "to_remote" }, value_to_a);
3601-
value_to_a = 0;
3602-
}
3603-
3604-
if value_to_b >= broadcaster_dust_limit_satoshis {
3605-
log_trace!(logger, " ...creating {} output with value {}", if local { "to_remote" } else { "to_local" }, value_to_b);
3606-
} else {
3607-
log_trace!(logger, " ...trimming {} output with value {} due to dust limit", if local { "to_remote" } else { "to_local" }, value_to_b);
3608-
value_to_b = 0;
3609-
}
3610-
3611-
let channel_parameters =
3612-
if local { self.channel_transaction_parameters.as_holder_broadcastable() }
3613-
else { self.channel_transaction_parameters.as_counterparty_broadcastable() };
3614-
let tx = CommitmentTransaction::new(commitment_number,
3615-
&per_commitment_point,
3616-
value_to_a,
3617-
value_to_b,
3618-
feerate_per_kw,
3619-
included_non_dust_htlcs.into_iter(),
3620-
&channel_parameters,
3621-
&self.secp_ctx,
3622-
);
3531+
use crate::sign::tx_builder::{TxBuilder, SpecTxBuilder};
3532+
let stats = TxBuilder::build_commitment_transaction(&SpecTxBuilder {}, local, commitment_number, per_commitment_point, &self.channel_transaction_parameters, &self.secp_ctx,
3533+
funding.channel_value_satoshis, value_to_self_with_offset_msat, htlcs_in_tx.iter_mut().map(|(htlc, _)| htlc), feerate_per_kw, broadcaster_dust_limit_satoshis, logger);
36233534

36243535
#[cfg(debug_assertions)]
36253536
{
@@ -3630,10 +3541,10 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
36303541
} else {
36313542
funding.counterparty_max_commitment_tx_output.lock().unwrap()
36323543
};
3633-
debug_assert!(broadcaster_max_commitment_tx_output.0 <= value_to_self_msat || value_to_self_msat / 1000 >= funding.counterparty_selected_channel_reserve_satoshis.unwrap());
3634-
broadcaster_max_commitment_tx_output.0 = cmp::max(broadcaster_max_commitment_tx_output.0, value_to_self_msat);
3635-
debug_assert!(broadcaster_max_commitment_tx_output.1 <= value_to_remote_msat || value_to_remote_msat / 1000 >= funding.holder_selected_channel_reserve_satoshis);
3636-
broadcaster_max_commitment_tx_output.1 = cmp::max(broadcaster_max_commitment_tx_output.1, value_to_remote_msat);
3544+
debug_assert!(broadcaster_max_commitment_tx_output.0 <= stats.local_balance_msat || stats.local_balance_msat / 1000 >= funding.counterparty_selected_channel_reserve_satoshis.unwrap());
3545+
broadcaster_max_commitment_tx_output.0 = cmp::max(broadcaster_max_commitment_tx_output.0, stats.local_balance_msat);
3546+
debug_assert!(broadcaster_max_commitment_tx_output.1 <= stats.remote_balance_msat || stats.remote_balance_msat / 1000 >= funding.holder_selected_channel_reserve_satoshis);
3547+
broadcaster_max_commitment_tx_output.1 = cmp::max(broadcaster_max_commitment_tx_output.1, stats.remote_balance_msat);
36373548
}
36383549

36393550
htlcs_in_tx.sort_unstable_by(|(htlc_a, _), (htlc_b, _)| {
@@ -3645,13 +3556,6 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
36453556
}
36463557
});
36473558

3648-
let stats = CommitmentStats {
3649-
tx,
3650-
total_fee_sat,
3651-
local_balance_msat: value_to_self_msat,
3652-
remote_balance_msat: value_to_remote_msat,
3653-
};
3654-
36553559
CommitmentData {
36563560
stats,
36573561
htlcs_included: htlcs_in_tx,

‎lightning/src/sign/mod.rs

+1
Original file line numberDiff line numberDiff line change
@@ -81,6 +81,7 @@ pub(crate) mod type_resolver;
8181
pub mod ecdsa;
8282
#[cfg(taproot)]
8383
pub mod taproot;
84+
pub(crate) mod tx_builder;
8485

8586
/// Information about a spendable output to a P2WSH script.
8687
///

‎lightning/src/sign/tx_builder.rs

+222
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,222 @@
1+
//! Defines the `TxBuilder` trait, and the `SpecTxBuilder` type
2+
#![allow(dead_code)]
3+
#![allow(unused_variables)]
4+
5+
use core::ops::Deref;
6+
7+
use bitcoin::secp256k1::{self, PublicKey, Secp256k1};
8+
9+
use crate::ln::chan_utils::{
10+
self, ChannelTransactionParameters, CommitmentTransaction, HTLCOutputInCommitment,
11+
};
12+
use crate::ln::channel::{self, CommitmentStats};
13+
use crate::prelude::*;
14+
use crate::util::logger::Logger;
15+
16+
/// A trait for types that can build commitment transactions, both for the holder, and the counterparty.
17+
pub(crate) trait TxBuilder {
18+
/// Build a commitment transaction, and populate the elements of `htlcs` with their output indices.
19+
fn build_commitment_transaction<'a, L: Deref>(
20+
&self, local: bool, commitment_number: u64, per_commitment_point: &PublicKey,
21+
channel_transaction_parameters: &ChannelTransactionParameters,
22+
secp_ctx: &Secp256k1<secp256k1::All>, channel_value_satoshis: u64,
23+
value_to_self_with_offset_msat: u64,
24+
htlcs_in_tx: impl Iterator<Item = &'a mut HTLCOutputInCommitment>, feerate_per_kw: u32,
25+
broadcaster_dust_limit_satoshis: u64, logger: &L,
26+
) -> CommitmentStats
27+
where
28+
L::Target: Logger;
29+
}
30+
31+
/// A type that builds commitment transactions according to the Lightning Specification.
32+
#[derive(Clone, Debug, Default)]
33+
pub(crate) struct SpecTxBuilder {}
34+
35+
impl TxBuilder for SpecTxBuilder {
36+
fn build_commitment_transaction<'a, L: Deref>(
37+
&self, local: bool, commitment_number: u64, per_commitment_point: &PublicKey,
38+
channel_transaction_parameters: &ChannelTransactionParameters,
39+
secp_ctx: &Secp256k1<secp256k1::All>, channel_value_satoshis: u64,
40+
value_to_self_with_offset_msat: u64,
41+
htlcs_in_tx: impl Iterator<Item = &'a mut HTLCOutputInCommitment>, feerate_per_kw: u32,
42+
broadcaster_dust_limit_satoshis: u64, logger: &L,
43+
) -> CommitmentStats
44+
where
45+
L::Target: Logger,
46+
{
47+
// We allocate this vector because we need to count the number of non-dust htlcs and calculate the total fee of the transaction
48+
// before calling `CommitmentTransaction::new`.
49+
// We could drop this vector and create two iterators: one to count the number of non-dust htlcs, and another to pass to `CommitmentTransaction::new`
50+
let mut included_non_dust_htlcs: Vec<&mut HTLCOutputInCommitment> =
51+
Vec::with_capacity(htlcs_in_tx.size_hint().0);
52+
53+
let mut remote_htlc_total_msat = 0;
54+
let mut local_htlc_total_msat = 0;
55+
56+
let channel_parameters = if local {
57+
channel_transaction_parameters.as_holder_broadcastable()
58+
} else {
59+
channel_transaction_parameters.as_counterparty_broadcastable()
60+
};
61+
let channel_type = channel_parameters.channel_type_features();
62+
63+
// Trim dust htlcs
64+
for htlc in htlcs_in_tx {
65+
if htlc.offered {
66+
let outbound = local;
67+
if outbound {
68+
local_htlc_total_msat += htlc.amount_msat;
69+
} else {
70+
remote_htlc_total_msat += htlc.amount_msat;
71+
}
72+
let htlc_tx_fee = if channel_type.supports_anchors_zero_fee_htlc_tx() {
73+
0
74+
} else {
75+
feerate_per_kw as u64 * chan_utils::htlc_timeout_tx_weight(&channel_type) / 1000
76+
};
77+
if htlc.amount_msat / 1000 >= broadcaster_dust_limit_satoshis + htlc_tx_fee {
78+
log_trace!(
79+
logger,
80+
" ...creating output for {} non-dust HTLC (hash {}) with value {}",
81+
if outbound { "outbound" } else { "inbound" },
82+
htlc.payment_hash,
83+
htlc.amount_msat
84+
);
85+
included_non_dust_htlcs.push(htlc);
86+
} else {
87+
log_trace!(
88+
logger,
89+
" ...trimming {} HTLC (hash {}) with value {} due to dust limit",
90+
if outbound { "outbound" } else { "inbound" },
91+
htlc.payment_hash,
92+
htlc.amount_msat
93+
);
94+
}
95+
} else {
96+
let outbound = !local;
97+
if outbound {
98+
local_htlc_total_msat += htlc.amount_msat;
99+
} else {
100+
remote_htlc_total_msat += htlc.amount_msat;
101+
}
102+
let htlc_tx_fee = if channel_type.supports_anchors_zero_fee_htlc_tx() {
103+
0
104+
} else {
105+
feerate_per_kw as u64 * chan_utils::htlc_success_tx_weight(&channel_type) / 1000
106+
};
107+
if htlc.amount_msat / 1000 >= broadcaster_dust_limit_satoshis + htlc_tx_fee {
108+
log_trace!(
109+
logger,
110+
" ...creating output for {} non-dust HTLC (hash {}) with value {}",
111+
if outbound { "outbound" } else { "inbound" },
112+
htlc.payment_hash,
113+
htlc.amount_msat
114+
);
115+
included_non_dust_htlcs.push(htlc);
116+
} else {
117+
log_trace!(
118+
logger,
119+
" ...trimming {} HTLC (hash {}) with value {} due to dust limit",
120+
if outbound { "outbound" } else { "inbound" },
121+
htlc.payment_hash,
122+
htlc.amount_msat
123+
);
124+
}
125+
}
126+
}
127+
128+
// Note that in case they have several just-awaiting-last-RAA fulfills in-progress (ie
129+
// AwaitingRemoteRevokeToRemove or AwaitingRemovedRemoteRevoke) we may have allowed them to
130+
// "violate" their reserve value by couting those against it. Thus, we have to do checked subtraction
131+
// as otherwise we can overflow.
132+
let mut value_to_remote_msat =
133+
u64::checked_sub(channel_value_satoshis * 1000, value_to_self_with_offset_msat)
134+
.unwrap();
135+
let value_to_self_msat =
136+
u64::checked_sub(value_to_self_with_offset_msat, local_htlc_total_msat).unwrap();
137+
value_to_remote_msat =
138+
u64::checked_sub(value_to_remote_msat, remote_htlc_total_msat).unwrap();
139+
140+
let total_fee_sat = chan_utils::commit_tx_fee_sat(
141+
feerate_per_kw,
142+
included_non_dust_htlcs.len(),
143+
&channel_type,
144+
);
145+
let anchors_val = if channel_type.supports_anchors_zero_fee_htlc_tx() {
146+
channel::ANCHOR_OUTPUT_VALUE_SATOSHI * 2
147+
} else {
148+
0
149+
};
150+
let (value_to_self, value_to_remote) =
151+
if channel_transaction_parameters.is_outbound_from_holder {
152+
(
153+
(value_to_self_msat / 1000)
154+
.saturating_sub(anchors_val)
155+
.saturating_sub(total_fee_sat),
156+
value_to_remote_msat / 1000,
157+
)
158+
} else {
159+
(
160+
value_to_self_msat / 1000,
161+
(value_to_remote_msat / 1000)
162+
.saturating_sub(anchors_val)
163+
.saturating_sub(total_fee_sat),
164+
)
165+
};
166+
167+
let mut value_to_a = if local { value_to_self } else { value_to_remote };
168+
let mut value_to_b = if local { value_to_remote } else { value_to_self };
169+
170+
if value_to_a >= broadcaster_dust_limit_satoshis {
171+
log_trace!(
172+
logger,
173+
" ...creating {} output with value {}",
174+
if local { "to_local" } else { "to_remote" },
175+
value_to_a
176+
);
177+
} else {
178+
log_trace!(
179+
logger,
180+
" ...trimming {} output with value {} due to dust limit",
181+
if local { "to_local" } else { "to_remote" },
182+
value_to_a
183+
);
184+
value_to_a = 0;
185+
}
186+
187+
if value_to_b >= broadcaster_dust_limit_satoshis {
188+
log_trace!(
189+
logger,
190+
" ...creating {} output with value {}",
191+
if local { "to_remote" } else { "to_local" },
192+
value_to_b
193+
);
194+
} else {
195+
log_trace!(
196+
logger,
197+
" ...trimming {} output with value {} due to dust limit",
198+
if local { "to_remote" } else { "to_local" },
199+
value_to_b
200+
);
201+
value_to_b = 0;
202+
}
203+
204+
let tx = CommitmentTransaction::new(
205+
commitment_number,
206+
&per_commitment_point,
207+
value_to_a,
208+
value_to_b,
209+
feerate_per_kw,
210+
included_non_dust_htlcs.into_iter(),
211+
&channel_parameters,
212+
&secp_ctx,
213+
);
214+
215+
CommitmentStats {
216+
tx,
217+
total_fee_sat,
218+
local_balance_msat: value_to_self_msat,
219+
remote_balance_msat: value_to_remote_msat,
220+
}
221+
}
222+
}

0 commit comments

Comments
 (0)