// You may not use this file except in accordance with one or both of these
// licenses.
-//! Utitilies for bumping transactions originating from [`super::Event`]s.
+//! Utilities for bumping transactions originating from [`Event`]s.
+//!
+//! [`Event`]: crate::events::Event
use core::convert::TryInto;
use core::ops::Deref;
use crate::chain::chaininterface::BroadcasterInterface;
use crate::chain::ClaimId;
-use crate::sign::{ChannelSigner, EcdsaChannelSigner, SignerProvider};
use crate::io_extras::sink;
-use crate::ln::PaymentPreimage;
use crate::ln::chan_utils;
use crate::ln::chan_utils::{
ANCHOR_INPUT_WITNESS_WEIGHT, HTLC_SUCCESS_INPUT_ANCHOR_WITNESS_WEIGHT,
HTLC_TIMEOUT_INPUT_ANCHOR_WITNESS_WEIGHT, ChannelTransactionParameters, HTLCOutputInCommitment
};
-use crate::events::Event;
-use crate::prelude::HashMap;
+use crate::ln::features::ChannelTypeFeatures;
+use crate::ln::PaymentPreimage;
+use crate::prelude::*;
+use crate::sign::{ChannelSigner, EcdsaChannelSigner, SignerProvider};
+use crate::sync::Mutex;
use crate::util::logger::Logger;
use bitcoin::{OutPoint, PackedLockTime, PubkeyHash, Sequence, Script, Transaction, Txid, TxIn, TxOut, Witness, WPubkeyHash};
pub commitment_txid: Txid,
/// The number of the commitment transaction in which the HTLC output lives.
pub per_commitment_number: u64,
+ /// The key tweak corresponding to the number of the commitment transaction in which the HTLC
+ /// output lives. This tweak is applied to all the basepoints for both parties in the channel to
+ /// arrive at unique keys per commitment.
+ ///
+ /// See <https://github.com/lightning/bolts/blob/master/03-transactions.md#keys> for more info.
+ pub per_commitment_point: PublicKey,
/// The details of the HTLC as it appears in the commitment transaction.
pub htlc: HTLCOutputInCommitment,
/// The preimage, if `Some`, to claim the HTLC output with. If `None`, the timeout path must be
/// Returns the unsigned transaction input spending the HTLC output in the commitment
/// transaction.
pub fn unsigned_tx_input(&self) -> TxIn {
- chan_utils::build_htlc_input(&self.commitment_txid, &self.htlc, true /* opt_anchors */)
+ chan_utils::build_htlc_input(&self.commitment_txid, &self.htlc, &ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies())
}
/// Returns the delayed output created as a result of spending the HTLC output in the commitment
/// transaction.
- pub fn tx_output<C: secp256k1::Signing + secp256k1::Verification>(
- &self, per_commitment_point: &PublicKey, secp: &Secp256k1<C>
- ) -> TxOut {
+ pub fn tx_output<C: secp256k1::Signing + secp256k1::Verification>(&self, secp: &Secp256k1<C>) -> TxOut {
let channel_params = self.channel_parameters.as_holder_broadcastable();
let broadcaster_keys = channel_params.broadcaster_pubkeys();
let counterparty_keys = channel_params.countersignatory_pubkeys();
let broadcaster_delayed_key = chan_utils::derive_public_key(
- secp, per_commitment_point, &broadcaster_keys.delayed_payment_basepoint
+ secp, &self.per_commitment_point, &broadcaster_keys.delayed_payment_basepoint
);
let counterparty_revocation_key = chan_utils::derive_public_revocation_key(
- secp, per_commitment_point, &counterparty_keys.revocation_basepoint
+ secp, &self.per_commitment_point, &counterparty_keys.revocation_basepoint
);
chan_utils::build_htlc_output(
- 0 /* feerate_per_kw */, channel_params.contest_delay(), &self.htlc, true /* opt_anchors */,
- false /* use_non_zero_fee_anchors */, &broadcaster_delayed_key, &counterparty_revocation_key
+ 0 /* feerate_per_kw */, channel_params.contest_delay(), &self.htlc,
+ &ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies(), &broadcaster_delayed_key, &counterparty_revocation_key
)
}
/// Returns the witness script of the HTLC output in the commitment transaction.
- pub fn witness_script<C: secp256k1::Signing + secp256k1::Verification>(
- &self, per_commitment_point: &PublicKey, secp: &Secp256k1<C>
- ) -> Script {
+ pub fn witness_script<C: secp256k1::Signing + secp256k1::Verification>(&self, secp: &Secp256k1<C>) -> Script {
let channel_params = self.channel_parameters.as_holder_broadcastable();
let broadcaster_keys = channel_params.broadcaster_pubkeys();
let counterparty_keys = channel_params.countersignatory_pubkeys();
let broadcaster_htlc_key = chan_utils::derive_public_key(
- secp, per_commitment_point, &broadcaster_keys.htlc_basepoint
+ secp, &self.per_commitment_point, &broadcaster_keys.htlc_basepoint
);
let counterparty_htlc_key = chan_utils::derive_public_key(
- secp, per_commitment_point, &counterparty_keys.htlc_basepoint
+ secp, &self.per_commitment_point, &counterparty_keys.htlc_basepoint
);
let counterparty_revocation_key = chan_utils::derive_public_revocation_key(
- secp, per_commitment_point, &counterparty_keys.revocation_basepoint
+ secp, &self.per_commitment_point, &counterparty_keys.revocation_basepoint
);
chan_utils::get_htlc_redeemscript_with_explicit_keys(
- &self.htlc, true /* opt_anchors */, &broadcaster_htlc_key, &counterparty_htlc_key,
+ &self.htlc, &ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies(), &broadcaster_htlc_key, &counterparty_htlc_key,
&counterparty_revocation_key,
)
}
/// transaction.
pub fn tx_input_witness(&self, signature: &Signature, witness_script: &Script) -> Witness {
chan_utils::build_htlc_input_witness(
- signature, &self.counterparty_sig, &self.preimage, witness_script, true /* opt_anchors */
+ signature, &self.counterparty_sig, &self.preimage, witness_script, &ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies() /* opt_anchors */
)
}
}
pub struct CoinSelection {
/// The set of UTXOs (with at least 1 confirmation) to spend and use within a transaction
/// requiring additional fees.
- confirmed_utxos: Vec<Utxo>,
+ pub confirmed_utxos: Vec<Utxo>,
/// An additional output tracking whether any change remained after coin selection. This output
/// should always have a value above dust for its given `script_pubkey`. It should not be
/// spent until the transaction it belongs to confirms to ensure mempool descendant limits are
/// not met. This implies no other party should be able to spend it except us.
- change_output: Option<TxOut>,
+ pub change_output: Option<TxOut>,
}
/// An abstraction over a bitcoin wallet that can perform coin selection over a set of UTXOs and can
/// sign for them. The coin selection method aims to mimic Bitcoin Core's `fundrawtransaction` RPC,
-/// which most wallets should be able to satisfy.
+/// which most wallets should be able to satisfy. Otherwise, consider implementing [`WalletSource`],
+/// which can provide a default implementation of this trait when used with [`Wallet`].
pub trait CoinSelectionSource {
/// Performs coin selection of a set of UTXOs, with at least 1 confirmation each, that are
/// available to spend. Implementations are free to pick their coin selection algorithm of
fn sign_tx(&self, tx: &mut Transaction) -> Result<(), ()>;
}
+/// An alternative to [`CoinSelectionSource`] that can be implemented and used along [`Wallet`] to
+/// provide a default implementation to [`CoinSelectionSource`].
+pub trait WalletSource {
+ /// Returns all UTXOs, with at least 1 confirmation each, that are available to spend.
+ fn list_confirmed_utxos(&self) -> Result<Vec<Utxo>, ()>;
+ /// Returns a script to use for change above dust resulting from a successful coin selection
+ /// attempt.
+ fn get_change_script(&self) -> Result<Script, ()>;
+ /// Signs and provides the full [`TxIn::script_sig`] and [`TxIn::witness`] for all inputs within
+ /// the transaction known to the wallet (i.e., any provided via
+ /// [`WalletSource::list_confirmed_utxos`]).
+ fn sign_tx(&self, tx: &mut Transaction) -> Result<(), ()>;
+}
+
+/// A wrapper over [`WalletSource`] that implements [`CoinSelection`] by preferring UTXOs that would
+/// avoid conflicting double spends. If not enough UTXOs are available to do so, conflicting double
+/// spends may happen.
+pub struct Wallet<W: Deref> where W::Target: WalletSource {
+ source: W,
+ // TODO: Do we care about cleaning this up once the UTXOs have a confirmed spend? We can do so
+ // by checking whether any UTXOs that exist in the map are no longer returned in
+ // `list_confirmed_utxos`.
+ locked_utxos: Mutex<HashMap<OutPoint, ClaimId>>,
+}
+
+impl<W: Deref> Wallet<W> where W::Target: WalletSource {
+ /// Returns a new instance backed by the given [`WalletSource`] that serves as an implementation
+ /// of [`CoinSelectionSource`].
+ pub fn new(source: W) -> Self {
+ Self { source, locked_utxos: Mutex::new(HashMap::new()) }
+ }
+
+ /// Performs coin selection on the set of UTXOs obtained from
+ /// [`WalletSource::list_confirmed_utxos`]. Its algorithm can be described as "smallest
+ /// above-dust-after-spend first", with a slight twist: we may skip UTXOs that are above dust at
+ /// the target feerate after having spent them in a separate claim transaction if
+ /// `force_conflicting_utxo_spend` is unset to avoid producing conflicting transactions. If
+ /// `tolerate_high_network_feerates` is set, we'll attempt to spend UTXOs that contribute at
+ /// least 1 satoshi at the current feerate, otherwise, we'll only attempt to spend those which
+ /// contribute at least twice their fee.
+ fn select_confirmed_utxos_internal(
+ &self, utxos: &[Utxo], claim_id: ClaimId, force_conflicting_utxo_spend: bool,
+ tolerate_high_network_feerates: bool, target_feerate_sat_per_1000_weight: u32,
+ preexisting_tx_weight: u64, target_amount_sat: u64,
+ ) -> Result<CoinSelection, ()> {
+ let mut locked_utxos = self.locked_utxos.lock().unwrap();
+ let mut eligible_utxos = utxos.iter().filter_map(|utxo| {
+ if let Some(utxo_claim_id) = locked_utxos.get(&utxo.outpoint) {
+ if *utxo_claim_id != claim_id && !force_conflicting_utxo_spend {
+ return None;
+ }
+ }
+ let fee_to_spend_utxo = fee_for_weight(
+ target_feerate_sat_per_1000_weight, BASE_INPUT_WEIGHT as u64 + utxo.satisfaction_weight,
+ );
+ let should_spend = if tolerate_high_network_feerates {
+ utxo.output.value > fee_to_spend_utxo
+ } else {
+ utxo.output.value >= fee_to_spend_utxo * 2
+ };
+ if should_spend {
+ Some((utxo, fee_to_spend_utxo))
+ } else {
+ None
+ }
+ }).collect::<Vec<_>>();
+ eligible_utxos.sort_unstable_by_key(|(utxo, _)| utxo.output.value);
+
+ let mut selected_amount = 0;
+ let mut total_fees = fee_for_weight(target_feerate_sat_per_1000_weight, preexisting_tx_weight);
+ let mut selected_utxos = Vec::new();
+ for (utxo, fee_to_spend_utxo) in eligible_utxos {
+ if selected_amount >= target_amount_sat + total_fees {
+ break;
+ }
+ selected_amount += utxo.output.value;
+ total_fees += fee_to_spend_utxo;
+ selected_utxos.push(utxo.clone());
+ }
+ if selected_amount < target_amount_sat + total_fees {
+ return Err(());
+ }
+ for utxo in &selected_utxos {
+ locked_utxos.insert(utxo.outpoint, claim_id);
+ }
+ core::mem::drop(locked_utxos);
+
+ let remaining_amount = selected_amount - target_amount_sat - total_fees;
+ let change_script = self.source.get_change_script()?;
+ let change_output_fee = fee_for_weight(
+ target_feerate_sat_per_1000_weight,
+ (8 /* value */ + change_script.consensus_encode(&mut sink()).unwrap() as u64) *
+ WITNESS_SCALE_FACTOR as u64,
+ );
+ let change_output_amount = remaining_amount.saturating_sub(change_output_fee);
+ let change_output = if change_output_amount < change_script.dust_value().to_sat() {
+ None
+ } else {
+ Some(TxOut { script_pubkey: change_script, value: change_output_amount })
+ };
+
+ Ok(CoinSelection {
+ confirmed_utxos: selected_utxos,
+ change_output,
+ })
+ }
+}
+
+impl<W: Deref> CoinSelectionSource for Wallet<W> where W::Target: WalletSource {
+ fn select_confirmed_utxos(
+ &self, claim_id: ClaimId, must_spend: &[Input], must_pay_to: &[TxOut],
+ target_feerate_sat_per_1000_weight: u32,
+ ) -> Result<CoinSelection, ()> {
+ let utxos = self.source.list_confirmed_utxos()?;
+ // TODO: Use fee estimation utils when we upgrade to bitcoin v0.30.0.
+ const BASE_TX_SIZE: u64 = 4 /* version */ + 1 /* input count */ + 1 /* output count */ + 4 /* locktime */;
+ let total_output_size: u64 = must_pay_to.iter().map(|output|
+ 8 /* value */ + 1 /* script len */ + output.script_pubkey.len() as u64
+ ).sum();
+ let total_satisfaction_weight: u64 = must_spend.iter().map(|input| input.satisfaction_weight).sum();
+ let total_input_weight = (BASE_INPUT_WEIGHT * must_spend.len() as u64) + total_satisfaction_weight;
+
+ let preexisting_tx_weight = 2 /* segwit marker & flag */ + total_input_weight +
+ ((BASE_TX_SIZE + total_output_size) * WITNESS_SCALE_FACTOR as u64);
+ let target_amount_sat = must_pay_to.iter().map(|output| output.value).sum();
+ let do_coin_selection = |force_conflicting_utxo_spend: bool, tolerate_high_network_feerates: bool| {
+ self.select_confirmed_utxos_internal(
+ &utxos, claim_id, force_conflicting_utxo_spend, tolerate_high_network_feerates,
+ target_feerate_sat_per_1000_weight, preexisting_tx_weight, target_amount_sat,
+ )
+ };
+ do_coin_selection(false, false)
+ .or_else(|_| do_coin_selection(false, true))
+ .or_else(|_| do_coin_selection(true, false))
+ .or_else(|_| do_coin_selection(true, true))
+ }
+
+ fn sign_tx(&self, tx: &mut Transaction) -> Result<(), ()> {
+ self.source.sign_tx(tx)
+ }
+}
+
/// A handler for [`Event::BumpTransaction`] events that sources confirmed UTXOs from a
/// [`CoinSelectionSource`] to fee bump transactions via Child-Pays-For-Parent (CPFP) or
/// Replace-By-Fee (RBF).
+///
+/// [`Event::BumpTransaction`]: crate::events::Event::BumpTransaction
pub struct BumpTransactionEventHandler<B: Deref, C: Deref, SP: Deref, L: Deref>
where
B::Target: BroadcasterInterface,
L::Target: Logger,
{
/// Returns a new instance capable of handling [`Event::BumpTransaction`] events.
+ ///
+ /// [`Event::BumpTransaction`]: crate::events::Event::BumpTransaction
pub fn new(broadcaster: B, utxo_source: C, signer_provider: SP, logger: L) -> Self {
Self {
broadcaster,
let mut signers = HashMap::new();
let mut must_spend = Vec::with_capacity(htlc_descriptors.len());
for htlc_descriptor in htlc_descriptors {
- let signer = signers.entry(htlc_descriptor.channel_keys_id)
+ signers.entry(htlc_descriptor.channel_keys_id)
.or_insert_with(||
self.signer_provider.derive_channel_signer(
htlc_descriptor.channel_value_satoshis, htlc_descriptor.channel_keys_id,
)
);
- let per_commitment_point = signer.get_per_commitment_point(
- htlc_descriptor.per_commitment_number, &self.secp
- );
let htlc_input = htlc_descriptor.unsigned_tx_input();
must_spend.push(Input {
},
});
tx.input.push(htlc_input);
- let htlc_output = htlc_descriptor.tx_output(&per_commitment_point, &self.secp);
+ let htlc_output = htlc_descriptor.tx_output(&self.secp);
tx.output.push(htlc_output);
}
let htlc_sig = signer.sign_holder_htlc_transaction(
&htlc_tx, idx, htlc_descriptor, &self.secp
)?;
- let per_commitment_point = signer.get_per_commitment_point(
- htlc_descriptor.per_commitment_number, &self.secp
- );
- let witness_script = htlc_descriptor.witness_script(&per_commitment_point, &self.secp);
+ let witness_script = htlc_descriptor.witness_script(&self.secp);
htlc_tx.input[idx].witness = htlc_descriptor.tx_input_witness(&htlc_sig, &witness_script);
}
Ok(())
}
- /// Handles all variants of [`BumpTransactionEvent`], immediately returning otherwise.
- pub fn handle_event(&self, event: &Event) {
- let event = if let Event::BumpTransaction(event) = event {
- event
- } else {
- return;
- };
+ /// Handles all variants of [`BumpTransactionEvent`].
+ pub fn handle_event(&self, event: &BumpTransactionEvent) {
match event {
BumpTransactionEvent::ChannelClose {
claim_id, package_target_feerate_sat_per_1000_weight, commitment_tx,