Skip to content

Track claimed outbound HTLCs in ChannelMonitors#2048

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
TheBlueMatt merged 3 commits into from
Mar 3, 2023
Merged

Track claimed outbound HTLCs in ChannelMonitors #2048

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
33c36d0
Avoid removing stale preimages when hashes collide in fuzzing
TheBlueMatt Mar 2, 2023
0ad1f4c
Track claimed outbound HTLCs in ChannelMonitors
TheBlueMatt Feb 22, 2023
75527db
Remove unused compat block in `provide_latest_holder_commitment_tx`
TheBlueMatt Mar 1, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
125 changes: 87 additions & 38 deletions lightning/src/chain/channelmonitor.rs
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -37,7 +37,7 @@ use crate::ln::{PaymentHash, PaymentPreimage};
use crate::ln::msgs::DecodeError;
use crate::ln::chan_utils;
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HTLCClaim, ChannelTransactionParameters, HolderCommitmentTransaction};
use crate::ln::channelmanager::HTLCSource;
use crate::ln::channelmanager::{HTLCSource, SentHTLCId};
use crate::chain;
use crate::chain::{BestBlock, WatchedOutput};
use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator, LowerBoundedFeeEstimator};
Expand DownExpand Up@@ -494,6 +494,7 @@ pub(crate) enum ChannelMonitorUpdateStep {
LatestHolderCommitmentTXInfo {
commitment_tx: HolderCommitmentTransaction,
htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
claimed_htlcs: Vec<(SentHTLCId, PaymentPreimage)>,
Comment thread
wpaulino marked this conversation as resolved.
},
LatestCounterpartyCommitmentTXInfo {
commitment_txid: Txid,
Expand DownExpand Up@@ -536,6 +537,7 @@ impl ChannelMonitorUpdateStep {
impl_writeable_tlv_based_enum_upgradable!(ChannelMonitorUpdateStep,
(0, LatestHolderCommitmentTXInfo) => {
(0, commitment_tx, required),
(1, claimed_htlcs, vec_type),
(2, htlc_outputs, vec_type),
},
(1, LatestCounterpartyCommitmentTXInfo) => {
Expand DownExpand Up@@ -750,6 +752,8 @@ pub(crate) struct ChannelMonitorImpl<Signer: WriteableEcdsaChannelSigner> {
/// Serialized to disk but should generally not be sent to Watchtowers.
counterparty_hash_commitment_number: HashMap<PaymentHash, u64>,

counterparty_fulfilled_htlcs: HashMap<SentHTLCId, PaymentPreimage>,

// We store two holder commitment transactions to avoid any race conditions where we may update
// some monitors (potentially on watchtowers) but then fail to update others, resulting in the
// various monitors for one channel being out of sync, and us broadcasting a holder
Expand DownExpand Up@@ -1033,6 +1037,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for ChannelMonitorImpl<Signe
(9, self.counterparty_node_id, option),
(11, self.confirmed_commitment_tx_counterparty_output, option),
(13, self.spendable_txids_confirmed, vec_type),
(15, self.counterparty_fulfilled_htlcs, required),
});

Ok(())
Expand DownExpand Up@@ -1120,6 +1125,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
counterparty_claimable_outpoints: HashMap::new(),
counterparty_commitment_txn_on_chain: HashMap::new(),
counterparty_hash_commitment_number: HashMap::new(),
counterparty_fulfilled_htlcs: HashMap::new(),

prev_holder_signed_commitment_tx: None,
current_holder_commitment_tx: holder_commitment_tx,
Expand DownExpand Up@@ -1174,7 +1180,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
&self, holder_commitment_tx: HolderCommitmentTransaction,
htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
) -> Result<(), ()> {
self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs).map_err(|_| ())
self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs, &Vec::new()).map_err(|_| ())
}

/// This is used to provide payment preimage(s) out-of-band during startup without updating the
Expand DownExpand Up@@ -1810,9 +1816,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
/// `ChannelMonitor`. This is used to determine if an HTLC was removed from the channel prior
/// to the `ChannelManager` having been persisted.
///
/// This is similar to [`Self::get_pending_outbound_htlcs`] except it includes HTLCs which were
/// resolved by this `ChannelMonitor`.
pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
/// This is similar to [`Self::get_pending_or_resolved_outbound_htlcs`] except it includes
/// HTLCs which were resolved on-chain (i.e. where the final HTLC resolution was done by an
/// event from this `ChannelMonitor`).
pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
let mut res = HashMap::new();
// Just examine the available counterparty commitment transactions. See docs on
// `fail_unbroadcast_htlcs`, below, for justification.
Expand All@@ -1822,7 +1829,8 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
if let Some(ref latest_outpoints) = us.counterparty_claimable_outpoints.get($txid) {
for &(ref htlc, ref source_option) in latest_outpoints.iter() {
if let &Some(ref source) = source_option {
res.insert((**source).clone(), htlc.clone());
res.insert((**source).clone(), (htlc.clone(),
us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned()));
}
}
}
Expand All@@ -1837,9 +1845,14 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
res
}

/// Gets the set of outbound HTLCs which are pending resolution in this channel.
/// Gets the set of outbound HTLCs which are pending resolution in this channel or which were
/// resolved with a preimage from our counterparty.
///
/// This is used to reconstruct pending outbound payments on restart in the ChannelManager.
pub(crate) fn get_pending_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
///
/// Currently, the preimage is unused, however if it is present in the relevant internal state
/// an HTLC is always included even if it has been resolved.
pub(crate) fn get_pending_or_resolved_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
Comment thread
wpaulino marked this conversation as resolved.
let us = self.inner.lock().unwrap();
// We're only concerned with the confirmation count of HTLC transactions, and don't
// actually care how many confirmations a commitment transaction may or may not have. Thus,
Expand DownExpand Up@@ -1887,8 +1900,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
Some(commitment_tx_output_idx) == htlc.transaction_output_index
} else { false }
});
if !htlc_update_confd {
res.insert(source.clone(), htlc.clone());
Comment thread
wpaulino marked this conversation as resolved.
let counterparty_resolved_preimage_opt =
us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned();
if !htlc_update_confd || counterparty_resolved_preimage_opt.is_some() {
res.insert(source.clone(), (htlc.clone(), counterparty_resolved_preimage_opt));
}
}
}
Expand DownExpand Up@@ -1970,6 +1985,9 @@ macro_rules! fail_unbroadcast_htlcs {
}
}
if matched_htlc { continue; }
if $self.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).is_some() {
continue;
}
Comment thread
wpaulino marked this conversation as resolved.
$self.onchain_events_awaiting_threshold_conf.retain(|ref entry| {
if entry.height != $commitment_tx_conf_height { return true; }
match entry.event {
Expand DownExpand Up@@ -2041,8 +2059,23 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
// Prune HTLCs from the previous counterparty commitment tx so we don't generate failure/fulfill
// events for now-revoked/fulfilled HTLCs.
if let Some(txid) = self.prev_counterparty_commitment_txid.take() {
for &mut (_, ref mut source) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
*source = None;
if self.current_counterparty_commitment_txid.unwrap() != txid {
let cur_claimables = self.counterparty_claimable_outpoints.get(
&self.current_counterparty_commitment_txid.unwrap()).unwrap();
for (_, ref source_opt) in self.counterparty_claimable_outpoints.get(&txid).unwrap() {
if let Some(source) = source_opt {
if !cur_claimables.iter()
.any(|(_, cur_source_opt)| cur_source_opt == source_opt)
{
self.counterparty_fulfilled_htlcs.remove(&SentHTLCId::from_source(source));
}
}
}
for &mut (_, ref mut source_opt) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
*source_opt = None;
}
Comment thread
valentinewallace marked this conversation as resolved.
} else {
assert!(cfg!(fuzzing), "Commitment txids are unique outside of fuzzing, where hashes can collide");
}
}

Expand DownExpand Up@@ -2127,28 +2160,37 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
/// is important that any clones of this channel monitor (including remote clones) by kept
/// up-to-date as our holder commitment transaction is updated.
/// Panics if set_on_holder_tx_csv has never been called.
fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>) -> Result<(), &'static str> {
// block for Rust 1.34 compat
let mut new_holder_commitment_tx = {
let trusted_tx = holder_commitment_tx.trust();
let txid = trusted_tx.txid();
let tx_keys = trusted_tx.keys();
self.current_holder_commitment_number = trusted_tx.commitment_number();
HolderSignedTx {
txid,
revocation_key: tx_keys.revocation_key,
a_htlc_key: tx_keys.broadcaster_htlc_key,
b_htlc_key: tx_keys.countersignatory_htlc_key,
delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
per_commitment_point: tx_keys.per_commitment_point,
htlc_outputs,
to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
feerate_per_kw: trusted_tx.feerate_per_kw(),
}
fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>, claimed_htlcs: &[(SentHTLCId, PaymentPreimage)]) -> Result<(), &'static str> {
let trusted_tx = holder_commitment_tx.trust();
let txid = trusted_tx.txid();
let tx_keys = trusted_tx.keys();
self.current_holder_commitment_number = trusted_tx.commitment_number();
let mut new_holder_commitment_tx = HolderSignedTx {
txid,
revocation_key: tx_keys.revocation_key,
a_htlc_key: tx_keys.broadcaster_htlc_key,
b_htlc_key: tx_keys.countersignatory_htlc_key,
delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
per_commitment_point: tx_keys.per_commitment_point,
htlc_outputs,
to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
feerate_per_kw: trusted_tx.feerate_per_kw(),
};
self.onchain_tx_handler.provide_latest_holder_tx(holder_commitment_tx);
mem::swap(&mut new_holder_commitment_tx, &mut self.current_holder_commitment_tx);
self.prev_holder_signed_commitment_tx = Some(new_holder_commitment_tx);
for (claimed_htlc_id, claimed_preimage) in claimed_htlcs {
#[cfg(debug_assertions)] {
let cur_counterparty_htlcs = self.counterparty_claimable_outpoints.get(
&self.current_counterparty_commitment_txid.unwrap()).unwrap();
assert!(cur_counterparty_htlcs.iter().any(|(_, source_opt)| {
if let Some(source) = source_opt {
SentHTLCId::from_source(source) == *claimed_htlc_id
} else { false }
}));
}
self.counterparty_fulfilled_htlcs.insert(*claimed_htlc_id, *claimed_preimage);
}
if self.holder_tx_signed {
return Err("Latest holder commitment signed has already been signed, update is rejected");
}
Expand DownExpand Up@@ -2243,10 +2285,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&*fee_estimator);
for update in updates.updates.iter() {
match update {
ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs } => {
ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs, claimed_htlcs } => {
log_trace!(logger, "Updating ChannelMonitor with latest holder commitment transaction info");
if self.lockdown_from_offchain { panic!(); }
if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone()) {
if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone(), &claimed_htlcs) {
log_error!(logger, "Providing latest holder commitment transaction failed/was refused:");
log_error!(logger, " {}", e);
ret = Err(());
Expand DownExpand Up@@ -3868,6 +3910,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
let mut counterparty_node_id = None;
let mut confirmed_commitment_tx_counterparty_output = None;
let mut spendable_txids_confirmed = Some(Vec::new());
let mut counterparty_fulfilled_htlcs = Some(HashMap::new());
read_tlv_fields!(reader, {
(1, funding_spend_confirmed, option),
(3, htlcs_resolved_on_chain, vec_type),
Expand All@@ -3876,6 +3919,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
(9, counterparty_node_id, option),
(11, confirmed_commitment_tx_counterparty_output, option),
(13, spendable_txids_confirmed, vec_type),
(15, counterparty_fulfilled_htlcs, option),
});

Ok((best_block.block_hash(), ChannelMonitor::from_impl(ChannelMonitorImpl {
Expand DownExpand Up@@ -3904,6 +3948,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
counterparty_claimable_outpoints,
counterparty_commitment_txn_on_chain,
counterparty_hash_commitment_number,
counterparty_fulfilled_htlcs: counterparty_fulfilled_htlcs.unwrap(),

prev_holder_signed_commitment_tx,
current_holder_commitment_tx,
Expand DownExpand Up@@ -4077,7 +4122,6 @@ mod tests {
let fee_estimator = TestFeeEstimator { sat_per_kw: Mutex::new(253) };

let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
let dummy_tx = Transaction { version: 0, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() };

let mut preimages = Vec::new();
{
Expand DownExpand Up@@ -4167,11 +4211,10 @@ mod tests {
HolderCommitmentTransaction::dummy(), best_block, dummy_key);

monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..10])).unwrap();
let dummy_txid = dummy_tx.txid();
monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);
monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);
monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"1").into_inner()),
preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"2").into_inner()),
preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
for &(ref preimage, ref hash) in preimages.iter() {
let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_estimator);
monitor.provide_payment_preimage(hash, preimage, &broadcaster, &bounded_fee_estimator, &logger);
Expand All@@ -4185,13 +4228,19 @@ mod tests {
test_preimages_exist!(&preimages[0..10], monitor);
test_preimages_exist!(&preimages[15..20], monitor);

monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"3").into_inner()),
preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);

// Now provide a further secret, pruning preimages 15-17
secret[0..32].clone_from_slice(&hex::decode("c7518c8ae4660ed02894df8976fa1a3659c1a8b4b5bec0c4b872abeba4cb8964").unwrap());
monitor.provide_secret(281474976710654, secret.clone()).unwrap();
assert_eq!(monitor.inner.lock().unwrap().payment_preimages.len(), 13);
test_preimages_exist!(&preimages[0..10], monitor);
test_preimages_exist!(&preimages[17..20], monitor);

monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"4").into_inner()),
preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);

// Now update holder commitment tx info, pruning only element 18 as we still care about the
// previous commitment tx's preimages too
monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..5])).unwrap();
Expand Down
32 changes: 22 additions & 10 deletions lightning/src/ln/channel.rs
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -27,7 +27,7 @@ use crate::ln::features::{ChannelTypeFeatures, InitFeatures};
use crate::ln::msgs;
use crate::ln::msgs::{DecodeError, OptionalField, DataLossProtect};
use crate::ln::script::{self, ShutdownScript};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, SentHTLCId, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, TxCreationKeys, HTLCOutputInCommitment, htlc_success_tx_weight, htlc_timeout_tx_weight, make_funding_redeemscript, ChannelPublicKeys, CommitmentTransaction, HolderCommitmentTransaction, ChannelTransactionParameters, CounterpartyChannelTransactionParameters, MAX_HTLCS, get_commitment_transaction_number_obscure_factor, ClosingTransaction};
use crate::ln::chan_utils;
use crate::ln::onion_utils::HTLCFailReason;
Expand DownExpand Up@@ -192,6 +192,7 @@ enum OutboundHTLCState {

#[derive(Clone)]
enum OutboundHTLCOutcome {
/// LDK version 0.0.105+ will always fill in the preimage here.
Success(Option<PaymentPreimage>),
Failure(HTLCFailReason),
}
Expand DownExpand Up@@ -3159,15 +3160,6 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
}
}

self.latest_monitor_update_id += 1;
let mut monitor_update = ChannelMonitorUpdate {
update_id: self.latest_monitor_update_id,
updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
commitment_tx: holder_commitment_tx,
htlc_outputs: htlcs_and_sigs
}]
};

for htlc in self.pending_inbound_htlcs.iter_mut() {
let new_forward = if let &InboundHTLCState::RemoteAnnounced(ref forward_info) = &htlc.state {
Some(forward_info.clone())
Expand All@@ -3179,18 +3171,38 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
need_commitment = true;
}
}
let mut claimed_htlcs = Vec::new();
for htlc in self.pending_outbound_htlcs.iter_mut() {
if let &mut OutboundHTLCState::RemoteRemoved(ref mut outcome) = &mut htlc.state {
log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToRemove due to commitment_signed in channel {}.",
log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id));
// Grab the preimage, if it exists, instead of cloning
let mut reason = OutboundHTLCOutcome::Success(None);
mem::swap(outcome, &mut reason);
if let OutboundHTLCOutcome::Success(Some(preimage)) = reason {
// If a user (a) receives an HTLC claim using LDK 0.0.104 or before, then (b)
// upgrades to LDK 0.0.114 or later before the HTLC is fully resolved, we could
// have a `Success(None)` reason. In this case we could forget some HTLC
// claims, but such an upgrade is unlikely and including claimed HTLCs here
// fixes a bug which the user was exposed to on 0.0.104 when they started the
// claim anyway.
claimed_htlcs.push((SentHTLCId::from_source(&htlc.source), preimage));
}
htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(reason);
need_commitment = true;
}
}

self.latest_monitor_update_id += 1;
let mut monitor_update = ChannelMonitorUpdate {
update_id: self.latest_monitor_update_id,
updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
commitment_tx: holder_commitment_tx,
htlc_outputs: htlcs_and_sigs,
claimed_htlcs,
}]
};

self.cur_holder_commitment_transaction_number -= 1;
// Note that if we need_commitment & !AwaitingRemoteRevoke we'll call
// build_commitment_no_status_check() next which will reset this to RAAFirst.
Expand Down
Loading
, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
Track claimed outbound HTLCs in ChannelMonitors by TheBlueMatt · Pull Request #2048 · lightningdevkit/rust-lightning · GitHub
Skip to content
Track claimed outbound HTLCs in ChannelMonitors#2048

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

TheBlueMatt
merged 3 commits into

from

Mar 3, 2023
 Merged


Track claimed outbound HTLCs in ChannelMonitors
#2048
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


3 commits


Select commit
Hold shift + click to select a range
33c36d0

Avoid removing stale preimages when hashes collide in fuzzing


TheBlueMatt Mar 2, 2023
0ad1f4c

Track claimed outbound HTLCs in ChannelMonitors


TheBlueMatt Feb 22, 2023
75527db

