mirrors/rust-lightning
1
0
Fork 0
mirror of https://github.com/lightningdevkit/rust-lightning.git synced 2025-02-25 07:17:40 +01:00
Code Issues Projects Releases Packages Wiki Activity

Add HolderCommitmentPoint struct to ChannelContext

Browse source
This commit is contained in:
Alec Chen 2024-05-30 15:35:11 -05:00
parent df0120809f
commit c08aa349f5
1 changed files with 110 additions and 4 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

114
lightning/src/ln/channel.rs
View file

@ -1119,6 +1119,75 @@ pub(crate) struct ShutdownResult {
pub(crate) channel_funding_txo: Option<OutPoint>,
}
/// Tracks the transaction number, along with current and next commitment points.
/// This consolidates the logic to advance our commitment number and request new
/// commitment points from our signer.
#[derive(Debug, Copy, Clone)]
enum HolderCommitmentPoint {
// TODO: add a variant for before our first commitment point is retrieved
/// We've advanced our commitment number and are waiting on the next commitment point.
/// Until the `get_per_commitment_point` signer method becomes async, this variant
/// will not be used.
PendingNext { transaction_number: u64, current: PublicKey },
/// Our current commitment point is ready, we've cached our next point,
/// and we are not pending a new one.
Available { transaction_number: u64, current: PublicKey, next: PublicKey },
}
impl HolderCommitmentPoint {
pub fn new<SP: Deref>(signer: &ChannelSignerType<SP>, secp_ctx: &Secp256k1<secp256k1::All>) -> Self
where SP::Target: SignerProvider
{
HolderCommitmentPoint::Available {
transaction_number: INITIAL_COMMITMENT_NUMBER,
current: signer.as_ref().get_per_commitment_point(INITIAL_COMMITMENT_NUMBER, secp_ctx),
next: signer.as_ref().get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - 1, secp_ctx),
}
}
pub fn is_available(&self) -> bool {
if let HolderCommitmentPoint::Available { .. } = self { true } else { false }
}
pub fn transaction_number(&self) -> u64 {
match self {
HolderCommitmentPoint::PendingNext { transaction_number, .. } => *transaction_number,
HolderCommitmentPoint::Available { transaction_number, .. } => *transaction_number,
}
}
pub fn current_point(&self) -> PublicKey {
match self {
HolderCommitmentPoint::PendingNext { current, .. } => *current,
HolderCommitmentPoint::Available { current, .. } => *current,
}
}
pub fn next_point(&self) -> Option<PublicKey> {
match self {
HolderCommitmentPoint::PendingNext { .. } => None,
HolderCommitmentPoint::Available { next, .. } => Some(*next),
}
}
pub fn advance<SP: Deref, L: Deref>(&mut self, signer: &ChannelSignerType<SP>, secp_ctx: &Secp256k1<secp256k1::All>, logger: &L)
where SP::Target: SignerProvider, L::Target: Logger
{
if let HolderCommitmentPoint::Available { transaction_number, next, .. } = self {
*self = HolderCommitmentPoint::PendingNext {
transaction_number: *transaction_number - 1,
current: *next,
};
}
if let HolderCommitmentPoint::PendingNext { transaction_number, current } = self {
let next = signer.as_ref().get_per_commitment_point(*transaction_number - 1, secp_ctx);
log_trace!(logger, "Retrieved next per-commitment point {}", *transaction_number - 1);
*self = HolderCommitmentPoint::Available { transaction_number: *transaction_number, current: *current, next };
}
}
}
/// If the majority of the channels funds are to the fundee and the initiator holds only just
/// enough funds to cover their reserve value, channels are at risk of getting "stuck". Because the
/// initiator controls the feerate, if they then go to increase the channel fee, they may have no
@ -1297,6 +1366,7 @@ pub(super) struct ChannelContext<SP: Deref> where SP::Target: SignerProvider {
// generation start at 0 and count up...this simplifies some parts of implementation at the
// cost of others, but should really just be changed.
holder_commitment_point: HolderCommitmentPoint,
cur_holder_commitment_transaction_number: u64,
cur_counterparty_commitment_transaction_number: u64,
value_to_self_msat: u64, // Excluding all pending_htlcs, fees, and anchor outputs
@ -1739,6 +1809,9 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
let value_to_self_msat = our_funding_satoshis * 1000 + msg_push_msat;
let holder_signer = ChannelSignerType::Ecdsa(holder_signer);
let holder_commitment_point = HolderCommitmentPoint::new(&holder_signer, &secp_ctx);
// TODO(dual_funding): Checks for `funding_feerate_sat_per_1000_weight`?
let channel_context = ChannelContext {
@ -1764,10 +1837,11 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
latest_monitor_update_id: 0,
holder_signer: ChannelSignerType::Ecdsa(holder_signer),
holder_signer,
shutdown_scriptpubkey,
destination_script,
holder_commitment_point,
cur_holder_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
cur_counterparty_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
value_to_self_msat,
@ -1963,6 +2037,9 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
let temporary_channel_id = temporary_channel_id.unwrap_or_else(|| ChannelId::temporary_from_entropy_source(entropy_source));
let holder_signer = ChannelSignerType::Ecdsa(holder_signer);
let holder_commitment_point = HolderCommitmentPoint::new(&holder_signer, &secp_ctx);
Ok(Self {
user_id,
@ -1986,10 +2063,11 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
latest_monitor_update_id: 0,
holder_signer: ChannelSignerType::Ecdsa(holder_signer),
holder_signer,
shutdown_scriptpubkey,
destination_script,
holder_commitment_point,
cur_holder_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
cur_counterparty_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
value_to_self_msat,
@ -8779,6 +8857,10 @@ impl<SP: Deref> Writeable for Channel<SP> where SP::Target: SignerProvider {
monitor_pending_update_adds = Some(&self.context.monitor_pending_update_adds);
}
// `current_point` will become optional when async signing is implemented.
let cur_holder_commitment_point = Some(self.context.holder_commitment_point.current_point());
let next_holder_commitment_point = self.context.holder_commitment_point.next_point();
write_tlv_fields!(writer, {
(0, self.context.announcement_sigs, option),
// minimum_depth and counterparty_selected_channel_reserve_satoshis used to have a
@ -8815,7 +8897,8 @@ impl<SP: Deref> Writeable for Channel<SP> where SP::Target: SignerProvider {
(39, pending_outbound_blinding_points, optional_vec),
(41, holding_cell_blinding_points, optional_vec),
(43, malformed_htlcs, optional_vec), // Added in 0.0.119
// 45 and 47 are reserved for async signing
(45, cur_holder_commitment_point, option),
(47, next_holder_commitment_point, option),
(49, self.context.local_initiated_shutdown, option), // Added in 0.0.122
});
@ -9126,6 +9209,9 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
let mut malformed_htlcs: Option<Vec<(u64, u16, [u8; 32])>> = None;
let mut monitor_pending_update_adds: Option<Vec<msgs::UpdateAddHTLC>> = None;
let mut cur_holder_commitment_point_opt: Option<PublicKey> = None;
let mut next_holder_commitment_point_opt: Option<PublicKey> = None;
read_tlv_fields!(reader, {
(0, announcement_sigs, option),
(1, minimum_depth, option),
@ -9156,7 +9242,8 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
(39, pending_outbound_blinding_points_opt, optional_vec),
(41, holding_cell_blinding_points_opt, optional_vec),
(43, malformed_htlcs, optional_vec), // Added in 0.0.119
// 45 and 47 are reserved for async signing
(45, cur_holder_commitment_point_opt, option),
(47, next_holder_commitment_point_opt, option),
(49, local_initiated_shutdown, option),
});
@ -9268,6 +9355,24 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
}
}
// If we're restoring this channel for the first time after an upgrade, then we require that the
// signer be available so that we can immediately populate the current commitment point. Channel
// restoration will fail if this is not possible.
let holder_commitment_point = match (cur_holder_commitment_point_opt, next_holder_commitment_point_opt) {
(Some(current), Some(next)) => HolderCommitmentPoint::Available {
transaction_number: cur_holder_commitment_transaction_number, current, next
},
(Some(current), _) => HolderCommitmentPoint::Available {
transaction_number: cur_holder_commitment_transaction_number, current,
next: holder_signer.get_per_commitment_point(cur_holder_commitment_transaction_number - 1, &secp_ctx),
},
(_, _) => HolderCommitmentPoint::Available {
transaction_number: cur_holder_commitment_transaction_number,
current: holder_signer.get_per_commitment_point(cur_holder_commitment_transaction_number, &secp_ctx),
next: holder_signer.get_per_commitment_point(cur_holder_commitment_transaction_number - 1, &secp_ctx),
},
};
Ok(Channel {
context: ChannelContext {
user_id,
@ -9293,6 +9398,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
shutdown_scriptpubkey,
destination_script,
holder_commitment_point,
cur_holder_commitment_transaction_number,
cur_counterparty_commitment_transaction_number,
value_to_self_msat,