let mut counterparty_htlc_base_key = RequiredWrapper(None);
let mut preimage = RequiredWrapper(None);
let mut htlc = RequiredWrapper(None);
- let mut legacy_deserialization_prevention_marker: Option<()> = None;
+ let mut _legacy_deserialization_prevention_marker: Option<()> = None;
let mut channel_type_features = None;
read_tlv_fields!(reader, {
(4, counterparty_htlc_base_key, required),
(6, preimage, required),
(8, htlc, required),
- (10, legacy_deserialization_prevention_marker, option),
+ (10, _legacy_deserialization_prevention_marker, option),
(11, channel_type_features, option),
});
let mut counterparty_delayed_payment_base_key = RequiredWrapper(None);
let mut counterparty_htlc_base_key = RequiredWrapper(None);
let mut htlc = RequiredWrapper(None);
- let mut legacy_deserialization_prevention_marker: Option<()> = None;
+ let mut _legacy_deserialization_prevention_marker: Option<()> = None;
let mut channel_type_features = None;
read_tlv_fields!(reader, {
(2, counterparty_delayed_payment_base_key, required),
(4, counterparty_htlc_base_key, required),
(6, htlc, required),
- (8, legacy_deserialization_prevention_marker, option),
+ (8, _legacy_deserialization_prevention_marker, option),
(9, channel_type_features, option),
});
let mut amount_msat = RequiredWrapper(None);
let mut cltv_expiry = RequiredWrapper(None);
let mut preimage = None;
- let mut legacy_deserialization_prevention_marker: Option<()> = None;
+ let mut _legacy_deserialization_prevention_marker: Option<()> = None;
let mut channel_type_features = None;
read_tlv_fields!(reader, {
(0, amount_msat, required),
(2, cltv_expiry, required),
(4, preimage, option),
- (6, legacy_deserialization_prevention_marker, option),
+ (6, _legacy_deserialization_prevention_marker, option),
(7, channel_type_features, option),
});
#[derive(Clone, PartialEq, Eq)]
pub(crate) struct HolderFundingOutput {
funding_redeemscript: Script,
- funding_amount: Option<u64>,
+ pub(crate) funding_amount: Option<u64>,
channel_type_features: ChannelTypeFeatures,
}
impl Readable for HolderFundingOutput {
fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
let mut funding_redeemscript = RequiredWrapper(None);
- let mut legacy_deserialization_prevention_marker: Option<()> = None;
+ let mut _legacy_deserialization_prevention_marker: Option<()> = None;
let mut channel_type_features = None;
let mut funding_amount = None;
read_tlv_fields!(reader, {
(0, funding_redeemscript, required),
(1, channel_type_features, option),
- (2, legacy_deserialization_prevention_marker, option),
+ (2, _legacy_deserialization_prevention_marker, option),
(3, funding_amount, option)
});
) -> 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...
+ // Use the new fee estimate if it's higher than the one previously used.
if feerate_estimate as u64 > self.feerate_previous {
feerate_estimate
} else if !force_feerate_bump {
self.feerate_previous.try_into().unwrap_or(u32::max_value())
} 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())
+ // Our fee estimate has decreased, but our transaction remains unconfirmed after
+ // using our previous fee estimate. This may point to an unreliable fee estimator,
+ // so we choose to bump our previous feerate by 25%, making sure we don't use a
+ // lower feerate or overpay by a large margin by limiting it to 5x the new fee
+ // estimate.
+ let previous_feerate = self.feerate_previous.try_into().unwrap_or(u32::max_value());
+ let mut new_feerate = previous_feerate.saturating_add(previous_feerate / 4);
+ if new_feerate > feerate_estimate * 5 {
+ new_feerate = cmp::max(feerate_estimate * 5, previous_feerate);
+ }
+ new_feerate
}
} else {
feerate_estimate