Remove unused compat block in `provide_latest_holder_commitment_tx`


TheBlueMatt Mar 1, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


125 changes: 87 additions & 38 deletions
lightning/src/chain/channelmonitor.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -37,7 +37,7 @@ use crate::ln::{PaymentHash, PaymentPreimage};
use crate::ln::msgs::DecodeError;
use crate::ln::chan_utils;
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HTLCClaim, ChannelTransactionParameters, HolderCommitmentTransaction};
use crate::ln::channelmanager::HTLCSource;
use crate::ln::channelmanager::{HTLCSource, SentHTLCId};
use crate::chain;
use crate::chain::{BestBlock, WatchedOutput};
use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator, LowerBoundedFeeEstimator};
Expand DownExpand Up@@ -494,6 +494,7 @@ pub(crate) enum ChannelMonitorUpdateStep {
	LatestHolderCommitmentTXInfo {
 commitment_tx: HolderCommitmentTransaction,
 htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
 claimed_htlcs: Vec<(SentHTLCId, PaymentPreimage)>,
Comment thread
wpaulino marked this conversation as resolved.

	},
	LatestCounterpartyCommitmentTXInfo {
 commitment_txid: Txid,
Expand DownExpand Up@@ -536,6 +537,7 @@ impl ChannelMonitorUpdateStep {
impl_writeable_tlv_based_enum_upgradable!(ChannelMonitorUpdateStep,
	(0, LatestHolderCommitmentTXInfo) => {
 (0, commitment_tx, required),
 (1, claimed_htlcs, vec_type),
 (2, htlc_outputs, vec_type),
	},
	(1, LatestCounterpartyCommitmentTXInfo) => {
Expand DownExpand Up@@ -750,6 +752,8 @@ pub(crate) struct ChannelMonitorImpl<Signer: WriteableEcdsaChannelSigner> {
	/// Serialized to disk but should generally not be sent to Watchtowers.
	counterparty_hash_commitment_number: HashMap<PaymentHash, u64>,

	counterparty_fulfilled_htlcs: HashMap<SentHTLCId, PaymentPreimage>,

	// We store two holder commitment transactions to avoid any race conditions where we may update
	// some monitors (potentially on watchtowers) but then fail to update others, resulting in the
	// various monitors for one channel being out of sync, and us broadcasting a holder
Expand DownExpand Up@@ -1033,6 +1037,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for ChannelMonitorImpl<Signe
 (9, self.counterparty_node_id, option),
 (11, self.confirmed_commitment_tx_counterparty_output, option),
 (13, self.spendable_txids_confirmed, vec_type),
 (15, self.counterparty_fulfilled_htlcs, required),
 });

 Ok(())
Expand DownExpand Up@@ -1120,6 +1125,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 counterparty_claimable_outpoints: HashMap::new(),
 counterparty_commitment_txn_on_chain: HashMap::new(),
 counterparty_hash_commitment_number: HashMap::new(),
 counterparty_fulfilled_htlcs: HashMap::new(),

 prev_holder_signed_commitment_tx: None,
 current_holder_commitment_tx: holder_commitment_tx,
Expand DownExpand Up@@ -1174,7 +1180,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 &self, holder_commitment_tx: HolderCommitmentTransaction,
 htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
	) -> Result<(), ()> {
 self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs).map_err(|_| ())
 self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs, &Vec::new()).map_err(|_| ())
	}

	/// This is used to provide payment preimage(s) out-of-band during startup without updating the
Expand DownExpand Up@@ -1810,9 +1816,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
	/// `ChannelMonitor`. This is used to determine if an HTLC was removed from the channel prior
	/// to the `ChannelManager` having been persisted.
	///
	/// This is similar to [`Self::get_pending_outbound_htlcs`] except it includes HTLCs which were
	/// resolved by this `ChannelMonitor`.
	pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
	/// This is similar to [`Self::get_pending_or_resolved_outbound_htlcs`] except it includes
	/// HTLCs which were resolved on-chain (i.e. where the final HTLC resolution was done by an
	/// event from this `ChannelMonitor`).
	pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
 let mut res = HashMap::new();
 // Just examine the available counterparty commitment transactions. See docs on
 // `fail_unbroadcast_htlcs`, below, for justification.
Expand All@@ -1822,7 +1829,8 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 if let Some(ref latest_outpoints) = us.counterparty_claimable_outpoints.get($txid) {
 for &(ref htlc, ref source_option) in latest_outpoints.iter() {
 if let &Some(ref source) = source_option {
 res.insert((**source).clone(), htlc.clone());
 res.insert((**source).clone(), (htlc.clone(),
 us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned()));
 }
 }
 }
Expand All@@ -1837,9 +1845,14 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 res
	}

	/// Gets the set of outbound HTLCs which are pending resolution in this channel.
	/// Gets the set of outbound HTLCs which are pending resolution in this channel or which were
	/// resolved with a preimage from our counterparty.
	///
	/// This is used to reconstruct pending outbound payments on restart in the ChannelManager.
	pub(crate) fn get_pending_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
	///
	/// Currently, the preimage is unused, however if it is present in the relevant internal state
	/// an HTLC is always included even if it has been resolved.
	pub(crate) fn get_pending_or_resolved_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
Comment thread
wpaulino marked this conversation as resolved.

 let us = self.inner.lock().unwrap();
 // We're only concerned with the confirmation count of HTLC transactions, and don't
 // actually care how many confirmations a commitment transaction may or may not have. Thus,
Expand DownExpand Up@@ -1887,8 +1900,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 Some(commitment_tx_output_idx) == htlc.transaction_output_index
 } else { false }
 });
 if !htlc_update_confd {
 res.insert(source.clone(), htlc.clone());
Comment thread
wpaulino marked this conversation as resolved.

 let counterparty_resolved_preimage_opt =
 us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned();
 if !htlc_update_confd || counterparty_resolved_preimage_opt.is_some() {
 res.insert(source.clone(), (htlc.clone(), counterparty_resolved_preimage_opt));
 }
 }
 }
Expand DownExpand Up@@ -1970,6 +1985,9 @@ macro_rules! fail_unbroadcast_htlcs {
 }
 }
 if matched_htlc { continue; }
 if $self.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).is_some() {
 continue;
 }
Comment thread
wpaulino marked this conversation as resolved.

 $self.onchain_events_awaiting_threshold_conf.retain(|ref entry| {
 if entry.height != $commitment_tx_conf_height { return true; }
 match entry.event {
Expand DownExpand Up@@ -2041,8 +2059,23 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 // Prune HTLCs from the previous counterparty commitment tx so we don't generate failure/fulfill
 // events for now-revoked/fulfilled HTLCs.
 if let Some(txid) = self.prev_counterparty_commitment_txid.take() {
 for &mut (_, ref mut source) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
 *source = None;
 if self.current_counterparty_commitment_txid.unwrap() != txid {
 let cur_claimables = self.counterparty_claimable_outpoints.get(
 &self.current_counterparty_commitment_txid.unwrap()).unwrap();
 for (_, ref source_opt) in self.counterparty_claimable_outpoints.get(&txid).unwrap() {
 if let Some(source) = source_opt {
 if !cur_claimables.iter()
 .any(|(_, cur_source_opt)| cur_source_opt == source_opt)
 {
 self.counterparty_fulfilled_htlcs.remove(&SentHTLCId::from_source(source));
 }
 }
 }
 for &mut (_, ref mut source_opt) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
 *source_opt = None;
 }
Comment thread
valentinewallace marked this conversation as resolved.

 } else {
 assert!(cfg!(fuzzing), "Commitment txids are unique outside of fuzzing, where hashes can collide");
 }
 }

Expand DownExpand Up@@ -2127,28 +2160,37 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
	/// is important that any clones of this channel monitor (including remote clones) by kept
	/// up-to-date as our holder commitment transaction is updated.
	/// Panics if set_on_holder_tx_csv has never been called.
	fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>) -> Result<(), &'static str> {
 // block for Rust 1.34 compat
 let mut new_holder_commitment_tx = {
 let trusted_tx = holder_commitment_tx.trust();
 let txid = trusted_tx.txid();
 let tx_keys = trusted_tx.keys();
 self.current_holder_commitment_number = trusted_tx.commitment_number();
 HolderSignedTx {
 txid,
 revocation_key: tx_keys.revocation_key,
 a_htlc_key: tx_keys.broadcaster_htlc_key,
 b_htlc_key: tx_keys.countersignatory_htlc_key,
 delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 per_commitment_point: tx_keys.per_commitment_point,
 htlc_outputs,
 to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
 feerate_per_kw: trusted_tx.feerate_per_kw(),
 }
	fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>, claimed_htlcs: &[(SentHTLCId, PaymentPreimage)]) -> Result<(), &'static str> {
 let trusted_tx = holder_commitment_tx.trust();
 let txid = trusted_tx.txid();
 let tx_keys = trusted_tx.keys();
 self.current_holder_commitment_number = trusted_tx.commitment_number();
 let mut new_holder_commitment_tx = HolderSignedTx {
 txid,
 revocation_key: tx_keys.revocation_key,
 a_htlc_key: tx_keys.broadcaster_htlc_key,
 b_htlc_key: tx_keys.countersignatory_htlc_key,
 delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 per_commitment_point: tx_keys.per_commitment_point,
 htlc_outputs,
 to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
 feerate_per_kw: trusted_tx.feerate_per_kw(),
 };
 self.onchain_tx_handler.provide_latest_holder_tx(holder_commitment_tx);
 mem::swap(&mut new_holder_commitment_tx, &mut self.current_holder_commitment_tx);
 self.prev_holder_signed_commitment_tx = Some(new_holder_commitment_tx);
 for (claimed_htlc_id, claimed_preimage) in claimed_htlcs {
 #[cfg(debug_assertions)] {
 let cur_counterparty_htlcs = self.counterparty_claimable_outpoints.get(
 &self.current_counterparty_commitment_txid.unwrap()).unwrap();
 assert!(cur_counterparty_htlcs.iter().any(|(_, source_opt)| {
 if let Some(source) = source_opt {
 SentHTLCId::from_source(source) == *claimed_htlc_id
 } else { false }
 }));
 }
 self.counterparty_fulfilled_htlcs.insert(*claimed_htlc_id, *claimed_preimage);
 }
 if self.holder_tx_signed {
 return Err("Latest holder commitment signed has already been signed, update is rejected");
 }
Expand DownExpand Up@@ -2243,10 +2285,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&*fee_estimator);
 for update in updates.updates.iter() {
 match update {
 ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs } => {
 ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs, claimed_htlcs } => {
 log_trace!(logger, "Updating ChannelMonitor with latest holder commitment transaction info");
 if self.lockdown_from_offchain { panic!(); }
 if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone()) {
 if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone(), &claimed_htlcs) {
 log_error!(logger, "Providing latest holder commitment transaction failed/was refused:");
 log_error!(logger, " {}", e);
 ret = Err(());
Expand DownExpand Up@@ -3868,6 +3910,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 let mut counterparty_node_id = None;
 let mut confirmed_commitment_tx_counterparty_output = None;
 let mut spendable_txids_confirmed = Some(Vec::new());
 let mut counterparty_fulfilled_htlcs = Some(HashMap::new());
 read_tlv_fields!(reader, {
 (1, funding_spend_confirmed, option),
 (3, htlcs_resolved_on_chain, vec_type),
Expand All@@ -3876,6 +3919,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 (9, counterparty_node_id, option),
 (11, confirmed_commitment_tx_counterparty_output, option),
 (13, spendable_txids_confirmed, vec_type),
 (15, counterparty_fulfilled_htlcs, option),
 });

 Ok((best_block.block_hash(), ChannelMonitor::from_impl(ChannelMonitorImpl {
Expand DownExpand Up@@ -3904,6 +3948,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 counterparty_claimable_outpoints,
 counterparty_commitment_txn_on_chain,
 counterparty_hash_commitment_number,
 counterparty_fulfilled_htlcs: counterparty_fulfilled_htlcs.unwrap(),

 prev_holder_signed_commitment_tx,
 current_holder_commitment_tx,
Expand DownExpand Up@@ -4077,7 +4122,6 @@ mod tests {
 let fee_estimator = TestFeeEstimator { sat_per_kw: Mutex::new(253) };

 let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
 let dummy_tx = Transaction { version: 0, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() };

 let mut preimages = Vec::new();
 {
Expand DownExpand Up@@ -4167,11 +4211,10 @@ mod tests {
 HolderCommitmentTransaction::dummy(), best_block, dummy_key);

 monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..10])).unwrap();
 let dummy_txid = dummy_tx.txid();
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"1").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"2").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 for &(ref preimage, ref hash) in preimages.iter() {
 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_estimator);
 monitor.provide_payment_preimage(hash, preimage, &broadcaster, &bounded_fee_estimator, &logger);
Expand All@@ -4185,13 +4228,19 @@ mod tests {
 test_preimages_exist!(&preimages[0..10], monitor);
 test_preimages_exist!(&preimages[15..20], monitor);

 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"3").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);

 // Now provide a further secret, pruning preimages 15-17
 secret[0..32].clone_from_slice(&hex::decode("c7518c8ae4660ed02894df8976fa1a3659c1a8b4b5bec0c4b872abeba4cb8964").unwrap());
 monitor.provide_secret(281474976710654, secret.clone()).unwrap();
 assert_eq!(monitor.inner.lock().unwrap().payment_preimages.len(), 13);
 test_preimages_exist!(&preimages[0..10], monitor);
 test_preimages_exist!(&preimages[17..20], monitor);

 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"4").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);

 // Now update holder commitment tx info, pruning only element 18 as we still care about the
 // previous commitment tx's preimages too
 monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..5])).unwrap();
Expand Down

32 changes: 22 additions & 10 deletions
lightning/src/ln/channel.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -27,7 +27,7 @@ use crate::ln::features::{ChannelTypeFeatures, InitFeatures};
use crate::ln::msgs;
use crate::ln::msgs::{DecodeError, OptionalField, DataLossProtect};
use crate::ln::script::{self, ShutdownScript};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, SentHTLCId, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, TxCreationKeys, HTLCOutputInCommitment, htlc_success_tx_weight, htlc_timeout_tx_weight, make_funding_redeemscript, ChannelPublicKeys, CommitmentTransaction, HolderCommitmentTransaction, ChannelTransactionParameters, CounterpartyChannelTransactionParameters, MAX_HTLCS, get_commitment_transaction_number_obscure_factor, ClosingTransaction};
use crate::ln::chan_utils;
use crate::ln::onion_utils::HTLCFailReason;
Expand DownExpand Up@@ -192,6 +192,7 @@ enum OutboundHTLCState {

#[derive(Clone)]
enum OutboundHTLCOutcome {
	/// LDK version 0.0.105+ will always fill in the preimage here.
	Success(Option<PaymentPreimage>),
	Failure(HTLCFailReason),
}
Expand DownExpand Up@@ -3159,15 +3160,6 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 }
 }

 self.latest_monitor_update_id += 1;
 let mut monitor_update = ChannelMonitorUpdate {
 update_id: self.latest_monitor_update_id,
 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
 commitment_tx: holder_commitment_tx,
 htlc_outputs: htlcs_and_sigs
 }]
 };

 for htlc in self.pending_inbound_htlcs.iter_mut() {
 let new_forward = if let &InboundHTLCState::RemoteAnnounced(ref forward_info) = &htlc.state {
 Some(forward_info.clone())
Expand All@@ -3179,18 +3171,38 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 need_commitment = true;
 }
 }
 let mut claimed_htlcs = Vec::new();
 for htlc in self.pending_outbound_htlcs.iter_mut() {
 if let &mut OutboundHTLCState::RemoteRemoved(ref mut outcome) = &mut htlc.state {
 log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToRemove due to commitment_signed in channel {}.",
 log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id));
 // Grab the preimage, if it exists, instead of cloning
 let mut reason = OutboundHTLCOutcome::Success(None);
 mem::swap(outcome, &mut reason);
 if let OutboundHTLCOutcome::Success(Some(preimage)) = reason {
 // If a user (a) receives an HTLC claim using LDK 0.0.104 or before, then (b)
 // upgrades to LDK 0.0.114 or later before the HTLC is fully resolved, we could
 // have a `Success(None)` reason. In this case we could forget some HTLC
 // claims, but such an upgrade is unlikely and including claimed HTLCs here
 // fixes a bug which the user was exposed to on 0.0.104 when they started the
 // claim anyway.
 claimed_htlcs.push((SentHTLCId::from_source(&htlc.source), preimage));
 }
 htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(reason);
 need_commitment = true;
 }
 }

 self.latest_monitor_update_id += 1;
 let mut monitor_update = ChannelMonitorUpdate {
 update_id: self.latest_monitor_update_id,
 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
 commitment_tx: holder_commitment_tx,
 htlc_outputs: htlcs_and_sigs,
 claimed_htlcs,
 }]
 };

 self.cur_holder_commitment_transaction_number -= 1;
 // Note that if we need_commitment & !AwaitingRemoteRevoke we'll call
 // build_commitment_no_status_check() next which will reset this to RAAFirst.
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Track claimed outbound HTLCs in ChannelMonitors by TheBlueMatt · Pull Request #2048 · lightningdevkit/rust-lightning · GitHub
Skip to content
Track claimed outbound HTLCs in ChannelMonitors#2048

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

TheBlueMatt
merged 3 commits into

from

Mar 3, 2023
 Merged


Track claimed outbound HTLCs in ChannelMonitors
#2048
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


3 commits


Select commit
Hold shift + click to select a range
33c36d0

Avoid removing stale preimages when hashes collide in fuzzing


TheBlueMatt Mar 2, 2023
0ad1f4c

Track claimed outbound HTLCs in ChannelMonitors


TheBlueMatt Feb 22, 2023
75527db

