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

Ensure ChannelMonitor Loggers are always wrapped with metadata

Browse source 
In order to ensure log lines generated by `ChannelMonitor` always
have a counterparty and channel ID entry, this consistently wraps
`Logger`s in a decorator in all `pub(X)` `ChannelMonitor` functions,
removing `pub` markings on `ChannelMonitorImpl` methods that aren't
actually publicly reachable anyway.

This also lets us clean up the `Logger` types in various
`ChannelMonitor` methods.
This commit is contained in:
Matt Corallo 2023-12-03 20:03:51 +00:00
parent 6b43153861
commit 65e37fdc29
4 changed files with 119 additions and 105 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
lightning/src/chain/chainmonitor.rs
View file

@ -620,9 +620,8 @@ where C::Target: chain::Filter,
pub fn rebroadcast_pending_claims(&self) { pub fn rebroadcast_pending_claims(&self) {
let monitors = self.monitors.read().unwrap(); let monitors = self.monitors.read().unwrap();
for (_, monitor_holder) in &*monitors { for (_, monitor_holder) in &*monitors {
let logger = WithChannelMonitor::from(&self.logger, &monitor_holder.monitor);
monitor_holder.monitor.rebroadcast_pending_claims( monitor_holder.monitor.rebroadcast_pending_claims(
&*self.broadcaster, &*self.fee_estimator, &logger &*self.broadcaster, &*self.fee_estimator, &self.logger
) )
} }
} }
@ -640,9 +639,8 @@ where
fn filtered_block_connected(&self, header: &Header, txdata: &TransactionData, height: u32) { fn filtered_block_connected(&self, header: &Header, txdata: &TransactionData, height: u32) {
log_debug!(self.logger, "New best block {} at height {} provided via block_connected", header.block_hash(), height); log_debug!(self.logger, "New best block {} at height {} provided via block_connected", header.block_hash(), height);
self.process_chain_data(header, Some(height), &txdata, |monitor, txdata| { self.process_chain_data(header, Some(height), &txdata, |monitor, txdata| {
let logger = WithChannelMonitor::from(&self.logger, &monitor);
monitor.block_connected( monitor.block_connected(
header, txdata, height, &*self.broadcaster, &*self.fee_estimator, &logger) header, txdata, height, &*self.broadcaster, &*self.fee_estimator, &self.logger)
}); });
} }
@ -650,9 +648,8 @@ where
let monitor_states = self.monitors.read().unwrap(); let monitor_states = self.monitors.read().unwrap();
log_debug!(self.logger, "Latest block {} at height {} removed via block_disconnected", header.block_hash(), height); log_debug!(self.logger, "Latest block {} at height {} removed via block_disconnected", header.block_hash(), height);
for monitor_state in monitor_states.values() { for monitor_state in monitor_states.values() {
let logger = WithChannelMonitor::from(&self.logger, &monitor_state.monitor);
monitor_state.monitor.block_disconnected( monitor_state.monitor.block_disconnected(
header, height, &*self.broadcaster, &*self.fee_estimator, &logger); header, height, &*self.broadcaster, &*self.fee_estimator, &self.logger);
} }
} }
} }
@ -669,9 +666,8 @@ where
fn transactions_confirmed(&self, header: &Header, txdata: &TransactionData, height: u32) { fn transactions_confirmed(&self, header: &Header, txdata: &TransactionData, height: u32) {
log_debug!(self.logger, "{} provided transactions confirmed at height {} in block {}", txdata.len(), height, header.block_hash()); log_debug!(self.logger, "{} provided transactions confirmed at height {} in block {}", txdata.len(), height, header.block_hash());
self.process_chain_data(header, None, txdata, |monitor, txdata| { self.process_chain_data(header, None, txdata, |monitor, txdata| {
let logger = WithChannelMonitor::from(&self.logger, &monitor);
monitor.transactions_confirmed( monitor.transactions_confirmed(
header, txdata, height, &*self.broadcaster, &*self.fee_estimator, &logger) header, txdata, height, &*self.broadcaster, &*self.fee_estimator, &self.logger)
}); });
} }
@ -679,20 +675,19 @@ where
log_debug!(self.logger, "Transaction {} reorganized out of chain", txid); log_debug!(self.logger, "Transaction {} reorganized out of chain", txid);
let monitor_states = self.monitors.read().unwrap(); let monitor_states = self.monitors.read().unwrap();
for monitor_state in monitor_states.values() { for monitor_state in monitor_states.values() {
let logger = WithChannelMonitor::from(&self.logger, &monitor_state.monitor); monitor_state.monitor.transaction_unconfirmed(txid, &*self.broadcaster, &*self.fee_estimator, &self.logger);
monitor_state.monitor.transaction_unconfirmed(txid, &*self.broadcaster, &*self.fee_estimator, &logger);
} }
} }
fn best_block_updated(&self, header: &Header, height: u32) { fn best_block_updated(&self, header: &Header, height: u32) {
log_debug!(self.logger, "New best block {} at height {} provided via best_block_updated", header.block_hash(), height); log_debug!(self.logger, "New best block {} at height {} provided via best_block_updated", header.block_hash(), height);
self.process_chain_data(header, Some(height), &[], |monitor, txdata| { self.process_chain_data(header, Some(height), &[], |monitor, txdata| {
let logger = WithChannelMonitor::from(&self.logger, &monitor);
// While in practice there shouldn't be any recursive calls when given empty txdata, // While in practice there shouldn't be any recursive calls when given empty txdata,
// it's still possible if a chain::Filter implementation returns a transaction. // it's still possible if a chain::Filter implementation returns a transaction.
debug_assert!(txdata.is_empty()); debug_assert!(txdata.is_empty());
monitor.best_block_updated( monitor.best_block_updated(
header, height, &*self.broadcaster, &*self.fee_estimator, &logger) header, height, &*self.broadcaster, &*self.fee_estimator, &self.logger
)
}); });
} }

148
lightning/src/chain/channelmonitor.rs
View file

