use bitcoin::secp256k1::{SecretKey,PublicKey};
-use ln::PaymentPreimage;
-use ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment};
-use ln::chan_utils;
-use ln::msgs::DecodeError;
-use chain::chaininterface::{FeeEstimator, ConfirmationTarget, MIN_RELAY_FEE_SAT_PER_1000_WEIGHT};
-use chain::keysinterface::Sign;
-use chain::onchaintx::OnchainTxHandler;
-use util::byte_utils;
-use util::logger::Logger;
-use util::ser::{Readable, Writer, Writeable};
-
-use io;
-use prelude::*;
+use crate::ln::PaymentPreimage;
+use crate::ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment};
+use crate::ln::chan_utils;
+use crate::ln::msgs::DecodeError;
+use crate::chain::chaininterface::{FeeEstimator, ConfirmationTarget, MIN_RELAY_FEE_SAT_PER_1000_WEIGHT};
+use crate::chain::keysinterface::Sign;
+use crate::chain::onchaintx::OnchainTxHandler;
+use crate::util::byte_utils;
+use crate::util::logger::Logger;
+use crate::util::ser::{Readable, Writer, Writeable};
+
+use crate::io;
+use crate::prelude::*;
use core::cmp;
+#[cfg(anchors)]
+use core::convert::TryInto;
use core::mem;
use core::ops::Deref;
use bitcoin::{PackedLockTime, Sequence, Witness};
pub(crate) fn outpoints(&self) -> Vec<&BitcoinOutPoint> {
self.inputs.iter().map(|(o, _)| o).collect()
}
+ pub(crate) fn inputs(&self) -> impl ExactSizeIterator<Item = &PackageSolvingData> {
+ self.inputs.iter().map(|(_, i)| i)
+ }
pub(crate) fn split_package(&mut self, split_outp: &BitcoinOutPoint) -> Option<PackageTemplate> {
match self.malleability {
PackageMalleability::Malleable => {
}
/// Gets the amount of all outptus being spent by this package, only valid for malleable
/// packages.
- fn package_amount(&self) -> u64 {
+ pub(crate) fn package_amount(&self) -> u64 {
let mut amounts = 0;
for (_, outp) in self.inputs.iter() {
amounts += outp.amount();
inputs_weight + witnesses_weight + transaction_weight + output_weight
}
pub(crate) fn finalize_malleable_package<L: Deref, Signer: Sign>(
- &self, onchain_handler: &mut OnchainTxHandler<Signer>, value: u64, destination_script: Script, logger: &L,
+ &self, onchain_handler: &mut OnchainTxHandler<Signer>, value: u64, destination_script: Script, logger: &L
) -> Option<Transaction> where L::Target: Logger {
debug_assert!(self.is_malleable());
let mut bumped_tx = Transaction {
}
None
}
+
+ #[cfg(anchors)]
+ /// Computes a feerate based on the given confirmation target. If a previous feerate was used,
+ /// and the new feerate is below it, we'll use a 25% increase of the previous feerate instead of
+ /// the new one.
+ pub(crate) fn compute_package_feerate<F: Deref>(
+ &self, fee_estimator: &LowerBoundedFeeEstimator<F>, conf_target: ConfirmationTarget,
+ ) -> u32 where F::Target: FeeEstimator {
+ let feerate_estimate = fee_estimator.bounded_sat_per_1000_weight(conf_target);
+ if self.feerate_previous != 0 {
+ // If old feerate inferior to actual one given back by Fee Estimator, use it to compute new fee...
+ if feerate_estimate as u64 > self.feerate_previous {
+ feerate_estimate
+ } else {
+ // ...else just increase the previous feerate by 25% (because that's a nice number)
+ (self.feerate_previous + (self.feerate_previous / 4)).try_into().unwrap_or(u32::max_value())
+ }
+ } else {
+ feerate_estimate
+ }
+ }
+
+ /// Determines whether a package contains an input which must have additional external inputs
+ /// attached to help the spending transaction reach confirmation.
+ pub(crate) fn requires_external_funding(&self) -> bool {
+ self.inputs.iter().find(|input| match input.1 {
+ PackageSolvingData::HolderFundingOutput(ref outp) => outp.opt_anchors(),
+ _ => false,
+ }).is_some()
+ }
+
pub (crate) fn build_package(txid: Txid, vout: u32, input_solving_data: PackageSolvingData, soonest_conf_deadline: u32, aggregable: bool, height_original: u32) -> Self {
let malleability = match input_solving_data {
- PackageSolvingData::RevokedOutput(..) => { PackageMalleability::Malleable },
- PackageSolvingData::RevokedHTLCOutput(..) => { PackageMalleability::Malleable },
- PackageSolvingData::CounterpartyOfferedHTLCOutput(..) => { PackageMalleability::Malleable },
- PackageSolvingData::CounterpartyReceivedHTLCOutput(..) => { PackageMalleability::Malleable },
- PackageSolvingData::HolderHTLCOutput(..) => { PackageMalleability::Untractable },
- PackageSolvingData::HolderFundingOutput(..) => { PackageMalleability::Untractable },
+ PackageSolvingData::RevokedOutput(..) => PackageMalleability::Malleable,
+ PackageSolvingData::RevokedHTLCOutput(..) => PackageMalleability::Malleable,
+ PackageSolvingData::CounterpartyOfferedHTLCOutput(..) => PackageMalleability::Malleable,
+ PackageSolvingData::CounterpartyReceivedHTLCOutput(..) => PackageMalleability::Malleable,
+ PackageSolvingData::HolderHTLCOutput(..) => PackageMalleability::Untractable,
+ PackageSolvingData::HolderFundingOutput(..) => PackageMalleability::Untractable,
};
let mut inputs = Vec::with_capacity(1);
inputs.push((BitcoinOutPoint { txid, vout }, input_solving_data));
#[cfg(test)]
mod tests {
- use chain::package::{CounterpartyOfferedHTLCOutput, CounterpartyReceivedHTLCOutput, HolderHTLCOutput, PackageTemplate, PackageSolvingData, RevokedOutput, WEIGHT_REVOKED_OUTPUT, weight_offered_htlc, weight_received_htlc};
- use chain::Txid;
- use ln::chan_utils::HTLCOutputInCommitment;
- use ln::{PaymentPreimage, PaymentHash};
+ use crate::chain::package::{CounterpartyOfferedHTLCOutput, CounterpartyReceivedHTLCOutput, HolderHTLCOutput, PackageTemplate, PackageSolvingData, RevokedOutput, WEIGHT_REVOKED_OUTPUT, weight_offered_htlc, weight_received_htlc};
+ use crate::chain::Txid;
+ use crate::ln::chan_utils::HTLCOutputInCommitment;
+ use crate::ln::{PaymentPreimage, PaymentHash};
use bitcoin::blockdata::constants::WITNESS_SCALE_FACTOR;
use bitcoin::blockdata::script::Script;
projects / rust-lightning / blobdiff