Remove unused compat block in `provide_latest_holder_commitment_tx`


TheBlueMatt Mar 1, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


125 changes: 87 additions & 38 deletions
lightning/src/chain/channelmonitor.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -37,7 +37,7 @@ use crate::ln::{PaymentHash, PaymentPreimage};
use crate::ln::msgs::DecodeError;
use crate::ln::chan_utils;
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HTLCClaim, ChannelTransactionParameters, HolderCommitmentTransaction};
use crate::ln::channelmanager::HTLCSource;
use crate::ln::channelmanager::{HTLCSource, SentHTLCId};
use crate::chain;
use crate::chain::{BestBlock, WatchedOutput};
use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator, LowerBoundedFeeEstimator};
Expand DownExpand Up@@ -494,6 +494,7 @@ pub(crate) enum ChannelMonitorUpdateStep {
	LatestHolderCommitmentTXInfo {
 commitment_tx: HolderCommitmentTransaction,
 htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
 claimed_htlcs: Vec<(SentHTLCId, PaymentPreimage)>,
Comment thread
wpaulino marked this conversation as resolved.

	},
	LatestCounterpartyCommitmentTXInfo {
 commitment_txid: Txid,
Expand DownExpand Up@@ -536,6 +537,7 @@ impl ChannelMonitorUpdateStep {
impl_writeable_tlv_based_enum_upgradable!(ChannelMonitorUpdateStep,
	(0, LatestHolderCommitmentTXInfo) => {
 (0, commitment_tx, required),
 (1, claimed_htlcs, vec_type),
 (2, htlc_outputs, vec_type),
	},
	(1, LatestCounterpartyCommitmentTXInfo) => {
Expand DownExpand Up@@ -750,6 +752,8 @@ pub(crate) struct ChannelMonitorImpl<Signer: WriteableEcdsaChannelSigner> {
	/// Serialized to disk but should generally not be sent to Watchtowers.
	counterparty_hash_commitment_number: HashMap<PaymentHash, u64>,

	counterparty_fulfilled_htlcs: HashMap<SentHTLCId, PaymentPreimage>,

	// We store two holder commitment transactions to avoid any race conditions where we may update
	// some monitors (potentially on watchtowers) but then fail to update others, resulting in the
	// various monitors for one channel being out of sync, and us broadcasting a holder
Expand DownExpand Up@@ -1033,6 +1037,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for ChannelMonitorImpl<Signe
 (9, self.counterparty_node_id, option),
 (11, self.confirmed_commitment_tx_counterparty_output, option),
 (13, self.spendable_txids_confirmed, vec_type),
 (15, self.counterparty_fulfilled_htlcs, required),
 });

 Ok(())
Expand DownExpand Up@@ -1120,6 +1125,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 counterparty_claimable_outpoints: HashMap::new(),
 counterparty_commitment_txn_on_chain: HashMap::new(),
 counterparty_hash_commitment_number: HashMap::new(),
 counterparty_fulfilled_htlcs: HashMap::new(),

 prev_holder_signed_commitment_tx: None,
 current_holder_commitment_tx: holder_commitment_tx,
Expand DownExpand Up@@ -1174,7 +1180,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 &self, holder_commitment_tx: HolderCommitmentTransaction,
 htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
	) -> Result<(), ()> {
 self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs).map_err(|_| ())
 self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs, &Vec::new()).map_err(|_| ())
	}

	/// This is used to provide payment preimage(s) out-of-band during startup without updating the
Expand DownExpand Up@@ -1810,9 +1816,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
	/// `ChannelMonitor`. This is used to determine if an HTLC was removed from the channel prior
	/// to the `ChannelManager` having been persisted.
	///
	/// This is similar to [`Self::get_pending_outbound_htlcs`] except it includes HTLCs which were
	/// resolved by this `ChannelMonitor`.
	pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
	/// This is similar to [`Self::get_pending_or_resolved_outbound_htlcs`] except it includes
	/// HTLCs which were resolved on-chain (i.e. where the final HTLC resolution was done by an
	/// event from this `ChannelMonitor`).
	pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
 let mut res = HashMap::new();
 // Just examine the available counterparty commitment transactions. See docs on
 // `fail_unbroadcast_htlcs`, below, for justification.
Expand All@@ -1822,7 +1829,8 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 if let Some(ref latest_outpoints) = us.counterparty_claimable_outpoints.get($txid) {
 for &(ref htlc, ref source_option) in latest_outpoints.iter() {
 if let &Some(ref source) = source_option {
 res.insert((**source).clone(), htlc.clone());
 res.insert((**source).clone(), (htlc.clone(),
 us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned()));
 }
 }
 }
Expand All@@ -1837,9 +1845,14 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 res
	}

	/// Gets the set of outbound HTLCs which are pending resolution in this channel.
	/// Gets the set of outbound HTLCs which are pending resolution in this channel or which were
	/// resolved with a preimage from our counterparty.
	///
	/// This is used to reconstruct pending outbound payments on restart in the ChannelManager.
	pub(crate) fn get_pending_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
	///
	/// Currently, the preimage is unused, however if it is present in the relevant internal state
	/// an HTLC is always included even if it has been resolved.
	pub(crate) fn get_pending_or_resolved_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
Comment thread
wpaulino marked this conversation as resolved.

 let us = self.inner.lock().unwrap();
 // We're only concerned with the confirmation count of HTLC transactions, and don't
 // actually care how many confirmations a commitment transaction may or may not have. Thus,
Expand DownExpand Up@@ -1887,8 +1900,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 Some(commitment_tx_output_idx) == htlc.transaction_output_index
 } else { false }
 });
 if !htlc_update_confd {
 res.insert(source.clone(), htlc.clone());
Comment thread
wpaulino marked this conversation as resolved.

 let counterparty_resolved_preimage_opt =
 us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned();
 if !htlc_update_confd || counterparty_resolved_preimage_opt.is_some() {
 res.insert(source.clone(), (htlc.clone(), counterparty_resolved_preimage_opt));
 }
 }
 }
Expand DownExpand Up@@ -1970,6 +1985,9 @@ macro_rules! fail_unbroadcast_htlcs {
 }
 }
 if matched_htlc { continue; }
 if $self.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).is_some() {
 continue;
 }
Comment thread
wpaulino marked this conversation as resolved.

 $self.onchain_events_awaiting_threshold_conf.retain(|ref entry| {
 if entry.height != $commitment_tx_conf_height { return true; }
 match entry.event {
Expand DownExpand Up@@ -2041,8 +2059,23 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 // Prune HTLCs from the previous counterparty commitment tx so we don't generate failure/fulfill
 // events for now-revoked/fulfilled HTLCs.
 if let Some(txid) = self.prev_counterparty_commitment_txid.take() {
 for &mut (_, ref mut source) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
 *source = None;
 if self.current_counterparty_commitment_txid.unwrap() != txid {
 let cur_claimables = self.counterparty_claimable_outpoints.get(
 &self.current_counterparty_commitment_txid.unwrap()).unwrap();
 for (_, ref source_opt) in self.counterparty_claimable_outpoints.get(&txid).unwrap() {
 if let Some(source) = source_opt {
 if !cur_claimables.iter()
 .any(|(_, cur_source_opt)| cur_source_opt == source_opt)
 {
 self.counterparty_fulfilled_htlcs.remove(&SentHTLCId::from_source(source));
 }
 }
 }
 for &mut (_, ref mut source_opt) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
 *source_opt = None;
 }
Comment thread
valentinewallace marked this conversation as resolved.

 } else {
 assert!(cfg!(fuzzing), "Commitment txids are unique outside of fuzzing, where hashes can collide");
 }
 }

Expand DownExpand Up@@ -2127,28 +2160,37 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
	/// is important that any clones of this channel monitor (including remote clones) by kept
	/// up-to-date as our holder commitment transaction is updated.
	/// Panics if set_on_holder_tx_csv has never been called.
	fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>) -> Result<(), &'static str> {
 // block for Rust 1.34 compat
 let mut new_holder_commitment_tx = {
 let trusted_tx = holder_commitment_tx.trust();
 let txid = trusted_tx.txid();
 let tx_keys = trusted_tx.keys();
 self.current_holder_commitment_number = trusted_tx.commitment_number();
 HolderSignedTx {
 txid,
 revocation_key: tx_keys.revocation_key,
 a_htlc_key: tx_keys.broadcaster_htlc_key,
 b_htlc_key: tx_keys.countersignatory_htlc_key,
 delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 per_commitment_point: tx_keys.per_commitment_point,
 htlc_outputs,
 to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
 feerate_per_kw: trusted_tx.feerate_per_kw(),
 }
	fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>, claimed_htlcs: &[(SentHTLCId, PaymentPreimage)]) -> Result<(), &'static str> {
 let trusted_tx = holder_commitment_tx.trust();
 let txid = trusted_tx.txid();
 let tx_keys = trusted_tx.keys();
 self.current_holder_commitment_number = trusted_tx.commitment_number();
 let mut new_holder_commitment_tx = HolderSignedTx {
 txid,
 revocation_key: tx_keys.revocation_key,
 a_htlc_key: tx_keys.broadcaster_htlc_key,
 b_htlc_key: tx_keys.countersignatory_htlc_key,
 delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 per_commitment_point: tx_keys.per_commitment_point,
 htlc_outputs,
 to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
 feerate_per_kw: trusted_tx.feerate_per_kw(),
 };
 self.onchain_tx_handler.provide_latest_holder_tx(holder_commitment_tx);
 mem::swap(&mut new_holder_commitment_tx, &mut self.current_holder_commitment_tx);
 self.prev_holder_signed_commitment_tx = Some(new_holder_commitment_tx);
 for (claimed_htlc_id, claimed_preimage) in claimed_htlcs {
 #[cfg(debug_assertions)] {
 let cur_counterparty_htlcs = self.counterparty_claimable_outpoints.get(
 &self.current_counterparty_commitment_txid.unwrap()).unwrap();
 assert!(cur_counterparty_htlcs.iter().any(|(_, source_opt)| {
 if let Some(source) = source_opt {
 SentHTLCId::from_source(source) == *claimed_htlc_id
 } else { false }
 }));
 }
 self.counterparty_fulfilled_htlcs.insert(*claimed_htlc_id, *claimed_preimage);
 }
 if self.holder_tx_signed {
 return Err("Latest holder commitment signed has already been signed, update is rejected");
 }
Expand DownExpand Up@@ -2243,10 +2285,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&*fee_estimator);
 for update in updates.updates.iter() {
 match update {
 ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs } => {
 ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs, claimed_htlcs } => {
 log_trace!(logger, "Updating ChannelMonitor with latest holder commitment transaction info");
 if self.lockdown_from_offchain { panic!(); }
 if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone()) {
 if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone(), &claimed_htlcs) {
 log_error!(logger, "Providing latest holder commitment transaction failed/was refused:");
 log_error!(logger, " {}", e);
 ret = Err(());
Expand DownExpand Up@@ -3868,6 +3910,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 let mut counterparty_node_id = None;
 let mut confirmed_commitment_tx_counterparty_output = None;
 let mut spendable_txids_confirmed = Some(Vec::new());
 let mut counterparty_fulfilled_htlcs = Some(HashMap::new());
 read_tlv_fields!(reader, {
 (1, funding_spend_confirmed, option),
 (3, htlcs_resolved_on_chain, vec_type),
Expand All@@ -3876,6 +3919,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 (9, counterparty_node_id, option),
 (11, confirmed_commitment_tx_counterparty_output, option),
 (13, spendable_txids_confirmed, vec_type),
 (15, counterparty_fulfilled_htlcs, option),
 });

 Ok((best_block.block_hash(), ChannelMonitor::from_impl(ChannelMonitorImpl {
Expand DownExpand Up@@ -3904,6 +3948,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 counterparty_claimable_outpoints,
 counterparty_commitment_txn_on_chain,
 counterparty_hash_commitment_number,
 counterparty_fulfilled_htlcs: counterparty_fulfilled_htlcs.unwrap(),

 prev_holder_signed_commitment_tx,
 current_holder_commitment_tx,
Expand DownExpand Up@@ -4077,7 +4122,6 @@ mod tests {
 let fee_estimator = TestFeeEstimator { sat_per_kw: Mutex::new(253) };

 let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
 let dummy_tx = Transaction { version: 0, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() };

 let mut preimages = Vec::new();
 {
Expand DownExpand Up@@ -4167,11 +4211,10 @@ mod tests {
 HolderCommitmentTransaction::dummy(), best_block, dummy_key);

 monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..10])).unwrap();
 let dummy_txid = dummy_tx.txid();
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"1").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"2").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 for &(ref preimage, ref hash) in preimages.iter() {
 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_estimator);
 monitor.provide_payment_preimage(hash, preimage, &broadcaster, &bounded_fee_estimator, &logger);
Expand All@@ -4185,13 +4228,19 @@ mod tests {
 test_preimages_exist!(&preimages[0..10], monitor);
 test_preimages_exist!(&preimages[15..20], monitor);

 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"3").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);

 // Now provide a further secret, pruning preimages 15-17
 secret[0..32].clone_from_slice(&hex::decode("c7518c8ae4660ed02894df8976fa1a3659c1a8b4b5bec0c4b872abeba4cb8964").unwrap());
 monitor.provide_secret(281474976710654, secret.clone()).unwrap();
 assert_eq!(monitor.inner.lock().unwrap().payment_preimages.len(), 13);
 test_preimages_exist!(&preimages[0..10], monitor);
 test_preimages_exist!(&preimages[17..20], monitor);

 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"4").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);

 // Now update holder commitment tx info, pruning only element 18 as we still care about the
 // previous commitment tx's preimages too
 monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..5])).unwrap();
Expand Down

32 changes: 22 additions & 10 deletions
lightning/src/ln/channel.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -27,7 +27,7 @@ use crate::ln::features::{ChannelTypeFeatures, InitFeatures};
use crate::ln::msgs;
use crate::ln::msgs::{DecodeError, OptionalField, DataLossProtect};
use crate::ln::script::{self, ShutdownScript};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, SentHTLCId, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, TxCreationKeys, HTLCOutputInCommitment, htlc_success_tx_weight, htlc_timeout_tx_weight, make_funding_redeemscript, ChannelPublicKeys, CommitmentTransaction, HolderCommitmentTransaction, ChannelTransactionParameters, CounterpartyChannelTransactionParameters, MAX_HTLCS, get_commitment_transaction_number_obscure_factor, ClosingTransaction};
use crate::ln::chan_utils;
use crate::ln::onion_utils::HTLCFailReason;
Expand DownExpand Up@@ -192,6 +192,7 @@ enum OutboundHTLCState {

#[derive(Clone)]
enum OutboundHTLCOutcome {
	/// LDK version 0.0.105+ will always fill in the preimage here.
	Success(Option<PaymentPreimage>),
	Failure(HTLCFailReason),
}
Expand DownExpand Up@@ -3159,15 +3160,6 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 }
 }

 self.latest_monitor_update_id += 1;
 let mut monitor_update = ChannelMonitorUpdate {
 update_id: self.latest_monitor_update_id,
 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
 commitment_tx: holder_commitment_tx,
 htlc_outputs: htlcs_and_sigs
 }]
 };

 for htlc in self.pending_inbound_htlcs.iter_mut() {
 let new_forward = if let &InboundHTLCState::RemoteAnnounced(ref forward_info) = &htlc.state {
 Some(forward_info.clone())
Expand All@@ -3179,18 +3171,38 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 need_commitment = true;
 }
 }
 let mut claimed_htlcs = Vec::new();
 for htlc in self.pending_outbound_htlcs.iter_mut() {
 if let &mut OutboundHTLCState::RemoteRemoved(ref mut outcome) = &mut htlc.state {
 log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToRemove due to commitment_signed in channel {}.",
 log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id));
 // Grab the preimage, if it exists, instead of cloning
 let mut reason = OutboundHTLCOutcome::Success(None);
 mem::swap(outcome, &mut reason);
 if let OutboundHTLCOutcome::Success(Some(preimage)) = reason {
 // If a user (a) receives an HTLC claim using LDK 0.0.104 or before, then (b)
 // upgrades to LDK 0.0.114 or later before the HTLC is fully resolved, we could
 // have a `Success(None)` reason. In this case we could forget some HTLC
 // claims, but such an upgrade is unlikely and including claimed HTLCs here
 // fixes a bug which the user was exposed to on 0.0.104 when they started the
 // claim anyway.
 claimed_htlcs.push((SentHTLCId::from_source(&htlc.source), preimage));
 }
 htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(reason);
 need_commitment = true;
 }
 }

 self.latest_monitor_update_id += 1;
 let mut monitor_update = ChannelMonitorUpdate {
 update_id: self.latest_monitor_update_id,
 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
 commitment_tx: holder_commitment_tx,
 htlc_outputs: htlcs_and_sigs,
 claimed_htlcs,
 }]
 };

 self.cur_holder_commitment_transaction_number -= 1;
 // Note that if we need_commitment & !AwaitingRemoteRevoke we'll call
 // build_commitment_no_status_check() next which will reset this to RAAFirst.
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Track claimed outbound HTLCs in ChannelMonitors by TheBlueMatt · Pull Request #2048 · lightningdevkit/rust-lightning · GitHub
Skip to content
Track claimed outbound HTLCs in ChannelMonitors#2048

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

TheBlueMatt
merged 3 commits into

from

Mar 3, 2023
 Merged


Track claimed outbound HTLCs in ChannelMonitors
#2048
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


3 commits


Select commit
Hold shift + click to select a range
33c36d0

Avoid removing stale preimages when hashes collide in fuzzing


TheBlueMatt Mar 2, 2023
0ad1f4c

Track claimed outbound HTLCs in ChannelMonitors


TheBlueMatt Feb 22, 2023
75527db

Remove unused compat block in `provide_latest_holder_commitment_tx`