@ -1139,8 +1139,8 @@ impl<'a, L: Deref> Logger for WithChannelMonitor<'a, L> where L::Target: Logger
} }
} }
impl<'a, 'b, L: Deref> WithChannelMonitor<'a, L> where L::Target: Logger { impl<'a, L: Deref> WithChannelMonitor<'a, L> where L::Target: Logger {
pub(crate) fn from<S: WriteableEcdsaChannelSigner>(logger: &'a L, monitor: &'b ChannelMonitor<S>) -> Self { pub(crate) fn from<S: WriteableEcdsaChannelSigner>(logger: &'a L, monitor: &ChannelMonitor<S>) -> Self {
WithChannelMonitor { WithChannelMonitor {
logger, logger,
peer_id: monitor.get_counterparty_node_id(), peer_id: monitor.get_counterparty_node_id(),
@ -1282,9 +1282,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
) )
where L::Target: Logger where L::Target: Logger
{ {
let logger = WithChannelMonitor::from(logger, self);
self.inner.lock().unwrap().provide_initial_counterparty_commitment_tx(txid, self.inner.lock().unwrap().provide_initial_counterparty_commitment_tx(txid,
htlc_outputs, commitment_number, their_cur_per_commitment_point, feerate_per_kw, htlc_outputs, commitment_number, their_cur_per_commitment_point, feerate_per_kw,
to_broadcaster_value_sat, to_countersignatory_value_sat, logger); to_broadcaster_value_sat, to_countersignatory_value_sat, &logger);
} }
/// Informs this monitor of the latest counterparty (ie non-broadcastable) commitment transaction. /// Informs this monitor of the latest counterparty (ie non-broadcastable) commitment transaction.
@ -1300,8 +1301,9 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
their_per_commitment_point: PublicKey, their_per_commitment_point: PublicKey,
logger: &L, logger: &L,
) where L::Target: Logger { ) where L::Target: Logger {
let logger = WithChannelMonitor::from(logger, self);
self.inner.lock().unwrap().provide_latest_counterparty_commitment_tx( self.inner.lock().unwrap().provide_latest_counterparty_commitment_tx(
txid, htlc_outputs, commitment_number, their_per_commitment_point, logger) txid, htlc_outputs, commitment_number, their_per_commitment_point, &logger)
} }
#[cfg(test)] #[cfg(test)]
@ -1326,8 +1328,9 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger, L::Target: Logger,
{ {
let logger = WithChannelMonitor::from(logger, self);
self.inner.lock().unwrap().provide_payment_preimage( self.inner.lock().unwrap().provide_payment_preimage(
payment_hash, payment_preimage, broadcaster, fee_estimator, logger) payment_hash, payment_preimage, broadcaster, fee_estimator, &logger)
} }
/// Updates a ChannelMonitor on the basis of some new information provided by the Channel /// Updates a ChannelMonitor on the basis of some new information provided by the Channel
@ -1346,7 +1349,8 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger, L::Target: Logger,
{ {
self.inner.lock().unwrap().update_monitor(updates, broadcaster, fee_estimator, logger) let logger = WithChannelMonitor::from(logger, self);
self.inner.lock().unwrap().update_monitor(updates, broadcaster, fee_estimator, &logger)
} }
/// Gets the update_id from the latest ChannelMonitorUpdate which was applied to this /// Gets the update_id from the latest ChannelMonitorUpdate which was applied to this
@ -1525,7 +1529,8 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
/// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
pub fn get_latest_holder_commitment_txn<L: Deref>(&self, logger: &L) -> Vec<Transaction> pub fn get_latest_holder_commitment_txn<L: Deref>(&self, logger: &L) -> Vec<Transaction>
where L::Target: Logger { where L::Target: Logger {
self.inner.lock().unwrap().get_latest_holder_commitment_txn(logger) let logger = WithChannelMonitor::from(logger, self);
self.inner.lock().unwrap().get_latest_holder_commitment_txn(&logger)
} }
/// Unsafe test-only version of get_latest_holder_commitment_txn used by our test framework /// Unsafe test-only version of get_latest_holder_commitment_txn used by our test framework
@ -1534,7 +1539,8 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
#[cfg(any(test, feature = "unsafe_revoked_tx_signing"))] #[cfg(any(test, feature = "unsafe_revoked_tx_signing"))]
pub fn unsafe_get_latest_holder_commitment_txn<L: Deref>(&self, logger: &L) -> Vec<Transaction> pub fn unsafe_get_latest_holder_commitment_txn<L: Deref>(&self, logger: &L) -> Vec<Transaction>
where L::Target: Logger { where L::Target: Logger {
self.inner.lock().unwrap().unsafe_get_latest_holder_commitment_txn(logger) let logger = WithChannelMonitor::from(logger, self);
self.inner.lock().unwrap().unsafe_get_latest_holder_commitment_txn(&logger)
} }
/// Processes transactions in a newly connected block, which may result in any of the following: /// Processes transactions in a newly connected block, which may result in any of the following:
@ -1555,15 +1561,16 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
height: u32, height: u32,
broadcaster: B, broadcaster: B,
fee_estimator: F, fee_estimator: F,
logger: L, logger: &L,
) -> Vec<TransactionOutputs> ) -> Vec<TransactionOutputs>
where where
B::Target: BroadcasterInterface, B::Target: BroadcasterInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger, L::Target: Logger,
{ {
let logger = WithChannelMonitor::from(logger, self);
self.inner.lock().unwrap().block_connected( self.inner.lock().unwrap().block_connected(
header, txdata, height, broadcaster, fee_estimator, logger) header, txdata, height, broadcaster, fee_estimator, &logger)
} }
/// Determines if the disconnected block contained any transactions of interest and updates /// Determines if the disconnected block contained any transactions of interest and updates
@ -1574,14 +1581,15 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
height: u32, height: u32,
broadcaster: B, broadcaster: B,
fee_estimator: F, fee_estimator: F,
logger: L, logger: &L,
) where ) where
B::Target: BroadcasterInterface, B::Target: BroadcasterInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger, L::Target: Logger,
{ {
let logger = WithChannelMonitor::from(logger, self);
self.inner.lock().unwrap().block_disconnected( self.inner.lock().unwrap().block_disconnected(
header, height, broadcaster, fee_estimator, logger) header, height, broadcaster, fee_estimator, &logger)
} }
/// Processes transactions confirmed in a block with the given header and height, returning new /// Processes transactions confirmed in a block with the given header and height, returning new
@ -1598,7 +1606,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
height: u32, height: u32,
broadcaster: B, broadcaster: B,
fee_estimator: F, fee_estimator: F,
logger: L, logger: &L,
) -> Vec<TransactionOutputs> ) -> Vec<TransactionOutputs>
where where
B::Target: BroadcasterInterface, B::Target: BroadcasterInterface,
@ -1606,8 +1614,9 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
L::Target: Logger, L::Target: Logger,
{ {
let bounded_fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator); let bounded_fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator);
let logger = WithChannelMonitor::from(logger, self);
self.inner.lock().unwrap().transactions_confirmed( self.inner.lock().unwrap().transactions_confirmed(
header, txdata, height, broadcaster, &bounded_fee_estimator, logger) header, txdata, height, broadcaster, &bounded_fee_estimator, &logger)
} }
/// Processes a transaction that was reorganized out of the chain. /// Processes a transaction that was reorganized out of the chain.
@ -1621,15 +1630,17 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
txid: &Txid, txid: &Txid,
broadcaster: B, broadcaster: B,
fee_estimator: F, fee_estimator: F,
logger: L, logger: &L,
) where ) where
B::Target: BroadcasterInterface, B::Target: BroadcasterInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger, L::Target: Logger,
{ {
let bounded_fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator); let bounded_fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator);
let logger = WithChannelMonitor::from(logger, self);
self.inner.lock().unwrap().transaction_unconfirmed( self.inner.lock().unwrap().transaction_unconfirmed(
txid, broadcaster, &bounded_fee_estimator, logger); txid, broadcaster, &bounded_fee_estimator, &logger
);
} }
/// Updates the monitor with the current best chain tip, returning new outputs to watch. See /// Updates the monitor with the current best chain tip, returning new outputs to watch. See
@ -1645,7 +1656,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
height: u32, height: u32,
broadcaster: B, broadcaster: B,
fee_estimator: F, fee_estimator: F,
logger: L, logger: &L,
) -> Vec<TransactionOutputs> ) -> Vec<TransactionOutputs>
where where
B::Target: BroadcasterInterface, B::Target: BroadcasterInterface,
@ -1653,8 +1664,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
L::Target: Logger, L::Target: Logger,
{ {
let bounded_fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator); let bounded_fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator);
let logger = WithChannelMonitor::from(logger, self);
self.inner.lock().unwrap().best_block_updated( self.inner.lock().unwrap().best_block_updated(
header, height, broadcaster, &bounded_fee_estimator, logger) header, height, broadcaster, &bounded_fee_estimator, &logger
)
} }
/// Returns the set of txids that should be monitored for re-organization out of the chain. /// Returns the set of txids that should be monitored for re-organization out of the chain.
@ -1682,7 +1695,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
/// invoking this every 30 seconds, or lower if running in an environment with spotty /// invoking this every 30 seconds, or lower if running in an environment with spotty
/// connections, like on mobile. /// connections, like on mobile.
pub fn rebroadcast_pending_claims<B: Deref, F: Deref, L: Deref>( pub fn rebroadcast_pending_claims<B: Deref, F: Deref, L: Deref>(
&self, broadcaster: B, fee_estimator: F, logger: L, &self, broadcaster: B, fee_estimator: F, logger: &L,
) )
where where
B::Target: BroadcasterInterface, B::Target: BroadcasterInterface,
@ -1690,6 +1703,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
L::Target: Logger, L::Target: Logger,
{ {
let fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator); let fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator);
let logger = WithChannelMonitor::from(logger, self);
let mut inner = self.inner.lock().unwrap(); let mut inner = self.inner.lock().unwrap();
let current_height = inner.best_block.height; let current_height = inner.best_block.height;
inner.onchain_tx_handler.rebroadcast_pending_claims( inner.onchain_tx_handler.rebroadcast_pending_claims(
@ -2399,13 +2413,11 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
Ok(()) Ok(())
} }
pub(crate) fn provide_initial_counterparty_commitment_tx<L: Deref>( fn provide_initial_counterparty_commitment_tx<L: Deref>(
&mut self, txid: Txid, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Box<HTLCSource>>)>, &mut self, txid: Txid, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Box<HTLCSource>>)>,
commitment_number: u64, their_per_commitment_point: PublicKey, feerate_per_kw: u32, commitment_number: u64, their_per_commitment_point: PublicKey, feerate_per_kw: u32,
to_broadcaster_value: u64, to_countersignatory_value: u64, logger: &L to_broadcaster_value: u64, to_countersignatory_value: u64, logger: &WithChannelMonitor<L>,
) ) where L::Target: Logger {
where L::Target: Logger
{
self.initial_counterparty_commitment_info = Some((their_per_commitment_point.clone(), self.initial_counterparty_commitment_info = Some((their_per_commitment_point.clone(),
feerate_per_kw, to_broadcaster_value, to_countersignatory_value)); feerate_per_kw, to_broadcaster_value, to_countersignatory_value));
@ -2418,7 +2430,11 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
their_per_commitment_point, logger); their_per_commitment_point, logger);
} }
pub(crate) fn provide_latest_counterparty_commitment_tx<L: Deref>(&mut self, txid: Txid, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Box<HTLCSource>>)>, commitment_number: u64, their_per_commitment_point: PublicKey, logger: &L) where L::Target: Logger { fn provide_latest_counterparty_commitment_tx<L: Deref>(
&mut self, txid: Txid,
htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Box<HTLCSource>>)>,
commitment_number: u64, their_per_commitment_point: PublicKey, logger: &WithChannelMonitor<L>,
) where L::Target: Logger {
// TODO: Encrypt the htlc_outputs data with the single-hash of the commitment transaction // TODO: Encrypt the htlc_outputs data with the single-hash of the commitment transaction
// so that a remote monitor doesn't learn anything unless there is a malicious close. // so that a remote monitor doesn't learn anything unless there is a malicious close.
// (only maybe, sadly we cant do the same for local info, as we need to be aware of // (only maybe, sadly we cant do the same for local info, as we need to be aware of
@ -2551,7 +2567,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
/// commitment_tx_infos which contain the payment hash have been revoked. /// commitment_tx_infos which contain the payment hash have been revoked.
fn provide_payment_preimage<B: Deref, F: Deref, L: Deref>( fn provide_payment_preimage<B: Deref, F: Deref, L: Deref>(
&mut self, payment_hash: &PaymentHash, payment_preimage: &PaymentPreimage, broadcaster: &B, &mut self, payment_hash: &PaymentHash, payment_preimage: &PaymentPreimage, broadcaster: &B,
fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L) fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &WithChannelMonitor<L>)
where B::Target: BroadcasterInterface, where B::Target: BroadcasterInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger, L::Target: Logger,
@ -2628,7 +2644,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
} }
} }
pub(crate) fn broadcast_latest_holder_commitment_txn<B: Deref, L: Deref>(&mut self, broadcaster: &B, logger: &L) fn broadcast_latest_holder_commitment_txn<B: Deref, L: Deref>(&mut self, broadcaster: &B, logger: &WithChannelMonitor<L>)
where B::Target: BroadcasterInterface, where B::Target: BroadcasterInterface,
L::Target: Logger, L::Target: Logger,
{ {
@ -2642,7 +2658,9 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
self.pending_monitor_events.push(MonitorEvent::HolderForceClosed(self.funding_info.0)); self.pending_monitor_events.push(MonitorEvent::HolderForceClosed(self.funding_info.0));
} }
pub fn update_monitor<B: Deref, F: Deref, L: Deref>(&mut self, updates: &ChannelMonitorUpdate, broadcaster: &B, fee_estimator: &F, logger: &L) -> Result<(), ()> fn update_monitor<B: Deref, F: Deref, L: Deref>(
&mut self, updates: &ChannelMonitorUpdate, broadcaster: &B, fee_estimator: &F, logger: &WithChannelMonitor<L>
) -> Result<(), ()>
where B::Target: BroadcasterInterface, where B::Target: BroadcasterInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger, L::Target: Logger,
@ -2787,15 +2805,15 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
} else { ret } } else { ret }
} }
pub fn get_latest_update_id(&self) -> u64 { fn get_latest_update_id(&self) -> u64 {
self.latest_update_id self.latest_update_id
} }
pub fn get_funding_txo(&self) -> &(OutPoint, ScriptBuf) { fn get_funding_txo(&self) -> &(OutPoint, ScriptBuf) {
&self.funding_info &self.funding_info
} }
pub fn get_outputs_to_watch(&self) -> &HashMap<Txid, Vec<(u32, ScriptBuf)>> { fn get_outputs_to_watch(&self) -> &HashMap<Txid, Vec<(u32, ScriptBuf)>> {
// If we've detected a counterparty commitment tx on chain, we must include it in the set // If we've detected a counterparty commitment tx on chain, we must include it in the set
// of outputs to watch for spends of, otherwise we're likely to lose user funds. Because // of outputs to watch for spends of, otherwise we're likely to lose user funds. Because
// its trivial to do, double-check that here. // its trivial to do, double-check that here.
@ -2805,7 +2823,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
&self.outputs_to_watch &self.outputs_to_watch
} }
pub fn get_and_clear_pending_monitor_events(&mut self) -> Vec<MonitorEvent> { fn get_and_clear_pending_monitor_events(&mut self) -> Vec<MonitorEvent> {
let mut ret = Vec::new(); let mut ret = Vec::new();
mem::swap(&mut ret, &mut self.pending_monitor_events); mem::swap(&mut ret, &mut self.pending_monitor_events);
ret ret
@ -2880,7 +2898,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
ret ret
} }
pub(crate) fn initial_counterparty_commitment_tx(&mut self) -> Option<CommitmentTransaction> { fn initial_counterparty_commitment_tx(&mut self) -> Option<CommitmentTransaction> {
let (their_per_commitment_point, feerate_per_kw, to_broadcaster_value, let (their_per_commitment_point, feerate_per_kw, to_broadcaster_value,
to_countersignatory_value) = self.initial_counterparty_commitment_info?; to_countersignatory_value) = self.initial_counterparty_commitment_info?;
let htlc_outputs = vec![]; let htlc_outputs = vec![];
@ -2914,7 +2932,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
channel_parameters) channel_parameters)
} }
pub(crate) fn counterparty_commitment_txs_from_update(&self, update: &ChannelMonitorUpdate) -> Vec<CommitmentTransaction> { fn counterparty_commitment_txs_from_update(&self, update: &ChannelMonitorUpdate) -> Vec<CommitmentTransaction> {
update.updates.iter().filter_map(|update| { update.updates.iter().filter_map(|update| {
match update { match update {
&ChannelMonitorUpdateStep::LatestCounterpartyCommitmentTXInfo { commitment_txid, &ChannelMonitorUpdateStep::LatestCounterpartyCommitmentTXInfo { commitment_txid,
@ -2940,7 +2958,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
}).collect() }).collect()
} }
pub(crate) fn sign_to_local_justice_tx( fn sign_to_local_justice_tx(
&self, mut justice_tx: Transaction, input_idx: usize, value: u64, commitment_number: u64 &self, mut justice_tx: Transaction, input_idx: usize, value: u64, commitment_number: u64
) -> Result<Transaction, ()> { ) -> Result<Transaction, ()> {
let secret = self.get_secret(commitment_number).ok_or(())?; let secret = self.get_secret(commitment_number).ok_or(())?;
@ -2968,15 +2986,15 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
self.commitment_secrets.get_secret(idx) self.commitment_secrets.get_secret(idx)
} }
pub(crate) fn get_min_seen_secret(&self) -> u64 { fn get_min_seen_secret(&self) -> u64 {
self.commitment_secrets.get_min_seen_secret() self.commitment_secrets.get_min_seen_secret()
} }
pub(crate) fn get_cur_counterparty_commitment_number(&self) -> u64 { fn get_cur_counterparty_commitment_number(&self) -> u64 {
self.current_counterparty_commitment_number self.current_counterparty_commitment_number
} }
pub(crate) fn get_cur_holder_commitment_number(&self) -> u64 { fn get_cur_holder_commitment_number(&self) -> u64 {
self.current_holder_commitment_number self.current_holder_commitment_number
} }
@ -3323,7 +3341,9 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
} }
} }
pub fn get_latest_holder_commitment_txn<L: Deref>(&mut self, logger: &L) -> Vec<Transaction> where L::Target: Logger { fn get_latest_holder_commitment_txn<L: Deref>(
&mut self, logger: &WithChannelMonitor<L>,
) -> Vec<Transaction> where L::Target: Logger {
log_debug!(logger, "Getting signed latest holder commitment transaction!"); log_debug!(logger, "Getting signed latest holder commitment transaction!");
self.holder_tx_signed = true; self.holder_tx_signed = true;
let commitment_tx = self.onchain_tx_handler.get_fully_signed_holder_tx(&self.funding_redeemscript); let commitment_tx = self.onchain_tx_handler.get_fully_signed_holder_tx(&self.funding_redeemscript);
@ -3362,7 +3382,9 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
#[cfg(any(test,feature = "unsafe_revoked_tx_signing"))] #[cfg(any(test,feature = "unsafe_revoked_tx_signing"))]
/// Note that this includes possibly-locktimed-in-the-future transactions! /// Note that this includes possibly-locktimed-in-the-future transactions!
fn unsafe_get_latest_holder_commitment_txn<L: Deref>(&mut self, logger: &L) -> Vec<Transaction> where L::Target: Logger { fn unsafe_get_latest_holder_commitment_txn<L: Deref>(
&mut self, logger: &WithChannelMonitor<L>
) -> Vec<Transaction> where L::Target: Logger {
log_debug!(logger, "Getting signed copy of latest holder commitment transaction!"); log_debug!(logger, "Getting signed copy of latest holder commitment transaction!");
let commitment_tx = self.onchain_tx_handler.get_fully_signed_copy_holder_tx(&self.funding_redeemscript); let commitment_tx = self.onchain_tx_handler.get_fully_signed_copy_holder_tx(&self.funding_redeemscript);
let txid = commitment_tx.txid(); let txid = commitment_tx.txid();
@ -3389,7 +3411,10 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
holder_transactions holder_transactions
} }
pub fn block_connected<B: Deref, F: Deref, L: Deref>(&mut self, header: &Header, txdata: &TransactionData, height: u32, broadcaster: B, fee_estimator: F, logger: L) -> Vec<TransactionOutputs> fn block_connected<B: Deref, F: Deref, L: Deref>(
&mut self, header: &Header, txdata: &TransactionData, height: u32, broadcaster: B,
fee_estimator: F, logger: &WithChannelMonitor<L>,
) -> Vec<TransactionOutputs>
where B::Target: BroadcasterInterface, where B::Target: BroadcasterInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger, L::Target: Logger,
@ -3407,7 +3432,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
height: u32, height: u32,
broadcaster: B, broadcaster: B,
fee_estimator: &LowerBoundedFeeEstimator<F>, fee_estimator: &LowerBoundedFeeEstimator<F>,
logger: L, logger: &WithChannelMonitor<L>,
) -> Vec<TransactionOutputs> ) -> Vec<TransactionOutputs>
where where
B::Target: BroadcasterInterface, B::Target: BroadcasterInterface,
@ -3418,7 +3443,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
if height > self.best_block.height() { if height > self.best_block.height() {
self.best_block = BestBlock::new(block_hash, height); self.best_block = BestBlock::new(block_hash, height);
self.block_confirmed(height, block_hash, vec![], vec![], vec![], &broadcaster, &fee_estimator, &logger) self.block_confirmed(height, block_hash, vec![], vec![], vec![], &broadcaster, &fee_estimator, logger)
} else if block_hash != self.best_block.block_hash() { } else if block_hash != self.best_block.block_hash() {
self.best_block = BestBlock::new(block_hash, height); self.best_block = BestBlock::new(block_hash, height);
self.onchain_events_awaiting_threshold_conf.retain(|ref entry| entry.height <= height); self.onchain_events_awaiting_threshold_conf.retain(|ref entry| entry.height <= height);
@ -3434,7 +3459,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
height: u32, height: u32,
broadcaster: B, broadcaster: B,
fee_estimator: &LowerBoundedFeeEstimator<F>, fee_estimator: &LowerBoundedFeeEstimator<F>,
logger: L, logger: &WithChannelMonitor<L>,
) -> Vec<TransactionOutputs> ) -> Vec<TransactionOutputs>
where where
B::Target: BroadcasterInterface, B::Target: BroadcasterInterface,
@ -3551,9 +3576,9 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
break; break;
} }
} }
self.is_resolving_htlc_output(&tx, height, &block_hash, &logger); self.is_resolving_htlc_output(&tx, height, &block_hash, logger);
self.check_tx_and_push_spendable_outputs(&tx, height, &block_hash, &logger); self.check_tx_and_push_spendable_outputs(&tx, height, &block_hash, logger);
} }
} }
@ -3561,7 +3586,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
self.best_block = BestBlock::new(block_hash, height); self.best_block = BestBlock::new(block_hash, height);
} }
self.block_confirmed(height, block_hash, txn_matched, watch_outputs, claimable_outpoints, &broadcaster, &fee_estimator, &logger) self.block_confirmed(height, block_hash, txn_matched, watch_outputs, claimable_outpoints, &broadcaster, &fee_estimator, logger)
} }
/// Update state for new block(s)/transaction(s) confirmed. Note that the caller must update /// Update state for new block(s)/transaction(s) confirmed. Note that the caller must update
@ -3581,7 +3606,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
mut claimable_outpoints: Vec<PackageTemplate>, mut claimable_outpoints: Vec<PackageTemplate>,
broadcaster: &B, broadcaster: &B,
fee_estimator: &LowerBoundedFeeEstimator<F>, fee_estimator: &LowerBoundedFeeEstimator<F>,
logger: &L, logger: &WithChannelMonitor<L>,
) -> Vec<TransactionOutputs> ) -> Vec<TransactionOutputs>
where where
B::Target: BroadcasterInterface, B::Target: BroadcasterInterface,
@ -3726,8 +3751,9 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
watch_outputs watch_outputs
} }
pub fn block_disconnected<B: Deref, F: Deref, L: Deref>(&mut self, header: &Header, height: u32, broadcaster: B, fee_estimator: F, logger: L) fn block_disconnected<B: Deref, F: Deref, L: Deref>(
where B::Target: BroadcasterInterface, &mut self, header: &Header, height: u32, broadcaster: B, fee_estimator: F, logger: &WithChannelMonitor<L>
) where B::Target: BroadcasterInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger, L::Target: Logger,
{ {
@ -3749,7 +3775,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
txid: &Txid, txid: &Txid,
broadcaster: B, broadcaster: B,
fee_estimator: &LowerBoundedFeeEstimator<F>, fee_estimator: &LowerBoundedFeeEstimator<F>,
logger: L, logger: &WithChannelMonitor<L>,
) where ) where
B::Target: BroadcasterInterface, B::Target: BroadcasterInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
@ -3828,7 +3854,9 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
false false
} }
fn should_broadcast_holder_commitment_txn<L: Deref>(&self, logger: &L) -> bool where L::Target: Logger { fn should_broadcast_holder_commitment_txn<L: Deref>(
&self, logger: &WithChannelMonitor<L>
) -> bool where L::Target: Logger {
// There's no need to broadcast our commitment transaction if we've seen one confirmed (even // There's no need to broadcast our commitment transaction if we've seen one confirmed (even
// with 1 confirmation) as it'll be rejected as duplicate/conflicting. // with 1 confirmation) as it'll be rejected as duplicate/conflicting.
if self.funding_spend_confirmed.is_some() || if self.funding_spend_confirmed.is_some() ||
@ -3904,7 +3932,9 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
/// Check if any transaction broadcasted is resolving HTLC output by a success or timeout on a holder /// Check if any transaction broadcasted is resolving HTLC output by a success or timeout on a holder
/// or counterparty commitment tx, if so send back the source, preimage if found and payment_hash of resolved HTLC /// or counterparty commitment tx, if so send back the source, preimage if found and payment_hash of resolved HTLC
fn is_resolving_htlc_output<L: Deref>(&mut self, tx: &Transaction, height: u32, block_hash: &BlockHash, logger: &L) where L::Target: Logger { fn is_resolving_htlc_output<L: Deref>(
&mut self, tx: &Transaction, height: u32, block_hash: &BlockHash, logger: &WithChannelMonitor<L>,
) where L::Target: Logger {
'outer_loop: for input in &tx.input { 'outer_loop: for input in &tx.input {
let mut payment_data = None; let mut payment_data = None;
let htlc_claim = HTLCClaim::from_witness(&input.witness); let htlc_claim = HTLCClaim::from_witness(&input.witness);
@ -4145,7 +4175,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
/// Checks if the confirmed transaction is paying funds back to some address we can assume to /// Checks if the confirmed transaction is paying funds back to some address we can assume to
/// own. /// own.
fn check_tx_and_push_spendable_outputs<L: Deref>( fn check_tx_and_push_spendable_outputs<L: Deref>(
&mut self, tx: &Transaction, height: u32, block_hash: &BlockHash, logger: &L, &mut self, tx: &Transaction, height: u32, block_hash: &BlockHash, logger: &WithChannelMonitor<L>,
) where L::Target: Logger { ) where L::Target: Logger {
for spendable_output in self.get_spendable_outputs(tx) { for spendable_output in self.get_spendable_outputs(tx) {
let entry = OnchainEventEntry { let entry = OnchainEventEntry {
@ -4168,11 +4198,11 @@ where
L::Target: Logger, L::Target: Logger,
{ {
fn filtered_block_connected(&self, header: &Header, txdata: &TransactionData, height: u32) { fn filtered_block_connected(&self, header: &Header, txdata: &TransactionData, height: u32) {
self.0.block_connected(header, txdata, height, &*self.1, &*self.2, &WithChannelMonitor::from(&self.3, &self.0)); self.0.block_connected(header, txdata, height, &*self.1, &*self.2, &self.3);
} }
fn block_disconnected(&self, header: &Header, height: u32) { fn block_disconnected(&self, header: &Header, height: u32) {
self.0.block_disconnected(header, height, &*self.1, &*self.2, &WithChannelMonitor::from(&self.3, &self.0)); self.0.block_disconnected(header, height, &*self.1, &*self.2, &self.3);
} }
} }
@ -4184,15 +4214,15 @@ where
L::Target: Logger, L::Target: Logger,
{ {
fn transactions_confirmed(&self, header: &Header, txdata: &TransactionData, height: u32) { fn transactions_confirmed(&self, header: &Header, txdata: &TransactionData, height: u32) {
self.0.transactions_confirmed(header, txdata, height, &*self.1, &*self.2, &WithChannelMonitor::from(&self.3, &self.0)); self.0.transactions_confirmed(header, txdata, height, &*self.1, &*self.2, &self.3);
} }
fn transaction_unconfirmed(&self, txid: &Txid) { fn transaction_unconfirmed(&self, txid: &Txid) {
self.0.transaction_unconfirmed(txid, &*self.1, &*self.2, &WithChannelMonitor::from(&self.3, &self.0)); self.0.transaction_unconfirmed(txid, &*self.1, &*self.2, &self.3);
} }
fn best_block_updated(&self, header: &Header, height: u32) { fn best_block_updated(&self, header: &Header, height: u32) {
self.0.best_block_updated(header, height, &*self.1, &*self.2, &WithChannelMonitor::from(&self.3, &self.0)); self.0.best_block_updated(header, height, &*self.1, &*self.2, &self.3);
} }
fn get_relevant_txids(&self) -> Vec<(Txid, u32, Option<BlockHash>)> { fn get_relevant_txids(&self) -> Vec<(Txid, u32, Option<BlockHash>)> {

25
lightning/src/chain/onchaintx.rs
View file

@ -473,14 +473,13 @@ impl<ChannelSigner: WriteableEcdsaChannelSigner> OnchainTxHandler<ChannelSigner>
/// feerate changes between blocks, and ensuring reliability if broadcasting fails. We recommend /// feerate changes between blocks, and ensuring reliability if broadcasting fails. We recommend
/// invoking this every 30 seconds, or lower if running in an environment with spotty /// invoking this every 30 seconds, or lower if running in an environment with spotty
/// connections, like on mobile. /// connections, like on mobile.
pub(crate) fn rebroadcast_pending_claims<B: Deref, F: Deref, L: Deref>( pub(super) fn rebroadcast_pending_claims<B: Deref, F: Deref, L: Logger>(
&mut self, current_height: u32, broadcaster: &B, fee_estimator: &LowerBoundedFeeEstimator<F>, &mut self, current_height: u32, broadcaster: &B, fee_estimator: &LowerBoundedFeeEstimator<F>,
logger: &L, logger: &L,
) )
where where
B::Target: BroadcasterInterface, B::Target: BroadcasterInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger,
{ {
let mut bump_requests = Vec::with_capacity(self.pending_claim_requests.len()); let mut bump_requests = Vec::with_capacity(self.pending_claim_requests.len());
for (claim_id, request) in self.pending_claim_requests.iter() { for (claim_id, request) in self.pending_claim_requests.iter() {
@ -528,13 +527,11 @@ impl<ChannelSigner: WriteableEcdsaChannelSigner> OnchainTxHandler<ChannelSigner>
/// ///
/// Panics if there are signing errors, because signing operations in reaction to on-chain /// Panics if there are signing errors, because signing operations in reaction to on-chain
/// events are not expected to fail, and if they do, we may lose funds. /// events are not expected to fail, and if they do, we may lose funds.
fn generate_claim<F: Deref, L: Deref>( fn generate_claim<F: Deref, L: Logger>(
&mut self, cur_height: u32, cached_request: &PackageTemplate, force_feerate_bump: bool, &mut self, cur_height: u32, cached_request: &PackageTemplate, force_feerate_bump: bool,
fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
) -> Option<(u32, u64, OnchainClaim)> ) -> Option<(u32, u64, OnchainClaim)>
where where F::Target: FeeEstimator,
F::Target: FeeEstimator,
L::Target: Logger,
{ {
let request_outpoints = cached_request.outpoints(); let request_outpoints = cached_request.outpoints();
if request_outpoints.is_empty() { if request_outpoints.is_empty() {
@ -688,13 +685,12 @@ impl<ChannelSigner: WriteableEcdsaChannelSigner> OnchainTxHandler<ChannelSigner>
/// `conf_height` represents the height at which the request was generated. This /// `conf_height` represents the height at which the request was generated. This
/// does not need to equal the current blockchain tip height, which should be provided via /// does not need to equal the current blockchain tip height, which should be provided via
/// `cur_height`, however it must never be higher than `cur_height`. /// `cur_height`, however it must never be higher than `cur_height`.
pub(crate) fn update_claims_view_from_requests<B: Deref, F: Deref, L: Deref>( pub(super) fn update_claims_view_from_requests<B: Deref, F: Deref, L: Logger>(
&mut self, requests: Vec<PackageTemplate>, conf_height: u32, cur_height: u32, &mut self, requests: Vec<PackageTemplate>, conf_height: u32, cur_height: u32,
broadcaster: &B, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L broadcaster: &B, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L
) where ) where
B::Target: BroadcasterInterface, B::Target: BroadcasterInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger,
{ {
log_debug!(logger, "Updating claims view at height {} with {} claim requests", cur_height, requests.len()); log_debug!(logger, "Updating claims view at height {} with {} claim requests", cur_height, requests.len());
let mut preprocessed_requests = Vec::with_capacity(requests.len()); let mut preprocessed_requests = Vec::with_capacity(requests.len());
@ -809,13 +805,12 @@ impl<ChannelSigner: WriteableEcdsaChannelSigner> OnchainTxHandler<ChannelSigner>
/// `conf_height` represents the height at which the transactions in `txn_matched` were /// `conf_height` represents the height at which the transactions in `txn_matched` were
/// confirmed. This does not need to equal the current blockchain tip height, which should be /// confirmed. This does not need to equal the current blockchain tip height, which should be
/// provided via `cur_height`, however it must never be higher than `cur_height`. /// provided via `cur_height`, however it must never be higher than `cur_height`.
pub(crate) fn update_claims_view_from_matched_txn<B: Deref, F: Deref, L: Deref>( pub(super) fn update_claims_view_from_matched_txn<B: Deref, F: Deref, L: Logger>(
&mut self, txn_matched: &[&Transaction], conf_height: u32, conf_hash: BlockHash, &mut self, txn_matched: &[&Transaction], conf_height: u32, conf_hash: BlockHash,
cur_height: u32, broadcaster: &B, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L cur_height: u32, broadcaster: &B, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L
) where ) where
B::Target: BroadcasterInterface, B::Target: BroadcasterInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger,
{ {
log_debug!(logger, "Updating claims view at height {} with {} matched transactions in block {}", cur_height, txn_matched.len(), conf_height); log_debug!(logger, "Updating claims view at height {} with {} matched transactions in block {}", cur_height, txn_matched.len(), conf_height);
let mut bump_candidates = HashMap::new(); let mut bump_candidates = HashMap::new();
@ -977,16 +972,15 @@ impl<ChannelSigner: WriteableEcdsaChannelSigner> OnchainTxHandler<ChannelSigner>
} }
} }
pub(crate) fn transaction_unconfirmed<B: Deref, F: Deref, L: Deref>( pub(super) fn transaction_unconfirmed<B: Deref, F: Deref, L: Logger>(
&mut self, &mut self,
txid: &Txid, txid: &Txid,
broadcaster: B, broadcaster: B,
fee_estimator: &LowerBoundedFeeEstimator<F>, fee_estimator: &LowerBoundedFeeEstimator<F>,
logger: L, logger: &L,
) where ) where
B::Target: BroadcasterInterface, B::Target: BroadcasterInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger,
{ {
let mut height = None; let mut height = None;
for entry in self.onchain_events_awaiting_threshold_conf.iter() { for entry in self.onchain_events_awaiting_threshold_conf.iter() {
@ -1001,10 +995,9 @@ impl<ChannelSigner: WriteableEcdsaChannelSigner> OnchainTxHandler<ChannelSigner>
} }
} }
pub(crate) fn block_disconnected<B: Deref, F: Deref, L: Deref>(&mut self, height: u32, broadcaster: B, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: L) pub(super) fn block_disconnected<B: Deref, F: Deref, L: Logger>(&mut self, height: u32, broadcaster: B, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L)
where B::Target: BroadcasterInterface, where B::Target: BroadcasterInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger,
{ {
let mut bump_candidates = HashMap::new(); let mut bump_candidates = HashMap::new();
let onchain_events_awaiting_threshold_conf = let onchain_events_awaiting_threshold_conf =
@ -1034,7 +1027,7 @@ impl<ChannelSigner: WriteableEcdsaChannelSigner> OnchainTxHandler<ChannelSigner>
// `height` is the height being disconnected, so our `current_height` is 1 lower. // `height` is the height being disconnected, so our `current_height` is 1 lower.
let current_height = height - 1; let current_height = height - 1;
if let Some((new_timer, new_feerate, bump_claim)) = self.generate_claim( if let Some((new_timer, new_feerate, bump_claim)) = self.generate_claim(
current_height, &request, true /* force_feerate_bump */, fee_estimator, &&*logger current_height, &request, true /* force_feerate_bump */, fee_estimator, logger
) { ) {
request.set_timer(new_timer); request.set_timer(new_timer);
request.set_feerate(new_feerate); request.set_feerate(new_feerate);

20
lightning/src/chain/package.rs
View file

@ -908,10 +908,10 @@ impl PackageTemplate {
} }
htlcs htlcs
} }
pub(crate) fn finalize_malleable_package<L: Deref, Signer: WriteableEcdsaChannelSigner>( pub(crate) fn finalize_malleable_package<L: Logger, Signer: WriteableEcdsaChannelSigner>(
&self, current_height: u32, onchain_handler: &mut OnchainTxHandler<Signer>, value: u64, &self, current_height: u32, onchain_handler: &mut OnchainTxHandler<Signer>, value: u64,
destination_script: ScriptBuf, logger: &L destination_script: ScriptBuf, logger: &L
) -> Option<Transaction> where L::Target: Logger { ) -> Option<Transaction> {
debug_assert!(self.is_malleable()); debug_assert!(self.is_malleable());
let mut bumped_tx = Transaction { let mut bumped_tx = Transaction {
version: 2, version: 2,
@ -932,9 +932,9 @@ impl PackageTemplate {
log_debug!(logger, "Finalized transaction {} ready to broadcast", bumped_tx.txid()); log_debug!(logger, "Finalized transaction {} ready to broadcast", bumped_tx.txid());
Some(bumped_tx) Some(bumped_tx)
} }
pub(crate) fn finalize_untractable_package<L: Deref, Signer: WriteableEcdsaChannelSigner>( pub(crate) fn finalize_untractable_package<L: Logger, Signer: WriteableEcdsaChannelSigner>(
&self, onchain_handler: &mut OnchainTxHandler<Signer>, logger: &L, &self, onchain_handler: &mut OnchainTxHandler<Signer>, logger: &L,
) -> Option<Transaction> where L::Target: Logger { ) -> Option<Transaction> {
debug_assert!(!self.is_malleable()); debug_assert!(!self.is_malleable());
if let Some((outpoint, outp)) = self.inputs.first() { if let Some((outpoint, outp)) = self.inputs.first() {
if let Some(final_tx) = outp.get_finalized_tx(outpoint, onchain_handler) { if let Some(final_tx) = outp.get_finalized_tx(outpoint, onchain_handler) {
@ -962,13 +962,11 @@ impl PackageTemplate {
/// Returns value in satoshis to be included as package outgoing output amount and feerate /// Returns value in satoshis to be included as package outgoing output amount and feerate
/// which was used to generate the value. Will not return less than `dust_limit_sats` for the /// which was used to generate the value. Will not return less than `dust_limit_sats` for the
/// value. /// value.
pub(crate) fn compute_package_output<F: Deref, L: Deref>( pub(crate) fn compute_package_output<F: Deref, L: Logger>(
&self, predicted_weight: u64, dust_limit_sats: u64, force_feerate_bump: bool, &self, predicted_weight: u64, dust_limit_sats: u64, force_feerate_bump: bool,
fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
) -> Option<(u64, u64)> ) -> Option<(u64, u64)>
where where F::Target: FeeEstimator,
F::Target: FeeEstimator,
L::Target: Logger,
{ {
debug_assert!(self.malleability == PackageMalleability::Malleable, "The package output is fixed for non-malleable packages"); debug_assert!(self.malleability == PackageMalleability::Malleable, "The package output is fixed for non-malleable packages");
let input_amounts = self.package_amount(); let input_amounts = self.package_amount();
@ -1111,9 +1109,8 @@ impl Readable for PackageTemplate {
/// ///
/// [`OnChainSweep`]: crate::chain::chaininterface::ConfirmationTarget::OnChainSweep /// [`OnChainSweep`]: crate::chain::chaininterface::ConfirmationTarget::OnChainSweep
/// [`FEERATE_FLOOR_SATS_PER_KW`]: crate::chain::chaininterface::MIN_RELAY_FEE_SAT_PER_1000_WEIGHT /// [`FEERATE_FLOOR_SATS_PER_KW`]: crate::chain::chaininterface::MIN_RELAY_FEE_SAT_PER_1000_WEIGHT
fn compute_fee_from_spent_amounts<F: Deref, L: Deref>(input_amounts: u64, predicted_weight: u64, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L) -> Option<(u64, u64)> fn compute_fee_from_spent_amounts<F: Deref, L: Logger>(input_amounts: u64, predicted_weight: u64, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L) -> Option<(u64, u64)>
where F::Target: FeeEstimator, where F::Target: FeeEstimator,
L::Target: Logger,
{ {
let sweep_feerate = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::OnChainSweep); let sweep_feerate = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::OnChainSweep);
let fee_rate = cmp::min(sweep_feerate, compute_feerate_sat_per_1000_weight(input_amounts / 2, predicted_weight)); let fee_rate = cmp::min(sweep_feerate, compute_feerate_sat_per_1000_weight(input_amounts / 2, predicted_weight));
@ -1135,13 +1132,12 @@ fn compute_fee_from_spent_amounts<F: Deref, L: Deref>(input_amounts: u64, predic
/// feerate, or just use the previous feerate otherwise. If a feerate bump did happen, we also /// feerate, or just use the previous feerate otherwise. If a feerate bump did happen, we also
/// verify that those bumping heuristics respect BIP125 rules 3) and 4) and if required adjust the /// verify that those bumping heuristics respect BIP125 rules 3) and 4) and if required adjust the
/// new fee to meet the RBF policy requirement. /// new fee to meet the RBF policy requirement.
fn feerate_bump<F: Deref, L: Deref>( fn feerate_bump<F: Deref, L: Logger>(
predicted_weight: u64, input_amounts: u64, previous_feerate: u64, force_feerate_bump: bool, predicted_weight: u64, input_amounts: u64, previous_feerate: u64, force_feerate_bump: bool,
fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
) -> Option<(u64, u64)> ) -> Option<(u64, u64)>
where where
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger,
{ {
// If old feerate inferior to actual one given back by Fee Estimator, use it to compute new fee... // If old feerate inferior to actual one given back by Fee Estimator, use it to compute new fee...
let (new_fee, new_feerate) = if let Some((new_fee, new_feerate)) = compute_fee_from_spent_amounts(input_amounts, predicted_weight, fee_estimator, logger) { let (new_fee, new_feerate) = if let Some((new_fee, new_feerate)) = compute_fee_from_spent_amounts(input_amounts, predicted_weight, fee_estimator, logger) {