Skip to content

Commit 2f705d1

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 da87b48 commit 2f705d1

File tree

3 files changed

+235
-109
lines changed

3 files changed

+235
-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

+221
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,221 @@
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> = Vec::with_capacity(htlcs_in_tx.size_hint().0);
51+
52+
let mut remote_htlc_total_msat = 0;
53+
let mut local_htlc_total_msat = 0;
54+
55+
let channel_parameters = if local {
56+
channel_transaction_parameters.as_holder_broadcastable()
57+
} else {
58+
channel_transaction_parameters.as_counterparty_broadcastable()
59+
};
60+
let channel_type = channel_parameters.channel_type_features();
61+
62+
// Trim dust htlcs
63+
for htlc in htlcs_in_tx {
64+
if htlc.offered {
65+
let outbound = local;
66+
if outbound {
67+
local_htlc_total_msat += htlc.amount_msat;
68+
} else {
69+
remote_htlc_total_msat += htlc.amount_msat;
70+
}
71+
let htlc_tx_fee = if channel_type.supports_anchors_zero_fee_htlc_tx() {
72+
0
73+
} else {
74+
feerate_per_kw as u64 * chan_utils::htlc_timeout_tx_weight(&channel_type) / 1000
75+
};
76+
if htlc.amount_msat / 1000 >= broadcaster_dust_limit_satoshis + htlc_tx_fee {
77+
log_trace!(
78+
logger,
79+
" ...creating output for {} non-dust HTLC (hash {}) with value {}",
80+
if outbound { "outbound" } else { "inbound" },
81+
htlc.payment_hash,
82+
htlc.amount_msat
83+
);
84+
included_non_dust_htlcs.push(htlc);
85+
} else {
86+
log_trace!(
87+
logger,
88+
" ...trimming {} HTLC (hash {}) with value {} due to dust limit",
89+
if outbound { "outbound" } else { "inbound" },
90+
htlc.payment_hash,
91+
htlc.amount_msat
92+
);
93+
}
94+
} else {
95+
let outbound = !local;
96+
if outbound {
97+
local_htlc_total_msat += htlc.amount_msat;
98+
} else {
99+
remote_htlc_total_msat += htlc.amount_msat;
100+
}
101+
let htlc_tx_fee = if channel_type.supports_anchors_zero_fee_htlc_tx() {
102+
0
103+
} else {
104+
feerate_per_kw as u64 * chan_utils::htlc_success_tx_weight(&channel_type) / 1000
105+
};
106+
if htlc.amount_msat / 1000 >= broadcaster_dust_limit_satoshis + htlc_tx_fee {
107+
log_trace!(
108+
logger,
109+
" ...creating output for {} non-dust HTLC (hash {}) with value {}",
110+
if outbound { "outbound" } else { "inbound" },
111+
htlc.payment_hash,
112+
htlc.amount_msat
113+
);
114+
included_non_dust_htlcs.push(htlc);
115+
} else {
116+
log_trace!(
117+
logger,
118+
" ...trimming {} HTLC (hash {}) with value {} due to dust limit",
119+
if outbound { "outbound" } else { "inbound" },
120+
htlc.payment_hash,
121+
htlc.amount_msat
122+
);
123+
}
124+
}
125+
}
126+
127+
// Note that in case they have several just-awaiting-last-RAA fulfills in-progress (ie
128+
// AwaitingRemoteRevokeToRemove or AwaitingRemovedRemoteRevoke) we may have allowed them to
129+
// "violate" their reserve value by couting those against it. Thus, we have to do checked subtraction
130+
// as otherwise we can overflow.
131+
let mut value_to_remote_msat =
132+
u64::checked_sub(channel_value_satoshis * 1000, value_to_self_with_offset_msat)
133+
.unwrap();
134+
let value_to_self_msat =
135+
u64::checked_sub(value_to_self_with_offset_msat, local_htlc_total_msat).unwrap();
136+
value_to_remote_msat =
137+
u64::checked_sub(value_to_remote_msat, remote_htlc_total_msat).unwrap();
138+
139+
let total_fee_sat = chan_utils::commit_tx_fee_sat(
140+
feerate_per_kw,
141+
included_non_dust_htlcs.len(),
142+
&channel_type,
143+
);
144+
let anchors_val = if channel_type.supports_anchors_zero_fee_htlc_tx() {
145+
channel::ANCHOR_OUTPUT_VALUE_SATOSHI * 2
146+
} else {
147+
0
148+
};
149+
let (value_to_self, value_to_remote) =
150+
if channel_transaction_parameters.is_outbound_from_holder {
151+
(
152+
(value_to_self_msat / 1000)
153+
.saturating_sub(anchors_val)
154+
.saturating_sub(total_fee_sat),
155+
value_to_remote_msat / 1000,
156+
)
157+
} else {
158+
(
159+
value_to_self_msat / 1000,
160+
(value_to_remote_msat / 1000)
161+
.saturating_sub(anchors_val)
162+
.saturating_sub(total_fee_sat),
163+
)
164+
};
165+
166+
let mut value_to_a = if local { value_to_self } else { value_to_remote };
167+
let mut value_to_b = if local { value_to_remote } else { value_to_self };
168+
169+
if value_to_a >= broadcaster_dust_limit_satoshis {
170+
log_trace!(
171+
logger,
172+
" ...creating {} output with value {}",
173+
if local { "to_local" } else { "to_remote" },
174+
value_to_a
175+
);
176+
} else {
177+
log_trace!(
178+
logger,
179+
" ...trimming {} output with value {} due to dust limit",
180+
if local { "to_local" } else { "to_remote" },
181+
value_to_a
182+
);
183+
value_to_a = 0;
184+
}
185+
186+
if value_to_b >= broadcaster_dust_limit_satoshis {
187+
log_trace!(
188+
logger,
189+
" ...creating {} output with value {}",
190+
if local { "to_remote" } else { "to_local" },
191+
value_to_b
192+
);
193+
} else {
194+
log_trace!(
195+
logger,
196+
" ...trimming {} output with value {} due to dust limit",
197+
if local { "to_remote" } else { "to_local" },
198+
value_to_b
199+
);
200+
value_to_b = 0;
201+
}
202+
203+
let tx = CommitmentTransaction::new(
204+
commitment_number,
205+
&per_commitment_point,
206+
value_to_a,
207+
value_to_b,
208+
feerate_per_kw,
209+
included_non_dust_htlcs.into_iter(),
210+
&channel_parameters,
211+
&secp_ctx,
212+
);
213+
214+
CommitmentStats {
215+
tx,
216+
total_fee_sat,
217+
local_balance_msat: value_to_self_msat,
218+
remote_balance_msat: value_to_remote_msat,
219+
}
220+
}
221+
}

0 commit comments

Comments
 (0)