TheBlueMatt Mar 1, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


125 changes: 87 additions & 38 deletions
lightning/src/chain/channelmonitor.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -37,7 +37,7 @@ use crate::ln::{PaymentHash, PaymentPreimage};
use crate::ln::msgs::DecodeError;
use crate::ln::chan_utils;
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HTLCClaim, ChannelTransactionParameters, HolderCommitmentTransaction};
use crate::ln::channelmanager::HTLCSource;
use crate::ln::channelmanager::{HTLCSource, SentHTLCId};
use crate::chain;
use crate::chain::{BestBlock, WatchedOutput};
use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator, LowerBoundedFeeEstimator};
Expand DownExpand Up@@ -494,6 +494,7 @@ pub(crate) enum ChannelMonitorUpdateStep {
	LatestHolderCommitmentTXInfo {
 commitment_tx: HolderCommitmentTransaction,
 htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
 claimed_htlcs: Vec<(SentHTLCId, PaymentPreimage)>,
Comment thread
wpaulino marked this conversation as resolved.

	},
	LatestCounterpartyCommitmentTXInfo {
 commitment_txid: Txid,
Expand DownExpand Up@@ -536,6 +537,7 @@ impl ChannelMonitorUpdateStep {
impl_writeable_tlv_based_enum_upgradable!(ChannelMonitorUpdateStep,
	(0, LatestHolderCommitmentTXInfo) => {
 (0, commitment_tx, required),
 (1, claimed_htlcs, vec_type),
 (2, htlc_outputs, vec_type),
	},
	(1, LatestCounterpartyCommitmentTXInfo) => {
Expand DownExpand Up@@ -750,6 +752,8 @@ pub(crate) struct ChannelMonitorImpl<Signer: WriteableEcdsaChannelSigner> {
	/// Serialized to disk but should generally not be sent to Watchtowers.
	counterparty_hash_commitment_number: HashMap<PaymentHash, u64>,

	counterparty_fulfilled_htlcs: HashMap<SentHTLCId, PaymentPreimage>,

	// We store two holder commitment transactions to avoid any race conditions where we may update
	// some monitors (potentially on watchtowers) but then fail to update others, resulting in the
	// various monitors for one channel being out of sync, and us broadcasting a holder
Expand DownExpand Up@@ -1033,6 +1037,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for ChannelMonitorImpl<Signe
 (9, self.counterparty_node_id, option),
 (11, self.confirmed_commitment_tx_counterparty_output, option),
 (13, self.spendable_txids_confirmed, vec_type),
 (15, self.counterparty_fulfilled_htlcs, required),
 });

 Ok(())
Expand DownExpand Up@@ -1120,6 +1125,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 counterparty_claimable_outpoints: HashMap::new(),
 counterparty_commitment_txn_on_chain: HashMap::new(),
 counterparty_hash_commitment_number: HashMap::new(),
 counterparty_fulfilled_htlcs: HashMap::new(),

 prev_holder_signed_commitment_tx: None,
 current_holder_commitment_tx: holder_commitment_tx,
Expand DownExpand Up@@ -1174,7 +1180,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 &self, holder_commitment_tx: HolderCommitmentTransaction,
 htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
	) -> Result<(), ()> {
 self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs).map_err(|_| ())
 self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs, &Vec::new()).map_err(|_| ())
	}

	/// This is used to provide payment preimage(s) out-of-band during startup without updating the
Expand DownExpand Up@@ -1810,9 +1816,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
	/// `ChannelMonitor`. This is used to determine if an HTLC was removed from the channel prior
	/// to the `ChannelManager` having been persisted.
	///
	/// This is similar to [`Self::get_pending_outbound_htlcs`] except it includes HTLCs which were
	/// resolved by this `ChannelMonitor`.
	pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
	/// This is similar to [`Self::get_pending_or_resolved_outbound_htlcs`] except it includes
	/// HTLCs which were resolved on-chain (i.e. where the final HTLC resolution was done by an
	/// event from this `ChannelMonitor`).
	pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
 let mut res = HashMap::new();
 // Just examine the available counterparty commitment transactions. See docs on
 // `fail_unbroadcast_htlcs`, below, for justification.
Expand All@@ -1822,7 +1829,8 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 if let Some(ref latest_outpoints) = us.counterparty_claimable_outpoints.get($txid) {
 for &(ref htlc, ref source_option) in latest_outpoints.iter() {
 if let &Some(ref source) = source_option {
 res.insert((**source).clone(), htlc.clone());
 res.insert((**source).clone(), (htlc.clone(),
 us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned()));
 }
 }
 }
Expand All@@ -1837,9 +1845,14 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 res
	}

	/// Gets the set of outbound HTLCs which are pending resolution in this channel.
	/// Gets the set of outbound HTLCs which are pending resolution in this channel or which were
	/// resolved with a preimage from our counterparty.
	///
	/// This is used to reconstruct pending outbound payments on restart in the ChannelManager.
	pub(crate) fn get_pending_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
	///
	/// Currently, the preimage is unused, however if it is present in the relevant internal state
	/// an HTLC is always included even if it has been resolved.
	pub(crate) fn get_pending_or_resolved_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
Comment thread
wpaulino marked this conversation as resolved.

 let us = self.inner.lock().unwrap();
 // We're only concerned with the confirmation count of HTLC transactions, and don't
 // actually care how many confirmations a commitment transaction may or may not have. Thus,
Expand DownExpand Up@@ -1887,8 +1900,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 Some(commitment_tx_output_idx) == htlc.transaction_output_index
 } else { false }
 });
 if !htlc_update_confd {
 res.insert(source.clone(), htlc.clone());
Comment thread
wpaulino marked this conversation as resolved.

 let counterparty_resolved_preimage_opt =
 us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned();
 if !htlc_update_confd || counterparty_resolved_preimage_opt.is_some() {
 res.insert(source.clone(), (htlc.clone(), counterparty_resolved_preimage_opt));
 }
 }
 }
Expand DownExpand Up@@ -1970,6 +1985,9 @@ macro_rules! fail_unbroadcast_htlcs {
 }
 }
 if matched_htlc { continue; }
 if $self.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).is_some() {
 continue;
 }
Comment thread
wpaulino marked this conversation as resolved.

 $self.onchain_events_awaiting_threshold_conf.retain(|ref entry| {
 if entry.height != $commitment_tx_conf_height { return true; }
 match entry.event {
Expand DownExpand Up@@ -2041,8 +2059,23 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 // Prune HTLCs from the previous counterparty commitment tx so we don't generate failure/fulfill
 // events for now-revoked/fulfilled HTLCs.
 if let Some(txid) = self.prev_counterparty_commitment_txid.take() {
 for &mut (_, ref mut source) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
 *source = None;
 if self.current_counterparty_commitment_txid.unwrap() != txid {
 let cur_claimables = self.counterparty_claimable_outpoints.get(
 &self.current_counterparty_commitment_txid.unwrap()).unwrap();
 for (_, ref source_opt) in self.counterparty_claimable_outpoints.get(&txid).unwrap() {
 if let Some(source) = source_opt {
 if !cur_claimables.iter()
 .any(|(_, cur_source_opt)| cur_source_opt == source_opt)
 {
 self.counterparty_fulfilled_htlcs.remove(&SentHTLCId::from_source(source));
 }
 }
 }
 for &mut (_, ref mut source_opt) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
 *source_opt = None;
 }
Comment thread
valentinewallace marked this conversation as resolved.

 } else {
 assert!(cfg!(fuzzing), "Commitment txids are unique outside of fuzzing, where hashes can collide");
 }
 }

Expand DownExpand Up@@ -2127,28 +2160,37 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
	/// is important that any clones of this channel monitor (including remote clones) by kept
	/// up-to-date as our holder commitment transaction is updated.
	/// Panics if set_on_holder_tx_csv has never been called.
	fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>) -> Result<(), &'static str> {
 // block for Rust 1.34 compat
 let mut new_holder_commitment_tx = {
 let trusted_tx = holder_commitment_tx.trust();
 let txid = trusted_tx.txid();
 let tx_keys = trusted_tx.keys();
 self.current_holder_commitment_number = trusted_tx.commitment_number();
 HolderSignedTx {
 txid,
 revocation_key: tx_keys.revocation_key,
 a_htlc_key: tx_keys.broadcaster_htlc_key,
 b_htlc_key: tx_keys.countersignatory_htlc_key,
 delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 per_commitment_point: tx_keys.per_commitment_point,
 htlc_outputs,
 to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
 feerate_per_kw: trusted_tx.feerate_per_kw(),
 }
	fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>, claimed_htlcs: &[(SentHTLCId, PaymentPreimage)]) -> Result<(), &'static str> {
 let trusted_tx = holder_commitment_tx.trust();
 let txid = trusted_tx.txid();
 let tx_keys = trusted_tx.keys();
 self.current_holder_commitment_number = trusted_tx.commitment_number();
 let mut new_holder_commitment_tx = HolderSignedTx {
 txid,
 revocation_key: tx_keys.revocation_key,
 a_htlc_key: tx_keys.broadcaster_htlc_key,
 b_htlc_key: tx_keys.countersignatory_htlc_key,
 delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 per_commitment_point: tx_keys.per_commitment_point,
 htlc_outputs,
 to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
 feerate_per_kw: trusted_tx.feerate_per_kw(),
 };
 self.onchain_tx_handler.provide_latest_holder_tx(holder_commitment_tx);
 mem::swap(&mut new_holder_commitment_tx, &mut self.current_holder_commitment_tx);
 self.prev_holder_signed_commitment_tx = Some(new_holder_commitment_tx);
 for (claimed_htlc_id, claimed_preimage) in claimed_htlcs {
 #[cfg(debug_assertions)] {
 let cur_counterparty_htlcs = self.counterparty_claimable_outpoints.get(
 &self.current_counterparty_commitment_txid.unwrap()).unwrap();
 assert!(cur_counterparty_htlcs.iter().any(|(_, source_opt)| {
 if let Some(source) = source_opt {
 SentHTLCId::from_source(source) == *claimed_htlc_id
 } else { false }
 }));
 }
 self.counterparty_fulfilled_htlcs.insert(*claimed_htlc_id, *claimed_preimage);
 }
 if self.holder_tx_signed {
 return Err("Latest holder commitment signed has already been signed, update is rejected");
 }
Expand DownExpand Up@@ -2243,10 +2285,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&*fee_estimator);
 for update in updates.updates.iter() {
 match update {
 ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs } => {
 ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs, claimed_htlcs } => {
 log_trace!(logger, "Updating ChannelMonitor with latest holder commitment transaction info");
 if self.lockdown_from_offchain { panic!(); }
 if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone()) {
 if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone(), &claimed_htlcs) {
 log_error!(logger, "Providing latest holder commitment transaction failed/was refused:");
 log_error!(logger, " {}", e);
 ret = Err(());
Expand DownExpand Up@@ -3868,6 +3910,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 let mut counterparty_node_id = None;
 let mut confirmed_commitment_tx_counterparty_output = None;
 let mut spendable_txids_confirmed = Some(Vec::new());
 let mut counterparty_fulfilled_htlcs = Some(HashMap::new());
 read_tlv_fields!(reader, {
 (1, funding_spend_confirmed, option),
 (3, htlcs_resolved_on_chain, vec_type),
Expand All@@ -3876,6 +3919,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 (9, counterparty_node_id, option),
 (11, confirmed_commitment_tx_counterparty_output, option),
 (13, spendable_txids_confirmed, vec_type),
 (15, counterparty_fulfilled_htlcs, option),
 });

 Ok((best_block.block_hash(), ChannelMonitor::from_impl(ChannelMonitorImpl {
Expand DownExpand Up@@ -3904,6 +3948,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 counterparty_claimable_outpoints,
 counterparty_commitment_txn_on_chain,
 counterparty_hash_commitment_number,
 counterparty_fulfilled_htlcs: counterparty_fulfilled_htlcs.unwrap(),

 prev_holder_signed_commitment_tx,
 current_holder_commitment_tx,
Expand DownExpand Up@@ -4077,7 +4122,6 @@ mod tests {
 let fee_estimator = TestFeeEstimator { sat_per_kw: Mutex::new(253) };

 let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
 let dummy_tx = Transaction { version: 0, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() };

 let mut preimages = Vec::new();
 {
Expand DownExpand Up@@ -4167,11 +4211,10 @@ mod tests {
 HolderCommitmentTransaction::dummy(), best_block, dummy_key);

 monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..10])).unwrap();
 let dummy_txid = dummy_tx.txid();
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"1").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"2").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 for &(ref preimage, ref hash) in preimages.iter() {
 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_estimator);
 monitor.provide_payment_preimage(hash, preimage, &broadcaster, &bounded_fee_estimator, &logger);
Expand All@@ -4185,13 +4228,19 @@ mod tests {
 test_preimages_exist!(&preimages[0..10], monitor);
 test_preimages_exist!(&preimages[15..20], monitor);

 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"3").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);

 // Now provide a further secret, pruning preimages 15-17
 secret[0..32].clone_from_slice(&hex::decode("c7518c8ae4660ed02894df8976fa1a3659c1a8b4b5bec0c4b872abeba4cb8964").unwrap());
 monitor.provide_secret(281474976710654, secret.clone()).unwrap();
 assert_eq!(monitor.inner.lock().unwrap().payment_preimages.len(), 13);
 test_preimages_exist!(&preimages[0..10], monitor);
 test_preimages_exist!(&preimages[17..20], monitor);

 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"4").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);

 // Now update holder commitment tx info, pruning only element 18 as we still care about the
 // previous commitment tx's preimages too
 monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..5])).unwrap();
Expand Down

32 changes: 22 additions & 10 deletions
lightning/src/ln/channel.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -27,7 +27,7 @@ use crate::ln::features::{ChannelTypeFeatures, InitFeatures};
use crate::ln::msgs;
use crate::ln::msgs::{DecodeError, OptionalField, DataLossProtect};
use crate::ln::script::{self, ShutdownScript};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, SentHTLCId, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, TxCreationKeys, HTLCOutputInCommitment, htlc_success_tx_weight, htlc_timeout_tx_weight, make_funding_redeemscript, ChannelPublicKeys, CommitmentTransaction, HolderCommitmentTransaction, ChannelTransactionParameters, CounterpartyChannelTransactionParameters, MAX_HTLCS, get_commitment_transaction_number_obscure_factor, ClosingTransaction};
use crate::ln::chan_utils;
use crate::ln::onion_utils::HTLCFailReason;
Expand DownExpand Up@@ -192,6 +192,7 @@ enum OutboundHTLCState {

#[derive(Clone)]
enum OutboundHTLCOutcome {
	/// LDK version 0.0.105+ will always fill in the preimage here.
	Success(Option<PaymentPreimage>),
	Failure(HTLCFailReason),
}
Expand DownExpand Up@@ -3159,15 +3160,6 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 }
 }

 self.latest_monitor_update_id += 1;
 let mut monitor_update = ChannelMonitorUpdate {
 update_id: self.latest_monitor_update_id,
 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
 commitment_tx: holder_commitment_tx,
 htlc_outputs: htlcs_and_sigs
 }]
 };

 for htlc in self.pending_inbound_htlcs.iter_mut() {
 let new_forward = if let &InboundHTLCState::RemoteAnnounced(ref forward_info) = &htlc.state {
 Some(forward_info.clone())
Expand All@@ -3179,18 +3171,38 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 need_commitment = true;
 }
 }
 let mut claimed_htlcs = Vec::new();
 for htlc in self.pending_outbound_htlcs.iter_mut() {
 if let &mut OutboundHTLCState::RemoteRemoved(ref mut outcome) = &mut htlc.state {
 log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToRemove due to commitment_signed in channel {}.",
 log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id));
 // Grab the preimage, if it exists, instead of cloning
 let mut reason = OutboundHTLCOutcome::Success(None);
 mem::swap(outcome, &mut reason);
 if let OutboundHTLCOutcome::Success(Some(preimage)) = reason {
 // If a user (a) receives an HTLC claim using LDK 0.0.104 or before, then (b)
 // upgrades to LDK 0.0.114 or later before the HTLC is fully resolved, we could
 // have a `Success(None)` reason. In this case we could forget some HTLC
 // claims, but such an upgrade is unlikely and including claimed HTLCs here
 // fixes a bug which the user was exposed to on 0.0.104 when they started the
 // claim anyway.
 claimed_htlcs.push((SentHTLCId::from_source(&htlc.source), preimage));
 }
 htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(reason);
 need_commitment = true;
 }
 }

 self.latest_monitor_update_id += 1;
 let mut monitor_update = ChannelMonitorUpdate {
 update_id: self.latest_monitor_update_id,
 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
 commitment_tx: holder_commitment_tx,
 htlc_outputs: htlcs_and_sigs,
 claimed_htlcs,
 }]
 };

 self.cur_holder_commitment_transaction_number -= 1;
 // Note that if we need_commitment & !AwaitingRemoteRevoke we'll call
 // build_commitment_no_status_check() next which will reset this to RAAFirst.
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
Track claimed outbound HTLCs in ChannelMonitors by TheBlueMatt · Pull Request #2048 · lightningdevkit/rust-lightning · GitHub
Skip to content
Track claimed outbound HTLCs in ChannelMonitors#2048

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

TheBlueMatt
merged 3 commits into

from

Mar 3, 2023
 Merged


Track claimed outbound HTLCs in ChannelMonitors
#2048
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


3 commits


Select commit
Hold shift + click to select a range
33c36d0

Avoid removing stale preimages when hashes collide in fuzzing


TheBlueMatt Mar 2, 2023
0ad1f4c

Track claimed outbound HTLCs in ChannelMonitors


TheBlueMatt Feb 22, 2023
75527db

Remove unused compat block in `provide_latest_holder_commitment_tx`


TheBlueMatt Mar 1, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


125 changes: 87 additions & 38 deletions
lightning/src/chain/channelmonitor.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -37,7 +37,7 @@ use crate::ln::{PaymentHash, PaymentPreimage};
use crate::ln::msgs::DecodeError;
use crate::ln::chan_utils;
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HTLCClaim, ChannelTransactionParameters, HolderCommitmentTransaction};
use crate::ln::channelmanager::HTLCSource;
use crate::ln::channelmanager::{HTLCSource, SentHTLCId};
use crate::chain;
use crate::chain::{BestBlock, WatchedOutput};
use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator, LowerBoundedFeeEstimator};
Expand DownExpand Up@@ -494,6 +494,7 @@ pub(crate) enum ChannelMonitorUpdateStep {
	LatestHolderCommitmentTXInfo {
 commitment_tx: HolderCommitmentTransaction,
 htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
 claimed_htlcs: Vec<(SentHTLCId, PaymentPreimage)>,
Comment thread
wpaulino marked this conversation as resolved.

	},
	LatestCounterpartyCommitmentTXInfo {
 commitment_txid: Txid,
Expand DownExpand Up@@ -536,6 +537,7 @@ impl ChannelMonitorUpdateStep {
impl_writeable_tlv_based_enum_upgradable!(ChannelMonitorUpdateStep,
	(0, LatestHolderCommitmentTXInfo) => {
 (0, commitment_tx, required),
 (1, claimed_htlcs, vec_type),
 (2, htlc_outputs, vec_type),
	},
	(1, LatestCounterpartyCommitmentTXInfo) => {
Expand DownExpand Up@@ -750,6 +752,8 @@ pub(crate) struct ChannelMonitorImpl<Signer: WriteableEcdsaChannelSigner> {
	/// Serialized to disk but should generally not be sent to Watchtowers.
	counterparty_hash_commitment_number: HashMap<PaymentHash, u64>,

	counterparty_fulfilled_htlcs: HashMap<SentHTLCId, PaymentPreimage>,

	// We store two holder commitment transactions to avoid any race conditions where we may update
	// some monitors (potentially on watchtowers) but then fail to update others, resulting in the
	// various monitors for one channel being out of sync, and us broadcasting a holder
Expand DownExpand Up@@ -1033,6 +1037,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for ChannelMonitorImpl<Signe
 (9, self.counterparty_node_id, option),
 (11, self.confirmed_commitment_tx_counterparty_output, option),
 (13, self.spendable_txids_confirmed, vec_type),
 (15, self.counterparty_fulfilled_htlcs, required),
 });

 Ok(())
Expand DownExpand Up@@ -1120,6 +1125,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 counterparty_claimable_outpoints: HashMap::new(),
 counterparty_commitment_txn_on_chain: HashMap::new(),
 counterparty_hash_commitment_number: HashMap::new(),
 counterparty_fulfilled_htlcs: HashMap::new(),

 prev_holder_signed_commitment_tx: None,
 current_holder_commitment_tx: holder_commitment_tx,
Expand DownExpand Up@@ -1174,7 +1180,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 &self, holder_commitment_tx: HolderCommitmentTransaction,
 htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
	) -> Result<(), ()> {
 self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs).map_err(|_| ())
 self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs, &Vec::new()).map_err(|_| ())
	}

	/// This is used to provide payment preimage(s) out-of-band during startup without updating the
Expand DownExpand Up@@ -1810,9 +1816,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
	/// `ChannelMonitor`. This is used to determine if an HTLC was removed from the channel prior
	/// to the `ChannelManager` having been persisted.
	///
	/// This is similar to [`Self::get_pending_outbound_htlcs`] except it includes HTLCs which were
	/// resolved by this `ChannelMonitor`.
	pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
	/// This is similar to [`Self::get_pending_or_resolved_outbound_htlcs`] except it includes
	/// HTLCs which were resolved on-chain (i.e. where the final HTLC resolution was done by an
	/// event from this `ChannelMonitor`).
	pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
 let mut res = HashMap::new();
 // Just examine the available counterparty commitment transactions. See docs on
 // `fail_unbroadcast_htlcs`, below, for justification.
Expand All@@ -1822,7 +1829,8 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 if let Some(ref latest_outpoints) = us.counterparty_claimable_outpoints.get($txid) {
 for &(ref htlc, ref source_option) in latest_outpoints.iter() {
 if let &Some(ref source) = source_option {
 res.insert((**source).clone(), htlc.clone());
 res.insert((**source).clone(), (htlc.clone(),
 us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned()));
 }
 }
 }
Expand All@@ -1837,9 +1845,14 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 res
	}

	/// Gets the set of outbound HTLCs which are pending resolution in this channel.
	/// Gets the set of outbound HTLCs which are pending resolution in this channel or which were
	/// resolved with a preimage from our counterparty.
	///
	/// This is used to reconstruct pending outbound payments on restart in the ChannelManager.
	pub(crate) fn get_pending_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
	///
	/// Currently, the preimage is unused, however if it is present in the relevant internal state
	/// an HTLC is always included even if it has been resolved.
	pub(crate) fn get_pending_or_resolved_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
Comment thread
wpaulino marked this conversation as resolved.

 let us = self.inner.lock().unwrap();
 // We're only concerned with the confirmation count of HTLC transactions, and don't
 // actually care how many confirmations a commitment transaction may or may not have. Thus,
Expand DownExpand Up@@ -1887,8 +1900,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 Some(commitment_tx_output_idx) == htlc.transaction_output_index
 } else { false }
 });
 if !htlc_update_confd {
 res.insert(source.clone(), htlc.clone());
Comment thread
wpaulino marked this conversation as resolved.

 let counterparty_resolved_preimage_opt =
 us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned();
 if !htlc_update_confd || counterparty_resolved_preimage_opt.is_some() {
 res.insert(source.clone(), (htlc.clone(), counterparty_resolved_preimage_opt));
 }
 }
 }
Expand DownExpand Up@@ -1970,6 +1985,9 @@ macro_rules! fail_unbroadcast_htlcs {
 }
 }
 if matched_htlc { continue; }
 if $self.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).is_some() {
 continue;
 }
Comment thread
wpaulino marked this conversation as resolved.

 $self.onchain_events_awaiting_threshold_conf.retain(|ref entry| {
 if entry.height != $commitment_tx_conf_height { return true; }
 match entry.event {
Expand DownExpand Up@@ -2041,8 +2059,23 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 // Prune HTLCs from the previous counterparty commitment tx so we don't generate failure/fulfill
 // events for now-revoked/fulfilled HTLCs.
 if let Some(txid) = self.prev_counterparty_commitment_txid.take() {
 for &mut (_, ref mut source) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
 *source = None;
 if self.current_counterparty_commitment_txid.unwrap() != txid {
 let cur_claimables = self.counterparty_claimable_outpoints.get(
 &self.current_counterparty_commitment_txid.unwrap()).unwrap();
 for (_, ref source_opt) in self.counterparty_claimable_outpoints.get(&txid).unwrap() {
 if let Some(source) = source_opt {
 if !cur_claimables.iter()
 .any(|(_, cur_source_opt)| cur_source_opt == source_opt)
 {
 self.counterparty_fulfilled_htlcs.remove(&SentHTLCId::from_source(source));
 }
 }
 }
 for &mut (_, ref mut source_opt) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
 *source_opt = None;
 }
Comment thread
valentinewallace marked this conversation as resolved.

 } else {
 assert!(cfg!(fuzzing), "Commitment txids are unique outside of fuzzing, where hashes can collide");
 }
 }

Expand DownExpand Up@@ -2127,28 +2160,37 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
	/// is important that any clones of this channel monitor (including remote clones) by kept
	/// up-to-date as our holder commitment transaction is updated.
	/// Panics if set_on_holder_tx_csv has never been called.
	fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>) -> Result<(), &'static str> {
 // block for Rust 1.34 compat
 let mut new_holder_commitment_tx = {
 let trusted_tx = holder_commitment_tx.trust();
 let txid = trusted_tx.txid();
 let tx_keys = trusted_tx.keys();
 self.current_holder_commitment_number = trusted_tx.commitment_number();
 HolderSignedTx {
 txid,
 revocation_key: tx_keys.revocation_key,
 a_htlc_key: tx_keys.broadcaster_htlc_key,
 b_htlc_key: tx_keys.countersignatory_htlc_key,
 delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 per_commitment_point: tx_keys.per_commitment_point,
 htlc_outputs,
 to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
 feerate_per_kw: trusted_tx.feerate_per_kw(),
 }
	fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>, claimed_htlcs: &[(SentHTLCId, PaymentPreimage)]) -> Result<(), &'static str> {
 let trusted_tx = holder_commitment_tx.trust();
 let txid = trusted_tx.txid();
 let tx_keys = trusted_tx.keys();
 self.current_holder_commitment_number = trusted_tx.commitment_number();
 let mut new_holder_commitment_tx = HolderSignedTx {
 txid,
 revocation_key: tx_keys.revocation_key,
 a_htlc_key: tx_keys.broadcaster_htlc_key,
 b_htlc_key: tx_keys.countersignatory_htlc_key,
 delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 per_commitment_point: tx_keys.per_commitment_point,
 htlc_outputs,
 to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
 feerate_per_kw: trusted_tx.feerate_per_kw(),
 };
 self.onchain_tx_handler.provide_latest_holder_tx(holder_commitment_tx);
 mem::swap(&mut new_holder_commitment_tx, &mut self.current_holder_commitment_tx);
 self.prev_holder_signed_commitment_tx = Some(new_holder_commitment_tx);
 for (claimed_htlc_id, claimed_preimage) in claimed_htlcs {
 #[cfg(debug_assertions)] {
 let cur_counterparty_htlcs = self.counterparty_claimable_outpoints.get(
 &self.current_counterparty_commitment_txid.unwrap()).unwrap();
 assert!(cur_counterparty_htlcs.iter().any(|(_, source_opt)| {
 if let Some(source) = source_opt {
 SentHTLCId::from_source(source) == *claimed_htlc_id
 } else { false }
 }));
 }
 self.counterparty_fulfilled_htlcs.insert(*claimed_htlc_id, *claimed_preimage);
 }
 if self.holder_tx_signed {
 return Err("Latest holder commitment signed has already been signed, update is rejected");
 }
Expand DownExpand Up@@ -2243,10 +2285,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&*fee_estimator);
 for update in updates.updates.iter() {
 match update {
 ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs } => {
 ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs, claimed_htlcs } => {
 log_trace!(logger, "Updating ChannelMonitor with latest holder commitment transaction info");
 if self.lockdown_from_offchain { panic!(); }
 if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone()) {
 if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone(), &claimed_htlcs) {
 log_error!(logger, "Providing latest holder commitment transaction failed/was refused:");
 log_error!(logger, " {}", e);
 ret = Err(());
Expand DownExpand Up@@ -3868,6 +3910,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 let mut counterparty_node_id = None;
 let mut confirmed_commitment_tx_counterparty_output = None;
 let mut spendable_txids_confirmed = Some(Vec::new());
 let mut counterparty_fulfilled_htlcs = Some(HashMap::new());
 read_tlv_fields!(reader, {
 (1, funding_spend_confirmed, option),
 (3, htlcs_resolved_on_chain, vec_type),
Expand All@@ -3876,6 +3919,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 (9, counterparty_node_id, option),
 (11, confirmed_commitment_tx_counterparty_output, option),
 (13, spendable_txids_confirmed, vec_type),
 (15, counterparty_fulfilled_htlcs, option),
 });

 Ok((best_block.block_hash(), ChannelMonitor::from_impl(ChannelMonitorImpl {
Expand DownExpand Up@@ -3904,6 +3948,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 counterparty_claimable_outpoints,
 counterparty_commitment_txn_on_chain,
 counterparty_hash_commitment_number,
 counterparty_fulfilled_htlcs: counterparty_fulfilled_htlcs.unwrap(),

 prev_holder_signed_commitment_tx,
 current_holder_commitment_tx,
Expand DownExpand Up@@ -4077,7 +4122,6 @@ mod tests {
 let fee_estimator = TestFeeEstimator { sat_per_kw: Mutex::new(253) };

 let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
 let dummy_tx = Transaction { version: 0, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() };

 let mut preimages = Vec::new();
 {
Expand DownExpand Up@@ -4167,11 +4211,10 @@ mod tests {
 HolderCommitmentTransaction::dummy(), best_block, dummy_key);

 monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..10])).unwrap();
 let dummy_txid = dummy_tx.txid();
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"1").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"2").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 for &(ref preimage, ref hash) in preimages.iter() {
 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_estimator);
 monitor.provide_payment_preimage(hash, preimage, &broadcaster, &bounded_fee_estimator, &logger);
Expand All@@ -4185,13 +4228,19 @@ mod tests {
 test_preimages_exist!(&preimages[0..10], monitor);
 test_preimages_exist!(&preimages[15..20], monitor);

 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"3").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);

 // Now provide a further secret, pruning preimages 15-17
 secret[0..32].clone_from_slice(&hex::decode("c7518c8ae4660ed02894df8976fa1a3659c1a8b4b5bec0c4b872abeba4cb8964").unwrap());
 monitor.provide_secret(281474976710654, secret.clone()).unwrap();
 assert_eq!(monitor.inner.lock().unwrap().payment_preimages.len(), 13);
 test_preimages_exist!(&preimages[0..10], monitor);
 test_preimages_exist!(&preimages[17..20], monitor);

 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"4").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);

 // Now update holder commitment tx info, pruning only element 18 as we still care about the
 // previous commitment tx's preimages too
 monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..5])).unwrap();
Expand Down

32 changes: 22 additions & 10 deletions
lightning/src/ln/channel.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -27,7 +27,7 @@ use crate::ln::features::{ChannelTypeFeatures, InitFeatures};
use crate::ln::msgs;
use crate::ln::msgs::{DecodeError, OptionalField, DataLossProtect};
use crate::ln::script::{self, ShutdownScript};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, SentHTLCId, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, TxCreationKeys, HTLCOutputInCommitment, htlc_success_tx_weight, htlc_timeout_tx_weight, make_funding_redeemscript, ChannelPublicKeys, CommitmentTransaction, HolderCommitmentTransaction, ChannelTransactionParameters, CounterpartyChannelTransactionParameters, MAX_HTLCS, get_commitment_transaction_number_obscure_factor, ClosingTransaction};
use crate::ln::chan_utils;
use crate::ln::onion_utils::HTLCFailReason;
Expand DownExpand Up@@ -192,6 +192,7 @@ enum OutboundHTLCState {

#[derive(Clone)]
enum OutboundHTLCOutcome {
	/// LDK version 0.0.105+ will always fill in the preimage here.
	Success(Option<PaymentPreimage>),
	Failure(HTLCFailReason),
}
Expand DownExpand Up@@ -3159,15 +3160,6 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 }
 }

 self.latest_monitor_update_id += 1;
 let mut monitor_update = ChannelMonitorUpdate {
 update_id: self.latest_monitor_update_id,
 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
 commitment_tx: holder_commitment_tx,
 htlc_outputs: htlcs_and_sigs
 }]
 };

 for htlc in self.pending_inbound_htlcs.iter_mut() {
 let new_forward = if let &InboundHTLCState::RemoteAnnounced(ref forward_info) = &htlc.state {
 Some(forward_info.clone())
Expand All@@ -3179,18 +3171,38 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 need_commitment = true;
 }
 }
 let mut claimed_htlcs = Vec::new();
 for htlc in self.pending_outbound_htlcs.iter_mut() {
 if let &mut OutboundHTLCState::RemoteRemoved(ref mut outcome) = &mut htlc.state {
 log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToRemove due to commitment_signed in channel {}.",
 log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id));
 // Grab the preimage, if it exists, instead of cloning
 let mut reason = OutboundHTLCOutcome::Success(None);
 mem::swap(outcome, &mut reason);
 if let OutboundHTLCOutcome::Success(Some(preimage)) = reason {
 // If a user (a) receives an HTLC claim using LDK 0.0.104 or before, then (b)
 // upgrades to LDK 0.0.114 or later before the HTLC is fully resolved, we could
 // have a `Success(None)` reason. In this case we could forget some HTLC
 // claims, but such an upgrade is unlikely and including claimed HTLCs here
 // fixes a bug which the user was exposed to on 0.0.104 when they started the
 // claim anyway.
 claimed_htlcs.push((SentHTLCId::from_source(&htlc.source), preimage));
 }
 htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(reason);
 need_commitment = true;
 }
 }

 self.latest_monitor_update_id += 1;
 let mut monitor_update = ChannelMonitorUpdate {
 update_id: self.latest_monitor_update_id,
 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
 commitment_tx: holder_commitment_tx,
 htlc_outputs: htlcs_and_sigs,
 claimed_htlcs,
 }]
 };

 self.cur_holder_commitment_transaction_number -= 1;
 // Note that if we need_commitment & !AwaitingRemoteRevoke we'll call
 // build_commitment_no_status_check() next which will reset this to RAAFirst.
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Track claimed outbound HTLCs in ChannelMonitors by TheBlueMatt · Pull Request #2048 · lightningdevkit/rust-lightning · GitHub
Skip to content
Track claimed outbound HTLCs in ChannelMonitors#2048

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

TheBlueMatt
merged 3 commits into

from

Mar 3, 2023
 Merged


Track claimed outbound HTLCs in ChannelMonitors
#2048
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


3 commits


Select commit
Hold shift + click to select a range
33c36d0

Avoid removing stale preimages when hashes collide in fuzzing


TheBlueMatt Mar 2, 2023
0ad1f4c

Track claimed outbound HTLCs in ChannelMonitors


TheBlueMatt Feb 22, 2023
75527db

Remove unused compat block in `provide_latest_holder_commitment_tx`


TheBlueMatt Mar 1, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


125 changes: 87 additions & 38 deletions
lightning/src/chain/channelmonitor.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -37,7 +37,7 @@ use crate::ln::{PaymentHash, PaymentPreimage};
use crate::ln::msgs::DecodeError;
use crate::ln::chan_utils;
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HTLCClaim, ChannelTransactionParameters, HolderCommitmentTransaction};
use crate::ln::channelmanager::HTLCSource;
use crate::ln::channelmanager::{HTLCSource, SentHTLCId};
use crate::chain;
use crate::chain::{BestBlock, WatchedOutput};
use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator, LowerBoundedFeeEstimator};
Expand DownExpand Up@@ -494,6 +494,7 @@ pub(crate) enum ChannelMonitorUpdateStep {
	LatestHolderCommitmentTXInfo {
 commitment_tx: HolderCommitmentTransaction,
 htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
 claimed_htlcs: Vec<(SentHTLCId, PaymentPreimage)>,
Comment thread
wpaulino marked this conversation as resolved.

	},
	LatestCounterpartyCommitmentTXInfo {
 commitment_txid: Txid,
Expand DownExpand Up@@ -536,6 +537,7 @@ impl ChannelMonitorUpdateStep {
impl_writeable_tlv_based_enum_upgradable!(ChannelMonitorUpdateStep,
	(0, LatestHolderCommitmentTXInfo) => {
 (0, commitment_tx, required),
 (1, claimed_htlcs, vec_type),
 (2, htlc_outputs, vec_type),
	},
	(1, LatestCounterpartyCommitmentTXInfo) => {
Expand DownExpand Up@@ -750,6 +752,8 @@ pub(crate) struct ChannelMonitorImpl<Signer: WriteableEcdsaChannelSigner> {
	/// Serialized to disk but should generally not be sent to Watchtowers.
	counterparty_hash_commitment_number: HashMap<PaymentHash, u64>,

	counterparty_fulfilled_htlcs: HashMap<SentHTLCId, PaymentPreimage>,

	// We store two holder commitment transactions to avoid any race conditions where we may update
	// some monitors (potentially on watchtowers) but then fail to update others, resulting in the
	// various monitors for one channel being out of sync, and us broadcasting a holder
Expand DownExpand Up@@ -1033,6 +1037,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for ChannelMonitorImpl<Signe
 (9, self.counterparty_node_id, option),
 (11, self.confirmed_commitment_tx_counterparty_output, option),
 (13, self.spendable_txids_confirmed, vec_type),
 (15, self.counterparty_fulfilled_htlcs, required),
 });

 Ok(())
Expand DownExpand Up@@ -1120,6 +1125,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 counterparty_claimable_outpoints: HashMap::new(),
 counterparty_commitment_txn_on_chain: HashMap::new(),
 counterparty_hash_commitment_number: HashMap::new(),
 counterparty_fulfilled_htlcs: HashMap::new(),

 prev_holder_signed_commitment_tx: None,
 current_holder_commitment_tx: holder_commitment_tx,
Expand DownExpand Up@@ -1174,7 +1180,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 &self, holder_commitment_tx: HolderCommitmentTransaction,
 htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
	) -> Result<(), ()> {
 self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs).map_err(|_| ())
 self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs, &Vec::new()).map_err(|_| ())
	}

	/// This is used to provide payment preimage(s) out-of-band during startup without updating the
Expand DownExpand Up@@ -1810,9 +1816,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
	/// `ChannelMonitor`. This is used to determine if an HTLC was removed from the channel prior
	/// to the `ChannelManager` having been persisted.
	///
	/// This is similar to [`Self::get_pending_outbound_htlcs`] except it includes HTLCs which were
	/// resolved by this `ChannelMonitor`.
	pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
	/// This is similar to [`Self::get_pending_or_resolved_outbound_htlcs`] except it includes
	/// HTLCs which were resolved on-chain (i.e. where the final HTLC resolution was done by an
	/// event from this `ChannelMonitor`).
	pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
 let mut res = HashMap::new();
 // Just examine the available counterparty commitment transactions. See docs on
 // `fail_unbroadcast_htlcs`, below, for justification.
Expand All@@ -1822,7 +1829,8 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 if let Some(ref latest_outpoints) = us.counterparty_claimable_outpoints.get($txid) {
 for &(ref htlc, ref source_option) in latest_outpoints.iter() {
 if let &Some(ref source) = source_option {
 res.insert((**source).clone(), htlc.clone());
 res.insert((**source).clone(), (htlc.clone(),
 us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned()));
 }
 }
 }
Expand All@@ -1837,9 +1845,14 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 res
	}

	/// Gets the set of outbound HTLCs which are pending resolution in this channel.
	/// Gets the set of outbound HTLCs which are pending resolution in this channel or which were
	/// resolved with a preimage from our counterparty.
	///
	/// This is used to reconstruct pending outbound payments on restart in the ChannelManager.
	pub(crate) fn get_pending_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
	///
	/// Currently, the preimage is unused, however if it is present in the relevant internal state
	/// an HTLC is always included even if it has been resolved.
	pub(crate) fn get_pending_or_resolved_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
Comment thread
wpaulino marked this conversation as resolved.

 let us = self.inner.lock().unwrap();
 // We're only concerned with the confirmation count of HTLC transactions, and don't
 // actually care how many confirmations a commitment transaction may or may not have. Thus,
Expand DownExpand Up@@ -1887,8 +1900,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 Some(commitment_tx_output_idx) == htlc.transaction_output_index
 } else { false }
 });
 if !htlc_update_confd {
 res.insert(source.clone(), htlc.clone());
Comment thread
wpaulino marked this conversation as resolved.

 let counterparty_resolved_preimage_opt =
 us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned();
 if !htlc_update_confd || counterparty_resolved_preimage_opt.is_some() {
 res.insert(source.clone(), (htlc.clone(), counterparty_resolved_preimage_opt));
 }
 }
 }
Expand DownExpand Up@@ -1970,6 +1985,9 @@ macro_rules! fail_unbroadcast_htlcs {
 }
 }
 if matched_htlc { continue; }
 if $self.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).is_some() {
 continue;
 }
Comment thread
wpaulino marked this conversation as resolved.

 $self.onchain_events_awaiting_threshold_conf.retain(|ref entry| {
 if entry.height != $commitment_tx_conf_height { return true; }
 match entry.event {
Expand DownExpand Up@@ -2041,8 +2059,23 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 // Prune HTLCs from the previous counterparty commitment tx so we don't generate failure/fulfill
 // events for now-revoked/fulfilled HTLCs.
 if let Some(txid) = self.prev_counterparty_commitment_txid.take() {
 for &mut (_, ref mut source) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
 *source = None;
 if self.current_counterparty_commitment_txid.unwrap() != txid {
 let cur_claimables = self.counterparty_claimable_outpoints.get(
 &self.current_counterparty_commitment_txid.unwrap()).unwrap();
 for (_, ref source_opt) in self.counterparty_claimable_outpoints.get(&txid).unwrap() {
 if let Some(source) = source_opt {
 if !cur_claimables.iter()
 .any(|(_, cur_source_opt)| cur_source_opt == source_opt)
 {
 self.counterparty_fulfilled_htlcs.remove(&SentHTLCId::from_source(source));
 }
 }
 }
 for &mut (_, ref mut source_opt) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
 *source_opt = None;
 }
Comment thread
valentinewallace marked this conversation as resolved.

 } else {
 assert!(cfg!(fuzzing), "Commitment txids are unique outside of fuzzing, where hashes can collide");
 }
 }

Expand DownExpand Up@@ -2127,28 +2160,37 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
	/// is important that any clones of this channel monitor (including remote clones) by kept
	/// up-to-date as our holder commitment transaction is updated.
	/// Panics if set_on_holder_tx_csv has never been called.
	fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>) -> Result<(), &'static str> {
 // block for Rust 1.34 compat
 let mut new_holder_commitment_tx = {
 let trusted_tx = holder_commitment_tx.trust();
 let txid = trusted_tx.txid();
 let tx_keys = trusted_tx.keys();
 self.current_holder_commitment_number = trusted_tx.commitment_number();
 HolderSignedTx {
 txid,
 revocation_key: tx_keys.revocation_key,
 a_htlc_key: tx_keys.broadcaster_htlc_key,
 b_htlc_key: tx_keys.countersignatory_htlc_key,
 delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 per_commitment_point: tx_keys.per_commitment_point,
 htlc_outputs,
 to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
 feerate_per_kw: trusted_tx.feerate_per_kw(),
 }
	fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>, claimed_htlcs: &[(SentHTLCId, PaymentPreimage)]) -> Result<(), &'static str> {
 let trusted_tx = holder_commitment_tx.trust();
 let txid = trusted_tx.txid();
 let tx_keys = trusted_tx.keys();
 self.current_holder_commitment_number = trusted_tx.commitment_number();
 let mut new_holder_commitment_tx = HolderSignedTx {
 txid,
 revocation_key: tx_keys.revocation_key,
 a_htlc_key: tx_keys.broadcaster_htlc_key,
 b_htlc_key: tx_keys.countersignatory_htlc_key,
 delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 per_commitment_point: tx_keys.per_commitment_point,
 htlc_outputs,
 to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
 feerate_per_kw: trusted_tx.feerate_per_kw(),
 };
 self.onchain_tx_handler.provide_latest_holder_tx(holder_commitment_tx);
 mem::swap(&mut new_holder_commitment_tx, &mut self.current_holder_commitment_tx);
 self.prev_holder_signed_commitment_tx = Some(new_holder_commitment_tx);
 for (claimed_htlc_id, claimed_preimage) in claimed_htlcs {
 #[cfg(debug_assertions)] {
 let cur_counterparty_htlcs = self.counterparty_claimable_outpoints.get(
 &self.current_counterparty_commitment_txid.unwrap()).unwrap();
 assert!(cur_counterparty_htlcs.iter().any(|(_, source_opt)| {
 if let Some(source) = source_opt {
 SentHTLCId::from_source(source) == *claimed_htlc_id
 } else { false }
 }));
 }
 self.counterparty_fulfilled_htlcs.insert(*claimed_htlc_id, *claimed_preimage);
 }
 if self.holder_tx_signed {
 return Err("Latest holder commitment signed has already been signed, update is rejected");
 }
Expand DownExpand Up@@ -2243,10 +2285,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&*fee_estimator);
 for update in updates.updates.iter() {
 match update {
 ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs } => {
 ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs, claimed_htlcs } => {
 log_trace!(logger, "Updating ChannelMonitor with latest holder commitment transaction info");
 if self.lockdown_from_offchain { panic!(); }
 if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone()) {
 if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone(), &claimed_htlcs) {
 log_error!(logger, "Providing latest holder commitment transaction failed/was refused:");
 log_error!(logger, " {}", e);
 ret = Err(());
Expand DownExpand Up@@ -3868,6 +3910,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 let mut counterparty_node_id = None;
 let mut confirmed_commitment_tx_counterparty_output = None;
 let mut spendable_txids_confirmed = Some(Vec::new());
 let mut counterparty_fulfilled_htlcs = Some(HashMap::new());
 read_tlv_fields!(reader, {
 (1, funding_spend_confirmed, option),
 (3, htlcs_resolved_on_chain, vec_type),
Expand All@@ -3876,6 +3919,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 (9, counterparty_node_id, option),
 (11, confirmed_commitment_tx_counterparty_output, option),
 (13, spendable_txids_confirmed, vec_type),
 (15, counterparty_fulfilled_htlcs, option),
 });

 Ok((best_block.block_hash(), ChannelMonitor::from_impl(ChannelMonitorImpl {
Expand DownExpand Up@@ -3904,6 +3948,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 counterparty_claimable_outpoints,
 counterparty_commitment_txn_on_chain,
 counterparty_hash_commitment_number,
 counterparty_fulfilled_htlcs: counterparty_fulfilled_htlcs.unwrap(),

 prev_holder_signed_commitment_tx,
 current_holder_commitment_tx,
Expand DownExpand Up@@ -4077,7 +4122,6 @@ mod tests {
 let fee_estimator = TestFeeEstimator { sat_per_kw: Mutex::new(253) };

 let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
 let dummy_tx = Transaction { version: 0, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() };

 let mut preimages = Vec::new();
 {
Expand DownExpand Up@@ -4167,11 +4211,10 @@ mod tests {
 HolderCommitmentTransaction::dummy(), best_block, dummy_key);

 monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..10])).unwrap();
 let dummy_txid = dummy_tx.txid();
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"1").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"2").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 for &(ref preimage, ref hash) in preimages.iter() {
 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_estimator);
 monitor.provide_payment_preimage(hash, preimage, &broadcaster, &bounded_fee_estimator, &logger);
Expand All@@ -4185,13 +4228,19 @@ mod tests {
 test_preimages_exist!(&preimages[0..10], monitor);
 test_preimages_exist!(&preimages[15..20], monitor);

 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"3").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);

 // Now provide a further secret, pruning preimages 15-17
 secret[0..32].clone_from_slice(&hex::decode("c7518c8ae4660ed02894df8976fa1a3659c1a8b4b5bec0c4b872abeba4cb8964").unwrap());
 monitor.provide_secret(281474976710654, secret.clone()).unwrap();
 assert_eq!(monitor.inner.lock().unwrap().payment_preimages.len(), 13);
 test_preimages_exist!(&preimages[0..10], monitor);
 test_preimages_exist!(&preimages[17..20], monitor);

 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"4").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);

 // Now update holder commitment tx info, pruning only element 18 as we still care about the
 // previous commitment tx's preimages too
 monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..5])).unwrap();
Expand Down

32 changes: 22 additions & 10 deletions
lightning/src/ln/channel.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -27,7 +27,7 @@ use crate::ln::features::{ChannelTypeFeatures, InitFeatures};
use crate::ln::msgs;
use crate::ln::msgs::{DecodeError, OptionalField, DataLossProtect};
use crate::ln::script::{self, ShutdownScript};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, SentHTLCId, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, TxCreationKeys, HTLCOutputInCommitment, htlc_success_tx_weight, htlc_timeout_tx_weight, make_funding_redeemscript, ChannelPublicKeys, CommitmentTransaction, HolderCommitmentTransaction, ChannelTransactionParameters, CounterpartyChannelTransactionParameters, MAX_HTLCS, get_commitment_transaction_number_obscure_factor, ClosingTransaction};
use crate::ln::chan_utils;
use crate::ln::onion_utils::HTLCFailReason;
Expand DownExpand Up@@ -192,6 +192,7 @@ enum OutboundHTLCState {

#[derive(Clone)]
enum OutboundHTLCOutcome {
	/// LDK version 0.0.105+ will always fill in the preimage here.
	Success(Option<PaymentPreimage>),
	Failure(HTLCFailReason),
}
Expand DownExpand Up@@ -3159,15 +3160,6 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 }
 }

 self.latest_monitor_update_id += 1;
 let mut monitor_update = ChannelMonitorUpdate {
 update_id: self.latest_monitor_update_id,
 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
 commitment_tx: holder_commitment_tx,
 htlc_outputs: htlcs_and_sigs
 }]
 };

 for htlc in self.pending_inbound_htlcs.iter_mut() {
 let new_forward = if let &InboundHTLCState::RemoteAnnounced(ref forward_info) = &htlc.state {
 Some(forward_info.clone())
Expand All@@ -3179,18 +3171,38 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 need_commitment = true;
 }
 }
 let mut claimed_htlcs = Vec::new();
 for htlc in self.pending_outbound_htlcs.iter_mut() {
 if let &mut OutboundHTLCState::RemoteRemoved(ref mut outcome) = &mut htlc.state {
 log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToRemove due to commitment_signed in channel {}.",
 log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id));
 // Grab the preimage, if it exists, instead of cloning
 let mut reason = OutboundHTLCOutcome::Success(None);
 mem::swap(outcome, &mut reason);
 if let OutboundHTLCOutcome::Success(Some(preimage)) = reason {
 // If a user (a) receives an HTLC claim using LDK 0.0.104 or before, then (b)
 // upgrades to LDK 0.0.114 or later before the HTLC is fully resolved, we could
 // have a `Success(None)` reason. In this case we could forget some HTLC
 // claims, but such an upgrade is unlikely and including claimed HTLCs here
 // fixes a bug which the user was exposed to on 0.0.104 when they started the
 // claim anyway.
 claimed_htlcs.push((SentHTLCId::from_source(&htlc.source), preimage));
 }
 htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(reason);
 need_commitment = true;
 }
 }

 self.latest_monitor_update_id += 1;
 let mut monitor_update = ChannelMonitorUpdate {
 update_id: self.latest_monitor_update_id,
 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
 commitment_tx: holder_commitment_tx,
 htlc_outputs: htlcs_and_sigs,
 claimed_htlcs,
 }]
 };

 self.cur_holder_commitment_transaction_number -= 1;
 // Note that if we need_commitment & !AwaitingRemoteRevoke we'll call
 // build_commitment_no_status_check() next which will reset this to RAAFirst.
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Track claimed outbound HTLCs in ChannelMonitors by TheBlueMatt · Pull Request #2048 · lightningdevkit/rust-lightning · GitHub
Skip to content
Track claimed outbound HTLCs in ChannelMonitors#2048

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

TheBlueMatt
merged 3 commits into

from

Mar 3, 2023
 Merged


Track claimed outbound HTLCs in ChannelMonitors
#2048
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


3 commits


Select commit
Hold shift + click to select a range
33c36d0

Avoid removing stale preimages when hashes collide in fuzzing


TheBlueMatt Mar 2, 2023
0ad1f4c

Track claimed outbound HTLCs in ChannelMonitors


TheBlueMatt Feb 22, 2023
75527db

Remove unused compat block in `provide_latest_holder_commitment_tx`


TheBlueMatt Mar 1, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


125 changes: 87 additions & 38 deletions
lightning/src/chain/channelmonitor.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -37,7 +37,7 @@ use crate::ln::{PaymentHash, PaymentPreimage};
use crate::ln::msgs::DecodeError;
use crate::ln::chan_utils;
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HTLCClaim, ChannelTransactionParameters, HolderCommitmentTransaction};
use crate::ln::channelmanager::HTLCSource;
use crate::ln::channelmanager::{HTLCSource, SentHTLCId};
use crate::chain;
use crate::chain::{BestBlock, WatchedOutput};
use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator, LowerBoundedFeeEstimator};
Expand DownExpand Up@@ -494,6 +494,7 @@ pub(crate) enum ChannelMonitorUpdateStep {
	LatestHolderCommitmentTXInfo {
 commitment_tx: HolderCommitmentTransaction,
 htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
 claimed_htlcs: Vec<(SentHTLCId, PaymentPreimage)>,
Comment thread
wpaulino marked this conversation as resolved.

	},
	LatestCounterpartyCommitmentTXInfo {
 commitment_txid: Txid,
Expand DownExpand Up@@ -536,6 +537,7 @@ impl ChannelMonitorUpdateStep {
impl_writeable_tlv_based_enum_upgradable!(ChannelMonitorUpdateStep,
	(0, LatestHolderCommitmentTXInfo) => {
 (0, commitment_tx, required),
 (1, claimed_htlcs, vec_type),
 (2, htlc_outputs, vec_type),
	},
	(1, LatestCounterpartyCommitmentTXInfo) => {
Expand DownExpand Up@@ -750,6 +752,8 @@ pub(crate) struct ChannelMonitorImpl<Signer: WriteableEcdsaChannelSigner> {
	/// Serialized to disk but should generally not be sent to Watchtowers.
	counterparty_hash_commitment_number: HashMap<PaymentHash, u64>,

	counterparty_fulfilled_htlcs: HashMap<SentHTLCId, PaymentPreimage>,

	// We store two holder commitment transactions to avoid any race conditions where we may update
	// some monitors (potentially on watchtowers) but then fail to update others, resulting in the
	// various monitors for one channel being out of sync, and us broadcasting a holder
Expand DownExpand Up@@ -1033,6 +1037,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for ChannelMonitorImpl<Signe
 (9, self.counterparty_node_id, option),
 (11, self.confirmed_commitment_tx_counterparty_output, option),
 (13, self.spendable_txids_confirmed, vec_type),
 (15, self.counterparty_fulfilled_htlcs, required),
 });

 Ok(())
Expand DownExpand Up@@ -1120,6 +1125,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 counterparty_claimable_outpoints: HashMap::new(),
 counterparty_commitment_txn_on_chain: HashMap::new(),
 counterparty_hash_commitment_number: HashMap::new(),
 counterparty_fulfilled_htlcs: HashMap::new(),

 prev_holder_signed_commitment_tx: None,
 current_holder_commitment_tx: holder_commitment_tx,
Expand DownExpand Up@@ -1174,7 +1180,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 &self, holder_commitment_tx: HolderCommitmentTransaction,
 htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
	) -> Result<(), ()> {
 self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs).map_err(|_| ())
 self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs, &Vec::new()).map_err(|_| ())
	}

	/// This is used to provide payment preimage(s) out-of-band during startup without updating the
Expand DownExpand Up@@ -1810,9 +1816,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
	/// `ChannelMonitor`. This is used to determine if an HTLC was removed from the channel prior
	/// to the `ChannelManager` having been persisted.
	///
	/// This is similar to [`Self::get_pending_outbound_htlcs`] except it includes HTLCs which were
	/// resolved by this `ChannelMonitor`.
	pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
	/// This is similar to [`Self::get_pending_or_resolved_outbound_htlcs`] except it includes
	/// HTLCs which were resolved on-chain (i.e. where the final HTLC resolution was done by an
	/// event from this `ChannelMonitor`).
	pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
 let mut res = HashMap::new();
 // Just examine the available counterparty commitment transactions. See docs on
 // `fail_unbroadcast_htlcs`, below, for justification.
Expand All@@ -1822,7 +1829,8 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 if let Some(ref latest_outpoints) = us.counterparty_claimable_outpoints.get($txid) {
 for &(ref htlc, ref source_option) in latest_outpoints.iter() {
 if let &Some(ref source) = source_option {
 res.insert((**source).clone(), htlc.clone());
 res.insert((**source).clone(), (htlc.clone(),
 us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned()));
 }
 }
 }
Expand All@@ -1837,9 +1845,14 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 res
	}

	/// Gets the set of outbound HTLCs which are pending resolution in this channel.
	/// Gets the set of outbound HTLCs which are pending resolution in this channel or which were
	/// resolved with a preimage from our counterparty.
	///
	/// This is used to reconstruct pending outbound payments on restart in the ChannelManager.
	pub(crate) fn get_pending_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
	///
	/// Currently, the preimage is unused, however if it is present in the relevant internal state
	/// an HTLC is always included even if it has been resolved.
	pub(crate) fn get_pending_or_resolved_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
Comment thread
wpaulino marked this conversation as resolved.

 let us = self.inner.lock().unwrap();
 // We're only concerned with the confirmation count of HTLC transactions, and don't
 // actually care how many confirmations a commitment transaction may or may not have. Thus,
Expand DownExpand Up@@ -1887,8 +1900,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 Some(commitment_tx_output_idx) == htlc.transaction_output_index
 } else { false }
 });
 if !htlc_update_confd {
 res.insert(source.clone(), htlc.clone());
Comment thread
wpaulino marked this conversation as resolved.

 let counterparty_resolved_preimage_opt =
 us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned();
 if !htlc_update_confd || counterparty_resolved_preimage_opt.is_some() {
 res.insert(source.clone(), (htlc.clone(), counterparty_resolved_preimage_opt));
 }
 }
 }
Expand DownExpand Up@@ -1970,6 +1985,9 @@ macro_rules! fail_unbroadcast_htlcs {
 }
 }
 if matched_htlc { continue; }
 if $self.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).is_some() {
 continue;
 }
Comment thread
wpaulino marked this conversation as resolved.

 $self.onchain_events_awaiting_threshold_conf.retain(|ref entry| {
 if entry.height != $commitment_tx_conf_height { return true; }
 match entry.event {
Expand DownExpand Up@@ -2041,8 +2059,23 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 // Prune HTLCs from the previous counterparty commitment tx so we don't generate failure/fulfill
 // events for now-revoked/fulfilled HTLCs.
 if let Some(txid) = self.prev_counterparty_commitment_txid.take() {
 for &mut (_, ref mut source) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
 *source = None;
 if self.current_counterparty_commitment_txid.unwrap() != txid {
 let cur_claimables = self.counterparty_claimable_outpoints.get(
 &self.current_counterparty_commitment_txid.unwrap()).unwrap();
 for (_, ref source_opt) in self.counterparty_claimable_outpoints.get(&txid).unwrap() {
 if let Some(source) = source_opt {
 if !cur_claimables.iter()
 .any(|(_, cur_source_opt)| cur_source_opt == source_opt)
 {
 self.counterparty_fulfilled_htlcs.remove(&SentHTLCId::from_source(source));
 }
 }
 }
 for &mut (_, ref mut source_opt) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
 *source_opt = None;
 }
Comment thread
valentinewallace marked this conversation as resolved.

 } else {
 assert!(cfg!(fuzzing), "Commitment txids are unique outside of fuzzing, where hashes can collide");
 }
 }

Expand DownExpand Up@@ -2127,28 +2160,37 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
	/// is important that any clones of this channel monitor (including remote clones) by kept
	/// up-to-date as our holder commitment transaction is updated.
	/// Panics if set_on_holder_tx_csv has never been called.
	fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>) -> Result<(), &'static str> {
 // block for Rust 1.34 compat
 let mut new_holder_commitment_tx = {
 let trusted_tx = holder_commitment_tx.trust();
 let txid = trusted_tx.txid();
 let tx_keys = trusted_tx.keys();
 self.current_holder_commitment_number = trusted_tx.commitment_number();
 HolderSignedTx {
 txid,
 revocation_key: tx_keys.revocation_key,
 a_htlc_key: tx_keys.broadcaster_htlc_key,
 b_htlc_key: tx_keys.countersignatory_htlc_key,
 delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 per_commitment_point: tx_keys.per_commitment_point,
 htlc_outputs,
 to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
 feerate_per_kw: trusted_tx.feerate_per_kw(),
 }
	fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>, claimed_htlcs: &[(SentHTLCId, PaymentPreimage)]) -> Result<(), &'static str> {
 let trusted_tx = holder_commitment_tx.trust();
 let txid = trusted_tx.txid();
 let tx_keys = trusted_tx.keys();
 self.current_holder_commitment_number = trusted_tx.commitment_number();
 let mut new_holder_commitment_tx = HolderSignedTx {
 txid,
 revocation_key: tx_keys.revocation_key,
 a_htlc_key: tx_keys.broadcaster_htlc_key,
 b_htlc_key: tx_keys.countersignatory_htlc_key,
 delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 per_commitment_point: tx_keys.per_commitment_point,
 htlc_outputs,
 to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
 feerate_per_kw: trusted_tx.feerate_per_kw(),
 };
 self.onchain_tx_handler.provide_latest_holder_tx(holder_commitment_tx);
 mem::swap(&mut new_holder_commitment_tx, &mut self.current_holder_commitment_tx);
 self.prev_holder_signed_commitment_tx = Some(new_holder_commitment_tx);
 for (claimed_htlc_id, claimed_preimage) in claimed_htlcs {
 #[cfg(debug_assertions)] {
 let cur_counterparty_htlcs = self.counterparty_claimable_outpoints.get(
 &self.current_counterparty_commitment_txid.unwrap()).unwrap();
 assert!(cur_counterparty_htlcs.iter().any(|(_, source_opt)| {
 if let Some(source) = source_opt {
 SentHTLCId::from_source(source) == *claimed_htlc_id
 } else { false }
 }));
 }
 self.counterparty_fulfilled_htlcs.insert(*claimed_htlc_id, *claimed_preimage);
 }
 if self.holder_tx_signed {
 return Err("Latest holder commitment signed has already been signed, update is rejected");
 }
Expand DownExpand Up@@ -2243,10 +2285,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&*fee_estimator);
 for update in updates.updates.iter() {
 match update {
 ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs } => {
 ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs, claimed_htlcs } => {
 log_trace!(logger, "Updating ChannelMonitor with latest holder commitment transaction info");
 if self.lockdown_from_offchain { panic!(); }
 if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone()) {
 if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone(), &claimed_htlcs) {
 log_error!(logger, "Providing latest holder commitment transaction failed/was refused:");
 log_error!(logger, " {}", e);
 ret = Err(());
Expand DownExpand Up@@ -3868,6 +3910,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 let mut counterparty_node_id = None;
 let mut confirmed_commitment_tx_counterparty_output = None;
 let mut spendable_txids_confirmed = Some(Vec::new());
 let mut counterparty_fulfilled_htlcs = Some(HashMap::new());
 read_tlv_fields!(reader, {
 (1, funding_spend_confirmed, option),
 (3, htlcs_resolved_on_chain, vec_type),
Expand All@@ -3876,6 +3919,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 (9, counterparty_node_id, option),
 (11, confirmed_commitment_tx_counterparty_output, option),
 (13, spendable_txids_confirmed, vec_type),
 (15, counterparty_fulfilled_htlcs, option),
 });

 Ok((best_block.block_hash(), ChannelMonitor::from_impl(ChannelMonitorImpl {
Expand DownExpand Up@@ -3904,6 +3948,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 counterparty_claimable_outpoints,
 counterparty_commitment_txn_on_chain,
 counterparty_hash_commitment_number,
 counterparty_fulfilled_htlcs: counterparty_fulfilled_htlcs.unwrap(),

 prev_holder_signed_commitment_tx,
 current_holder_commitment_tx,
Expand DownExpand Up@@ -4077,7 +4122,6 @@ mod tests {
 let fee_estimator = TestFeeEstimator { sat_per_kw: Mutex::new(253) };

 let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
 let dummy_tx = Transaction { version: 0, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() };

 let mut preimages = Vec::new();
 {
Expand DownExpand Up@@ -4167,11 +4211,10 @@ mod tests {
 HolderCommitmentTransaction::dummy(), best_block, dummy_key);

 monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..10])).unwrap();
 let dummy_txid = dummy_tx.txid();
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"1").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"2").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 for &(ref preimage, ref hash) in preimages.iter() {
 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_estimator);
 monitor.provide_payment_preimage(hash, preimage, &broadcaster, &bounded_fee_estimator, &logger);
Expand All@@ -4185,13 +4228,19 @@ mod tests {
 test_preimages_exist!(&preimages[0..10], monitor);
 test_preimages_exist!(&preimages[15..20], monitor);

 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"3").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);

 // Now provide a further secret, pruning preimages 15-17
 secret[0..32].clone_from_slice(&hex::decode("c7518c8ae4660ed02894df8976fa1a3659c1a8b4b5bec0c4b872abeba4cb8964").unwrap());
 monitor.provide_secret(281474976710654, secret.clone()).unwrap();
 assert_eq!(monitor.inner.lock().unwrap().payment_preimages.len(), 13);
 test_preimages_exist!(&preimages[0..10], monitor);
 test_preimages_exist!(&preimages[17..20], monitor);

 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"4").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);

 // Now update holder commitment tx info, pruning only element 18 as we still care about the
 // previous commitment tx's preimages too
 monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..5])).unwrap();
Expand Down

32 changes: 22 additions & 10 deletions
lightning/src/ln/channel.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -27,7 +27,7 @@ use crate::ln::features::{ChannelTypeFeatures, InitFeatures};
use crate::ln::msgs;
use crate::ln::msgs::{DecodeError, OptionalField, DataLossProtect};
use crate::ln::script::{self, ShutdownScript};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, SentHTLCId, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, TxCreationKeys, HTLCOutputInCommitment, htlc_success_tx_weight, htlc_timeout_tx_weight, make_funding_redeemscript, ChannelPublicKeys, CommitmentTransaction, HolderCommitmentTransaction, ChannelTransactionParameters, CounterpartyChannelTransactionParameters, MAX_HTLCS, get_commitment_transaction_number_obscure_factor, ClosingTransaction};
use crate::ln::chan_utils;
use crate::ln::onion_utils::HTLCFailReason;
Expand DownExpand Up@@ -192,6 +192,7 @@ enum OutboundHTLCState {

#[derive(Clone)]
enum OutboundHTLCOutcome {
	/// LDK version 0.0.105+ will always fill in the preimage here.
	Success(Option<PaymentPreimage>),
	Failure(HTLCFailReason),
}
Expand DownExpand Up@@ -3159,15 +3160,6 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 }
 }

 self.latest_monitor_update_id += 1;
 let mut monitor_update = ChannelMonitorUpdate {
 update_id: self.latest_monitor_update_id,
 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
 commitment_tx: holder_commitment_tx,
 htlc_outputs: htlcs_and_sigs
 }]
 };

 for htlc in self.pending_inbound_htlcs.iter_mut() {
 let new_forward = if let &InboundHTLCState::RemoteAnnounced(ref forward_info) = &htlc.state {
 Some(forward_info.clone())
Expand All@@ -3179,18 +3171,38 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 need_commitment = true;
 }
 }
 let mut claimed_htlcs = Vec::new();
 for htlc in self.pending_outbound_htlcs.iter_mut() {
 if let &mut OutboundHTLCState::RemoteRemoved(ref mut outcome) = &mut htlc.state {
 log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToRemove due to commitment_signed in channel {}.",
 log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id));
 // Grab the preimage, if it exists, instead of cloning
 let mut reason = OutboundHTLCOutcome::Success(None);
 mem::swap(outcome, &mut reason);
 if let OutboundHTLCOutcome::Success(Some(preimage)) = reason {
 // If a user (a) receives an HTLC claim using LDK 0.0.104 or before, then (b)
 // upgrades to LDK 0.0.114 or later before the HTLC is fully resolved, we could
 // have a `Success(None)` reason. In this case we could forget some HTLC
 // claims, but such an upgrade is unlikely and including claimed HTLCs here
 // fixes a bug which the user was exposed to on 0.0.104 when they started the
 // claim anyway.
 claimed_htlcs.push((SentHTLCId::from_source(&htlc.source), preimage));
 }
 htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(reason);
 need_commitment = true;
 }
 }

 self.latest_monitor_update_id += 1;
 let mut monitor_update = ChannelMonitorUpdate {
 update_id: self.latest_monitor_update_id,
 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
 commitment_tx: holder_commitment_tx,
 htlc_outputs: htlcs_and_sigs,
 claimed_htlcs,
 }]
 };

 self.cur_holder_commitment_transaction_number -= 1;
 // Note that if we need_commitment & !AwaitingRemoteRevoke we'll call
 // build_commitment_no_status_check() next which will reset this to RAAFirst.
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
Track claimed outbound HTLCs in ChannelMonitors by TheBlueMatt · Pull Request #2048 · lightningdevkit/rust-lightning · GitHub
Skip to content
Track claimed outbound HTLCs in ChannelMonitors#2048

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

TheBlueMatt
merged 3 commits into

from

Mar 3, 2023
 Merged


Track claimed outbound HTLCs in ChannelMonitors
#2048
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


3 commits


Select commit
Hold shift + click to select a range
33c36d0

Avoid removing stale preimages when hashes collide in fuzzing


TheBlueMatt Mar 2, 2023
0ad1f4c

Track claimed outbound HTLCs in ChannelMonitors


TheBlueMatt Feb 22, 2023
75527db

Remove unused compat block in `provide_latest_holder_commitment_tx`


TheBlueMatt Mar 1, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


125 changes: 87 additions & 38 deletions
lightning/src/chain/channelmonitor.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -37,7 +37,7 @@ use crate::ln::{PaymentHash, PaymentPreimage};
use crate::ln::msgs::DecodeError;
use crate::ln::chan_utils;
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HTLCClaim, ChannelTransactionParameters, HolderCommitmentTransaction};
use crate::ln::channelmanager::HTLCSource;
use crate::ln::channelmanager::{HTLCSource, SentHTLCId};
use crate::chain;
use crate::chain::{BestBlock, WatchedOutput};
use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator, LowerBoundedFeeEstimator};
Expand DownExpand Up@@ -494,6 +494,7 @@ pub(crate) enum ChannelMonitorUpdateStep {
	LatestHolderCommitmentTXInfo {
 commitment_tx: HolderCommitmentTransaction,
 htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
 claimed_htlcs: Vec<(SentHTLCId, PaymentPreimage)>,
Comment thread
wpaulino marked this conversation as resolved.

	},
	LatestCounterpartyCommitmentTXInfo {
 commitment_txid: Txid,
Expand DownExpand Up@@ -536,6 +537,7 @@ impl ChannelMonitorUpdateStep {
impl_writeable_tlv_based_enum_upgradable!(ChannelMonitorUpdateStep,
	(0, LatestHolderCommitmentTXInfo) => {
 (0, commitment_tx, required),
 (1, claimed_htlcs, vec_type),
 (2, htlc_outputs, vec_type),
	},
	(1, LatestCounterpartyCommitmentTXInfo) => {
Expand DownExpand Up@@ -750,6 +752,8 @@ pub(crate) struct ChannelMonitorImpl<Signer: WriteableEcdsaChannelSigner> {
	/// Serialized to disk but should generally not be sent to Watchtowers.
	counterparty_hash_commitment_number: HashMap<PaymentHash, u64>,

	counterparty_fulfilled_htlcs: HashMap<SentHTLCId, PaymentPreimage>,

	// We store two holder commitment transactions to avoid any race conditions where we may update
	// some monitors (potentially on watchtowers) but then fail to update others, resulting in the
	// various monitors for one channel being out of sync, and us broadcasting a holder
Expand DownExpand Up@@ -1033,6 +1037,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for ChannelMonitorImpl<Signe
 (9, self.counterparty_node_id, option),
 (11, self.confirmed_commitment_tx_counterparty_output, option),
 (13, self.spendable_txids_confirmed, vec_type),
 (15, self.counterparty_fulfilled_htlcs, required),
 });

 Ok(())
Expand DownExpand Up@@ -1120,6 +1125,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 counterparty_claimable_outpoints: HashMap::new(),
 counterparty_commitment_txn_on_chain: HashMap::new(),
 counterparty_hash_commitment_number: HashMap::new(),
 counterparty_fulfilled_htlcs: HashMap::new(),

 prev_holder_signed_commitment_tx: None,
 current_holder_commitment_tx: holder_commitment_tx,
Expand DownExpand Up@@ -1174,7 +1180,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 &self, holder_commitment_tx: HolderCommitmentTransaction,
 htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
	) -> Result<(), ()> {
 self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs).map_err(|_| ())
 self.inner.lock().unwrap().provide_latest_holder_commitment_tx(holder_commitment_tx, htlc_outputs, &Vec::new()).map_err(|_| ())
	}

	/// This is used to provide payment preimage(s) out-of-band during startup without updating the
Expand DownExpand Up@@ -1810,9 +1816,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
	/// `ChannelMonitor`. This is used to determine if an HTLC was removed from the channel prior
	/// to the `ChannelManager` having been persisted.
	///
	/// This is similar to [`Self::get_pending_outbound_htlcs`] except it includes HTLCs which were
	/// resolved by this `ChannelMonitor`.
	pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
	/// This is similar to [`Self::get_pending_or_resolved_outbound_htlcs`] except it includes
	/// HTLCs which were resolved on-chain (i.e. where the final HTLC resolution was done by an
	/// event from this `ChannelMonitor`).
	pub(crate) fn get_all_current_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
 let mut res = HashMap::new();
 // Just examine the available counterparty commitment transactions. See docs on
 // `fail_unbroadcast_htlcs`, below, for justification.
Expand All@@ -1822,7 +1829,8 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 if let Some(ref latest_outpoints) = us.counterparty_claimable_outpoints.get($txid) {
 for &(ref htlc, ref source_option) in latest_outpoints.iter() {
 if let &Some(ref source) = source_option {
 res.insert((**source).clone(), htlc.clone());
 res.insert((**source).clone(), (htlc.clone(),
 us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned()));
 }
 }
 }
Expand All@@ -1837,9 +1845,14 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 res
	}

	/// Gets the set of outbound HTLCs which are pending resolution in this channel.
	/// Gets the set of outbound HTLCs which are pending resolution in this channel or which were
	/// resolved with a preimage from our counterparty.
	///
	/// This is used to reconstruct pending outbound payments on restart in the ChannelManager.
	pub(crate) fn get_pending_outbound_htlcs(&self) -> HashMap<HTLCSource, HTLCOutputInCommitment> {
	///
	/// Currently, the preimage is unused, however if it is present in the relevant internal state
	/// an HTLC is always included even if it has been resolved.
	pub(crate) fn get_pending_or_resolved_outbound_htlcs(&self) -> HashMap<HTLCSource, (HTLCOutputInCommitment, Option<PaymentPreimage>)> {
Comment thread
wpaulino marked this conversation as resolved.

 let us = self.inner.lock().unwrap();
 // We're only concerned with the confirmation count of HTLC transactions, and don't
 // actually care how many confirmations a commitment transaction may or may not have. Thus,
Expand DownExpand Up@@ -1887,8 +1900,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 Some(commitment_tx_output_idx) == htlc.transaction_output_index
 } else { false }
 });
 if !htlc_update_confd {
 res.insert(source.clone(), htlc.clone());
Comment thread
wpaulino marked this conversation as resolved.

 let counterparty_resolved_preimage_opt =
 us.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).cloned();
 if !htlc_update_confd || counterparty_resolved_preimage_opt.is_some() {
 res.insert(source.clone(), (htlc.clone(), counterparty_resolved_preimage_opt));
 }
 }
 }
Expand DownExpand Up@@ -1970,6 +1985,9 @@ macro_rules! fail_unbroadcast_htlcs {
 }
 }
 if matched_htlc { continue; }
 if $self.counterparty_fulfilled_htlcs.get(&SentHTLCId::from_source(source)).is_some() {
 continue;
 }
Comment thread
wpaulino marked this conversation as resolved.

 $self.onchain_events_awaiting_threshold_conf.retain(|ref entry| {
 if entry.height != $commitment_tx_conf_height { return true; }
 match entry.event {
Expand DownExpand Up@@ -2041,8 +2059,23 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 // Prune HTLCs from the previous counterparty commitment tx so we don't generate failure/fulfill
 // events for now-revoked/fulfilled HTLCs.
 if let Some(txid) = self.prev_counterparty_commitment_txid.take() {
 for &mut (_, ref mut source) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
 *source = None;
 if self.current_counterparty_commitment_txid.unwrap() != txid {
 let cur_claimables = self.counterparty_claimable_outpoints.get(
 &self.current_counterparty_commitment_txid.unwrap()).unwrap();
 for (_, ref source_opt) in self.counterparty_claimable_outpoints.get(&txid).unwrap() {
 if let Some(source) = source_opt {
 if !cur_claimables.iter()
 .any(|(_, cur_source_opt)| cur_source_opt == source_opt)
 {
 self.counterparty_fulfilled_htlcs.remove(&SentHTLCId::from_source(source));
 }
 }
 }
 for &mut (_, ref mut source_opt) in self.counterparty_claimable_outpoints.get_mut(&txid).unwrap() {
 *source_opt = None;
 }
Comment thread
valentinewallace marked this conversation as resolved.

 } else {
 assert!(cfg!(fuzzing), "Commitment txids are unique outside of fuzzing, where hashes can collide");
 }
 }

Expand DownExpand Up@@ -2127,28 +2160,37 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
	/// is important that any clones of this channel monitor (including remote clones) by kept
	/// up-to-date as our holder commitment transaction is updated.
	/// Panics if set_on_holder_tx_csv has never been called.
	fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>) -> Result<(), &'static str> {
 // block for Rust 1.34 compat
 let mut new_holder_commitment_tx = {
 let trusted_tx = holder_commitment_tx.trust();
 let txid = trusted_tx.txid();
 let tx_keys = trusted_tx.keys();
 self.current_holder_commitment_number = trusted_tx.commitment_number();
 HolderSignedTx {
 txid,
 revocation_key: tx_keys.revocation_key,
 a_htlc_key: tx_keys.broadcaster_htlc_key,
 b_htlc_key: tx_keys.countersignatory_htlc_key,
 delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 per_commitment_point: tx_keys.per_commitment_point,
 htlc_outputs,
 to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
 feerate_per_kw: trusted_tx.feerate_per_kw(),
 }
	fn provide_latest_holder_commitment_tx(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>, claimed_htlcs: &[(SentHTLCId, PaymentPreimage)]) -> Result<(), &'static str> {
 let trusted_tx = holder_commitment_tx.trust();
 let txid = trusted_tx.txid();
 let tx_keys = trusted_tx.keys();
 self.current_holder_commitment_number = trusted_tx.commitment_number();
 let mut new_holder_commitment_tx = HolderSignedTx {
 txid,
 revocation_key: tx_keys.revocation_key,
 a_htlc_key: tx_keys.broadcaster_htlc_key,
 b_htlc_key: tx_keys.countersignatory_htlc_key,
 delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 per_commitment_point: tx_keys.per_commitment_point,
 htlc_outputs,
 to_self_value_sat: holder_commitment_tx.to_broadcaster_value_sat(),
 feerate_per_kw: trusted_tx.feerate_per_kw(),
 };
 self.onchain_tx_handler.provide_latest_holder_tx(holder_commitment_tx);
 mem::swap(&mut new_holder_commitment_tx, &mut self.current_holder_commitment_tx);
 self.prev_holder_signed_commitment_tx = Some(new_holder_commitment_tx);
 for (claimed_htlc_id, claimed_preimage) in claimed_htlcs {
 #[cfg(debug_assertions)] {
 let cur_counterparty_htlcs = self.counterparty_claimable_outpoints.get(
 &self.current_counterparty_commitment_txid.unwrap()).unwrap();
 assert!(cur_counterparty_htlcs.iter().any(|(_, source_opt)| {
 if let Some(source) = source_opt {
 SentHTLCId::from_source(source) == *claimed_htlc_id
 } else { false }
 }));
 }
 self.counterparty_fulfilled_htlcs.insert(*claimed_htlc_id, *claimed_preimage);
 }
 if self.holder_tx_signed {
 return Err("Latest holder commitment signed has already been signed, update is rejected");
 }
Expand DownExpand Up@@ -2243,10 +2285,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&*fee_estimator);
 for update in updates.updates.iter() {
 match update {
 ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs } => {
 ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs, claimed_htlcs } => {
 log_trace!(logger, "Updating ChannelMonitor with latest holder commitment transaction info");
 if self.lockdown_from_offchain { panic!(); }
 if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone()) {
 if let Err(e) = self.provide_latest_holder_commitment_tx(commitment_tx.clone(), htlc_outputs.clone(), &claimed_htlcs) {
 log_error!(logger, "Providing latest holder commitment transaction failed/was refused:");
 log_error!(logger, " {}", e);
 ret = Err(());
Expand DownExpand Up@@ -3868,6 +3910,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 let mut counterparty_node_id = None;
 let mut confirmed_commitment_tx_counterparty_output = None;
 let mut spendable_txids_confirmed = Some(Vec::new());
 let mut counterparty_fulfilled_htlcs = Some(HashMap::new());
 read_tlv_fields!(reader, {
 (1, funding_spend_confirmed, option),
 (3, htlcs_resolved_on_chain, vec_type),
Expand All@@ -3876,6 +3919,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 (9, counterparty_node_id, option),
 (11, confirmed_commitment_tx_counterparty_output, option),
 (13, spendable_txids_confirmed, vec_type),
 (15, counterparty_fulfilled_htlcs, option),
 });

 Ok((best_block.block_hash(), ChannelMonitor::from_impl(ChannelMonitorImpl {
Expand DownExpand Up@@ -3904,6 +3948,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 counterparty_claimable_outpoints,
 counterparty_commitment_txn_on_chain,
 counterparty_hash_commitment_number,
 counterparty_fulfilled_htlcs: counterparty_fulfilled_htlcs.unwrap(),

 prev_holder_signed_commitment_tx,
 current_holder_commitment_tx,
Expand DownExpand Up@@ -4077,7 +4122,6 @@ mod tests {
 let fee_estimator = TestFeeEstimator { sat_per_kw: Mutex::new(253) };

 let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
 let dummy_tx = Transaction { version: 0, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() };

 let mut preimages = Vec::new();
 {
Expand DownExpand Up@@ -4167,11 +4211,10 @@ mod tests {
 HolderCommitmentTransaction::dummy(), best_block, dummy_key);

 monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..10])).unwrap();
 let dummy_txid = dummy_tx.txid();
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"1").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"2").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 for &(ref preimage, ref hash) in preimages.iter() {
 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_estimator);
 monitor.provide_payment_preimage(hash, preimage, &broadcaster, &bounded_fee_estimator, &logger);
Expand All@@ -4185,13 +4228,19 @@ mod tests {
 test_preimages_exist!(&preimages[0..10], monitor);
 test_preimages_exist!(&preimages[15..20], monitor);

 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"3").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);

 // Now provide a further secret, pruning preimages 15-17
 secret[0..32].clone_from_slice(&hex::decode("c7518c8ae4660ed02894df8976fa1a3659c1a8b4b5bec0c4b872abeba4cb8964").unwrap());
 monitor.provide_secret(281474976710654, secret.clone()).unwrap();
 assert_eq!(monitor.inner.lock().unwrap().payment_preimages.len(), 13);
 test_preimages_exist!(&preimages[0..10], monitor);
 test_preimages_exist!(&preimages[17..20], monitor);

 monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"4").into_inner()),
 preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);

 // Now update holder commitment tx info, pruning only element 18 as we still care about the
 // previous commitment tx's preimages too
 monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..5])).unwrap();
Expand Down

32 changes: 22 additions & 10 deletions
lightning/src/ln/channel.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -27,7 +27,7 @@ use crate::ln::features::{ChannelTypeFeatures, InitFeatures};
use crate::ln::msgs;
use crate::ln::msgs::{DecodeError, OptionalField, DataLossProtect};
use crate::ln::script::{self, ShutdownScript};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, SentHTLCId, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, TxCreationKeys, HTLCOutputInCommitment, htlc_success_tx_weight, htlc_timeout_tx_weight, make_funding_redeemscript, ChannelPublicKeys, CommitmentTransaction, HolderCommitmentTransaction, ChannelTransactionParameters, CounterpartyChannelTransactionParameters, MAX_HTLCS, get_commitment_transaction_number_obscure_factor, ClosingTransaction};
use crate::ln::chan_utils;
use crate::ln::onion_utils::HTLCFailReason;
Expand DownExpand Up@@ -192,6 +192,7 @@ enum OutboundHTLCState {

#[derive(Clone)]
enum OutboundHTLCOutcome {
	/// LDK version 0.0.105+ will always fill in the preimage here.
	Success(Option<PaymentPreimage>),
	Failure(HTLCFailReason),
}
Expand DownExpand Up@@ -3159,15 +3160,6 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 }
 }

 self.latest_monitor_update_id += 1;
 let mut monitor_update = ChannelMonitorUpdate {
 update_id: self.latest_monitor_update_id,
 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
 commitment_tx: holder_commitment_tx,
 htlc_outputs: htlcs_and_sigs
 }]
 };

 for htlc in self.pending_inbound_htlcs.iter_mut() {
 let new_forward = if let &InboundHTLCState::RemoteAnnounced(ref forward_info) = &htlc.state {
 Some(forward_info.clone())
Expand All@@ -3179,18 +3171,38 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 need_commitment = true;
 }
 }
 let mut claimed_htlcs = Vec::new();
 for htlc in self.pending_outbound_htlcs.iter_mut() {
 if let &mut OutboundHTLCState::RemoteRemoved(ref mut outcome) = &mut htlc.state {
 log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToRemove due to commitment_signed in channel {}.",
 log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id));
 // Grab the preimage, if it exists, instead of cloning
 let mut reason = OutboundHTLCOutcome::Success(None);
 mem::swap(outcome, &mut reason);
 if let OutboundHTLCOutcome::Success(Some(preimage)) = reason {
 // If a user (a) receives an HTLC claim using LDK 0.0.104 or before, then (b)
 // upgrades to LDK 0.0.114 or later before the HTLC is fully resolved, we could
 // have a `Success(None)` reason. In this case we could forget some HTLC
 // claims, but such an upgrade is unlikely and including claimed HTLCs here
 // fixes a bug which the user was exposed to on 0.0.104 when they started the
 // claim anyway.
 claimed_htlcs.push((SentHTLCId::from_source(&htlc.source), preimage));
 }
 htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(reason);
 need_commitment = true;
 }
 }

 self.latest_monitor_update_id += 1;
 let mut monitor_update = ChannelMonitorUpdate {
 update_id: self.latest_monitor_update_id,
 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
 commitment_tx: holder_commitment_tx,
 htlc_outputs: htlcs_and_sigs,
 claimed_htlcs,
 }]
 };

 self.cur_holder_commitment_transaction_number -= 1;
 // Note that if we need_commitment & !AwaitingRemoteRevoke we'll call
 // build_commitment_no_status_check() next which will reset this to RAAFirst.
Expand Down
Loading